bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   3    Written by Linus Nordberg, Swox AB <info@swox.com>,
   4    based on elf32-ppc.c by Ian Lance Taylor.
   5    Largely rewritten by Alan Modra.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, write to the Free Software Foundation, Inc.,
  21    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23
  24 /* The 64-bit PowerPC ELF ABI may be found at
  25    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  26    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  27
  28 #include "sysdep.h"
  29 #include <stdarg.h>
  30 #include "bfd.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/ppc64.h"
  35 #include "elf64-ppc.h"
  36 #include "dwarf2.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  58
  59 #define TARGET_LITTLE_SYM       powerpc_elf64_le_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          powerpc_elf64_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_TARGET_ID           PPC64_ELF_DATA
  65 #define ELF_MACHINE_CODE        EM_PPC64
  66 #define ELF_MAXPAGESIZE         0x10000
  67 #define ELF_COMMONPAGESIZE      0x1000
  68 #define elf_info_to_howto       ppc64_elf_info_to_howto
  69
  70 #define elf_backend_want_got_sym 0
  71 #define elf_backend_want_plt_sym 0
  72 #define elf_backend_plt_alignment 3
  73 #define elf_backend_plt_not_loaded 1
  74 #define elf_backend_got_header_size 8
  75 #define elf_backend_can_gc_sections 1
  76 #define elf_backend_can_refcount 1
  77 #define elf_backend_rela_normal 1
  78 #define elf_backend_default_execstack 0
  79
  80 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  81 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  82 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  83 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  84 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_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
 142 /* Offset of tp and dtp pointers from start of TLS block.  */
 143 #define TP_OFFSET       0x7000
 144 #define DTP_OFFSET      0x8000
 145
 146 /* .plt call stub instructions.  The normal stub is like this, but
 147    sometimes the .plt entry crosses a 64k boundary and we need to
 148    insert an addi to adjust r11.  */
 149 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 150 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 151 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 152 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 153 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 154 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 155 #define BCTR            0x4e800420      /* bctr                      */
 156
 157 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 158 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 159 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 160
 161 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 162 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 163 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 164 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 165 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 166 #define BNECTR          0x4ca20420      /* bnectr+               */
 167 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 168
 169 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 170 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 171 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 172
 173 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 174
 175 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 176 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 177 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 178
 179 /* glink call stub instructions.  We enter with the index in R0.  */
 180 #define GLINK_CALL_STUB_SIZE (16*4)
 181                                         /* 0:                           */
 182                                         /*  .quad plt0-1f               */
 183                                         /* __glink:                     */
 184 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 185 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 186                                         /* 1:                           */
 187 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 188                                         /*  ld %2,(0b-1b)(%11)          */
 189 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 190 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 191                                         /*  ld %12,0(%11)               */
 192                                         /*  ld %2,8(%11)                */
 193                                         /*  mtctr %12                   */
 194                                         /*  ld %11,16(%11)              */
 195                                         /*  bctr                        */
 196 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 197 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 198 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 199 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 200 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 201
 202 /* Pad with this.  */
 203 #define NOP             0x60000000
 204
 205 /* Some other nops.  */
 206 #define CROR_151515     0x4def7b82
 207 #define CROR_313131     0x4ffffb82
 208
 209 /* .glink entries for the first 32k functions are two instructions.  */
 210 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 211 #define B_DOT           0x48000000      /* b     .              */
 212
 213 /* After that, we need two instructions to load the index, followed by
 214    a branch.  */
 215 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 216 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 217
 218 /* Instructions used by the save and restore reg functions.  */
 219 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 220 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 221 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 222 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 223 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 224 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 225 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 226 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 227 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 228 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 229 #define BLR             0x4e800020      /* blr                  */
 230
 231 /* Since .opd is an array of descriptors and each entry will end up
 232    with identical R_PPC64_RELATIVE relocs, there is really no need to
 233    propagate .opd relocs;  The dynamic linker should be taught to
 234    relocate .opd without reloc entries.  */
 235 #ifndef NO_OPD_RELOCS
 236 #define NO_OPD_RELOCS 0
 237 #endif
 238
 239 static inline int
 240 abiversion (bfd *abfd)
 241 {
 242   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
 243 }
 244
 245 static inline void
 246 set_abiversion (bfd *abfd, int ver)
 247 {
 248   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
 249   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
 250 }
 251 \f
 252 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 253
 254 /* Relocation HOWTO's.  */
 255 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 256
 257 static reloc_howto_type ppc64_elf_howto_raw[] = {
 258   /* This reloc does nothing.  */
 259   HOWTO (R_PPC64_NONE,          /* type */
 260          0,                     /* rightshift */
 261          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 262          32,                    /* bitsize */
 263          FALSE,                 /* pc_relative */
 264          0,                     /* bitpos */
 265          complain_overflow_dont, /* complain_on_overflow */
 266          bfd_elf_generic_reloc, /* special_function */
 267          "R_PPC64_NONE",        /* name */
 268          FALSE,                 /* partial_inplace */
 269          0,                     /* src_mask */
 270          0,                     /* dst_mask */
 271          FALSE),                /* pcrel_offset */
 272
 273   /* A standard 32 bit relocation.  */
 274   HOWTO (R_PPC64_ADDR32,        /* type */
 275          0,                     /* rightshift */
 276          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 277          32,                    /* bitsize */
 278          FALSE,                 /* pc_relative */
 279          0,                     /* bitpos */
 280          complain_overflow_bitfield, /* complain_on_overflow */
 281          bfd_elf_generic_reloc, /* special_function */
 282          "R_PPC64_ADDR32",      /* name */
 283          FALSE,                 /* partial_inplace */
 284          0,                     /* src_mask */
 285          0xffffffff,            /* dst_mask */
 286          FALSE),                /* pcrel_offset */
 287
 288   /* An absolute 26 bit branch; the lower two bits must be zero.
 289      FIXME: we don't check that, we just clear them.  */
 290   HOWTO (R_PPC64_ADDR24,        /* type */
 291          0,                     /* rightshift */
 292          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 293          26,                    /* bitsize */
 294          FALSE,                 /* pc_relative */
 295          0,                     /* bitpos */
 296          complain_overflow_bitfield, /* complain_on_overflow */
 297          bfd_elf_generic_reloc, /* special_function */
 298          "R_PPC64_ADDR24",      /* name */
 299          FALSE,                 /* partial_inplace */
 300          0,                     /* src_mask */
 301          0x03fffffc,            /* dst_mask */
 302          FALSE),                /* pcrel_offset */
 303
 304   /* A standard 16 bit relocation.  */
 305   HOWTO (R_PPC64_ADDR16,        /* type */
 306          0,                     /* rightshift */
 307          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 308          16,                    /* bitsize */
 309          FALSE,                 /* pc_relative */
 310          0,                     /* bitpos */
 311          complain_overflow_bitfield, /* complain_on_overflow */
 312          bfd_elf_generic_reloc, /* special_function */
 313          "R_PPC64_ADDR16",      /* name */
 314          FALSE,                 /* partial_inplace */
 315          0,                     /* src_mask */
 316          0xffff,                /* dst_mask */
 317          FALSE),                /* pcrel_offset */
 318
 319   /* A 16 bit relocation without overflow.  */
 320   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 321          0,                     /* rightshift */
 322          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 323          16,                    /* bitsize */
 324          FALSE,                 /* pc_relative */
 325          0,                     /* bitpos */
 326          complain_overflow_dont,/* complain_on_overflow */
 327          bfd_elf_generic_reloc, /* special_function */
 328          "R_PPC64_ADDR16_LO",   /* name */
 329          FALSE,                 /* partial_inplace */
 330          0,                     /* src_mask */
 331          0xffff,                /* dst_mask */
 332          FALSE),                /* pcrel_offset */
 333
 334   /* Bits 16-31 of an address.  */
 335   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 336          16,                    /* rightshift */
 337          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 338          16,                    /* bitsize */
 339          FALSE,                 /* pc_relative */
 340          0,                     /* bitpos */
 341          complain_overflow_signed, /* complain_on_overflow */
 342          bfd_elf_generic_reloc, /* special_function */
 343          "R_PPC64_ADDR16_HI",   /* name */
 344          FALSE,                 /* partial_inplace */
 345          0,                     /* src_mask */
 346          0xffff,                /* dst_mask */
 347          FALSE),                /* pcrel_offset */
 348
 349   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 350      bits, treated as a signed number, is negative.  */
 351   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 352          16,                    /* rightshift */
 353          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          16,                    /* bitsize */
 355          FALSE,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_signed, /* complain_on_overflow */
 358          ppc64_elf_ha_reloc,    /* special_function */
 359          "R_PPC64_ADDR16_HA",   /* name */
 360          FALSE,                 /* partial_inplace */
 361          0,                     /* src_mask */
 362          0xffff,                /* dst_mask */
 363          FALSE),                /* pcrel_offset */
 364
 365   /* An absolute 16 bit branch; the lower two bits must be zero.
 366      FIXME: we don't check that, we just clear them.  */
 367   HOWTO (R_PPC64_ADDR14,        /* type */
 368          0,                     /* rightshift */
 369          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 370          16,                    /* bitsize */
 371          FALSE,                 /* pc_relative */
 372          0,                     /* bitpos */
 373          complain_overflow_signed, /* complain_on_overflow */
 374          ppc64_elf_branch_reloc, /* special_function */
 375          "R_PPC64_ADDR14",      /* name */
 376          FALSE,                 /* partial_inplace */
 377          0,                     /* src_mask */
 378          0x0000fffc,            /* dst_mask */
 379          FALSE),                /* pcrel_offset */
 380
 381   /* An absolute 16 bit branch, for which bit 10 should be set to
 382      indicate that the branch is expected to be taken.  The lower two
 383      bits must be zero.  */
 384   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          16,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_signed, /* complain_on_overflow */
 391          ppc64_elf_brtaken_reloc, /* special_function */
 392          "R_PPC64_ADDR14_BRTAKEN",/* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0x0000fffc,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   /* An absolute 16 bit branch, for which bit 10 should be set to
 399      indicate that the branch is not expected to be taken.  The lower
 400      two bits must be zero.  */
 401   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_signed, /* complain_on_overflow */
 408          ppc64_elf_brtaken_reloc, /* special_function */
 409          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 410          FALSE,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0x0000fffc,            /* dst_mask */
 413          FALSE),                /* pcrel_offset */
 414
 415   /* A relative 26 bit branch; the lower two bits must be zero.  */
 416   HOWTO (R_PPC64_REL24,         /* type */
 417          0,                     /* rightshift */
 418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 419          26,                    /* bitsize */
 420          TRUE,                  /* pc_relative */
 421          0,                     /* bitpos */
 422          complain_overflow_signed, /* complain_on_overflow */
 423          ppc64_elf_branch_reloc, /* special_function */
 424          "R_PPC64_REL24",       /* name */
 425          FALSE,                 /* partial_inplace */
 426          0,                     /* src_mask */
 427          0x03fffffc,            /* dst_mask */
 428          TRUE),                 /* pcrel_offset */
 429
 430   /* A relative 16 bit branch; the lower two bits must be zero.  */
 431   HOWTO (R_PPC64_REL14,         /* type */
 432          0,                     /* rightshift */
 433          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 434          16,                    /* bitsize */
 435          TRUE,                  /* pc_relative */
 436          0,                     /* bitpos */
 437          complain_overflow_signed, /* complain_on_overflow */
 438          ppc64_elf_branch_reloc, /* special_function */
 439          "R_PPC64_REL14",       /* name */
 440          FALSE,                 /* partial_inplace */
 441          0,                     /* src_mask */
 442          0x0000fffc,            /* dst_mask */
 443          TRUE),                 /* pcrel_offset */
 444
 445   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 446      the branch is expected to be taken.  The lower two bits must be
 447      zero.  */
 448   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 449          0,                     /* rightshift */
 450          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 451          16,                    /* bitsize */
 452          TRUE,                  /* pc_relative */
 453          0,                     /* bitpos */
 454          complain_overflow_signed, /* complain_on_overflow */
 455          ppc64_elf_brtaken_reloc, /* special_function */
 456          "R_PPC64_REL14_BRTAKEN", /* name */
 457          FALSE,                 /* partial_inplace */
 458          0,                     /* src_mask */
 459          0x0000fffc,            /* dst_mask */
 460          TRUE),                 /* pcrel_offset */
 461
 462   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 463      the branch is not expected to be taken.  The lower two bits must
 464      be zero.  */
 465   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 466          0,                     /* rightshift */
 467          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 468          16,                    /* bitsize */
 469          TRUE,                  /* pc_relative */
 470          0,                     /* bitpos */
 471          complain_overflow_signed, /* complain_on_overflow */
 472          ppc64_elf_brtaken_reloc, /* special_function */
 473          "R_PPC64_REL14_BRNTAKEN",/* name */
 474          FALSE,                 /* partial_inplace */
 475          0,                     /* src_mask */
 476          0x0000fffc,            /* dst_mask */
 477          TRUE),                 /* pcrel_offset */
 478
 479   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 480      symbol.  */
 481   HOWTO (R_PPC64_GOT16,         /* type */
 482          0,                     /* rightshift */
 483          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 484          16,                    /* bitsize */
 485          FALSE,                 /* pc_relative */
 486          0,                     /* bitpos */
 487          complain_overflow_signed, /* complain_on_overflow */
 488          ppc64_elf_unhandled_reloc, /* special_function */
 489          "R_PPC64_GOT16",       /* name */
 490          FALSE,                 /* partial_inplace */
 491          0,                     /* src_mask */
 492          0xffff,                /* dst_mask */
 493          FALSE),                /* pcrel_offset */
 494
 495   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 496      the symbol.  */
 497   HOWTO (R_PPC64_GOT16_LO,      /* type */
 498          0,                     /* rightshift */
 499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 500          16,                    /* bitsize */
 501          FALSE,                 /* pc_relative */
 502          0,                     /* bitpos */
 503          complain_overflow_dont, /* complain_on_overflow */
 504          ppc64_elf_unhandled_reloc, /* special_function */
 505          "R_PPC64_GOT16_LO",    /* name */
 506          FALSE,                 /* partial_inplace */
 507          0,                     /* src_mask */
 508          0xffff,                /* dst_mask */
 509          FALSE),                /* pcrel_offset */
 510
 511   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 512      the symbol.  */
 513   HOWTO (R_PPC64_GOT16_HI,      /* type */
 514          16,                    /* rightshift */
 515          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 516          16,                    /* bitsize */
 517          FALSE,                 /* pc_relative */
 518          0,                     /* bitpos */
 519          complain_overflow_signed,/* complain_on_overflow */
 520          ppc64_elf_unhandled_reloc, /* special_function */
 521          "R_PPC64_GOT16_HI",    /* name */
 522          FALSE,                 /* partial_inplace */
 523          0,                     /* src_mask */
 524          0xffff,                /* dst_mask */
 525          FALSE),                /* pcrel_offset */
 526
 527   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 528      the symbol.  */
 529   HOWTO (R_PPC64_GOT16_HA,      /* type */
 530          16,                    /* rightshift */
 531          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 532          16,                    /* bitsize */
 533          FALSE,                 /* pc_relative */
 534          0,                     /* bitpos */
 535          complain_overflow_signed,/* complain_on_overflow */
 536          ppc64_elf_unhandled_reloc, /* special_function */
 537          "R_PPC64_GOT16_HA",    /* name */
 538          FALSE,                 /* partial_inplace */
 539          0,                     /* src_mask */
 540          0xffff,                /* dst_mask */
 541          FALSE),                /* pcrel_offset */
 542
 543   /* This is used only by the dynamic linker.  The symbol should exist
 544      both in the object being run and in some shared library.  The
 545      dynamic linker copies the data addressed by the symbol from the
 546      shared library into the object, because the object being
 547      run has to have the data at some particular address.  */
 548   HOWTO (R_PPC64_COPY,          /* type */
 549          0,                     /* rightshift */
 550          0,                     /* this one is variable size */
 551          0,                     /* bitsize */
 552          FALSE,                 /* pc_relative */
 553          0,                     /* bitpos */
 554          complain_overflow_dont, /* complain_on_overflow */
 555          ppc64_elf_unhandled_reloc, /* special_function */
 556          "R_PPC64_COPY",        /* name */
 557          FALSE,                 /* partial_inplace */
 558          0,                     /* src_mask */
 559          0,                     /* dst_mask */
 560          FALSE),                /* pcrel_offset */
 561
 562   /* Like R_PPC64_ADDR64, but used when setting global offset table
 563      entries.  */
 564   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 565          0,                     /* rightshift */
 566          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 567          64,                    /* bitsize */
 568          FALSE,                 /* pc_relative */
 569          0,                     /* bitpos */
 570          complain_overflow_dont, /* complain_on_overflow */
 571          ppc64_elf_unhandled_reloc,  /* special_function */
 572          "R_PPC64_GLOB_DAT",    /* name */
 573          FALSE,                 /* partial_inplace */
 574          0,                     /* src_mask */
 575          ONES (64),             /* dst_mask */
 576          FALSE),                /* pcrel_offset */
 577
 578   /* Created by the link editor.  Marks a procedure linkage table
 579      entry for a symbol.  */
 580   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 581          0,                     /* rightshift */
 582          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          0,                     /* bitsize */
 584          FALSE,                 /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_dont, /* complain_on_overflow */
 587          ppc64_elf_unhandled_reloc, /* special_function */
 588          "R_PPC64_JMP_SLOT",    /* name */
 589          FALSE,                 /* partial_inplace */
 590          0,                     /* src_mask */
 591          0,                     /* dst_mask */
 592          FALSE),                /* pcrel_offset */
 593
 594   /* Used only by the dynamic linker.  When the object is run, this
 595      doubleword64 is set to the load address of the object, plus the
 596      addend.  */
 597   HOWTO (R_PPC64_RELATIVE,      /* type */
 598          0,                     /* rightshift */
 599          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 600          64,                    /* bitsize */
 601          FALSE,                 /* pc_relative */
 602          0,                     /* bitpos */
 603          complain_overflow_dont, /* complain_on_overflow */
 604          bfd_elf_generic_reloc, /* special_function */
 605          "R_PPC64_RELATIVE",    /* name */
 606          FALSE,                 /* partial_inplace */
 607          0,                     /* src_mask */
 608          ONES (64),             /* dst_mask */
 609          FALSE),                /* pcrel_offset */
 610
 611   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 612   HOWTO (R_PPC64_UADDR32,       /* type */
 613          0,                     /* rightshift */
 614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 615          32,                    /* bitsize */
 616          FALSE,                 /* pc_relative */
 617          0,                     /* bitpos */
 618          complain_overflow_bitfield, /* complain_on_overflow */
 619          bfd_elf_generic_reloc, /* special_function */
 620          "R_PPC64_UADDR32",     /* name */
 621          FALSE,                 /* partial_inplace */
 622          0,                     /* src_mask */
 623          0xffffffff,            /* dst_mask */
 624          FALSE),                /* pcrel_offset */
 625
 626   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 627   HOWTO (R_PPC64_UADDR16,       /* type */
 628          0,                     /* rightshift */
 629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          16,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_bitfield, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_PPC64_UADDR16",     /* name */
 636          FALSE,                 /* partial_inplace */
 637          0,                     /* src_mask */
 638          0xffff,                /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* 32-bit PC relative.  */
 642   HOWTO (R_PPC64_REL32,         /* type */
 643          0,                     /* rightshift */
 644          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 645          32,                    /* bitsize */
 646          TRUE,                  /* pc_relative */
 647          0,                     /* bitpos */
 648          complain_overflow_signed, /* complain_on_overflow */
 649          bfd_elf_generic_reloc, /* special_function */
 650          "R_PPC64_REL32",       /* name */
 651          FALSE,                 /* partial_inplace */
 652          0,                     /* src_mask */
 653          0xffffffff,            /* dst_mask */
 654          TRUE),                 /* pcrel_offset */
 655
 656   /* 32-bit relocation to the symbol's procedure linkage table.  */
 657   HOWTO (R_PPC64_PLT32,         /* type */
 658          0,                     /* rightshift */
 659          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 660          32,                    /* bitsize */
 661          FALSE,                 /* pc_relative */
 662          0,                     /* bitpos */
 663          complain_overflow_bitfield, /* complain_on_overflow */
 664          ppc64_elf_unhandled_reloc, /* special_function */
 665          "R_PPC64_PLT32",       /* name */
 666          FALSE,                 /* partial_inplace */
 667          0,                     /* src_mask */
 668          0xffffffff,            /* dst_mask */
 669          FALSE),                /* pcrel_offset */
 670
 671   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 672      FIXME: R_PPC64_PLTREL32 not supported.  */
 673   HOWTO (R_PPC64_PLTREL32,      /* type */
 674          0,                     /* rightshift */
 675          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          32,                    /* bitsize */
 677          TRUE,                  /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_signed, /* complain_on_overflow */
 680          bfd_elf_generic_reloc, /* special_function */
 681          "R_PPC64_PLTREL32",    /* name */
 682          FALSE,                 /* partial_inplace */
 683          0,                     /* src_mask */
 684          0xffffffff,            /* dst_mask */
 685          TRUE),                 /* pcrel_offset */
 686
 687   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 688      the symbol.  */
 689   HOWTO (R_PPC64_PLT16_LO,      /* type */
 690          0,                     /* rightshift */
 691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 692          16,                    /* bitsize */
 693          FALSE,                 /* pc_relative */
 694          0,                     /* bitpos */
 695          complain_overflow_dont, /* complain_on_overflow */
 696          ppc64_elf_unhandled_reloc, /* special_function */
 697          "R_PPC64_PLT16_LO",    /* name */
 698          FALSE,                 /* partial_inplace */
 699          0,                     /* src_mask */
 700          0xffff,                /* dst_mask */
 701          FALSE),                /* pcrel_offset */
 702
 703   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 704      the symbol.  */
 705   HOWTO (R_PPC64_PLT16_HI,      /* type */
 706          16,                    /* rightshift */
 707          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 708          16,                    /* bitsize */
 709          FALSE,                 /* pc_relative */
 710          0,                     /* bitpos */
 711          complain_overflow_signed, /* complain_on_overflow */
 712          ppc64_elf_unhandled_reloc, /* special_function */
 713          "R_PPC64_PLT16_HI",    /* name */
 714          FALSE,                 /* partial_inplace */
 715          0,                     /* src_mask */
 716          0xffff,                /* dst_mask */
 717          FALSE),                /* pcrel_offset */
 718
 719   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 720      the symbol.  */
 721   HOWTO (R_PPC64_PLT16_HA,      /* type */
 722          16,                    /* rightshift */
 723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 724          16,                    /* bitsize */
 725          FALSE,                 /* pc_relative */
 726          0,                     /* bitpos */
 727          complain_overflow_signed, /* complain_on_overflow */
 728          ppc64_elf_unhandled_reloc, /* special_function */
 729          "R_PPC64_PLT16_HA",    /* name */
 730          FALSE,                 /* partial_inplace */
 731          0,                     /* src_mask */
 732          0xffff,                /* dst_mask */
 733          FALSE),                /* pcrel_offset */
 734
 735   /* 16-bit section relative relocation.  */
 736   HOWTO (R_PPC64_SECTOFF,       /* type */
 737          0,                     /* rightshift */
 738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_signed, /* complain_on_overflow */
 743          ppc64_elf_sectoff_reloc, /* special_function */
 744          "R_PPC64_SECTOFF",     /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0xffff,                /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 751   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 752          0,                     /* rightshift */
 753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          0,                     /* bitpos */
 757          complain_overflow_dont, /* complain_on_overflow */
 758          ppc64_elf_sectoff_reloc, /* special_function */
 759          "R_PPC64_SECTOFF_LO",  /* name */
 760          FALSE,                 /* partial_inplace */
 761          0,                     /* src_mask */
 762          0xffff,                /* dst_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* 16-bit upper half section relative relocation.  */
 766   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 767          16,                    /* rightshift */
 768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          0,                     /* bitpos */
 772          complain_overflow_signed, /* complain_on_overflow */
 773          ppc64_elf_sectoff_reloc, /* special_function */
 774          "R_PPC64_SECTOFF_HI",  /* name */
 775          FALSE,                 /* partial_inplace */
 776          0,                     /* src_mask */
 777          0xffff,                /* dst_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   /* 16-bit upper half adjusted section relative relocation.  */
 781   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 782          16,                    /* rightshift */
 783          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 784          16,                    /* bitsize */
 785          FALSE,                 /* pc_relative */
 786          0,                     /* bitpos */
 787          complain_overflow_signed, /* complain_on_overflow */
 788          ppc64_elf_sectoff_ha_reloc, /* special_function */
 789          "R_PPC64_SECTOFF_HA",  /* name */
 790          FALSE,                 /* partial_inplace */
 791          0,                     /* src_mask */
 792          0xffff,                /* dst_mask */
 793          FALSE),                /* pcrel_offset */
 794
 795   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 796   HOWTO (R_PPC64_REL30,         /* type */
 797          2,                     /* rightshift */
 798          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 799          30,                    /* bitsize */
 800          TRUE,                  /* pc_relative */
 801          0,                     /* bitpos */
 802          complain_overflow_dont, /* complain_on_overflow */
 803          bfd_elf_generic_reloc, /* special_function */
 804          "R_PPC64_REL30",       /* name */
 805          FALSE,                 /* partial_inplace */
 806          0,                     /* src_mask */
 807          0xfffffffc,            /* dst_mask */
 808          TRUE),                 /* pcrel_offset */
 809
 810   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 811
 812   /* A standard 64-bit relocation.  */
 813   HOWTO (R_PPC64_ADDR64,        /* type */
 814          0,                     /* rightshift */
 815          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 816          64,                    /* bitsize */
 817          FALSE,                 /* pc_relative */
 818          0,                     /* bitpos */
 819          complain_overflow_dont, /* complain_on_overflow */
 820          bfd_elf_generic_reloc, /* special_function */
 821          "R_PPC64_ADDR64",      /* name */
 822          FALSE,                 /* partial_inplace */
 823          0,                     /* src_mask */
 824          ONES (64),             /* dst_mask */
 825          FALSE),                /* pcrel_offset */
 826
 827   /* The bits 32-47 of an address.  */
 828   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 829          32,                    /* rightshift */
 830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 831          16,                    /* bitsize */
 832          FALSE,                 /* pc_relative */
 833          0,                     /* bitpos */
 834          complain_overflow_dont, /* complain_on_overflow */
 835          bfd_elf_generic_reloc, /* special_function */
 836          "R_PPC64_ADDR16_HIGHER", /* name */
 837          FALSE,                 /* partial_inplace */
 838          0,                     /* src_mask */
 839          0xffff,                /* dst_mask */
 840          FALSE),                /* pcrel_offset */
 841
 842   /* The bits 32-47 of an address, plus 1 if the contents of the low
 843      16 bits, treated as a signed number, is negative.  */
 844   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 845          32,                    /* rightshift */
 846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 847          16,                    /* bitsize */
 848          FALSE,                 /* pc_relative */
 849          0,                     /* bitpos */
 850          complain_overflow_dont, /* complain_on_overflow */
 851          ppc64_elf_ha_reloc,    /* special_function */
 852          "R_PPC64_ADDR16_HIGHERA", /* name */
 853          FALSE,                 /* partial_inplace */
 854          0,                     /* src_mask */
 855          0xffff,                /* dst_mask */
 856          FALSE),                /* pcrel_offset */
 857
 858   /* The bits 48-63 of an address.  */
 859   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 860          48,                    /* rightshift */
 861          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 862          16,                    /* bitsize */
 863          FALSE,                 /* pc_relative */
 864          0,                     /* bitpos */
 865          complain_overflow_dont, /* complain_on_overflow */
 866          bfd_elf_generic_reloc, /* special_function */
 867          "R_PPC64_ADDR16_HIGHEST", /* name */
 868          FALSE,                 /* partial_inplace */
 869          0,                     /* src_mask */
 870          0xffff,                /* dst_mask */
 871          FALSE),                /* pcrel_offset */
 872
 873   /* The bits 48-63 of an address, plus 1 if the contents of the low
 874      16 bits, treated as a signed number, is negative.  */
 875   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 876          48,                    /* rightshift */
 877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 878          16,                    /* bitsize */
 879          FALSE,                 /* pc_relative */
 880          0,                     /* bitpos */
 881          complain_overflow_dont, /* complain_on_overflow */
 882          ppc64_elf_ha_reloc,    /* special_function */
 883          "R_PPC64_ADDR16_HIGHESTA", /* name */
 884          FALSE,                 /* partial_inplace */
 885          0,                     /* src_mask */
 886          0xffff,                /* dst_mask */
 887          FALSE),                /* pcrel_offset */
 888
 889   /* Like ADDR64, but may be unaligned.  */
 890   HOWTO (R_PPC64_UADDR64,       /* type */
 891          0,                     /* rightshift */
 892          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 893          64,                    /* bitsize */
 894          FALSE,                 /* pc_relative */
 895          0,                     /* bitpos */
 896          complain_overflow_dont, /* complain_on_overflow */
 897          bfd_elf_generic_reloc, /* special_function */
 898          "R_PPC64_UADDR64",     /* name */
 899          FALSE,                 /* partial_inplace */
 900          0,                     /* src_mask */
 901          ONES (64),             /* dst_mask */
 902          FALSE),                /* pcrel_offset */
 903
 904   /* 64-bit relative relocation.  */
 905   HOWTO (R_PPC64_REL64,         /* type */
 906          0,                     /* rightshift */
 907          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 908          64,                    /* bitsize */
 909          TRUE,                  /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont, /* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_PPC64_REL64",       /* name */
 914          FALSE,                 /* partial_inplace */
 915          0,                     /* src_mask */
 916          ONES (64),             /* dst_mask */
 917          TRUE),                 /* pcrel_offset */
 918
 919   /* 64-bit relocation to the symbol's procedure linkage table.  */
 920   HOWTO (R_PPC64_PLT64,         /* type */
 921          0,                     /* rightshift */
 922          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 923          64,                    /* bitsize */
 924          FALSE,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_dont, /* complain_on_overflow */
 927          ppc64_elf_unhandled_reloc, /* special_function */
 928          "R_PPC64_PLT64",       /* name */
 929          FALSE,                 /* partial_inplace */
 930          0,                     /* src_mask */
 931          ONES (64),             /* dst_mask */
 932          FALSE),                /* pcrel_offset */
 933
 934   /* 64-bit PC relative relocation to the symbol's procedure linkage
 935      table.  */
 936   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 937   HOWTO (R_PPC64_PLTREL64,      /* type */
 938          0,                     /* rightshift */
 939          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 940          64,                    /* bitsize */
 941          TRUE,                  /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont, /* complain_on_overflow */
 944          ppc64_elf_unhandled_reloc, /* special_function */
 945          "R_PPC64_PLTREL64",    /* name */
 946          FALSE,                 /* partial_inplace */
 947          0,                     /* src_mask */
 948          ONES (64),             /* dst_mask */
 949          TRUE),                 /* pcrel_offset */
 950
 951   /* 16 bit TOC-relative relocation.  */
 952
 953   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 954   HOWTO (R_PPC64_TOC16,         /* type */
 955          0,                     /* rightshift */
 956          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 957          16,                    /* bitsize */
 958          FALSE,                 /* pc_relative */
 959          0,                     /* bitpos */
 960          complain_overflow_signed, /* complain_on_overflow */
 961          ppc64_elf_toc_reloc,   /* special_function */
 962          "R_PPC64_TOC16",       /* name */
 963          FALSE,                 /* partial_inplace */
 964          0,                     /* src_mask */
 965          0xffff,                /* dst_mask */
 966          FALSE),                /* pcrel_offset */
 967
 968   /* 16 bit TOC-relative relocation without overflow.  */
 969
 970   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_LO,      /* type */
 972          0,                     /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_reloc,   /* special_function */
 979          "R_PPC64_TOC16_LO",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 16 bit TOC-relative relocation, high 16 bits.  */
 986
 987   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 988   HOWTO (R_PPC64_TOC16_HI,      /* type */
 989          16,                    /* rightshift */
 990          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 991          16,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_signed, /* complain_on_overflow */
 995          ppc64_elf_toc_reloc,   /* special_function */
 996          "R_PPC64_TOC16_HI",    /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          0xffff,                /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1003      contents of the low 16 bits, treated as a signed number, is
1004      negative.  */
1005
1006   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
1007   HOWTO (R_PPC64_TOC16_HA,      /* type */
1008          16,                    /* rightshift */
1009          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          16,                    /* bitsize */
1011          FALSE,                 /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_signed, /* complain_on_overflow */
1014          ppc64_elf_toc_ha_reloc, /* special_function */
1015          "R_PPC64_TOC16_HA",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0,                     /* src_mask */
1018          0xffff,                /* dst_mask */
1019          FALSE),                /* pcrel_offset */
1020
1021   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1022
1023   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1024   HOWTO (R_PPC64_TOC,           /* type */
1025          0,                     /* rightshift */
1026          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1027          64,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_toc64_reloc, /* special_function */
1032          "R_PPC64_TOC",         /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          ONES (64),             /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_GOT16, but also informs the link editor that the
1039      value to relocate may (!) refer to a PLT entry which the link
1040      editor (a) may replace with the symbol value.  If the link editor
1041      is unable to fully resolve the symbol, it may (b) create a PLT
1042      entry and store the address to the new PLT entry in the GOT.
1043      This permits lazy resolution of function symbols at run time.
1044      The link editor may also skip all of this and just (c) emit a
1045      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1046   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1047     HOWTO (R_PPC64_PLTGOT16,    /* type */
1048          0,                     /* rightshift */
1049          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1050          16,                    /* bitsize */
1051          FALSE,                 /* pc_relative */
1052          0,                     /* bitpos */
1053          complain_overflow_signed, /* complain_on_overflow */
1054          ppc64_elf_unhandled_reloc, /* special_function */
1055          "R_PPC64_PLTGOT16",    /* name */
1056          FALSE,                 /* partial_inplace */
1057          0,                     /* src_mask */
1058          0xffff,                /* dst_mask */
1059          FALSE),                /* pcrel_offset */
1060
1061   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1062   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1063   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1064          0,                     /* rightshift */
1065          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1066          16,                    /* bitsize */
1067          FALSE,                 /* pc_relative */
1068          0,                     /* bitpos */
1069          complain_overflow_dont, /* complain_on_overflow */
1070          ppc64_elf_unhandled_reloc, /* special_function */
1071          "R_PPC64_PLTGOT16_LO", /* name */
1072          FALSE,                 /* partial_inplace */
1073          0,                     /* src_mask */
1074          0xffff,                /* dst_mask */
1075          FALSE),                /* pcrel_offset */
1076
1077   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1078   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1079   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1080          16,                    /* rightshift */
1081          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1082          16,                    /* bitsize */
1083          FALSE,                 /* pc_relative */
1084          0,                     /* bitpos */
1085          complain_overflow_signed, /* complain_on_overflow */
1086          ppc64_elf_unhandled_reloc, /* special_function */
1087          "R_PPC64_PLTGOT16_HI", /* name */
1088          FALSE,                 /* partial_inplace */
1089          0,                     /* src_mask */
1090          0xffff,                /* dst_mask */
1091          FALSE),                /* pcrel_offset */
1092
1093   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1094      1 if the contents of the low 16 bits, treated as a signed number,
1095      is negative.  */
1096   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1097   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1098          16,                    /* rightshift */
1099          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1100          16,                    /* bitsize */
1101          FALSE,                 /* pc_relative */
1102          0,                     /* bitpos */
1103          complain_overflow_signed, /* complain_on_overflow */
1104          ppc64_elf_unhandled_reloc, /* special_function */
1105          "R_PPC64_PLTGOT16_HA", /* name */
1106          FALSE,                 /* partial_inplace */
1107          0,                     /* src_mask */
1108          0xffff,                /* dst_mask */
1109          FALSE),                /* pcrel_offset */
1110
1111   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1112   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1113          0,                     /* rightshift */
1114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          16,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_signed, /* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_PPC64_ADDR16_DS",   /* name */
1121          FALSE,                 /* partial_inplace */
1122          0,                     /* src_mask */
1123          0xfffc,                /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1127   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1128          0,                     /* rightshift */
1129          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1130          16,                    /* bitsize */
1131          FALSE,                 /* pc_relative */
1132          0,                     /* bitpos */
1133          complain_overflow_dont,/* complain_on_overflow */
1134          bfd_elf_generic_reloc, /* special_function */
1135          "R_PPC64_ADDR16_LO_DS",/* name */
1136          FALSE,                 /* partial_inplace */
1137          0,                     /* src_mask */
1138          0xfffc,                /* dst_mask */
1139          FALSE),                /* pcrel_offset */
1140
1141   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1142   HOWTO (R_PPC64_GOT16_DS,      /* type */
1143          0,                     /* rightshift */
1144          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1145          16,                    /* bitsize */
1146          FALSE,                 /* pc_relative */
1147          0,                     /* bitpos */
1148          complain_overflow_signed, /* complain_on_overflow */
1149          ppc64_elf_unhandled_reloc, /* special_function */
1150          "R_PPC64_GOT16_DS",    /* name */
1151          FALSE,                 /* partial_inplace */
1152          0,                     /* src_mask */
1153          0xfffc,                /* dst_mask */
1154          FALSE),                /* pcrel_offset */
1155
1156   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1157   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1158          0,                     /* rightshift */
1159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          16,                    /* bitsize */
1161          FALSE,                 /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_dont, /* complain_on_overflow */
1164          ppc64_elf_unhandled_reloc, /* special_function */
1165          "R_PPC64_GOT16_LO_DS", /* name */
1166          FALSE,                 /* partial_inplace */
1167          0,                     /* src_mask */
1168          0xfffc,                /* dst_mask */
1169          FALSE),                /* pcrel_offset */
1170
1171   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1172   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1173          0,                     /* rightshift */
1174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1175          16,                    /* bitsize */
1176          FALSE,                 /* pc_relative */
1177          0,                     /* bitpos */
1178          complain_overflow_dont, /* complain_on_overflow */
1179          ppc64_elf_unhandled_reloc, /* special_function */
1180          "R_PPC64_PLT16_LO_DS", /* name */
1181          FALSE,                 /* partial_inplace */
1182          0,                     /* src_mask */
1183          0xfffc,                /* dst_mask */
1184          FALSE),                /* pcrel_offset */
1185
1186   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1187   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1188          0,                     /* rightshift */
1189          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          16,                    /* bitsize */
1191          FALSE,                 /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_signed, /* complain_on_overflow */
1194          ppc64_elf_sectoff_reloc, /* special_function */
1195          "R_PPC64_SECTOFF_DS",  /* name */
1196          FALSE,                 /* partial_inplace */
1197          0,                     /* src_mask */
1198          0xfffc,                /* dst_mask */
1199          FALSE),                /* pcrel_offset */
1200
1201   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1202   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1203          0,                     /* rightshift */
1204          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1205          16,                    /* bitsize */
1206          FALSE,                 /* pc_relative */
1207          0,                     /* bitpos */
1208          complain_overflow_dont, /* complain_on_overflow */
1209          ppc64_elf_sectoff_reloc, /* special_function */
1210          "R_PPC64_SECTOFF_LO_DS",/* name */
1211          FALSE,                 /* partial_inplace */
1212          0,                     /* src_mask */
1213          0xfffc,                /* dst_mask */
1214          FALSE),                /* pcrel_offset */
1215
1216   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1217   HOWTO (R_PPC64_TOC16_DS,      /* type */
1218          0,                     /* rightshift */
1219          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          16,                    /* bitsize */
1221          FALSE,                 /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_signed, /* complain_on_overflow */
1224          ppc64_elf_toc_reloc,   /* special_function */
1225          "R_PPC64_TOC16_DS",    /* name */
1226          FALSE,                 /* partial_inplace */
1227          0,                     /* src_mask */
1228          0xfffc,                /* dst_mask */
1229          FALSE),                /* pcrel_offset */
1230
1231   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1232   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1233          0,                     /* rightshift */
1234          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1235          16,                    /* bitsize */
1236          FALSE,                 /* pc_relative */
1237          0,                     /* bitpos */
1238          complain_overflow_dont, /* complain_on_overflow */
1239          ppc64_elf_toc_reloc,   /* special_function */
1240          "R_PPC64_TOC16_LO_DS", /* name */
1241          FALSE,                 /* partial_inplace */
1242          0,                     /* src_mask */
1243          0xfffc,                /* dst_mask */
1244          FALSE),                /* pcrel_offset */
1245
1246   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1247   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1248   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1249          0,                     /* rightshift */
1250          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1251          16,                    /* bitsize */
1252          FALSE,                 /* pc_relative */
1253          0,                     /* bitpos */
1254          complain_overflow_signed, /* complain_on_overflow */
1255          ppc64_elf_unhandled_reloc, /* special_function */
1256          "R_PPC64_PLTGOT16_DS", /* name */
1257          FALSE,                 /* partial_inplace */
1258          0,                     /* src_mask */
1259          0xfffc,                /* dst_mask */
1260          FALSE),                /* pcrel_offset */
1261
1262   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1263   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1264   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1265          0,                     /* rightshift */
1266          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1267          16,                    /* bitsize */
1268          FALSE,                 /* pc_relative */
1269          0,                     /* bitpos */
1270          complain_overflow_dont, /* complain_on_overflow */
1271          ppc64_elf_unhandled_reloc, /* special_function */
1272          "R_PPC64_PLTGOT16_LO_DS",/* name */
1273          FALSE,                 /* partial_inplace */
1274          0,                     /* src_mask */
1275          0xfffc,                /* dst_mask */
1276          FALSE),                /* pcrel_offset */
1277
1278   /* Marker relocs for TLS.  */
1279   HOWTO (R_PPC64_TLS,
1280          0,                     /* rightshift */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          32,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC64_TLS",         /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0,                     /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   HOWTO (R_PPC64_TLSGD,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TLSGD",       /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   HOWTO (R_PPC64_TLSLD,
1308          0,                     /* rightshift */
1309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1310          32,                    /* bitsize */
1311          FALSE,                 /* pc_relative */
1312          0,                     /* bitpos */
1313          complain_overflow_dont, /* complain_on_overflow */
1314          bfd_elf_generic_reloc, /* special_function */
1315          "R_PPC64_TLSLD",       /* name */
1316          FALSE,                 /* partial_inplace */
1317          0,                     /* src_mask */
1318          0,                     /* dst_mask */
1319          FALSE),                /* pcrel_offset */
1320
1321   HOWTO (R_PPC64_TOCSAVE,
1322          0,                     /* rightshift */
1323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1324          32,                    /* bitsize */
1325          FALSE,                 /* pc_relative */
1326          0,                     /* bitpos */
1327          complain_overflow_dont, /* complain_on_overflow */
1328          bfd_elf_generic_reloc, /* special_function */
1329          "R_PPC64_TOCSAVE",     /* name */
1330          FALSE,                 /* partial_inplace */
1331          0,                     /* src_mask */
1332          0,                     /* dst_mask */
1333          FALSE),                /* pcrel_offset */
1334
1335   /* Computes the load module index of the load module that contains the
1336      definition of its TLS sym.  */
1337   HOWTO (R_PPC64_DTPMOD64,
1338          0,                     /* rightshift */
1339          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1340          64,                    /* bitsize */
1341          FALSE,                 /* pc_relative */
1342          0,                     /* bitpos */
1343          complain_overflow_dont, /* complain_on_overflow */
1344          ppc64_elf_unhandled_reloc, /* special_function */
1345          "R_PPC64_DTPMOD64",    /* name */
1346          FALSE,                 /* partial_inplace */
1347          0,                     /* src_mask */
1348          ONES (64),             /* dst_mask */
1349          FALSE),                /* pcrel_offset */
1350
1351   /* Computes a dtv-relative displacement, the difference between the value
1352      of sym+add and the base address of the thread-local storage block that
1353      contains the definition of sym, minus 0x8000.  */
1354   HOWTO (R_PPC64_DTPREL64,
1355          0,                     /* rightshift */
1356          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1357          64,                    /* bitsize */
1358          FALSE,                 /* pc_relative */
1359          0,                     /* bitpos */
1360          complain_overflow_dont, /* complain_on_overflow */
1361          ppc64_elf_unhandled_reloc, /* special_function */
1362          "R_PPC64_DTPREL64",    /* name */
1363          FALSE,                 /* partial_inplace */
1364          0,                     /* src_mask */
1365          ONES (64),             /* dst_mask */
1366          FALSE),                /* pcrel_offset */
1367
1368   /* A 16 bit dtprel reloc.  */
1369   HOWTO (R_PPC64_DTPREL16,
1370          0,                     /* rightshift */
1371          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          16,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_signed, /* complain_on_overflow */
1376          ppc64_elf_unhandled_reloc, /* special_function */
1377          "R_PPC64_DTPREL16",    /* name */
1378          FALSE,                 /* partial_inplace */
1379          0,                     /* src_mask */
1380          0xffff,                /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   /* Like DTPREL16, but no overflow.  */
1384   HOWTO (R_PPC64_DTPREL16_LO,
1385          0,                     /* rightshift */
1386          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1387          16,                    /* bitsize */
1388          FALSE,                 /* pc_relative */
1389          0,                     /* bitpos */
1390          complain_overflow_dont, /* complain_on_overflow */
1391          ppc64_elf_unhandled_reloc, /* special_function */
1392          "R_PPC64_DTPREL16_LO", /* name */
1393          FALSE,                 /* partial_inplace */
1394          0,                     /* src_mask */
1395          0xffff,                /* dst_mask */
1396          FALSE),                /* pcrel_offset */
1397
1398   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1399   HOWTO (R_PPC64_DTPREL16_HI,
1400          16,                    /* rightshift */
1401          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1402          16,                    /* bitsize */
1403          FALSE,                 /* pc_relative */
1404          0,                     /* bitpos */
1405          complain_overflow_signed, /* complain_on_overflow */
1406          ppc64_elf_unhandled_reloc, /* special_function */
1407          "R_PPC64_DTPREL16_HI", /* name */
1408          FALSE,                 /* partial_inplace */
1409          0,                     /* src_mask */
1410          0xffff,                /* dst_mask */
1411          FALSE),                /* pcrel_offset */
1412
1413   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1414   HOWTO (R_PPC64_DTPREL16_HA,
1415          16,                    /* rightshift */
1416          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1417          16,                    /* bitsize */
1418          FALSE,                 /* pc_relative */
1419          0,                     /* bitpos */
1420          complain_overflow_signed, /* complain_on_overflow */
1421          ppc64_elf_unhandled_reloc, /* special_function */
1422          "R_PPC64_DTPREL16_HA", /* name */
1423          FALSE,                 /* partial_inplace */
1424          0,                     /* src_mask */
1425          0xffff,                /* dst_mask */
1426          FALSE),                /* pcrel_offset */
1427
1428   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1429   HOWTO (R_PPC64_DTPREL16_HIGHER,
1430          32,                    /* rightshift */
1431          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          16,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_dont, /* complain_on_overflow */
1436          ppc64_elf_unhandled_reloc, /* special_function */
1437          "R_PPC64_DTPREL16_HIGHER", /* name */
1438          FALSE,                 /* partial_inplace */
1439          0,                     /* src_mask */
1440          0xffff,                /* dst_mask */
1441          FALSE),                /* pcrel_offset */
1442
1443   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1444   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1445          32,                    /* rightshift */
1446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1447          16,                    /* bitsize */
1448          FALSE,                 /* pc_relative */
1449          0,                     /* bitpos */
1450          complain_overflow_dont, /* complain_on_overflow */
1451          ppc64_elf_unhandled_reloc, /* special_function */
1452          "R_PPC64_DTPREL16_HIGHERA", /* name */
1453          FALSE,                 /* partial_inplace */
1454          0,                     /* src_mask */
1455          0xffff,                /* dst_mask */
1456          FALSE),                /* pcrel_offset */
1457
1458   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1459   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1460          48,                    /* rightshift */
1461          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1462          16,                    /* bitsize */
1463          FALSE,                 /* pc_relative */
1464          0,                     /* bitpos */
1465          complain_overflow_dont, /* complain_on_overflow */
1466          ppc64_elf_unhandled_reloc, /* special_function */
1467          "R_PPC64_DTPREL16_HIGHEST", /* name */
1468          FALSE,                 /* partial_inplace */
1469          0,                     /* src_mask */
1470          0xffff,                /* dst_mask */
1471          FALSE),                /* pcrel_offset */
1472
1473   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1474   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1475          48,                    /* rightshift */
1476          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1477          16,                    /* bitsize */
1478          FALSE,                 /* pc_relative */
1479          0,                     /* bitpos */
1480          complain_overflow_dont, /* complain_on_overflow */
1481          ppc64_elf_unhandled_reloc, /* special_function */
1482          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1483          FALSE,                 /* partial_inplace */
1484          0,                     /* src_mask */
1485          0xffff,                /* dst_mask */
1486          FALSE),                /* pcrel_offset */
1487
1488   /* Like DTPREL16, but for insns with a DS field.  */
1489   HOWTO (R_PPC64_DTPREL16_DS,
1490          0,                     /* rightshift */
1491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1492          16,                    /* bitsize */
1493          FALSE,                 /* pc_relative */
1494          0,                     /* bitpos */
1495          complain_overflow_signed, /* complain_on_overflow */
1496          ppc64_elf_unhandled_reloc, /* special_function */
1497          "R_PPC64_DTPREL16_DS", /* name */
1498          FALSE,                 /* partial_inplace */
1499          0,                     /* src_mask */
1500          0xfffc,                /* dst_mask */
1501          FALSE),                /* pcrel_offset */
1502
1503   /* Like DTPREL16_DS, but no overflow.  */
1504   HOWTO (R_PPC64_DTPREL16_LO_DS,
1505          0,                     /* rightshift */
1506          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1507          16,                    /* bitsize */
1508          FALSE,                 /* pc_relative */
1509          0,                     /* bitpos */
1510          complain_overflow_dont, /* complain_on_overflow */
1511          ppc64_elf_unhandled_reloc, /* special_function */
1512          "R_PPC64_DTPREL16_LO_DS", /* name */
1513          FALSE,                 /* partial_inplace */
1514          0,                     /* src_mask */
1515          0xfffc,                /* dst_mask */
1516          FALSE),                /* pcrel_offset */
1517
1518   /* Computes a tp-relative displacement, the difference between the value of
1519      sym+add and the value of the thread pointer (r13).  */
1520   HOWTO (R_PPC64_TPREL64,
1521          0,                     /* rightshift */
1522          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1523          64,                    /* bitsize */
1524          FALSE,                 /* pc_relative */
1525          0,                     /* bitpos */
1526          complain_overflow_dont, /* complain_on_overflow */
1527          ppc64_elf_unhandled_reloc, /* special_function */
1528          "R_PPC64_TPREL64",     /* name */
1529          FALSE,                 /* partial_inplace */
1530          0,                     /* src_mask */
1531          ONES (64),             /* dst_mask */
1532          FALSE),                /* pcrel_offset */
1533
1534   /* A 16 bit tprel reloc.  */
1535   HOWTO (R_PPC64_TPREL16,
1536          0,                     /* rightshift */
1537          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          16,                    /* bitsize */
1539          FALSE,                 /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_signed, /* complain_on_overflow */
1542          ppc64_elf_unhandled_reloc, /* special_function */
1543          "R_PPC64_TPREL16",     /* name */
1544          FALSE,                 /* partial_inplace */
1545          0,                     /* src_mask */
1546          0xffff,                /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   /* Like TPREL16, but no overflow.  */
1550   HOWTO (R_PPC64_TPREL16_LO,
1551          0,                     /* rightshift */
1552          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1553          16,                    /* bitsize */
1554          FALSE,                 /* pc_relative */
1555          0,                     /* bitpos */
1556          complain_overflow_dont, /* complain_on_overflow */
1557          ppc64_elf_unhandled_reloc, /* special_function */
1558          "R_PPC64_TPREL16_LO",  /* name */
1559          FALSE,                 /* partial_inplace */
1560          0,                     /* src_mask */
1561          0xffff,                /* dst_mask */
1562          FALSE),                /* pcrel_offset */
1563
1564   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1565   HOWTO (R_PPC64_TPREL16_HI,
1566          16,                    /* rightshift */
1567          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1568          16,                    /* bitsize */
1569          FALSE,                 /* pc_relative */
1570          0,                     /* bitpos */
1571          complain_overflow_signed, /* complain_on_overflow */
1572          ppc64_elf_unhandled_reloc, /* special_function */
1573          "R_PPC64_TPREL16_HI",  /* name */
1574          FALSE,                 /* partial_inplace */
1575          0,                     /* src_mask */
1576          0xffff,                /* dst_mask */
1577          FALSE),                /* pcrel_offset */
1578
1579   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1580   HOWTO (R_PPC64_TPREL16_HA,
1581          16,                    /* rightshift */
1582          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1583          16,                    /* bitsize */
1584          FALSE,                 /* pc_relative */
1585          0,                     /* bitpos */
1586          complain_overflow_signed, /* complain_on_overflow */
1587          ppc64_elf_unhandled_reloc, /* special_function */
1588          "R_PPC64_TPREL16_HA",  /* name */
1589          FALSE,                 /* partial_inplace */
1590          0,                     /* src_mask */
1591          0xffff,                /* dst_mask */
1592          FALSE),                /* pcrel_offset */
1593
1594   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1595   HOWTO (R_PPC64_TPREL16_HIGHER,
1596          32,                    /* rightshift */
1597          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1598          16,                    /* bitsize */
1599          FALSE,                 /* pc_relative */
1600          0,                     /* bitpos */
1601          complain_overflow_dont, /* complain_on_overflow */
1602          ppc64_elf_unhandled_reloc, /* special_function */
1603          "R_PPC64_TPREL16_HIGHER",      /* name */
1604          FALSE,                 /* partial_inplace */
1605          0,                     /* src_mask */
1606          0xffff,                /* dst_mask */
1607          FALSE),                /* pcrel_offset */
1608
1609   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1610   HOWTO (R_PPC64_TPREL16_HIGHERA,
1611          32,                    /* rightshift */
1612          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1613          16,                    /* bitsize */
1614          FALSE,                 /* pc_relative */
1615          0,                     /* bitpos */
1616          complain_overflow_dont, /* complain_on_overflow */
1617          ppc64_elf_unhandled_reloc, /* special_function */
1618          "R_PPC64_TPREL16_HIGHERA", /* name */
1619          FALSE,                 /* partial_inplace */
1620          0,                     /* src_mask */
1621          0xffff,                /* dst_mask */
1622          FALSE),                /* pcrel_offset */
1623
1624   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1625   HOWTO (R_PPC64_TPREL16_HIGHEST,
1626          48,                    /* rightshift */
1627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                    /* bitsize */
1629          FALSE,                 /* pc_relative */
1630          0,                     /* bitpos */
1631          complain_overflow_dont, /* complain_on_overflow */
1632          ppc64_elf_unhandled_reloc, /* special_function */
1633          "R_PPC64_TPREL16_HIGHEST", /* name */
1634          FALSE,                 /* partial_inplace */
1635          0,                     /* src_mask */
1636          0xffff,                /* dst_mask */
1637          FALSE),                /* pcrel_offset */
1638
1639   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1640   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1641          48,                    /* rightshift */
1642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          16,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont, /* complain_on_overflow */
1647          ppc64_elf_unhandled_reloc, /* special_function */
1648          "R_PPC64_TPREL16_HIGHESTA", /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0xffff,                /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* Like TPREL16, but for insns with a DS field.  */
1655   HOWTO (R_PPC64_TPREL16_DS,
1656          0,                     /* rightshift */
1657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1658          16,                    /* bitsize */
1659          FALSE,                 /* pc_relative */
1660          0,                     /* bitpos */
1661          complain_overflow_signed, /* complain_on_overflow */
1662          ppc64_elf_unhandled_reloc, /* special_function */
1663          "R_PPC64_TPREL16_DS",  /* name */
1664          FALSE,                 /* partial_inplace */
1665          0,                     /* src_mask */
1666          0xfffc,                /* dst_mask */
1667          FALSE),                /* pcrel_offset */
1668
1669   /* Like TPREL16_DS, but no overflow.  */
1670   HOWTO (R_PPC64_TPREL16_LO_DS,
1671          0,                     /* rightshift */
1672          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1673          16,                    /* bitsize */
1674          FALSE,                 /* pc_relative */
1675          0,                     /* bitpos */
1676          complain_overflow_dont, /* complain_on_overflow */
1677          ppc64_elf_unhandled_reloc, /* special_function */
1678          "R_PPC64_TPREL16_LO_DS", /* name */
1679          FALSE,                 /* partial_inplace */
1680          0,                     /* src_mask */
1681          0xfffc,                /* dst_mask */
1682          FALSE),                /* pcrel_offset */
1683
1684   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1685      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1686      to the first entry relative to the TOC base (r2).  */
1687   HOWTO (R_PPC64_GOT_TLSGD16,
1688          0,                     /* rightshift */
1689          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1690          16,                    /* bitsize */
1691          FALSE,                 /* pc_relative */
1692          0,                     /* bitpos */
1693          complain_overflow_signed, /* complain_on_overflow */
1694          ppc64_elf_unhandled_reloc, /* special_function */
1695          "R_PPC64_GOT_TLSGD16", /* name */
1696          FALSE,                 /* partial_inplace */
1697          0,                     /* src_mask */
1698          0xffff,                /* dst_mask */
1699          FALSE),                /* pcrel_offset */
1700
1701   /* Like GOT_TLSGD16, but no overflow.  */
1702   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1703          0,                     /* rightshift */
1704          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1705          16,                    /* bitsize */
1706          FALSE,                 /* pc_relative */
1707          0,                     /* bitpos */
1708          complain_overflow_dont, /* complain_on_overflow */
1709          ppc64_elf_unhandled_reloc, /* special_function */
1710          "R_PPC64_GOT_TLSGD16_LO", /* name */
1711          FALSE,                 /* partial_inplace */
1712          0,                     /* src_mask */
1713          0xffff,                /* dst_mask */
1714          FALSE),                /* pcrel_offset */
1715
1716   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1717   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1718          16,                    /* rightshift */
1719          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1720          16,                    /* bitsize */
1721          FALSE,                 /* pc_relative */
1722          0,                     /* bitpos */
1723          complain_overflow_signed, /* complain_on_overflow */
1724          ppc64_elf_unhandled_reloc, /* special_function */
1725          "R_PPC64_GOT_TLSGD16_HI", /* name */
1726          FALSE,                 /* partial_inplace */
1727          0,                     /* src_mask */
1728          0xffff,                /* dst_mask */
1729          FALSE),                /* pcrel_offset */
1730
1731   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1732   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1733          16,                    /* rightshift */
1734          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1735          16,                    /* bitsize */
1736          FALSE,                 /* pc_relative */
1737          0,                     /* bitpos */
1738          complain_overflow_signed, /* complain_on_overflow */
1739          ppc64_elf_unhandled_reloc, /* special_function */
1740          "R_PPC64_GOT_TLSGD16_HA", /* name */
1741          FALSE,                 /* partial_inplace */
1742          0,                     /* src_mask */
1743          0xffff,                /* dst_mask */
1744          FALSE),                /* pcrel_offset */
1745
1746   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1747      with values (sym+add)@dtpmod and zero, and computes the offset to the
1748      first entry relative to the TOC base (r2).  */
1749   HOWTO (R_PPC64_GOT_TLSLD16,
1750          0,                     /* rightshift */
1751          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1752          16,                    /* bitsize */
1753          FALSE,                 /* pc_relative */
1754          0,                     /* bitpos */
1755          complain_overflow_signed, /* complain_on_overflow */
1756          ppc64_elf_unhandled_reloc, /* special_function */
1757          "R_PPC64_GOT_TLSLD16", /* name */
1758          FALSE,                 /* partial_inplace */
1759          0,                     /* src_mask */
1760          0xffff,                /* dst_mask */
1761          FALSE),                /* pcrel_offset */
1762
1763   /* Like GOT_TLSLD16, but no overflow.  */
1764   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1765          0,                     /* rightshift */
1766          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1767          16,                    /* bitsize */
1768          FALSE,                 /* pc_relative */
1769          0,                     /* bitpos */
1770          complain_overflow_dont, /* complain_on_overflow */
1771          ppc64_elf_unhandled_reloc, /* special_function */
1772          "R_PPC64_GOT_TLSLD16_LO", /* name */
1773          FALSE,                 /* partial_inplace */
1774          0,                     /* src_mask */
1775          0xffff,                /* dst_mask */
1776          FALSE),                /* pcrel_offset */
1777
1778   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1779   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1780          16,                    /* rightshift */
1781          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1782          16,                    /* bitsize */
1783          FALSE,                 /* pc_relative */
1784          0,                     /* bitpos */
1785          complain_overflow_signed, /* complain_on_overflow */
1786          ppc64_elf_unhandled_reloc, /* special_function */
1787          "R_PPC64_GOT_TLSLD16_HI", /* name */
1788          FALSE,                 /* partial_inplace */
1789          0,                     /* src_mask */
1790          0xffff,                /* dst_mask */
1791          FALSE),                /* pcrel_offset */
1792
1793   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1794   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1795          16,                    /* rightshift */
1796          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1797          16,                    /* bitsize */
1798          FALSE,                 /* pc_relative */
1799          0,                     /* bitpos */
1800          complain_overflow_signed, /* complain_on_overflow */
1801          ppc64_elf_unhandled_reloc, /* special_function */
1802          "R_PPC64_GOT_TLSLD16_HA", /* name */
1803          FALSE,                 /* partial_inplace */
1804          0,                     /* src_mask */
1805          0xffff,                /* dst_mask */
1806          FALSE),                /* pcrel_offset */
1807
1808   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1809      the offset to the entry relative to the TOC base (r2).  */
1810   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1811          0,                     /* rightshift */
1812          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1813          16,                    /* bitsize */
1814          FALSE,                 /* pc_relative */
1815          0,                     /* bitpos */
1816          complain_overflow_signed, /* complain_on_overflow */
1817          ppc64_elf_unhandled_reloc, /* special_function */
1818          "R_PPC64_GOT_DTPREL16_DS", /* name */
1819          FALSE,                 /* partial_inplace */
1820          0,                     /* src_mask */
1821          0xfffc,                /* dst_mask */
1822          FALSE),                /* pcrel_offset */
1823
1824   /* Like GOT_DTPREL16_DS, but no overflow.  */
1825   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1826          0,                     /* rightshift */
1827          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1828          16,                    /* bitsize */
1829          FALSE,                 /* pc_relative */
1830          0,                     /* bitpos */
1831          complain_overflow_dont, /* complain_on_overflow */
1832          ppc64_elf_unhandled_reloc, /* special_function */
1833          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1834          FALSE,                 /* partial_inplace */
1835          0,                     /* src_mask */
1836          0xfffc,                /* dst_mask */
1837          FALSE),                /* pcrel_offset */
1838
1839   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1840   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1841          16,                    /* rightshift */
1842          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1843          16,                    /* bitsize */
1844          FALSE,                 /* pc_relative */
1845          0,                     /* bitpos */
1846          complain_overflow_signed, /* complain_on_overflow */
1847          ppc64_elf_unhandled_reloc, /* special_function */
1848          "R_PPC64_GOT_DTPREL16_HI", /* name */
1849          FALSE,                 /* partial_inplace */
1850          0,                     /* src_mask */
1851          0xffff,                /* dst_mask */
1852          FALSE),                /* pcrel_offset */
1853
1854   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1855   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1856          16,                    /* rightshift */
1857          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1858          16,                    /* bitsize */
1859          FALSE,                 /* pc_relative */
1860          0,                     /* bitpos */
1861          complain_overflow_signed, /* complain_on_overflow */
1862          ppc64_elf_unhandled_reloc, /* special_function */
1863          "R_PPC64_GOT_DTPREL16_HA", /* name */
1864          FALSE,                 /* partial_inplace */
1865          0,                     /* src_mask */
1866          0xffff,                /* dst_mask */
1867          FALSE),                /* pcrel_offset */
1868
1869   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1870      offset to the entry relative to the TOC base (r2).  */
1871   HOWTO (R_PPC64_GOT_TPREL16_DS,
1872          0,                     /* rightshift */
1873          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1874          16,                    /* bitsize */
1875          FALSE,                 /* pc_relative */
1876          0,                     /* bitpos */
1877          complain_overflow_signed, /* complain_on_overflow */
1878          ppc64_elf_unhandled_reloc, /* special_function */
1879          "R_PPC64_GOT_TPREL16_DS", /* name */
1880          FALSE,                 /* partial_inplace */
1881          0,                     /* src_mask */
1882          0xfffc,                /* dst_mask */
1883          FALSE),                /* pcrel_offset */
1884
1885   /* Like GOT_TPREL16_DS, but no overflow.  */
1886   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1887          0,                     /* rightshift */
1888          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1889          16,                    /* bitsize */
1890          FALSE,                 /* pc_relative */
1891          0,                     /* bitpos */
1892          complain_overflow_dont, /* complain_on_overflow */
1893          ppc64_elf_unhandled_reloc, /* special_function */
1894          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1895          FALSE,                 /* partial_inplace */
1896          0,                     /* src_mask */
1897          0xfffc,                /* dst_mask */
1898          FALSE),                /* pcrel_offset */
1899
1900   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1901   HOWTO (R_PPC64_GOT_TPREL16_HI,
1902          16,                    /* rightshift */
1903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1904          16,                    /* bitsize */
1905          FALSE,                 /* pc_relative */
1906          0,                     /* bitpos */
1907          complain_overflow_signed, /* complain_on_overflow */
1908          ppc64_elf_unhandled_reloc, /* special_function */
1909          "R_PPC64_GOT_TPREL16_HI", /* name */
1910          FALSE,                 /* partial_inplace */
1911          0,                     /* src_mask */
1912          0xffff,                /* dst_mask */
1913          FALSE),                /* pcrel_offset */
1914
1915   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1916   HOWTO (R_PPC64_GOT_TPREL16_HA,
1917          16,                    /* rightshift */
1918          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1919          16,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_signed, /* complain_on_overflow */
1923          ppc64_elf_unhandled_reloc, /* special_function */
1924          "R_PPC64_GOT_TPREL16_HA", /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          0xffff,                /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   HOWTO (R_PPC64_JMP_IREL,      /* type */
1931          0,                     /* rightshift */
1932          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1933          0,                     /* bitsize */
1934          FALSE,                 /* pc_relative */
1935          0,                     /* bitpos */
1936          complain_overflow_dont, /* complain_on_overflow */
1937          ppc64_elf_unhandled_reloc, /* special_function */
1938          "R_PPC64_JMP_IREL",    /* name */
1939          FALSE,                 /* partial_inplace */
1940          0,                     /* src_mask */
1941          0,                     /* dst_mask */
1942          FALSE),                /* pcrel_offset */
1943
1944   HOWTO (R_PPC64_IRELATIVE,     /* type */
1945          0,                     /* rightshift */
1946          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947          64,                    /* bitsize */
1948          FALSE,                 /* pc_relative */
1949          0,                     /* bitpos */
1950          complain_overflow_dont, /* complain_on_overflow */
1951          bfd_elf_generic_reloc, /* special_function */
1952          "R_PPC64_IRELATIVE",   /* name */
1953          FALSE,                 /* partial_inplace */
1954          0,                     /* src_mask */
1955          ONES (64),             /* dst_mask */
1956          FALSE),                /* pcrel_offset */
1957
1958   /* A 16 bit relative relocation.  */
1959   HOWTO (R_PPC64_REL16,         /* type */
1960          0,                     /* rightshift */
1961          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1962          16,                    /* bitsize */
1963          TRUE,                  /* pc_relative */
1964          0,                     /* bitpos */
1965          complain_overflow_signed, /* complain_on_overflow */
1966          bfd_elf_generic_reloc, /* special_function */
1967          "R_PPC64_REL16",       /* name */
1968          FALSE,                 /* partial_inplace */
1969          0,                     /* src_mask */
1970          0xffff,                /* dst_mask */
1971          TRUE),                 /* pcrel_offset */
1972
1973   /* A 16 bit relative relocation without overflow.  */
1974   HOWTO (R_PPC64_REL16_LO,      /* type */
1975          0,                     /* rightshift */
1976          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1977          16,                    /* bitsize */
1978          TRUE,                  /* pc_relative */
1979          0,                     /* bitpos */
1980          complain_overflow_dont,/* complain_on_overflow */
1981          bfd_elf_generic_reloc, /* special_function */
1982          "R_PPC64_REL16_LO",    /* name */
1983          FALSE,                 /* partial_inplace */
1984          0,                     /* src_mask */
1985          0xffff,                /* dst_mask */
1986          TRUE),                 /* pcrel_offset */
1987
1988   /* The high order 16 bits of a relative address.  */
1989   HOWTO (R_PPC64_REL16_HI,      /* type */
1990          16,                    /* rightshift */
1991          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1992          16,                    /* bitsize */
1993          TRUE,                  /* pc_relative */
1994          0,                     /* bitpos */
1995          complain_overflow_signed, /* complain_on_overflow */
1996          bfd_elf_generic_reloc, /* special_function */
1997          "R_PPC64_REL16_HI",    /* name */
1998          FALSE,                 /* partial_inplace */
1999          0,                     /* src_mask */
2000          0xffff,                /* dst_mask */
2001          TRUE),                 /* pcrel_offset */
2002
2003   /* The high order 16 bits of a relative address, plus 1 if the contents of
2004      the low 16 bits, treated as a signed number, is negative.  */
2005   HOWTO (R_PPC64_REL16_HA,      /* type */
2006          16,                    /* rightshift */
2007          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2008          16,                    /* bitsize */
2009          TRUE,                  /* pc_relative */
2010          0,                     /* bitpos */
2011          complain_overflow_signed, /* complain_on_overflow */
2012          ppc64_elf_ha_reloc,    /* special_function */
2013          "R_PPC64_REL16_HA",    /* name */
2014          FALSE,                 /* partial_inplace */
2015          0,                     /* src_mask */
2016          0xffff,                /* dst_mask */
2017          TRUE),                 /* pcrel_offset */
2018
2019   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2020   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2021          16,                    /* rightshift */
2022          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2023          16,                    /* bitsize */
2024          FALSE,                 /* pc_relative */
2025          0,                     /* bitpos */
2026          complain_overflow_dont, /* complain_on_overflow */
2027          bfd_elf_generic_reloc, /* special_function */
2028          "R_PPC64_ADDR16_HIGH", /* name */
2029          FALSE,                 /* partial_inplace */
2030          0,                     /* src_mask */
2031          0xffff,                /* dst_mask */
2032          FALSE),                /* pcrel_offset */
2033
2034   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2035   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2036          16,                    /* rightshift */
2037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2038          16,                    /* bitsize */
2039          FALSE,                 /* pc_relative */
2040          0,                     /* bitpos */
2041          complain_overflow_dont, /* complain_on_overflow */
2042          ppc64_elf_ha_reloc,    /* special_function */
2043          "R_PPC64_ADDR16_HIGHA",        /* name */
2044          FALSE,                 /* partial_inplace */
2045          0,                     /* src_mask */
2046          0xffff,                /* dst_mask */
2047          FALSE),                /* pcrel_offset */
2048
2049   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2050   HOWTO (R_PPC64_DTPREL16_HIGH,
2051          16,                    /* rightshift */
2052          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2053          16,                    /* bitsize */
2054          FALSE,                 /* pc_relative */
2055          0,                     /* bitpos */
2056          complain_overflow_dont, /* complain_on_overflow */
2057          ppc64_elf_unhandled_reloc, /* special_function */
2058          "R_PPC64_DTPREL16_HIGH", /* name */
2059          FALSE,                 /* partial_inplace */
2060          0,                     /* src_mask */
2061          0xffff,                /* dst_mask */
2062          FALSE),                /* pcrel_offset */
2063
2064   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2065   HOWTO (R_PPC64_DTPREL16_HIGHA,
2066          16,                    /* rightshift */
2067          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2068          16,                    /* bitsize */
2069          FALSE,                 /* pc_relative */
2070          0,                     /* bitpos */
2071          complain_overflow_dont, /* complain_on_overflow */
2072          ppc64_elf_unhandled_reloc, /* special_function */
2073          "R_PPC64_DTPREL16_HIGHA", /* name */
2074          FALSE,                 /* partial_inplace */
2075          0,                     /* src_mask */
2076          0xffff,                /* dst_mask */
2077          FALSE),                /* pcrel_offset */
2078
2079   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2080   HOWTO (R_PPC64_TPREL16_HIGH,
2081          16,                    /* rightshift */
2082          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2083          16,                    /* bitsize */
2084          FALSE,                 /* pc_relative */
2085          0,                     /* bitpos */
2086          complain_overflow_dont, /* complain_on_overflow */
2087          ppc64_elf_unhandled_reloc, /* special_function */
2088          "R_PPC64_TPREL16_HIGH",        /* name */
2089          FALSE,                 /* partial_inplace */
2090          0,                     /* src_mask */
2091          0xffff,                /* dst_mask */
2092          FALSE),                /* pcrel_offset */
2093
2094   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2095   HOWTO (R_PPC64_TPREL16_HIGHA,
2096          16,                    /* rightshift */
2097          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2098          16,                    /* bitsize */
2099          FALSE,                 /* pc_relative */
2100          0,                     /* bitpos */
2101          complain_overflow_dont, /* complain_on_overflow */
2102          ppc64_elf_unhandled_reloc, /* special_function */
2103          "R_PPC64_TPREL16_HIGHA",       /* name */
2104          FALSE,                 /* partial_inplace */
2105          0,                     /* src_mask */
2106          0xffff,                /* dst_mask */
2107          FALSE),                /* pcrel_offset */
2108
2109   /* Like ADDR64, but use local entry point of function.  */
2110   HOWTO (R_PPC64_ADDR64_LOCAL,  /* type */
2111          0,                     /* rightshift */
2112          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2113          64,                    /* bitsize */
2114          FALSE,                 /* pc_relative */
2115          0,                     /* bitpos */
2116          complain_overflow_dont, /* complain_on_overflow */
2117          bfd_elf_generic_reloc, /* special_function */
2118          "R_PPC64_ADDR64_LOCAL", /* name */
2119          FALSE,                 /* partial_inplace */
2120          0,                     /* src_mask */
2121          ONES (64),             /* dst_mask */
2122          FALSE),                /* pcrel_offset */
2123
2124   /* GNU extension to record C++ vtable hierarchy.  */
2125   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2126          0,                     /* rightshift */
2127          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2128          0,                     /* bitsize */
2129          FALSE,                 /* pc_relative */
2130          0,                     /* bitpos */
2131          complain_overflow_dont, /* complain_on_overflow */
2132          NULL,                  /* special_function */
2133          "R_PPC64_GNU_VTINHERIT", /* name */
2134          FALSE,                 /* partial_inplace */
2135          0,                     /* src_mask */
2136          0,                     /* dst_mask */
2137          FALSE),                /* pcrel_offset */
2138
2139   /* GNU extension to record C++ vtable member usage.  */
2140   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2141          0,                     /* rightshift */
2142          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2143          0,                     /* bitsize */
2144          FALSE,                 /* pc_relative */
2145          0,                     /* bitpos */
2146          complain_overflow_dont, /* complain_on_overflow */
2147          NULL,                  /* special_function */
2148          "R_PPC64_GNU_VTENTRY", /* name */
2149          FALSE,                 /* partial_inplace */
2150          0,                     /* src_mask */
2151          0,                     /* dst_mask */
2152          FALSE),                /* pcrel_offset */
2153 };
2154
2155 \f
2156 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2157    be done.  */
2158
2159 static void
2160 ppc_howto_init (void)
2161 {
2162   unsigned int i, type;
2163
2164   for (i = 0;
2165        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2166        i++)
2167     {
2168       type = ppc64_elf_howto_raw[i].type;
2169       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2170                           / sizeof (ppc64_elf_howto_table[0])));
2171       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2172     }
2173 }
2174
2175 static reloc_howto_type *
2176 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2177                              bfd_reloc_code_real_type code)
2178 {
2179   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2180
2181   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2182     /* Initialize howto table if needed.  */
2183     ppc_howto_init ();
2184
2185   switch (code)
2186     {
2187     default:
2188       return NULL;
2189
2190     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2191       break;
2192     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2193       break;
2194     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2195       break;
2196     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2197       break;
2198     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2199       break;
2200     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2201       break;
2202     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2203       break;
2204     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2205       break;
2206     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2207       break;
2208     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2209       break;
2210     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2211       break;
2212     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2213       break;
2214     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2215       break;
2216     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2217       break;
2218     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2219       break;
2220     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2221       break;
2222     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2223       break;
2224     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2225       break;
2226     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2227       break;
2228     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2229       break;
2230     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2231       break;
2232     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2233       break;
2234     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2235       break;
2236     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2237       break;
2238     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2239       break;
2240     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2241       break;
2242     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2243       break;
2244     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2245       break;
2246     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2247       break;
2248     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2249       break;
2250     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2251       break;
2252     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2253       break;
2254     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2255       break;
2256     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2257       break;
2258     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2259       break;
2260     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2261       break;
2262     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2263       break;
2264     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2265       break;
2266     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2267       break;
2268     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2269       break;
2270     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2271       break;
2272     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2273       break;
2274     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2275       break;
2276     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2279       break;
2280     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2285       break;
2286     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2287       break;
2288     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2289       break;
2290     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2291       break;
2292     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2293       break;
2294     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2295       break;
2296     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2297       break;
2298     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2299       break;
2300     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2301       break;
2302     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2303       break;
2304     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2305       break;
2306     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2307       break;
2308     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2309       break;
2310     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2311       break;
2312     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2313       break;
2314     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2315       break;
2316     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2317       break;
2318     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2319       break;
2320     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2321       break;
2322     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2323       break;
2324     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2325       break;
2326     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2327       break;
2328     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2329       break;
2330     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2331       break;
2332     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2333       break;
2334     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2335       break;
2336     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2337       break;
2338     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2339       break;
2340     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2341       break;
2342     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2343       break;
2344     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2345       break;
2346     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2347       break;
2348     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2349       break;
2350     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2351       break;
2352     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2353       break;
2354     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2355       break;
2356     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2357       break;
2358     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2359       break;
2360     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2361       break;
2362     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2363       break;
2364     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2365       break;
2366     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2367       break;
2368     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2369       break;
2370     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2371       break;
2372     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2373       break;
2374     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2375       break;
2376     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2377       break;
2378     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2379       break;
2380     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2381       break;
2382     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2383       break;
2384     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2385       break;
2386     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2387       break;
2388     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2389       break;
2390     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2391       break;
2392     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2393       break;
2394     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2395       break;
2396     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2397       break;
2398     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2399       break;
2400     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2401       break;
2402     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2403       break;
2404     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2405       break;
2406     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2407       break;
2408     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2409       break;
2410     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2411       break;
2412     case BFD_RELOC_PPC64_ADDR64_LOCAL:          r = R_PPC64_ADDR64_LOCAL;
2413       break;
2414     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2415       break;
2416     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2417       break;
2418     }
2419
2420   return ppc64_elf_howto_table[r];
2421 };
2422
2423 static reloc_howto_type *
2424 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2425                              const char *r_name)
2426 {
2427   unsigned int i;
2428
2429   for (i = 0;
2430        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2431        i++)
2432     if (ppc64_elf_howto_raw[i].name != NULL
2433         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2434       return &ppc64_elf_howto_raw[i];
2435
2436   return NULL;
2437 }
2438
2439 /* Set the howto pointer for a PowerPC ELF reloc.  */
2440
2441 static void
2442 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2443                          Elf_Internal_Rela *dst)
2444 {
2445   unsigned int type;
2446
2447   /* Initialize howto table if needed.  */
2448   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2449     ppc_howto_init ();
2450
2451   type = ELF64_R_TYPE (dst->r_info);
2452   if (type >= (sizeof (ppc64_elf_howto_table)
2453                / sizeof (ppc64_elf_howto_table[0])))
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     struct _opd_sec_data
2959     {
2960       /* Points to the function code section for local opd entries.  */
2961       asection **func_sec;
2962
2963       /* After editing .opd, adjust references to opd local syms.  */
2964       long *adjust;
2965     } opd;
2966
2967     /* An array for toc sections, indexed by offset/8.  */
2968     struct _toc_sec_data
2969     {
2970       /* Specifies the relocation symbol index used at a given toc offset.  */
2971       unsigned *symndx;
2972
2973       /* And the relocation addend.  */
2974       bfd_vma *add;
2975     } toc;
2976   } u;
2977
2978   enum _ppc64_sec_type sec_type:2;
2979
2980   /* Flag set when small branches are detected.  Used to
2981      select suitable defaults for the stub group size.  */
2982   unsigned int has_14bit_branch:1;
2983 };
2984
2985 #define ppc64_elf_section_data(sec) \
2986   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2987
2988 static bfd_boolean
2989 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2990 {
2991   if (!sec->used_by_bfd)
2992     {
2993       struct _ppc64_elf_section_data *sdata;
2994       bfd_size_type amt = sizeof (*sdata);
2995
2996       sdata = bfd_zalloc (abfd, amt);
2997       if (sdata == NULL)
2998         return FALSE;
2999       sec->used_by_bfd = sdata;
3000     }
3001
3002   return _bfd_elf_new_section_hook (abfd, sec);
3003 }
3004
3005 static struct _opd_sec_data *
3006 get_opd_info (asection * sec)
3007 {
3008   if (sec != NULL
3009       && ppc64_elf_section_data (sec) != NULL
3010       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3011     return &ppc64_elf_section_data (sec)->u.opd;
3012   return NULL;
3013 }
3014 \f
3015 /* Parameters for the qsort hook.  */
3016 static bfd_boolean synthetic_relocatable;
3017
3018 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
3019
3020 static int
3021 compare_symbols (const void *ap, const void *bp)
3022 {
3023   const asymbol *a = * (const asymbol **) ap;
3024   const asymbol *b = * (const asymbol **) bp;
3025
3026   /* Section symbols first.  */
3027   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3028     return -1;
3029   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3030     return 1;
3031
3032   /* then .opd symbols.  */
3033   if (strcmp (a->section->name, ".opd") == 0
3034       && strcmp (b->section->name, ".opd") != 0)
3035     return -1;
3036   if (strcmp (a->section->name, ".opd") != 0
3037       && strcmp (b->section->name, ".opd") == 0)
3038     return 1;
3039
3040   /* then other code symbols.  */
3041   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3042       == (SEC_CODE | SEC_ALLOC)
3043       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044          != (SEC_CODE | SEC_ALLOC))
3045     return -1;
3046
3047   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048       != (SEC_CODE | SEC_ALLOC)
3049       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050          == (SEC_CODE | SEC_ALLOC))
3051     return 1;
3052
3053   if (synthetic_relocatable)
3054     {
3055       if (a->section->id < b->section->id)
3056         return -1;
3057
3058       if (a->section->id > b->section->id)
3059         return 1;
3060     }
3061
3062   if (a->value + a->section->vma < b->value + b->section->vma)
3063     return -1;
3064
3065   if (a->value + a->section->vma > b->value + b->section->vma)
3066     return 1;
3067
3068   /* For syms with the same value, prefer strong dynamic global function
3069      syms over other syms.  */
3070   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3071     return -1;
3072
3073   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3074     return 1;
3075
3076   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3077     return -1;
3078
3079   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3080     return 1;
3081
3082   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3083     return -1;
3084
3085   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3086     return 1;
3087
3088   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3089     return -1;
3090
3091   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3092     return 1;
3093
3094   return 0;
3095 }
3096
3097 /* Search SYMS for a symbol of the given VALUE.  */
3098
3099 static asymbol *
3100 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3101 {
3102   long mid;
3103
3104   if (id == -1)
3105     {
3106       while (lo < hi)
3107         {
3108           mid = (lo + hi) >> 1;
3109           if (syms[mid]->value + syms[mid]->section->vma < value)
3110             lo = mid + 1;
3111           else if (syms[mid]->value + syms[mid]->section->vma > value)
3112             hi = mid;
3113           else
3114             return syms[mid];
3115         }
3116     }
3117   else
3118     {
3119       while (lo < hi)
3120         {
3121           mid = (lo + hi) >> 1;
3122           if (syms[mid]->section->id < id)
3123             lo = mid + 1;
3124           else if (syms[mid]->section->id > id)
3125             hi = mid;
3126           else if (syms[mid]->value < value)
3127             lo = mid + 1;
3128           else if (syms[mid]->value > value)
3129             hi = mid;
3130           else
3131             return syms[mid];
3132         }
3133     }
3134   return NULL;
3135 }
3136
3137 static bfd_boolean
3138 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3139 {
3140   bfd_vma vma = *(bfd_vma *) ptr;
3141   return ((section->flags & SEC_ALLOC) != 0
3142           && section->vma <= vma
3143           && vma < section->vma + section->size);
3144 }
3145
3146 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3147    entry syms.  Also generate @plt symbols for the glink branch table.  */
3148
3149 static long
3150 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3151                                 long static_count, asymbol **static_syms,
3152                                 long dyn_count, asymbol **dyn_syms,
3153                                 asymbol **ret)
3154 {
3155   asymbol *s;
3156   long i;
3157   long count;
3158   char *names;
3159   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3160   asection *opd = NULL;
3161   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3162   asymbol **syms;
3163   int abi = abiversion (abfd);
3164
3165   *ret = NULL;
3166
3167   if (abi < 2)
3168     {
3169       opd = bfd_get_section_by_name (abfd, ".opd");
3170       if (opd == NULL && abi == 1)
3171         return 0;
3172     }
3173
3174   symcount = static_count;
3175   if (!relocatable)
3176     symcount += dyn_count;
3177   if (symcount == 0)
3178     return 0;
3179
3180   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3181   if (syms == NULL)
3182     return -1;
3183
3184   if (!relocatable && static_count != 0 && dyn_count != 0)
3185     {
3186       /* Use both symbol tables.  */
3187       memcpy (syms, static_syms, static_count * sizeof (*syms));
3188       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3189     }
3190   else if (!relocatable && static_count == 0)
3191     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3192   else
3193     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3194
3195   synthetic_relocatable = relocatable;
3196   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3197
3198   if (!relocatable && symcount > 1)
3199     {
3200       long j;
3201       /* Trim duplicate syms, since we may have merged the normal and
3202          dynamic symbols.  Actually, we only care about syms that have
3203          different values, so trim any with the same value.  */
3204       for (i = 1, j = 1; i < symcount; ++i)
3205         if (syms[i - 1]->value + syms[i - 1]->section->vma
3206             != syms[i]->value + syms[i]->section->vma)
3207           syms[j++] = syms[i];
3208       symcount = j;
3209     }
3210
3211   i = 0;
3212   if (strcmp (syms[i]->section->name, ".opd") == 0)
3213     ++i;
3214   codesecsym = i;
3215
3216   for (; i < symcount; ++i)
3217     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3218          != (SEC_CODE | SEC_ALLOC))
3219         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3220       break;
3221   codesecsymend = i;
3222
3223   for (; i < symcount; ++i)
3224     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3225       break;
3226   secsymend = i;
3227
3228   for (; i < symcount; ++i)
3229     if (strcmp (syms[i]->section->name, ".opd") != 0)
3230       break;
3231   opdsymend = i;
3232
3233   for (; i < symcount; ++i)
3234     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3235         != (SEC_CODE | SEC_ALLOC))
3236       break;
3237   symcount = i;
3238
3239   count = 0;
3240
3241   if (relocatable)
3242     {
3243       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3244       arelent *r;
3245       size_t size;
3246       long relcount;
3247
3248       if (opdsymend == secsymend)
3249         goto done;
3250
3251       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3252       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3253       if (relcount == 0)
3254         goto done;
3255
3256       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3257         {
3258           count = -1;
3259           goto done;
3260         }
3261
3262       size = 0;
3263       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3264         {
3265           asymbol *sym;
3266
3267           while (r < opd->relocation + relcount
3268                  && r->address < syms[i]->value + opd->vma)
3269             ++r;
3270
3271           if (r == opd->relocation + relcount)
3272             break;
3273
3274           if (r->address != syms[i]->value + opd->vma)
3275             continue;
3276
3277           if (r->howto->type != R_PPC64_ADDR64)
3278             continue;
3279
3280           sym = *r->sym_ptr_ptr;
3281           if (!sym_exists_at (syms, opdsymend, symcount,
3282                               sym->section->id, sym->value + r->addend))
3283             {
3284               ++count;
3285               size += sizeof (asymbol);
3286               size += strlen (syms[i]->name) + 2;
3287             }
3288         }
3289
3290       s = *ret = bfd_malloc (size);
3291       if (s == NULL)
3292         {
3293           count = -1;
3294           goto done;
3295         }
3296
3297       names = (char *) (s + count);
3298
3299       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3300         {
3301           asymbol *sym;
3302
3303           while (r < opd->relocation + relcount
3304                  && r->address < syms[i]->value + opd->vma)
3305             ++r;
3306
3307           if (r == opd->relocation + relcount)
3308             break;
3309
3310           if (r->address != syms[i]->value + opd->vma)
3311             continue;
3312
3313           if (r->howto->type != R_PPC64_ADDR64)
3314             continue;
3315
3316           sym = *r->sym_ptr_ptr;
3317           if (!sym_exists_at (syms, opdsymend, symcount,
3318                               sym->section->id, sym->value + r->addend))
3319             {
3320               size_t len;
3321
3322               *s = *syms[i];
3323               s->flags |= BSF_SYNTHETIC;
3324               s->section = sym->section;
3325               s->value = sym->value + r->addend;
3326               s->name = names;
3327               *names++ = '.';
3328               len = strlen (syms[i]->name);
3329               memcpy (names, syms[i]->name, len + 1);
3330               names += len + 1;
3331               /* Have udata.p point back to the original symbol this
3332                  synthetic symbol was derived from.  */
3333               s->udata.p = syms[i];
3334               s++;
3335             }
3336         }
3337     }
3338   else
3339     {
3340       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3341       bfd_byte *contents = NULL;
3342       size_t size;
3343       long plt_count = 0;
3344       bfd_vma glink_vma = 0, resolv_vma = 0;
3345       asection *dynamic, *glink = NULL, *relplt = NULL;
3346       arelent *p;
3347
3348       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3349         {
3350         free_contents_and_exit:
3351           if (contents)
3352             free (contents);
3353           count = -1;
3354           goto done;
3355         }
3356
3357       size = 0;
3358       for (i = secsymend; i < opdsymend; ++i)
3359         {
3360           bfd_vma ent;
3361
3362           /* Ignore bogus symbols.  */
3363           if (syms[i]->value > opd->size - 8)
3364             continue;
3365
3366           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3367           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3368             {
3369               ++count;
3370               size += sizeof (asymbol);
3371               size += strlen (syms[i]->name) + 2;
3372             }
3373         }
3374
3375       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3376       if (dyn_count != 0
3377           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3378         {
3379           bfd_byte *dynbuf, *extdyn, *extdynend;
3380           size_t extdynsize;
3381           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3382
3383           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3384             goto free_contents_and_exit;
3385
3386           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3387           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3388
3389           extdyn = dynbuf;
3390           extdynend = extdyn + dynamic->size;
3391           for (; extdyn < extdynend; extdyn += extdynsize)
3392             {
3393               Elf_Internal_Dyn dyn;
3394               (*swap_dyn_in) (abfd, extdyn, &dyn);
3395
3396               if (dyn.d_tag == DT_NULL)
3397                 break;
3398
3399               if (dyn.d_tag == DT_PPC64_GLINK)
3400                 {
3401                   /* The first glink stub starts at offset 32; see
3402                      comment in ppc64_elf_finish_dynamic_sections. */
3403                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3404                   /* The .glink section usually does not survive the final
3405                      link; search for the section (usually .text) where the
3406                      glink stubs now reside.  */
3407                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3408                                                 &glink_vma);
3409                   break;
3410                 }
3411             }
3412
3413           free (dynbuf);
3414         }
3415
3416       if (glink != NULL)
3417         {
3418           /* Determine __glink trampoline by reading the relative branch
3419              from the first glink stub.  */
3420           bfd_byte buf[4];
3421           unsigned int off = 0;
3422
3423           while (bfd_get_section_contents (abfd, glink, buf,
3424                                            glink_vma + off - glink->vma, 4))
3425             {
3426               unsigned int insn = bfd_get_32 (abfd, buf);
3427               insn ^= B_DOT;
3428               if ((insn & ~0x3fffffc) == 0)
3429                 {
3430                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3431                   break;
3432                 }
3433               off += 4;
3434               if (off > 4)
3435                 break;
3436             }
3437
3438           if (resolv_vma)
3439             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3440
3441           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3442           if (relplt != NULL)
3443             {
3444               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3445               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3446                 goto free_contents_and_exit;
3447
3448               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3449               size += plt_count * sizeof (asymbol);
3450
3451               p = relplt->relocation;
3452               for (i = 0; i < plt_count; i++, p++)
3453                 {
3454                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3455                   if (p->addend != 0)
3456                     size += sizeof ("+0x") - 1 + 16;
3457                 }
3458             }
3459         }
3460
3461       s = *ret = bfd_malloc (size);
3462       if (s == NULL)
3463         goto free_contents_and_exit;
3464
3465       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3466
3467       for (i = secsymend; i < opdsymend; ++i)
3468         {
3469           bfd_vma ent;
3470
3471           if (syms[i]->value > opd->size - 8)
3472             continue;
3473
3474           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476             {
3477               long lo, hi;
3478               size_t len;
3479               asection *sec = abfd->sections;
3480
3481               *s = *syms[i];
3482               lo = codesecsym;
3483               hi = codesecsymend;
3484               while (lo < hi)
3485                 {
3486                   long mid = (lo + hi) >> 1;
3487                   if (syms[mid]->section->vma < ent)
3488                     lo = mid + 1;
3489                   else if (syms[mid]->section->vma > ent)
3490                     hi = mid;
3491                   else
3492                     {
3493                       sec = syms[mid]->section;
3494                       break;
3495                     }
3496                 }
3497
3498               if (lo >= hi && lo > codesecsym)
3499                 sec = syms[lo - 1]->section;
3500
3501               for (; sec != NULL; sec = sec->next)
3502                 {
3503                   if (sec->vma > ent)
3504                     break;
3505                   /* SEC_LOAD may not be set if SEC is from a separate debug
3506                      info file.  */
3507                   if ((sec->flags & SEC_ALLOC) == 0)
3508                     break;
3509                   if ((sec->flags & SEC_CODE) != 0)
3510                     s->section = sec;
3511                 }
3512               s->flags |= BSF_SYNTHETIC;
3513               s->value = ent - s->section->vma;
3514               s->name = names;
3515               *names++ = '.';
3516               len = strlen (syms[i]->name);
3517               memcpy (names, syms[i]->name, len + 1);
3518               names += len + 1;
3519               /* Have udata.p point back to the original symbol this
3520                  synthetic symbol was derived from.  */
3521               s->udata.p = syms[i];
3522               s++;
3523             }
3524         }
3525       free (contents);
3526
3527       if (glink != NULL && relplt != NULL)
3528         {
3529           if (resolv_vma)
3530             {
3531               /* Add a symbol for the main glink trampoline.  */
3532               memset (s, 0, sizeof *s);
3533               s->the_bfd = abfd;
3534               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3535               s->section = glink;
3536               s->value = resolv_vma - glink->vma;
3537               s->name = names;
3538               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3539               names += sizeof ("__glink_PLTresolve");
3540               s++;
3541               count++;
3542             }
3543
3544           /* FIXME: It would be very much nicer to put sym@plt on the
3545              stub rather than on the glink branch table entry.  The
3546              objdump disassembler would then use a sensible symbol
3547              name on plt calls.  The difficulty in doing so is
3548              a) finding the stubs, and,
3549              b) matching stubs against plt entries, and,
3550              c) there can be multiple stubs for a given plt entry.
3551
3552              Solving (a) could be done by code scanning, but older
3553              ppc64 binaries used different stubs to current code.
3554              (b) is the tricky one since you need to known the toc
3555              pointer for at least one function that uses a pic stub to
3556              be able to calculate the plt address referenced.
3557              (c) means gdb would need to set multiple breakpoints (or
3558              find the glink branch itself) when setting breakpoints
3559              for pending shared library loads.  */
3560           p = relplt->relocation;
3561           for (i = 0; i < plt_count; i++, p++)
3562             {
3563               size_t len;
3564
3565               *s = **p->sym_ptr_ptr;
3566               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3567                  we are defining a symbol, ensure one of them is set.  */
3568               if ((s->flags & BSF_LOCAL) == 0)
3569                 s->flags |= BSF_GLOBAL;
3570               s->flags |= BSF_SYNTHETIC;
3571               s->section = glink;
3572               s->value = glink_vma - glink->vma;
3573               s->name = names;
3574               s->udata.p = NULL;
3575               len = strlen ((*p->sym_ptr_ptr)->name);
3576               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3577               names += len;
3578               if (p->addend != 0)
3579                 {
3580                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3581                   names += sizeof ("+0x") - 1;
3582                   bfd_sprintf_vma (abfd, names, p->addend);
3583                   names += strlen (names);
3584                 }
3585               memcpy (names, "@plt", sizeof ("@plt"));
3586               names += sizeof ("@plt");
3587               s++;
3588               if (abi < 2)
3589                 {
3590                   glink_vma += 8;
3591                   if (i >= 0x8000)
3592                     glink_vma += 4;
3593                 }
3594               else
3595                 glink_vma += 4;
3596             }
3597           count += plt_count;
3598         }
3599     }
3600
3601  done:
3602   free (syms);
3603   return count;
3604 }
3605 \f
3606 /* The following functions are specific to the ELF linker, while
3607    functions above are used generally.  Those named ppc64_elf_* are
3608    called by the main ELF linker code.  They appear in this file more
3609    or less in the order in which they are called.  eg.
3610    ppc64_elf_check_relocs is called early in the link process,
3611    ppc64_elf_finish_dynamic_sections is one of the last functions
3612    called.
3613
3614    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3615    functions have both a function code symbol and a function descriptor
3616    symbol.  A call to foo in a relocatable object file looks like:
3617
3618    .            .text
3619    .    x:
3620    .            bl      .foo
3621    .            nop
3622
3623    The function definition in another object file might be:
3624
3625    .            .section .opd
3626    .    foo:    .quad   .foo
3627    .            .quad   .TOC.@tocbase
3628    .            .quad   0
3629    .
3630    .            .text
3631    .    .foo:   blr
3632
3633    When the linker resolves the call during a static link, the branch
3634    unsurprisingly just goes to .foo and the .opd information is unused.
3635    If the function definition is in a shared library, things are a little
3636    different:  The call goes via a plt call stub, the opd information gets
3637    copied to the plt, and the linker patches the nop.
3638
3639    .    x:
3640    .            bl      .foo_stub
3641    .            ld      2,40(1)
3642    .
3643    .
3644    .    .foo_stub:
3645    .            std     2,40(1)                 # in practice, the call stub
3646    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3647    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3648    .            ld      12,0(11)
3649    .            ld      2,8(11)
3650    .            mtctr   12
3651    .            ld      11,16(11)
3652    .            bctr
3653    .
3654    .            .section .plt
3655    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3656
3657    The "reloc ()" notation is supposed to indicate that the linker emits
3658    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3659    copying.
3660
3661    What are the difficulties here?  Well, firstly, the relocations
3662    examined by the linker in check_relocs are against the function code
3663    sym .foo, while the dynamic relocation in the plt is emitted against
3664    the function descriptor symbol, foo.  Somewhere along the line, we need
3665    to carefully copy dynamic link information from one symbol to the other.
3666    Secondly, the generic part of the elf linker will make .foo a dynamic
3667    symbol as is normal for most other backends.  We need foo dynamic
3668    instead, at least for an application final link.  However, when
3669    creating a shared library containing foo, we need to have both symbols
3670    dynamic so that references to .foo are satisfied during the early
3671    stages of linking.  Otherwise the linker might decide to pull in a
3672    definition from some other object, eg. a static library.
3673
3674    Update: As of August 2004, we support a new convention.  Function
3675    calls may use the function descriptor symbol, ie. "bl foo".  This
3676    behaves exactly as "bl .foo".  */
3677
3678 /* Of those relocs that might be copied as dynamic relocs, this function
3679    selects those that must be copied when linking a shared library,
3680    even when the symbol is local.  */
3681
3682 static int
3683 must_be_dyn_reloc (struct bfd_link_info *info,
3684                    enum elf_ppc64_reloc_type r_type)
3685 {
3686   switch (r_type)
3687     {
3688     default:
3689       return 1;
3690
3691     case R_PPC64_REL32:
3692     case R_PPC64_REL64:
3693     case R_PPC64_REL30:
3694       return 0;
3695
3696     case R_PPC64_TPREL16:
3697     case R_PPC64_TPREL16_LO:
3698     case R_PPC64_TPREL16_HI:
3699     case R_PPC64_TPREL16_HA:
3700     case R_PPC64_TPREL16_DS:
3701     case R_PPC64_TPREL16_LO_DS:
3702     case R_PPC64_TPREL16_HIGH:
3703     case R_PPC64_TPREL16_HIGHA:
3704     case R_PPC64_TPREL16_HIGHER:
3705     case R_PPC64_TPREL16_HIGHERA:
3706     case R_PPC64_TPREL16_HIGHEST:
3707     case R_PPC64_TPREL16_HIGHESTA:
3708     case R_PPC64_TPREL64:
3709       return !info->executable;
3710     }
3711 }
3712
3713 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3714    copying dynamic variables from a shared lib into an app's dynbss
3715    section, and instead use a dynamic relocation to point into the
3716    shared lib.  With code that gcc generates, it's vital that this be
3717    enabled;  In the PowerPC64 ABI, the address of a function is actually
3718    the address of a function descriptor, which resides in the .opd
3719    section.  gcc uses the descriptor directly rather than going via the
3720    GOT as some other ABI's do, which means that initialized function
3721    pointers must reference the descriptor.  Thus, a function pointer
3722    initialized to the address of a function in a shared library will
3723    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3724    redefines the function descriptor symbol to point to the copy.  This
3725    presents a problem as a plt entry for that function is also
3726    initialized from the function descriptor symbol and the copy reloc
3727    may not be initialized first.  */
3728 #define ELIMINATE_COPY_RELOCS 1
3729
3730 /* Section name for stubs is the associated section name plus this
3731    string.  */
3732 #define STUB_SUFFIX ".stub"
3733
3734 /* Linker stubs.
3735    ppc_stub_long_branch:
3736    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3737    destination, but a 24 bit branch in a stub section will reach.
3738    .    b       dest
3739
3740    ppc_stub_plt_branch:
3741    Similar to the above, but a 24 bit branch in the stub section won't
3742    reach its destination.
3743    .    addis   %r11,%r2,xxx@toc@ha
3744    .    ld      %r12,xxx@toc@l(%r11)
3745    .    mtctr   %r12
3746    .    bctr
3747
3748    ppc_stub_plt_call:
3749    Used to call a function in a shared library.  If it so happens that
3750    the plt entry referenced crosses a 64k boundary, then an extra
3751    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3752    .    std     %r2,40(%r1)
3753    .    addis   %r11,%r2,xxx@toc@ha
3754    .    ld      %r12,xxx+0@toc@l(%r11)
3755    .    mtctr   %r12
3756    .    ld      %r2,xxx+8@toc@l(%r11)
3757    .    ld      %r11,xxx+16@toc@l(%r11)
3758    .    bctr
3759
3760    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3761    code to adjust the value and save r2 to support multiple toc sections.
3762    A ppc_stub_long_branch with an r2 offset looks like:
3763    .    std     %r2,40(%r1)
3764    .    addis   %r2,%r2,off@ha
3765    .    addi    %r2,%r2,off@l
3766    .    b       dest
3767
3768    A ppc_stub_plt_branch with an r2 offset looks like:
3769    .    std     %r2,40(%r1)
3770    .    addis   %r11,%r2,xxx@toc@ha
3771    .    ld      %r12,xxx@toc@l(%r11)
3772    .    addis   %r2,%r2,off@ha
3773    .    addi    %r2,%r2,off@l
3774    .    mtctr   %r12
3775    .    bctr
3776
3777    In cases where the "addis" instruction would add zero, the "addis" is
3778    omitted and following instructions modified slightly in some cases.
3779 */
3780
3781 enum ppc_stub_type {
3782   ppc_stub_none,
3783   ppc_stub_long_branch,
3784   ppc_stub_long_branch_r2off,
3785   ppc_stub_plt_branch,
3786   ppc_stub_plt_branch_r2off,
3787   ppc_stub_plt_call,
3788   ppc_stub_plt_call_r2save,
3789   ppc_stub_global_entry
3790 };
3791
3792 struct ppc_stub_hash_entry {
3793
3794   /* Base hash table entry structure.  */
3795   struct bfd_hash_entry root;
3796
3797   enum ppc_stub_type stub_type;
3798
3799   /* The stub section.  */
3800   asection *stub_sec;
3801
3802   /* Offset within stub_sec of the beginning of this stub.  */
3803   bfd_vma stub_offset;
3804
3805   /* Given the symbol's value and its section we can determine its final
3806      value when building the stubs (so the stub knows where to jump.  */
3807   bfd_vma target_value;
3808   asection *target_section;
3809
3810   /* The symbol table entry, if any, that this was derived from.  */
3811   struct ppc_link_hash_entry *h;
3812   struct plt_entry *plt_ent;
3813
3814   /* Where this stub is being called from, or, in the case of combined
3815      stub sections, the first input section in the group.  */
3816   asection *id_sec;
3817
3818   /* Symbol st_other.  */
3819   unsigned char other;
3820 };
3821
3822 struct ppc_branch_hash_entry {
3823
3824   /* Base hash table entry structure.  */
3825   struct bfd_hash_entry root;
3826
3827   /* Offset within branch lookup table.  */
3828   unsigned int offset;
3829
3830   /* Generation marker.  */
3831   unsigned int iter;
3832 };
3833
3834 /* Used to track dynamic relocations for local symbols.  */
3835 struct ppc_dyn_relocs
3836 {
3837   struct ppc_dyn_relocs *next;
3838
3839   /* The input section of the reloc.  */
3840   asection *sec;
3841
3842   /* Total number of relocs copied for the input section.  */
3843   unsigned int count : 31;
3844
3845   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3846   unsigned int ifunc : 1;
3847 };
3848
3849 struct ppc_link_hash_entry
3850 {
3851   struct elf_link_hash_entry elf;
3852
3853   union {
3854     /* A pointer to the most recently used stub hash entry against this
3855        symbol.  */
3856     struct ppc_stub_hash_entry *stub_cache;
3857
3858     /* A pointer to the next symbol starting with a '.'  */
3859     struct ppc_link_hash_entry *next_dot_sym;
3860   } u;
3861
3862   /* Track dynamic relocs copied for this symbol.  */
3863   struct elf_dyn_relocs *dyn_relocs;
3864
3865   /* Link between function code and descriptor symbols.  */
3866   struct ppc_link_hash_entry *oh;
3867
3868   /* Flag function code and descriptor symbols.  */
3869   unsigned int is_func:1;
3870   unsigned int is_func_descriptor:1;
3871   unsigned int fake:1;
3872
3873   /* Whether global opd/toc sym has been adjusted or not.
3874      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3875      should be set for all globals defined in any opd/toc section.  */
3876   unsigned int adjust_done:1;
3877
3878   /* Set if we twiddled this symbol to weak at some stage.  */
3879   unsigned int was_undefined:1;
3880
3881   /* Contexts in which symbol is used in the GOT (or TOC).
3882      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3883      corresponding relocs are encountered during check_relocs.
3884      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3885      indicate the corresponding GOT entry type is not needed.
3886      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3887      a TPREL one.  We use a separate flag rather than setting TPREL
3888      just for convenience in distinguishing the two cases.  */
3889 #define TLS_GD           1      /* GD reloc. */
3890 #define TLS_LD           2      /* LD reloc. */
3891 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3892 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3893 #define TLS_TLS         16      /* Any TLS reloc.  */
3894 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3895 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3896 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3897   unsigned char tls_mask;
3898 };
3899
3900 /* ppc64 ELF linker hash table.  */
3901
3902 struct ppc_link_hash_table
3903 {
3904   struct elf_link_hash_table elf;
3905
3906   /* The stub hash table.  */
3907   struct bfd_hash_table stub_hash_table;
3908
3909   /* Another hash table for plt_branch stubs.  */
3910   struct bfd_hash_table branch_hash_table;
3911
3912   /* Hash table for function prologue tocsave.  */
3913   htab_t tocsave_htab;
3914
3915   /* Various options and other info passed from the linker.  */
3916   struct ppc64_elf_params *params;
3917
3918   /* Array to keep track of which stub sections have been created, and
3919      information on stub grouping.  */
3920   struct map_stub {
3921     /* This is the section to which stubs in the group will be attached.  */
3922     asection *link_sec;
3923     /* The stub section.  */
3924     asection *stub_sec;
3925     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3926     bfd_vma toc_off;
3927   } *stub_group;
3928
3929   /* Temp used when calculating TOC pointers.  */
3930   bfd_vma toc_curr;
3931   bfd *toc_bfd;
3932   asection *toc_first_sec;
3933
3934   /* Highest input section id.  */
3935   int top_id;
3936
3937   /* Highest output section index.  */
3938   int top_index;
3939
3940   /* Used when adding symbols.  */
3941   struct ppc_link_hash_entry *dot_syms;
3942
3943   /* List of input sections for each output section.  */
3944   asection **input_list;
3945
3946   /* Shortcuts to get to dynamic linker sections.  */
3947   asection *dynbss;
3948   asection *relbss;
3949   asection *glink;
3950   asection *sfpr;
3951   asection *brlt;
3952   asection *relbrlt;
3953   asection *glink_eh_frame;
3954
3955   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3956   struct ppc_link_hash_entry *tls_get_addr;
3957   struct ppc_link_hash_entry *tls_get_addr_fd;
3958
3959   /* The size of reliplt used by got entry relocs.  */
3960   bfd_size_type got_reli_size;
3961
3962   /* Statistics.  */
3963   unsigned long stub_count[ppc_stub_global_entry];
3964
3965   /* Number of stubs against global syms.  */
3966   unsigned long stub_globals;
3967
3968   /* Set if we're linking code with function descriptors.  */
3969   unsigned int opd_abi:1;
3970
3971   /* Support for multiple toc sections.  */
3972   unsigned int do_multi_toc:1;
3973   unsigned int multi_toc_needed:1;
3974   unsigned int second_toc_pass:1;
3975   unsigned int do_toc_opt:1;
3976
3977   /* Set on error.  */
3978   unsigned int stub_error:1;
3979
3980   /* Temp used by ppc64_elf_before_check_relocs.  */
3981   unsigned int twiddled_syms:1;
3982
3983   /* Incremented every time we size stubs.  */
3984   unsigned int stub_iteration;
3985
3986   /* Small local sym cache.  */
3987   struct sym_cache sym_cache;
3988 };
3989
3990 /* Rename some of the generic section flags to better document how they
3991    are used here.  */
3992
3993 /* Nonzero if this section has TLS related relocations.  */
3994 #define has_tls_reloc sec_flg0
3995
3996 /* Nonzero if this section has a call to __tls_get_addr.  */
3997 #define has_tls_get_addr_call sec_flg1
3998
3999 /* Nonzero if this section has any toc or got relocs.  */
4000 #define has_toc_reloc sec_flg2
4001
4002 /* Nonzero if this section has a call to another section that uses
4003    the toc or got.  */
4004 #define makes_toc_func_call sec_flg3
4005
4006 /* Recursion protection when determining above flag.  */
4007 #define call_check_in_progress sec_flg4
4008 #define call_check_done sec_flg5
4009
4010 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
4011
4012 #define ppc_hash_table(p) \
4013   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4014   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4015
4016 #define ppc_stub_hash_lookup(table, string, create, copy) \
4017   ((struct ppc_stub_hash_entry *) \
4018    bfd_hash_lookup ((table), (string), (create), (copy)))
4019
4020 #define ppc_branch_hash_lookup(table, string, create, copy) \
4021   ((struct ppc_branch_hash_entry *) \
4022    bfd_hash_lookup ((table), (string), (create), (copy)))
4023
4024 /* Create an entry in the stub hash table.  */
4025
4026 static struct bfd_hash_entry *
4027 stub_hash_newfunc (struct bfd_hash_entry *entry,
4028                    struct bfd_hash_table *table,
4029                    const char *string)
4030 {
4031   /* Allocate the structure if it has not already been allocated by a
4032      subclass.  */
4033   if (entry == NULL)
4034     {
4035       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4036       if (entry == NULL)
4037         return entry;
4038     }
4039
4040   /* Call the allocation method of the superclass.  */
4041   entry = bfd_hash_newfunc (entry, table, string);
4042   if (entry != NULL)
4043     {
4044       struct ppc_stub_hash_entry *eh;
4045
4046       /* Initialize the local fields.  */
4047       eh = (struct ppc_stub_hash_entry *) entry;
4048       eh->stub_type = ppc_stub_none;
4049       eh->stub_sec = NULL;
4050       eh->stub_offset = 0;
4051       eh->target_value = 0;
4052       eh->target_section = NULL;
4053       eh->h = NULL;
4054       eh->plt_ent = NULL;
4055       eh->id_sec = NULL;
4056       eh->other = 0;
4057     }
4058
4059   return entry;
4060 }
4061
4062 /* Create an entry in the branch hash table.  */
4063
4064 static struct bfd_hash_entry *
4065 branch_hash_newfunc (struct bfd_hash_entry *entry,
4066                      struct bfd_hash_table *table,
4067                      const char *string)
4068 {
4069   /* Allocate the structure if it has not already been allocated by a
4070      subclass.  */
4071   if (entry == NULL)
4072     {
4073       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4074       if (entry == NULL)
4075         return entry;
4076     }
4077
4078   /* Call the allocation method of the superclass.  */
4079   entry = bfd_hash_newfunc (entry, table, string);
4080   if (entry != NULL)
4081     {
4082       struct ppc_branch_hash_entry *eh;
4083
4084       /* Initialize the local fields.  */
4085       eh = (struct ppc_branch_hash_entry *) entry;
4086       eh->offset = 0;
4087       eh->iter = 0;
4088     }
4089
4090   return entry;
4091 }
4092
4093 /* Create an entry in a ppc64 ELF linker hash table.  */
4094
4095 static struct bfd_hash_entry *
4096 link_hash_newfunc (struct bfd_hash_entry *entry,
4097                    struct bfd_hash_table *table,
4098                    const char *string)
4099 {
4100   /* Allocate the structure if it has not already been allocated by a
4101      subclass.  */
4102   if (entry == NULL)
4103     {
4104       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4105       if (entry == NULL)
4106         return entry;
4107     }
4108
4109   /* Call the allocation method of the superclass.  */
4110   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4111   if (entry != NULL)
4112     {
4113       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4114
4115       memset (&eh->u.stub_cache, 0,
4116               (sizeof (struct ppc_link_hash_entry)
4117                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4118
4119       /* When making function calls, old ABI code references function entry
4120          points (dot symbols), while new ABI code references the function
4121          descriptor symbol.  We need to make any combination of reference and
4122          definition work together, without breaking archive linking.
4123
4124          For a defined function "foo" and an undefined call to "bar":
4125          An old object defines "foo" and ".foo", references ".bar" (possibly
4126          "bar" too).
4127          A new object defines "foo" and references "bar".
4128
4129          A new object thus has no problem with its undefined symbols being
4130          satisfied by definitions in an old object.  On the other hand, the
4131          old object won't have ".bar" satisfied by a new object.
4132
4133          Keep a list of newly added dot-symbols.  */
4134
4135       if (string[0] == '.')
4136         {
4137           struct ppc_link_hash_table *htab;
4138
4139           htab = (struct ppc_link_hash_table *) table;
4140           eh->u.next_dot_sym = htab->dot_syms;
4141           htab->dot_syms = eh;
4142         }
4143     }
4144
4145   return entry;
4146 }
4147
4148 struct tocsave_entry {
4149   asection *sec;
4150   bfd_vma offset;
4151 };
4152
4153 static hashval_t
4154 tocsave_htab_hash (const void *p)
4155 {
4156   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4157   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4158 }
4159
4160 static int
4161 tocsave_htab_eq (const void *p1, const void *p2)
4162 {
4163   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4164   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4165   return e1->sec == e2->sec && e1->offset == e2->offset;
4166 }
4167
4168 /* Destroy a ppc64 ELF linker hash table.  */
4169
4170 static void
4171 ppc64_elf_link_hash_table_free (bfd *obfd)
4172 {
4173   struct ppc_link_hash_table *htab;
4174
4175   htab = (struct ppc_link_hash_table *) obfd->link.hash;
4176   if (htab->tocsave_htab)
4177     htab_delete (htab->tocsave_htab);
4178   bfd_hash_table_free (&htab->branch_hash_table);
4179   bfd_hash_table_free (&htab->stub_hash_table);
4180   _bfd_elf_link_hash_table_free (obfd);
4181 }
4182
4183 /* Create a ppc64 ELF linker hash table.  */
4184
4185 static struct bfd_link_hash_table *
4186 ppc64_elf_link_hash_table_create (bfd *abfd)
4187 {
4188   struct ppc_link_hash_table *htab;
4189   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4190
4191   htab = bfd_zmalloc (amt);
4192   if (htab == NULL)
4193     return NULL;
4194
4195   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4196                                       sizeof (struct ppc_link_hash_entry),
4197                                       PPC64_ELF_DATA))
4198     {
4199       free (htab);
4200       return NULL;
4201     }
4202
4203   /* Init the stub hash table too.  */
4204   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4205                             sizeof (struct ppc_stub_hash_entry)))
4206     {
4207       _bfd_elf_link_hash_table_free (abfd);
4208       return NULL;
4209     }
4210
4211   /* And the branch hash table.  */
4212   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4213                             sizeof (struct ppc_branch_hash_entry)))
4214     {
4215       bfd_hash_table_free (&htab->stub_hash_table);
4216       _bfd_elf_link_hash_table_free (abfd);
4217       return NULL;
4218     }
4219
4220   htab->tocsave_htab = htab_try_create (1024,
4221                                         tocsave_htab_hash,
4222                                         tocsave_htab_eq,
4223                                         NULL);
4224   if (htab->tocsave_htab == NULL)
4225     {
4226       ppc64_elf_link_hash_table_free (abfd);
4227       return NULL;
4228     }
4229   htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4230
4231   /* Initializing two fields of the union is just cosmetic.  We really
4232      only care about glist, but when compiled on a 32-bit host the
4233      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4234      debugger inspection of these fields look nicer.  */
4235   htab->elf.init_got_refcount.refcount = 0;
4236   htab->elf.init_got_refcount.glist = NULL;
4237   htab->elf.init_plt_refcount.refcount = 0;
4238   htab->elf.init_plt_refcount.glist = NULL;
4239   htab->elf.init_got_offset.offset = 0;
4240   htab->elf.init_got_offset.glist = NULL;
4241   htab->elf.init_plt_offset.offset = 0;
4242   htab->elf.init_plt_offset.glist = NULL;
4243
4244   return &htab->elf.root;
4245 }
4246
4247 /* Create sections for linker generated code.  */
4248
4249 static bfd_boolean
4250 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4251 {
4252   struct ppc_link_hash_table *htab;
4253   flagword flags;
4254
4255   htab = ppc_hash_table (info);
4256
4257   /* Create .sfpr for code to save and restore fp regs.  */
4258   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4259            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4260   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4261                                                    flags);
4262   if (htab->sfpr == NULL
4263       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4264     return FALSE;
4265
4266   /* Create .glink for lazy dynamic linking support.  */
4267   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4268                                                     flags);
4269   if (htab->glink == NULL
4270       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4271     return FALSE;
4272
4273   if (!info->no_ld_generated_unwind_info)
4274     {
4275       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4276                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4277       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4278                                                                  ".eh_frame",
4279                                                                  flags);
4280       if (htab->glink_eh_frame == NULL
4281           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4282         return FALSE;
4283     }
4284
4285   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4286   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4287   if (htab->elf.iplt == NULL
4288       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4289     return FALSE;
4290
4291   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4292            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4293   htab->elf.irelplt
4294     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4295   if (htab->elf.irelplt == NULL
4296       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4297     return FALSE;
4298
4299   /* Create branch lookup table for plt_branch stubs.  */
4300   flags = (SEC_ALLOC | SEC_LOAD
4301            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4302   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4303                                                    flags);
4304   if (htab->brlt == NULL
4305       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4306     return FALSE;
4307
4308   if (!info->shared)
4309     return TRUE;
4310
4311   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4312            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4313   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4314                                                       ".rela.branch_lt",
4315                                                       flags);
4316   if (htab->relbrlt == NULL
4317       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4318     return FALSE;
4319
4320   return TRUE;
4321 }
4322
4323 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4324
4325 bfd_boolean
4326 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4327                          struct ppc64_elf_params *params)
4328 {
4329   struct ppc_link_hash_table *htab;
4330
4331   elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4332
4333 /* Always hook our dynamic sections into the first bfd, which is the
4334    linker created stub bfd.  This ensures that the GOT header is at
4335    the start of the output TOC section.  */
4336   htab = ppc_hash_table (info);
4337   if (htab == NULL)
4338     return FALSE;
4339   htab->elf.dynobj = params->stub_bfd;
4340   htab->params = params;
4341
4342   if (info->relocatable)
4343     return TRUE;
4344
4345   return create_linkage_sections (htab->elf.dynobj, info);
4346 }
4347
4348 /* Build a name for an entry in the stub hash table.  */
4349
4350 static char *
4351 ppc_stub_name (const asection *input_section,
4352                const asection *sym_sec,
4353                const struct ppc_link_hash_entry *h,
4354                const Elf_Internal_Rela *rel)
4355 {
4356   char *stub_name;
4357   ssize_t len;
4358
4359   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4360      offsets from a sym as a branch target?  In fact, we could
4361      probably assume the addend is always zero.  */
4362   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4363
4364   if (h)
4365     {
4366       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4367       stub_name = bfd_malloc (len);
4368       if (stub_name == NULL)
4369         return stub_name;
4370
4371       len = sprintf (stub_name, "%08x.%s+%x",
4372                      input_section->id & 0xffffffff,
4373                      h->elf.root.root.string,
4374                      (int) rel->r_addend & 0xffffffff);
4375     }
4376   else
4377     {
4378       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4379       stub_name = bfd_malloc (len);
4380       if (stub_name == NULL)
4381         return stub_name;
4382
4383       len = sprintf (stub_name, "%08x.%x:%x+%x",
4384                      input_section->id & 0xffffffff,
4385                      sym_sec->id & 0xffffffff,
4386                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4387                      (int) rel->r_addend & 0xffffffff);
4388     }
4389   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4390     stub_name[len - 2] = 0;
4391   return stub_name;
4392 }
4393
4394 /* Look up an entry in the stub hash.  Stub entries are cached because
4395    creating the stub name takes a bit of time.  */
4396
4397 static struct ppc_stub_hash_entry *
4398 ppc_get_stub_entry (const asection *input_section,
4399                     const asection *sym_sec,
4400                     struct ppc_link_hash_entry *h,
4401                     const Elf_Internal_Rela *rel,
4402                     struct ppc_link_hash_table *htab)
4403 {
4404   struct ppc_stub_hash_entry *stub_entry;
4405   const asection *id_sec;
4406
4407   /* If this input section is part of a group of sections sharing one
4408      stub section, then use the id of the first section in the group.
4409      Stub names need to include a section id, as there may well be
4410      more than one stub used to reach say, printf, and we need to
4411      distinguish between them.  */
4412   id_sec = htab->stub_group[input_section->id].link_sec;
4413
4414   if (h != NULL && h->u.stub_cache != NULL
4415       && h->u.stub_cache->h == h
4416       && h->u.stub_cache->id_sec == id_sec)
4417     {
4418       stub_entry = h->u.stub_cache;
4419     }
4420   else
4421     {
4422       char *stub_name;
4423
4424       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4425       if (stub_name == NULL)
4426         return NULL;
4427
4428       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4429                                          stub_name, FALSE, FALSE);
4430       if (h != NULL)
4431         h->u.stub_cache = stub_entry;
4432
4433       free (stub_name);
4434     }
4435
4436   return stub_entry;
4437 }
4438
4439 /* Add a new stub entry to the stub hash.  Not all fields of the new
4440    stub entry are initialised.  */
4441
4442 static struct ppc_stub_hash_entry *
4443 ppc_add_stub (const char *stub_name,
4444               asection *section,
4445               struct bfd_link_info *info)
4446 {
4447   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4448   asection *link_sec;
4449   asection *stub_sec;
4450   struct ppc_stub_hash_entry *stub_entry;
4451
4452   link_sec = htab->stub_group[section->id].link_sec;
4453   stub_sec = htab->stub_group[section->id].stub_sec;
4454   if (stub_sec == NULL)
4455     {
4456       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4457       if (stub_sec == NULL)
4458         {
4459           size_t namelen;
4460           bfd_size_type len;
4461           char *s_name;
4462
4463           namelen = strlen (link_sec->name);
4464           len = namelen + sizeof (STUB_SUFFIX);
4465           s_name = bfd_alloc (htab->params->stub_bfd, len);
4466           if (s_name == NULL)
4467             return NULL;
4468
4469           memcpy (s_name, link_sec->name, namelen);
4470           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4471           stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4472           if (stub_sec == NULL)
4473             return NULL;
4474           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4475         }
4476       htab->stub_group[section->id].stub_sec = stub_sec;
4477     }
4478
4479   /* Enter this entry into the linker stub hash table.  */
4480   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4481                                      TRUE, FALSE);
4482   if (stub_entry == NULL)
4483     {
4484       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4485                               section->owner, stub_name);
4486       return NULL;
4487     }
4488
4489   stub_entry->stub_sec = stub_sec;
4490   stub_entry->stub_offset = 0;
4491   stub_entry->id_sec = link_sec;
4492   return stub_entry;
4493 }
4494
4495 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4496    not already done.  */
4497
4498 static bfd_boolean
4499 create_got_section (bfd *abfd, struct bfd_link_info *info)
4500 {
4501   asection *got, *relgot;
4502   flagword flags;
4503   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4504
4505   if (!is_ppc64_elf (abfd))
4506     return FALSE;
4507   if (htab == NULL)
4508     return FALSE;
4509
4510   if (!htab->elf.sgot
4511       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4512     return FALSE;
4513
4514   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4515            | SEC_LINKER_CREATED);
4516
4517   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4518   if (!got
4519       || !bfd_set_section_alignment (abfd, got, 3))
4520     return FALSE;
4521
4522   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4523                                                flags | SEC_READONLY);
4524   if (!relgot
4525       || ! bfd_set_section_alignment (abfd, relgot, 3))
4526     return FALSE;
4527
4528   ppc64_elf_tdata (abfd)->got = got;
4529   ppc64_elf_tdata (abfd)->relgot = relgot;
4530   return TRUE;
4531 }
4532
4533 /* Create the dynamic sections, and set up shortcuts.  */
4534
4535 static bfd_boolean
4536 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4537 {
4538   struct ppc_link_hash_table *htab;
4539
4540   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4541     return FALSE;
4542
4543   htab = ppc_hash_table (info);
4544   if (htab == NULL)
4545     return FALSE;
4546
4547   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4548   if (!info->shared)
4549     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4550
4551   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4552       || (!info->shared && !htab->relbss))
4553     abort ();
4554
4555   return TRUE;
4556 }
4557
4558 /* Follow indirect and warning symbol links.  */
4559
4560 static inline struct bfd_link_hash_entry *
4561 follow_link (struct bfd_link_hash_entry *h)
4562 {
4563   while (h->type == bfd_link_hash_indirect
4564          || h->type == bfd_link_hash_warning)
4565     h = h->u.i.link;
4566   return h;
4567 }
4568
4569 static inline struct elf_link_hash_entry *
4570 elf_follow_link (struct elf_link_hash_entry *h)
4571 {
4572   return (struct elf_link_hash_entry *) follow_link (&h->root);
4573 }
4574
4575 static inline struct ppc_link_hash_entry *
4576 ppc_follow_link (struct ppc_link_hash_entry *h)
4577 {
4578   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4579 }
4580
4581 /* Merge PLT info on FROM with that on TO.  */
4582
4583 static void
4584 move_plt_plist (struct ppc_link_hash_entry *from,
4585                 struct ppc_link_hash_entry *to)
4586 {
4587   if (from->elf.plt.plist != NULL)
4588     {
4589       if (to->elf.plt.plist != NULL)
4590         {
4591           struct plt_entry **entp;
4592           struct plt_entry *ent;
4593
4594           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4595             {
4596               struct plt_entry *dent;
4597
4598               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4599                 if (dent->addend == ent->addend)
4600                   {
4601                     dent->plt.refcount += ent->plt.refcount;
4602                     *entp = ent->next;
4603                     break;
4604                   }
4605               if (dent == NULL)
4606                 entp = &ent->next;
4607             }
4608           *entp = to->elf.plt.plist;
4609         }
4610
4611       to->elf.plt.plist = from->elf.plt.plist;
4612       from->elf.plt.plist = NULL;
4613     }
4614 }
4615
4616 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4617
4618 static void
4619 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4620                                 struct elf_link_hash_entry *dir,
4621                                 struct elf_link_hash_entry *ind)
4622 {
4623   struct ppc_link_hash_entry *edir, *eind;
4624
4625   edir = (struct ppc_link_hash_entry *) dir;
4626   eind = (struct ppc_link_hash_entry *) ind;
4627
4628   edir->is_func |= eind->is_func;
4629   edir->is_func_descriptor |= eind->is_func_descriptor;
4630   edir->tls_mask |= eind->tls_mask;
4631   if (eind->oh != NULL)
4632     edir->oh = ppc_follow_link (eind->oh);
4633
4634   /* If called to transfer flags for a weakdef during processing
4635      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4636      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4637   if (!(ELIMINATE_COPY_RELOCS
4638         && eind->elf.root.type != bfd_link_hash_indirect
4639         && edir->elf.dynamic_adjusted))
4640     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4641
4642   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4643   edir->elf.ref_regular |= eind->elf.ref_regular;
4644   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4645   edir->elf.needs_plt |= eind->elf.needs_plt;
4646   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4647
4648   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4649   if (eind->dyn_relocs != NULL)
4650     {
4651       if (edir->dyn_relocs != NULL)
4652         {
4653           struct elf_dyn_relocs **pp;
4654           struct elf_dyn_relocs *p;
4655
4656           /* Add reloc counts against the indirect sym to the direct sym
4657              list.  Merge any entries against the same section.  */
4658           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4659             {
4660               struct elf_dyn_relocs *q;
4661
4662               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4663                 if (q->sec == p->sec)
4664                   {
4665                     q->pc_count += p->pc_count;
4666                     q->count += p->count;
4667                     *pp = p->next;
4668                     break;
4669                   }
4670               if (q == NULL)
4671                 pp = &p->next;
4672             }
4673           *pp = edir->dyn_relocs;
4674         }
4675
4676       edir->dyn_relocs = eind->dyn_relocs;
4677       eind->dyn_relocs = NULL;
4678     }
4679
4680   /* If we were called to copy over info for a weak sym, that's all.
4681      You might think dyn_relocs need not be copied over;  After all,
4682      both syms will be dynamic or both non-dynamic so we're just
4683      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4684      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4685      dyn_relocs in read-only sections, and it does so on what is the
4686      DIR sym here.  */
4687   if (eind->elf.root.type != bfd_link_hash_indirect)
4688     return;
4689
4690   /* Copy over got entries that we may have already seen to the
4691      symbol which just became indirect.  */
4692   if (eind->elf.got.glist != NULL)
4693     {
4694       if (edir->elf.got.glist != NULL)
4695         {
4696           struct got_entry **entp;
4697           struct got_entry *ent;
4698
4699           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4700             {
4701               struct got_entry *dent;
4702
4703               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4704                 if (dent->addend == ent->addend
4705                     && dent->owner == ent->owner
4706                     && dent->tls_type == ent->tls_type)
4707                   {
4708                     dent->got.refcount += ent->got.refcount;
4709                     *entp = ent->next;
4710                     break;
4711                   }
4712               if (dent == NULL)
4713                 entp = &ent->next;
4714             }
4715           *entp = edir->elf.got.glist;
4716         }
4717
4718       edir->elf.got.glist = eind->elf.got.glist;
4719       eind->elf.got.glist = NULL;
4720     }
4721
4722   /* And plt entries.  */
4723   move_plt_plist (eind, edir);
4724
4725   if (eind->elf.dynindx != -1)
4726     {
4727       if (edir->elf.dynindx != -1)
4728         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4729                                 edir->elf.dynstr_index);
4730       edir->elf.dynindx = eind->elf.dynindx;
4731       edir->elf.dynstr_index = eind->elf.dynstr_index;
4732       eind->elf.dynindx = -1;
4733       eind->elf.dynstr_index = 0;
4734     }
4735 }
4736
4737 /* Find the function descriptor hash entry from the given function code
4738    hash entry FH.  Link the entries via their OH fields.  */
4739
4740 static struct ppc_link_hash_entry *
4741 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4742 {
4743   struct ppc_link_hash_entry *fdh = fh->oh;
4744
4745   if (fdh == NULL)
4746     {
4747       const char *fd_name = fh->elf.root.root.string + 1;
4748
4749       fdh = (struct ppc_link_hash_entry *)
4750         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4751       if (fdh == NULL)
4752         return fdh;
4753
4754       fdh->is_func_descriptor = 1;
4755       fdh->oh = fh;
4756       fh->is_func = 1;
4757       fh->oh = fdh;
4758     }
4759
4760   return ppc_follow_link (fdh);
4761 }
4762
4763 /* Make a fake function descriptor sym for the code sym FH.  */
4764
4765 static struct ppc_link_hash_entry *
4766 make_fdh (struct bfd_link_info *info,
4767           struct ppc_link_hash_entry *fh)
4768 {
4769   bfd *abfd;
4770   asymbol *newsym;
4771   struct bfd_link_hash_entry *bh;
4772   struct ppc_link_hash_entry *fdh;
4773
4774   abfd = fh->elf.root.u.undef.abfd;
4775   newsym = bfd_make_empty_symbol (abfd);
4776   newsym->name = fh->elf.root.root.string + 1;
4777   newsym->section = bfd_und_section_ptr;
4778   newsym->value = 0;
4779   newsym->flags = BSF_WEAK;
4780
4781   bh = NULL;
4782   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4783                                          newsym->flags, newsym->section,
4784                                          newsym->value, NULL, FALSE, FALSE,
4785                                          &bh))
4786     return NULL;
4787
4788   fdh = (struct ppc_link_hash_entry *) bh;
4789   fdh->elf.non_elf = 0;
4790   fdh->fake = 1;
4791   fdh->is_func_descriptor = 1;
4792   fdh->oh = fh;
4793   fh->is_func = 1;
4794   fh->oh = fdh;
4795   return fdh;
4796 }
4797
4798 /* Fix function descriptor symbols defined in .opd sections to be
4799    function type.  */
4800
4801 static bfd_boolean
4802 ppc64_elf_add_symbol_hook (bfd *ibfd,
4803                            struct bfd_link_info *info,
4804                            Elf_Internal_Sym *isym,
4805                            const char **name,
4806                            flagword *flags ATTRIBUTE_UNUSED,
4807                            asection **sec,
4808                            bfd_vma *value ATTRIBUTE_UNUSED)
4809 {
4810   if ((ibfd->flags & DYNAMIC) == 0
4811       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4812     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4813
4814   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4815     {
4816       if ((ibfd->flags & DYNAMIC) == 0)
4817         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4818     }
4819   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4820     ;
4821   else if (*sec != NULL
4822            && strcmp ((*sec)->name, ".opd") == 0)
4823     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4824
4825   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4826     {
4827       if (abiversion (ibfd) == 0)
4828         set_abiversion (ibfd, 2);
4829       else if (abiversion (ibfd) == 1)
4830         {
4831           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4832                                     " for ABI version 1\n"), name);
4833           bfd_set_error (bfd_error_bad_value);
4834           return FALSE;
4835         }
4836     }
4837
4838   return TRUE;
4839 }
4840
4841 /* Merge non-visibility st_other attributes: local entry point.  */
4842
4843 static void
4844 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4845                                   const Elf_Internal_Sym *isym,
4846                                   bfd_boolean definition,
4847                                   bfd_boolean dynamic)
4848 {
4849   if (definition && !dynamic)
4850     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4851                 | ELF_ST_VISIBILITY (h->other));
4852 }
4853
4854 /* This function makes an old ABI object reference to ".bar" cause the
4855    inclusion of a new ABI object archive that defines "bar".
4856    NAME is a symbol defined in an archive.  Return a symbol in the hash
4857    table that might be satisfied by the archive symbols.  */
4858
4859 static struct elf_link_hash_entry *
4860 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4861                                  struct bfd_link_info *info,
4862                                  const char *name)
4863 {
4864   struct elf_link_hash_entry *h;
4865   char *dot_name;
4866   size_t len;
4867
4868   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4869   if (h != NULL
4870       /* Don't return this sym if it is a fake function descriptor
4871          created by add_symbol_adjust.  */
4872       && !(h->root.type == bfd_link_hash_undefweak
4873            && ((struct ppc_link_hash_entry *) h)->fake))
4874     return h;
4875
4876   if (name[0] == '.')
4877     return h;
4878
4879   len = strlen (name);
4880   dot_name = bfd_alloc (abfd, len + 2);
4881   if (dot_name == NULL)
4882     return (struct elf_link_hash_entry *) 0 - 1;
4883   dot_name[0] = '.';
4884   memcpy (dot_name + 1, name, len + 1);
4885   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4886   bfd_release (abfd, dot_name);
4887   return h;
4888 }
4889
4890 /* This function satisfies all old ABI object references to ".bar" if a
4891    new ABI object defines "bar".  Well, at least, undefined dot symbols
4892    are made weak.  This stops later archive searches from including an
4893    object if we already have a function descriptor definition.  It also
4894    prevents the linker complaining about undefined symbols.
4895    We also check and correct mismatched symbol visibility here.  The
4896    most restrictive visibility of the function descriptor and the
4897    function entry symbol is used.  */
4898
4899 static bfd_boolean
4900 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4901 {
4902   struct ppc_link_hash_table *htab;
4903   struct ppc_link_hash_entry *fdh;
4904
4905   if (eh->elf.root.type == bfd_link_hash_indirect)
4906     return TRUE;
4907
4908   if (eh->elf.root.type == bfd_link_hash_warning)
4909     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4910
4911   if (eh->elf.root.root.string[0] != '.')
4912     abort ();
4913
4914   htab = ppc_hash_table (info);
4915   if (htab == NULL)
4916     return FALSE;
4917
4918   fdh = lookup_fdh (eh, htab);
4919   if (fdh == NULL)
4920     {
4921       if (!info->relocatable
4922           && (eh->elf.root.type == bfd_link_hash_undefined
4923               || eh->elf.root.type == bfd_link_hash_undefweak)
4924           && eh->elf.ref_regular)
4925         {
4926           /* Make an undefweak function descriptor sym, which is enough to
4927              pull in an --as-needed shared lib, but won't cause link
4928              errors.  Archives are handled elsewhere.  */
4929           fdh = make_fdh (info, eh);
4930           if (fdh == NULL)
4931             return FALSE;
4932           fdh->elf.ref_regular = 1;
4933         }
4934     }
4935   else
4936     {
4937       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4938       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4939       if (entry_vis < descr_vis)
4940         fdh->elf.other += entry_vis - descr_vis;
4941       else if (entry_vis > descr_vis)
4942         eh->elf.other += descr_vis - entry_vis;
4943
4944       if ((fdh->elf.root.type == bfd_link_hash_defined
4945            || fdh->elf.root.type == bfd_link_hash_defweak)
4946           && eh->elf.root.type == bfd_link_hash_undefined)
4947         {
4948           eh->elf.root.type = bfd_link_hash_undefweak;
4949           eh->was_undefined = 1;
4950           htab->twiddled_syms = 1;
4951         }
4952     }
4953
4954   return TRUE;
4955 }
4956
4957 /* Set up opd section info and abiversion for IBFD, and process list
4958    of dot-symbols we made in link_hash_newfunc.  */
4959
4960 static bfd_boolean
4961 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4962 {
4963   struct ppc_link_hash_table *htab;
4964   struct ppc_link_hash_entry **p, *eh;
4965
4966   if (!is_ppc64_elf (info->output_bfd))
4967     return TRUE;
4968   htab = ppc_hash_table (info);
4969   if (htab == NULL)
4970     return FALSE;
4971
4972   if (is_ppc64_elf (ibfd))
4973     {
4974       asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4975
4976       if (opd != NULL && opd->size != 0)
4977         {
4978           if (abiversion (ibfd) == 0)
4979             set_abiversion (ibfd, 1);
4980           else if (abiversion (ibfd) == 2)
4981             {
4982               info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4983                                         " version %d\n"),
4984                                       ibfd, abiversion (ibfd));
4985               bfd_set_error (bfd_error_bad_value);
4986               return FALSE;
4987             }
4988
4989           if ((ibfd->flags & DYNAMIC) == 0
4990               && (opd->flags & SEC_RELOC) != 0
4991               && opd->reloc_count != 0
4992               && !bfd_is_abs_section (opd->output_section))
4993             {
4994               /* Garbage collection needs some extra help with .opd sections.
4995                  We don't want to necessarily keep everything referenced by
4996                  relocs in .opd, as that would keep all functions.  Instead,
4997                  if we reference an .opd symbol (a function descriptor), we
4998                  want to keep the function code symbol's section.  This is
4999                  easy for global symbols, but for local syms we need to keep
5000                  information about the associated function section.  */
5001               bfd_size_type amt;
5002               asection **opd_sym_map;
5003
5004               amt = opd->size * sizeof (*opd_sym_map) / 8;
5005               opd_sym_map = bfd_zalloc (ibfd, amt);
5006               if (opd_sym_map == NULL)
5007                 return FALSE;
5008               ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5009               BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5010               ppc64_elf_section_data (opd)->sec_type = sec_opd;
5011             }
5012         }
5013
5014       /* For input files without an explicit abiversion in e_flags
5015          we should have flagged any with symbol st_other bits set
5016          as ELFv1 and above flagged those with .opd as ELFv2.
5017          Set the output abiversion if not yet set, and for any input
5018          still ambiguous, take its abiversion from the output.
5019          Differences in ABI are reported later.  */
5020       if (abiversion (info->output_bfd) == 0)
5021         set_abiversion (info->output_bfd, abiversion (ibfd));
5022       else if (abiversion (ibfd) == 0)
5023         set_abiversion (ibfd, abiversion (info->output_bfd));
5024
5025       p = &htab->dot_syms;
5026       while ((eh = *p) != NULL)
5027         {
5028           *p = NULL;
5029           if (&eh->elf == htab->elf.hgot)
5030             ;
5031           else if (htab->elf.hgot == NULL
5032                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5033             htab->elf.hgot = &eh->elf;
5034           else if (!add_symbol_adjust (eh, info))
5035             return FALSE;
5036           p = &eh->u.next_dot_sym;
5037         }
5038     }
5039
5040   /* Clear the list for non-ppc64 input files.  */
5041   p = &htab->dot_syms;
5042   while ((eh = *p) != NULL)
5043     {
5044       *p = NULL;
5045       p = &eh->u.next_dot_sym;
5046     }
5047
5048   /* We need to fix the undefs list for any syms we have twiddled to
5049      undef_weak.  */
5050   if (htab->twiddled_syms)
5051     {
5052       bfd_link_repair_undef_list (&htab->elf.root);
5053       htab->twiddled_syms = 0;
5054     }
5055   return TRUE;
5056 }
5057
5058 /* Undo hash table changes when an --as-needed input file is determined
5059    not to be needed.  */
5060
5061 static bfd_boolean
5062 ppc64_elf_notice_as_needed (bfd *ibfd,
5063                             struct bfd_link_info *info,
5064                             enum notice_asneeded_action act)
5065 {
5066   if (act == notice_not_needed)
5067     {
5068       struct ppc_link_hash_table *htab = ppc_hash_table (info);
5069
5070       if (htab == NULL)
5071         return FALSE;
5072
5073       htab->dot_syms = NULL;
5074     }
5075   return _bfd_elf_notice_as_needed (ibfd, info, act);
5076 }
5077
5078 /* If --just-symbols against a final linked binary, then assume we need
5079    toc adjusting stubs when calling functions defined there.  */
5080
5081 static void
5082 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5083 {
5084   if ((sec->flags & SEC_CODE) != 0
5085       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5086       && is_ppc64_elf (sec->owner))
5087     {
5088       if (abiversion (sec->owner) >= 2
5089           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5090         sec->has_toc_reloc = 1;
5091     }
5092   _bfd_elf_link_just_syms (sec, info);
5093 }
5094
5095 static struct plt_entry **
5096 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5097                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5098 {
5099   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5100   struct plt_entry **local_plt;
5101   unsigned char *local_got_tls_masks;
5102
5103   if (local_got_ents == NULL)
5104     {
5105       bfd_size_type size = symtab_hdr->sh_info;
5106
5107       size *= (sizeof (*local_got_ents)
5108                + sizeof (*local_plt)
5109                + sizeof (*local_got_tls_masks));
5110       local_got_ents = bfd_zalloc (abfd, size);
5111       if (local_got_ents == NULL)
5112         return NULL;
5113       elf_local_got_ents (abfd) = local_got_ents;
5114     }
5115
5116   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5117     {
5118       struct got_entry *ent;
5119
5120       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5121         if (ent->addend == r_addend
5122             && ent->owner == abfd
5123             && ent->tls_type == tls_type)
5124           break;
5125       if (ent == NULL)
5126         {
5127           bfd_size_type amt = sizeof (*ent);
5128           ent = bfd_alloc (abfd, amt);
5129           if (ent == NULL)
5130             return FALSE;
5131           ent->next = local_got_ents[r_symndx];
5132           ent->addend = r_addend;
5133           ent->owner = abfd;
5134           ent->tls_type = tls_type;
5135           ent->is_indirect = FALSE;
5136           ent->got.refcount = 0;
5137           local_got_ents[r_symndx] = ent;
5138         }
5139       ent->got.refcount += 1;
5140     }
5141
5142   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5143   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5144   local_got_tls_masks[r_symndx] |= tls_type;
5145
5146   return local_plt + r_symndx;
5147 }
5148
5149 static bfd_boolean
5150 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5151 {
5152   struct plt_entry *ent;
5153
5154   for (ent = *plist; ent != NULL; ent = ent->next)
5155     if (ent->addend == addend)
5156       break;
5157   if (ent == NULL)
5158     {
5159       bfd_size_type amt = sizeof (*ent);
5160       ent = bfd_alloc (abfd, amt);
5161       if (ent == NULL)
5162         return FALSE;
5163       ent->next = *plist;
5164       ent->addend = addend;
5165       ent->plt.refcount = 0;
5166       *plist = ent;
5167     }
5168   ent->plt.refcount += 1;
5169   return TRUE;
5170 }
5171
5172 static bfd_boolean
5173 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5174 {
5175   return (r_type == R_PPC64_REL24
5176           || r_type == R_PPC64_REL14
5177           || r_type == R_PPC64_REL14_BRTAKEN
5178           || r_type == R_PPC64_REL14_BRNTAKEN
5179           || r_type == R_PPC64_ADDR24
5180           || r_type == R_PPC64_ADDR14
5181           || r_type == R_PPC64_ADDR14_BRTAKEN
5182           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5183 }
5184
5185 /* Look through the relocs for a section during the first phase, and
5186    calculate needed space in the global offset table, procedure
5187    linkage table, and dynamic reloc sections.  */
5188
5189 static bfd_boolean
5190 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5191                         asection *sec, const Elf_Internal_Rela *relocs)
5192 {
5193   struct ppc_link_hash_table *htab;
5194   Elf_Internal_Shdr *symtab_hdr;
5195   struct elf_link_hash_entry **sym_hashes;
5196   const Elf_Internal_Rela *rel;
5197   const Elf_Internal_Rela *rel_end;
5198   asection *sreloc;
5199   asection **opd_sym_map;
5200   struct elf_link_hash_entry *tga, *dottga;
5201
5202   if (info->relocatable)
5203     return TRUE;
5204
5205   /* Don't do anything special with non-loaded, non-alloced sections.
5206      In particular, any relocs in such sections should not affect GOT
5207      and PLT reference counting (ie. we don't allow them to create GOT
5208      or PLT entries), there's no possibility or desire to optimize TLS
5209      relocs, and there's not much point in propagating relocs to shared
5210      libs that the dynamic linker won't relocate.  */
5211   if ((sec->flags & SEC_ALLOC) == 0)
5212     return TRUE;
5213
5214   BFD_ASSERT (is_ppc64_elf (abfd));
5215
5216   htab = ppc_hash_table (info);
5217   if (htab == NULL)
5218     return FALSE;
5219
5220   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5221                               FALSE, FALSE, TRUE);
5222   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5223                                  FALSE, FALSE, TRUE);
5224   symtab_hdr = &elf_symtab_hdr (abfd);
5225   sym_hashes = elf_sym_hashes (abfd);
5226   sreloc = NULL;
5227   opd_sym_map = NULL;
5228   if (ppc64_elf_section_data (sec) != NULL
5229       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5230     opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5231
5232   rel_end = relocs + sec->reloc_count;
5233   for (rel = relocs; rel < rel_end; rel++)
5234     {
5235       unsigned long r_symndx;
5236       struct elf_link_hash_entry *h;
5237       enum elf_ppc64_reloc_type r_type;
5238       int tls_type;
5239       struct _ppc64_elf_section_data *ppc64_sec;
5240       struct plt_entry **ifunc;
5241
5242       r_symndx = ELF64_R_SYM (rel->r_info);
5243       if (r_symndx < symtab_hdr->sh_info)
5244         h = NULL;
5245       else
5246         {
5247           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5248           h = elf_follow_link (h);
5249
5250           /* PR15323, ref flags aren't set for references in the same
5251              object.  */
5252           h->root.non_ir_ref = 1;
5253
5254           if (h == htab->elf.hgot)
5255             sec->has_toc_reloc = 1;
5256         }
5257
5258       tls_type = 0;
5259       ifunc = NULL;
5260       if (h != NULL)
5261         {
5262           if (h->type == STT_GNU_IFUNC)
5263             {
5264               h->needs_plt = 1;
5265               ifunc = &h->plt.plist;
5266             }
5267         }
5268       else
5269         {
5270           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5271                                                           abfd, r_symndx);
5272           if (isym == NULL)
5273             return FALSE;
5274
5275           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5276             {
5277               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5278                                              rel->r_addend, PLT_IFUNC);
5279               if (ifunc == NULL)
5280                 return FALSE;
5281             }
5282         }
5283       r_type = ELF64_R_TYPE (rel->r_info);
5284       if (is_branch_reloc (r_type))
5285         {
5286           if (h != NULL && (h == tga || h == dottga))
5287             {
5288               if (rel != relocs
5289                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5290                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5291                 /* We have a new-style __tls_get_addr call with a marker
5292                    reloc.  */
5293                 ;
5294               else
5295                 /* Mark this section as having an old-style call.  */
5296                 sec->has_tls_get_addr_call = 1;
5297             }
5298
5299           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5300           if (ifunc != NULL
5301               && !update_plt_info (abfd, ifunc, rel->r_addend))
5302             return FALSE;
5303         }
5304
5305       switch (r_type)
5306         {
5307         case R_PPC64_TLSGD:
5308         case R_PPC64_TLSLD:
5309           /* These special tls relocs tie a call to __tls_get_addr with
5310              its parameter symbol.  */
5311           break;
5312
5313         case R_PPC64_GOT_TLSLD16:
5314         case R_PPC64_GOT_TLSLD16_LO:
5315         case R_PPC64_GOT_TLSLD16_HI:
5316         case R_PPC64_GOT_TLSLD16_HA:
5317           tls_type = TLS_TLS | TLS_LD;
5318           goto dogottls;
5319
5320         case R_PPC64_GOT_TLSGD16:
5321         case R_PPC64_GOT_TLSGD16_LO:
5322         case R_PPC64_GOT_TLSGD16_HI:
5323         case R_PPC64_GOT_TLSGD16_HA:
5324           tls_type = TLS_TLS | TLS_GD;
5325           goto dogottls;
5326
5327         case R_PPC64_GOT_TPREL16_DS:
5328         case R_PPC64_GOT_TPREL16_LO_DS:
5329         case R_PPC64_GOT_TPREL16_HI:
5330         case R_PPC64_GOT_TPREL16_HA:
5331           if (info->shared)
5332             info->flags |= DF_STATIC_TLS;
5333           tls_type = TLS_TLS | TLS_TPREL;
5334           goto dogottls;
5335
5336         case R_PPC64_GOT_DTPREL16_DS:
5337         case R_PPC64_GOT_DTPREL16_LO_DS:
5338         case R_PPC64_GOT_DTPREL16_HI:
5339         case R_PPC64_GOT_DTPREL16_HA:
5340           tls_type = TLS_TLS | TLS_DTPREL;
5341         dogottls:
5342           sec->has_tls_reloc = 1;
5343           /* Fall thru */
5344
5345         case R_PPC64_GOT16:
5346         case R_PPC64_GOT16_DS:
5347         case R_PPC64_GOT16_HA:
5348         case R_PPC64_GOT16_HI:
5349         case R_PPC64_GOT16_LO:
5350         case R_PPC64_GOT16_LO_DS:
5351           /* This symbol requires a global offset table entry.  */
5352           sec->has_toc_reloc = 1;
5353           if (r_type == R_PPC64_GOT_TLSLD16
5354               || r_type == R_PPC64_GOT_TLSGD16
5355               || r_type == R_PPC64_GOT_TPREL16_DS
5356               || r_type == R_PPC64_GOT_DTPREL16_DS
5357               || r_type == R_PPC64_GOT16
5358               || r_type == R_PPC64_GOT16_DS)
5359             {
5360               htab->do_multi_toc = 1;
5361               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5362             }
5363
5364           if (ppc64_elf_tdata (abfd)->got == NULL
5365               && !create_got_section (abfd, info))
5366             return FALSE;
5367
5368           if (h != NULL)
5369             {
5370               struct ppc_link_hash_entry *eh;
5371               struct got_entry *ent;
5372
5373               eh = (struct ppc_link_hash_entry *) h;
5374               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5375                 if (ent->addend == rel->r_addend
5376                     && ent->owner == abfd
5377                     && ent->tls_type == tls_type)
5378                   break;
5379               if (ent == NULL)
5380                 {
5381                   bfd_size_type amt = sizeof (*ent);
5382                   ent = bfd_alloc (abfd, amt);
5383                   if (ent == NULL)
5384                     return FALSE;
5385                   ent->next = eh->elf.got.glist;
5386                   ent->addend = rel->r_addend;
5387                   ent->owner = abfd;
5388                   ent->tls_type = tls_type;
5389                   ent->is_indirect = FALSE;
5390                   ent->got.refcount = 0;
5391                   eh->elf.got.glist = ent;
5392                 }
5393               ent->got.refcount += 1;
5394               eh->tls_mask |= tls_type;
5395             }
5396           else
5397             /* This is a global offset table entry for a local symbol.  */
5398             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5399                                         rel->r_addend, tls_type))
5400               return FALSE;
5401
5402           /* We may also need a plt entry if the symbol turns out to be
5403              an ifunc.  */
5404           if (h != NULL && !info->shared && abiversion (abfd) != 1)
5405             {
5406               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5407                 return FALSE;
5408             }
5409           break;
5410
5411         case R_PPC64_PLT16_HA:
5412         case R_PPC64_PLT16_HI:
5413         case R_PPC64_PLT16_LO:
5414         case R_PPC64_PLT32:
5415         case R_PPC64_PLT64:
5416           /* This symbol requires a procedure linkage table entry.  We
5417              actually build the entry in adjust_dynamic_symbol,
5418              because this might be a case of linking PIC code without
5419              linking in any dynamic objects, in which case we don't
5420              need to generate a procedure linkage table after all.  */
5421           if (h == NULL)
5422             {
5423               /* It does not make sense to have a procedure linkage
5424                  table entry for a local symbol.  */
5425               bfd_set_error (bfd_error_bad_value);
5426               return FALSE;
5427             }
5428           else
5429             {
5430               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5431                 return FALSE;
5432               h->needs_plt = 1;
5433               if (h->root.root.string[0] == '.'
5434                   && h->root.root.string[1] != '\0')
5435                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5436             }
5437           break;
5438
5439           /* The following relocations don't need to propagate the
5440              relocation if linking a shared object since they are
5441              section relative.  */
5442         case R_PPC64_SECTOFF:
5443         case R_PPC64_SECTOFF_LO:
5444         case R_PPC64_SECTOFF_HI:
5445         case R_PPC64_SECTOFF_HA:
5446         case R_PPC64_SECTOFF_DS:
5447         case R_PPC64_SECTOFF_LO_DS:
5448         case R_PPC64_DTPREL16:
5449         case R_PPC64_DTPREL16_LO:
5450         case R_PPC64_DTPREL16_HI:
5451         case R_PPC64_DTPREL16_HA:
5452         case R_PPC64_DTPREL16_DS:
5453         case R_PPC64_DTPREL16_LO_DS:
5454         case R_PPC64_DTPREL16_HIGH:
5455         case R_PPC64_DTPREL16_HIGHA:
5456         case R_PPC64_DTPREL16_HIGHER:
5457         case R_PPC64_DTPREL16_HIGHERA:
5458         case R_PPC64_DTPREL16_HIGHEST:
5459         case R_PPC64_DTPREL16_HIGHESTA:
5460           break;
5461
5462           /* Nor do these.  */
5463         case R_PPC64_REL16:
5464         case R_PPC64_REL16_LO:
5465         case R_PPC64_REL16_HI:
5466         case R_PPC64_REL16_HA:
5467           break;
5468
5469           /* Not supported as a dynamic relocation.  */
5470         case R_PPC64_ADDR64_LOCAL:
5471           if (info->shared)
5472             {
5473               if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5474                 ppc_howto_init ();
5475               info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5476                                         "in shared libraries and PIEs.\n"),
5477                                       abfd, sec, rel->r_offset,
5478                                       ppc64_elf_howto_table[r_type]->name);
5479               bfd_set_error (bfd_error_bad_value);
5480               return FALSE;
5481             }
5482           break;
5483
5484         case R_PPC64_TOC16:
5485         case R_PPC64_TOC16_DS:
5486           htab->do_multi_toc = 1;
5487           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5488         case R_PPC64_TOC16_LO:
5489         case R_PPC64_TOC16_HI:
5490         case R_PPC64_TOC16_HA:
5491         case R_PPC64_TOC16_LO_DS:
5492           sec->has_toc_reloc = 1;
5493           break;
5494
5495           /* This relocation describes the C++ object vtable hierarchy.
5496              Reconstruct it for later use during GC.  */
5497         case R_PPC64_GNU_VTINHERIT:
5498           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5499             return FALSE;
5500           break;
5501
5502           /* This relocation describes which C++ vtable entries are actually
5503              used.  Record for later use during GC.  */
5504         case R_PPC64_GNU_VTENTRY:
5505           BFD_ASSERT (h != NULL);
5506           if (h != NULL
5507               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5508             return FALSE;
5509           break;
5510
5511         case R_PPC64_REL14:
5512         case R_PPC64_REL14_BRTAKEN:
5513         case R_PPC64_REL14_BRNTAKEN:
5514           {
5515             asection *dest = NULL;
5516
5517             /* Heuristic: If jumping outside our section, chances are
5518                we are going to need a stub.  */
5519             if (h != NULL)
5520               {
5521                 /* If the sym is weak it may be overridden later, so
5522                    don't assume we know where a weak sym lives.  */
5523                 if (h->root.type == bfd_link_hash_defined)
5524                   dest = h->root.u.def.section;
5525               }
5526             else
5527               {
5528                 Elf_Internal_Sym *isym;
5529
5530                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5531                                               abfd, r_symndx);
5532                 if (isym == NULL)
5533                   return FALSE;
5534
5535                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5536               }
5537
5538             if (dest != sec)
5539               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5540           }
5541           /* Fall through.  */
5542
5543         case R_PPC64_REL24:
5544           if (h != NULL && ifunc == NULL)
5545             {
5546               /* We may need a .plt entry if the function this reloc
5547                  refers to is in a shared lib.  */
5548               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5549                 return FALSE;
5550               h->needs_plt = 1;
5551               if (h->root.root.string[0] == '.'
5552                   && h->root.root.string[1] != '\0')
5553                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5554               if (h == tga || h == dottga)
5555                 sec->has_tls_reloc = 1;
5556             }
5557           break;
5558
5559         case R_PPC64_TPREL64:
5560           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5561           if (info->shared)
5562             info->flags |= DF_STATIC_TLS;
5563           goto dotlstoc;
5564
5565         case R_PPC64_DTPMOD64:
5566           if (rel + 1 < rel_end
5567               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5568               && rel[1].r_offset == rel->r_offset + 8)
5569             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5570           else
5571             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5572           goto dotlstoc;
5573
5574         case R_PPC64_DTPREL64:
5575           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5576           if (rel != relocs
5577               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5578               && rel[-1].r_offset == rel->r_offset - 8)
5579             /* This is the second reloc of a dtpmod, dtprel pair.
5580                Don't mark with TLS_DTPREL.  */
5581             goto dodyn;
5582
5583         dotlstoc:
5584           sec->has_tls_reloc = 1;
5585           if (h != NULL)
5586             {
5587               struct ppc_link_hash_entry *eh;
5588               eh = (struct ppc_link_hash_entry *) h;
5589               eh->tls_mask |= tls_type;
5590             }
5591           else
5592             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5593                                         rel->r_addend, tls_type))
5594               return FALSE;
5595
5596           ppc64_sec = ppc64_elf_section_data (sec);
5597           if (ppc64_sec->sec_type != sec_toc)
5598             {
5599               bfd_size_type amt;
5600
5601               /* One extra to simplify get_tls_mask.  */
5602               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5603               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5604               if (ppc64_sec->u.toc.symndx == NULL)
5605                 return FALSE;
5606               amt = sec->size * sizeof (bfd_vma) / 8;
5607               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5608               if (ppc64_sec->u.toc.add == NULL)
5609                 return FALSE;
5610               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5611               ppc64_sec->sec_type = sec_toc;
5612             }
5613           BFD_ASSERT (rel->r_offset % 8 == 0);
5614           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5615           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5616
5617           /* Mark the second slot of a GD or LD entry.
5618              -1 to indicate GD and -2 to indicate LD.  */
5619           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5620             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5621           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5622             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5623           goto dodyn;
5624
5625         case R_PPC64_TPREL16:
5626         case R_PPC64_TPREL16_LO:
5627         case R_PPC64_TPREL16_HI:
5628         case R_PPC64_TPREL16_HA:
5629         case R_PPC64_TPREL16_DS:
5630         case R_PPC64_TPREL16_LO_DS:
5631         case R_PPC64_TPREL16_HIGH:
5632         case R_PPC64_TPREL16_HIGHA:
5633         case R_PPC64_TPREL16_HIGHER:
5634         case R_PPC64_TPREL16_HIGHERA:
5635         case R_PPC64_TPREL16_HIGHEST:
5636         case R_PPC64_TPREL16_HIGHESTA:
5637           if (info->shared)
5638             {
5639               info->flags |= DF_STATIC_TLS;
5640               goto dodyn;
5641             }
5642           break;
5643
5644         case R_PPC64_ADDR64:
5645           if (opd_sym_map != NULL
5646               && rel + 1 < rel_end
5647               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5648             {
5649               if (h != NULL)
5650                 {
5651                   if (h->root.root.string[0] == '.'
5652                       && h->root.root.string[1] != 0
5653                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5654                     ;
5655                   else
5656                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5657                 }
5658               else
5659                 {
5660                   asection *s;
5661                   Elf_Internal_Sym *isym;
5662
5663                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5664                                                 abfd, r_symndx);
5665                   if (isym == NULL)
5666                     return FALSE;
5667
5668                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5669                   if (s != NULL && s != sec)
5670                     opd_sym_map[rel->r_offset / 8] = s;
5671                 }
5672             }
5673           /* Fall through.  */
5674
5675         case R_PPC64_ADDR16:
5676         case R_PPC64_ADDR16_DS:
5677         case R_PPC64_ADDR16_HA:
5678         case R_PPC64_ADDR16_HI:
5679         case R_PPC64_ADDR16_HIGH:
5680         case R_PPC64_ADDR16_HIGHA:
5681         case R_PPC64_ADDR16_HIGHER:
5682         case R_PPC64_ADDR16_HIGHERA:
5683         case R_PPC64_ADDR16_HIGHEST:
5684         case R_PPC64_ADDR16_HIGHESTA:
5685         case R_PPC64_ADDR16_LO:
5686         case R_PPC64_ADDR16_LO_DS:
5687           if (h != NULL && !info->shared && abiversion (abfd) != 1
5688               && rel->r_addend == 0)
5689             {
5690               /* We may need a .plt entry if this reloc refers to a
5691                  function in a shared lib.  */
5692               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5693                 return FALSE;
5694               h->pointer_equality_needed = 1;
5695             }
5696           /* Fall through.  */
5697
5698         case R_PPC64_REL30:
5699         case R_PPC64_REL32:
5700         case R_PPC64_REL64:
5701         case R_PPC64_ADDR14:
5702         case R_PPC64_ADDR14_BRNTAKEN:
5703         case R_PPC64_ADDR14_BRTAKEN:
5704         case R_PPC64_ADDR24:
5705         case R_PPC64_ADDR32:
5706         case R_PPC64_UADDR16:
5707         case R_PPC64_UADDR32:
5708         case R_PPC64_UADDR64:
5709         case R_PPC64_TOC:
5710           if (h != NULL && !info->shared)
5711             /* We may need a copy reloc.  */
5712             h->non_got_ref = 1;
5713
5714           /* Don't propagate .opd relocs.  */
5715           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5716             break;
5717
5718           /* If we are creating a shared library, and this is a reloc
5719              against a global symbol, or a non PC relative reloc
5720              against a local symbol, then we need to copy the reloc
5721              into the shared library.  However, if we are linking with
5722              -Bsymbolic, we do not need to copy a reloc against a
5723              global symbol which is defined in an object we are
5724              including in the link (i.e., DEF_REGULAR is set).  At
5725              this point we have not seen all the input files, so it is
5726              possible that DEF_REGULAR is not set now but will be set
5727              later (it is never cleared).  In case of a weak definition,
5728              DEF_REGULAR may be cleared later by a strong definition in
5729              a shared library.  We account for that possibility below by
5730              storing information in the dyn_relocs field of the hash
5731              table entry.  A similar situation occurs when creating
5732              shared libraries and symbol visibility changes render the
5733              symbol local.
5734
5735              If on the other hand, we are creating an executable, we
5736              may need to keep relocations for symbols satisfied by a
5737              dynamic library if we manage to avoid copy relocs for the
5738              symbol.  */
5739         dodyn:
5740           if ((info->shared
5741                && (must_be_dyn_reloc (info, r_type)
5742                    || (h != NULL
5743                        && (!SYMBOLIC_BIND (info, h)
5744                            || h->root.type == bfd_link_hash_defweak
5745                            || !h->def_regular))))
5746               || (ELIMINATE_COPY_RELOCS
5747                   && !info->shared
5748                   && h != NULL
5749                   && (h->root.type == bfd_link_hash_defweak
5750                       || !h->def_regular))
5751               || (!info->shared
5752                   && ifunc != NULL))
5753             {
5754               /* We must copy these reloc types into the output file.
5755                  Create a reloc section in dynobj and make room for
5756                  this reloc.  */
5757               if (sreloc == NULL)
5758                 {
5759                   sreloc = _bfd_elf_make_dynamic_reloc_section
5760                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5761
5762                   if (sreloc == NULL)
5763                     return FALSE;
5764                 }
5765
5766               /* If this is a global symbol, we count the number of
5767                  relocations we need for this symbol.  */
5768               if (h != NULL)
5769                 {
5770                   struct elf_dyn_relocs *p;
5771                   struct elf_dyn_relocs **head;
5772
5773                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5774                   p = *head;
5775                   if (p == NULL || p->sec != sec)
5776                     {
5777                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5778                       if (p == NULL)
5779                         return FALSE;
5780                       p->next = *head;
5781                       *head = p;
5782                       p->sec = sec;
5783                       p->count = 0;
5784                       p->pc_count = 0;
5785                     }
5786                   p->count += 1;
5787                   if (!must_be_dyn_reloc (info, r_type))
5788                     p->pc_count += 1;
5789                 }
5790               else
5791                 {
5792                   /* Track dynamic relocs needed for local syms too.
5793                      We really need local syms available to do this
5794                      easily.  Oh well.  */
5795                   struct ppc_dyn_relocs *p;
5796                   struct ppc_dyn_relocs **head;
5797                   bfd_boolean is_ifunc;
5798                   asection *s;
5799                   void *vpp;
5800                   Elf_Internal_Sym *isym;
5801
5802                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5803                                                 abfd, r_symndx);
5804                   if (isym == NULL)
5805                     return FALSE;
5806
5807                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5808                   if (s == NULL)
5809                     s = sec;
5810
5811                   vpp = &elf_section_data (s)->local_dynrel;
5812                   head = (struct ppc_dyn_relocs **) vpp;
5813                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5814                   p = *head;
5815                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5816                     p = p->next;
5817                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5818                     {
5819                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5820                       if (p == NULL)
5821                         return FALSE;
5822                       p->next = *head;
5823                       *head = p;
5824                       p->sec = sec;
5825                       p->ifunc = is_ifunc;
5826                       p->count = 0;
5827                     }
5828                   p->count += 1;
5829                 }
5830             }
5831           break;
5832
5833         default:
5834           break;
5835         }
5836     }
5837
5838   return TRUE;
5839 }
5840
5841 /* Merge backend specific data from an object file to the output
5842    object file when linking.  */
5843
5844 static bfd_boolean
5845 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5846 {
5847   unsigned long iflags, oflags;
5848
5849   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5850     return TRUE;
5851
5852   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5853     return TRUE;
5854
5855   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5856     return FALSE;
5857
5858   iflags = elf_elfheader (ibfd)->e_flags;
5859   oflags = elf_elfheader (obfd)->e_flags;
5860
5861   if (iflags & ~EF_PPC64_ABI)
5862     {
5863       (*_bfd_error_handler)
5864         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5865       bfd_set_error (bfd_error_bad_value);
5866       return FALSE;
5867     }
5868   else if (iflags != oflags && iflags != 0)
5869     {
5870       (*_bfd_error_handler)
5871         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5872          ibfd, iflags, oflags);
5873       bfd_set_error (bfd_error_bad_value);
5874       return FALSE;
5875     }
5876
5877   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5878   _bfd_elf_merge_object_attributes (ibfd, obfd);
5879
5880   return TRUE;
5881 }
5882
5883 static bfd_boolean
5884 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5885 {
5886   /* Print normal ELF private data.  */
5887   _bfd_elf_print_private_bfd_data (abfd, ptr);
5888
5889   if (elf_elfheader (abfd)->e_flags != 0)
5890     {
5891       FILE *file = ptr;
5892
5893       /* xgettext:c-format */
5894       fprintf (file, _("private flags = 0x%lx:"),
5895                elf_elfheader (abfd)->e_flags);
5896
5897       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5898         fprintf (file, _(" [abiv%ld]"),
5899                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5900       fputc ('\n', file);
5901     }
5902
5903   return TRUE;
5904 }
5905
5906 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5907    of the code entry point, and its section.  */
5908
5909 static bfd_vma
5910 opd_entry_value (asection *opd_sec,
5911                  bfd_vma offset,
5912                  asection **code_sec,
5913                  bfd_vma *code_off,
5914                  bfd_boolean in_code_sec)
5915 {
5916   bfd *opd_bfd = opd_sec->owner;
5917   Elf_Internal_Rela *relocs;
5918   Elf_Internal_Rela *lo, *hi, *look;
5919   bfd_vma val;
5920
5921   /* No relocs implies we are linking a --just-symbols object, or looking
5922      at a final linked executable with addr2line or somesuch.  */
5923   if (opd_sec->reloc_count == 0)
5924     {
5925       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5926
5927       if (contents == NULL)
5928         {
5929           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5930             return (bfd_vma) -1;
5931           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5932         }
5933
5934       val = bfd_get_64 (opd_bfd, contents + offset);
5935       if (code_sec != NULL)
5936         {
5937           asection *sec, *likely = NULL;
5938
5939           if (in_code_sec)
5940             {
5941               sec = *code_sec;
5942               if (sec->vma <= val
5943                   && val < sec->vma + sec->size)
5944                 likely = sec;
5945               else
5946                 val = -1;
5947             }
5948           else
5949             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5950               if (sec->vma <= val
5951                   && (sec->flags & SEC_LOAD) != 0
5952                   && (sec->flags & SEC_ALLOC) != 0)
5953                 likely = sec;
5954           if (likely != NULL)
5955             {
5956               *code_sec = likely;
5957               if (code_off != NULL)
5958                 *code_off = val - likely->vma;
5959             }
5960         }
5961       return val;
5962     }
5963
5964   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5965
5966   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5967   if (relocs == NULL)
5968     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5969
5970   /* Go find the opd reloc at the sym address.  */
5971   lo = relocs;
5972   BFD_ASSERT (lo != NULL);
5973   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5974   val = (bfd_vma) -1;
5975   while (lo < hi)
5976     {
5977       look = lo + (hi - lo) / 2;
5978       if (look->r_offset < offset)
5979         lo = look + 1;
5980       else if (look->r_offset > offset)
5981         hi = look;
5982       else
5983         {
5984           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5985
5986           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5987               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5988             {
5989               unsigned long symndx = ELF64_R_SYM (look->r_info);
5990               asection *sec;
5991
5992               if (symndx < symtab_hdr->sh_info
5993                   || elf_sym_hashes (opd_bfd) == NULL)
5994                 {
5995                   Elf_Internal_Sym *sym;
5996
5997                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5998                   if (sym == NULL)
5999                     {
6000                       size_t symcnt = symtab_hdr->sh_info;
6001                       if (elf_sym_hashes (opd_bfd) == NULL)
6002                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
6003                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
6004                                                   0, NULL, NULL, NULL);
6005                       if (sym == NULL)
6006                         break;
6007                       symtab_hdr->contents = (bfd_byte *) sym;
6008                     }
6009
6010                   sym += symndx;
6011                   val = sym->st_value;
6012                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6013                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6014                 }
6015               else
6016                 {
6017                   struct elf_link_hash_entry **sym_hashes;
6018                   struct elf_link_hash_entry *rh;
6019
6020                   sym_hashes = elf_sym_hashes (opd_bfd);
6021                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
6022                   if (rh != NULL)
6023                     {
6024                       rh = elf_follow_link (rh);
6025                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6026                                   || rh->root.type == bfd_link_hash_defweak);
6027                       val = rh->root.u.def.value;
6028                       sec = rh->root.u.def.section;
6029                     }
6030                   else
6031                     {
6032                       /* Handle the odd case where we can be called
6033                          during bfd_elf_link_add_symbols before the
6034                          symbol hashes have been fully populated.  */
6035                       Elf_Internal_Sym *sym;
6036
6037                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6038                                                   symndx, NULL, NULL, NULL);
6039                       if (sym == NULL)
6040                         break;
6041
6042                       val = sym->st_value;
6043                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6044                       free (sym);
6045                     }
6046                 }
6047               val += look->r_addend;
6048               if (code_off != NULL)
6049                 *code_off = val;
6050               if (code_sec != NULL)
6051                 {
6052                   if (in_code_sec && *code_sec != sec)
6053                     return -1;
6054                   else
6055                     *code_sec = sec;
6056                 }
6057               if (sec != NULL && sec->output_section != NULL)
6058                 val += sec->output_section->vma + sec->output_offset;
6059             }
6060           break;
6061         }
6062     }
6063
6064   return val;
6065 }
6066
6067 /* If the ELF symbol SYM might be a function in SEC, return the
6068    function size and set *CODE_OFF to the function's entry point,
6069    otherwise return zero.  */
6070
6071 static bfd_size_type
6072 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6073                               bfd_vma *code_off)
6074 {
6075   bfd_size_type size;
6076
6077   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6078                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6079     return 0;
6080
6081   size = 0;
6082   if (!(sym->flags & BSF_SYNTHETIC))
6083     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6084
6085   if (strcmp (sym->section->name, ".opd") == 0)
6086     {
6087       if (opd_entry_value (sym->section, sym->value,
6088                            &sec, code_off, TRUE) == (bfd_vma) -1)
6089         return 0;
6090       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6091          symbol.  This size has nothing to do with the code size of the
6092          function, which is what we're supposed to return, but the
6093          code size isn't available without looking up the dot-sym.
6094          However, doing that would be a waste of time particularly
6095          since elf_find_function will look at the dot-sym anyway.
6096          Now, elf_find_function will keep the largest size of any
6097          function sym found at the code address of interest, so return
6098          1 here to avoid it incorrectly caching a larger function size
6099          for a small function.  This does mean we return the wrong
6100          size for a new-ABI function of size 24, but all that does is
6101          disable caching for such functions.  */
6102       if (size == 24)
6103         size = 1;
6104     }
6105   else
6106     {
6107       if (sym->section != sec)
6108         return 0;
6109       *code_off = sym->value;
6110     }
6111   if (size == 0)
6112     size = 1;
6113   return size;
6114 }
6115
6116 /* Return true if symbol is defined in a regular object file.  */
6117
6118 static bfd_boolean
6119 is_static_defined (struct elf_link_hash_entry *h)
6120 {
6121   return ((h->root.type == bfd_link_hash_defined
6122            || h->root.type == bfd_link_hash_defweak)
6123           && h->root.u.def.section != NULL
6124           && h->root.u.def.section->output_section != NULL);
6125 }
6126
6127 /* If FDH is a function descriptor symbol, return the associated code
6128    entry symbol if it is defined.  Return NULL otherwise.  */
6129
6130 static struct ppc_link_hash_entry *
6131 defined_code_entry (struct ppc_link_hash_entry *fdh)
6132 {
6133   if (fdh->is_func_descriptor)
6134     {
6135       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6136       if (fh->elf.root.type == bfd_link_hash_defined
6137           || fh->elf.root.type == bfd_link_hash_defweak)
6138         return fh;
6139     }
6140   return NULL;
6141 }
6142
6143 /* If FH is a function code entry symbol, return the associated
6144    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6145
6146 static struct ppc_link_hash_entry *
6147 defined_func_desc (struct ppc_link_hash_entry *fh)
6148 {
6149   if (fh->oh != NULL
6150       && fh->oh->is_func_descriptor)
6151     {
6152       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6153       if (fdh->elf.root.type == bfd_link_hash_defined
6154           || fdh->elf.root.type == bfd_link_hash_defweak)
6155         return fdh;
6156     }
6157   return NULL;
6158 }
6159
6160 /* Mark all our entry sym sections, both opd and code section.  */
6161
6162 static void
6163 ppc64_elf_gc_keep (struct bfd_link_info *info)
6164 {
6165   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6166   struct bfd_sym_chain *sym;
6167
6168   if (htab == NULL)
6169     return;
6170
6171   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6172     {
6173       struct ppc_link_hash_entry *eh, *fh;
6174       asection *sec;
6175
6176       eh = (struct ppc_link_hash_entry *)
6177         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6178       if (eh == NULL)
6179         continue;
6180       if (eh->elf.root.type != bfd_link_hash_defined
6181           && eh->elf.root.type != bfd_link_hash_defweak)
6182         continue;
6183
6184       fh = defined_code_entry (eh);
6185       if (fh != NULL)
6186         {
6187           sec = fh->elf.root.u.def.section;
6188           sec->flags |= SEC_KEEP;
6189         }
6190       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6191                && opd_entry_value (eh->elf.root.u.def.section,
6192                                    eh->elf.root.u.def.value,
6193                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6194         sec->flags |= SEC_KEEP;
6195
6196       sec = eh->elf.root.u.def.section;
6197       sec->flags |= SEC_KEEP;
6198     }
6199 }
6200
6201 /* Mark sections containing dynamically referenced symbols.  When
6202    building shared libraries, we must assume that any visible symbol is
6203    referenced.  */
6204
6205 static bfd_boolean
6206 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6207 {
6208   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6209   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6210   struct ppc_link_hash_entry *fdh;
6211   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6212
6213   /* Dynamic linking info is on the func descriptor sym.  */
6214   fdh = defined_func_desc (eh);
6215   if (fdh != NULL)
6216     eh = fdh;
6217
6218   if ((eh->elf.root.type == bfd_link_hash_defined
6219        || eh->elf.root.type == bfd_link_hash_defweak)
6220       && (eh->elf.ref_dynamic
6221           || (eh->elf.def_regular
6222               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6223               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6224               && (!info->executable
6225                   || info->export_dynamic
6226                   || (eh->elf.dynamic
6227                       && d != NULL
6228                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6229               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6230                   || !bfd_hide_sym_by_version (info->version_info,
6231                                                eh->elf.root.root.string)))))
6232     {
6233       asection *code_sec;
6234       struct ppc_link_hash_entry *fh;
6235
6236       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6237
6238       /* Function descriptor syms cause the associated
6239          function code sym section to be marked.  */
6240       fh = defined_code_entry (eh);
6241       if (fh != NULL)
6242         {
6243           code_sec = fh->elf.root.u.def.section;
6244           code_sec->flags |= SEC_KEEP;
6245         }
6246       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6247                && opd_entry_value (eh->elf.root.u.def.section,
6248                                    eh->elf.root.u.def.value,
6249                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6250         code_sec->flags |= SEC_KEEP;
6251     }
6252
6253   return TRUE;
6254 }
6255
6256 /* Return the section that should be marked against GC for a given
6257    relocation.  */
6258
6259 static asection *
6260 ppc64_elf_gc_mark_hook (asection *sec,
6261                         struct bfd_link_info *info,
6262                         Elf_Internal_Rela *rel,
6263                         struct elf_link_hash_entry *h,
6264                         Elf_Internal_Sym *sym)
6265 {
6266   asection *rsec;
6267
6268   /* Syms return NULL if we're marking .opd, so we avoid marking all
6269      function sections, as all functions are referenced in .opd.  */
6270   rsec = NULL;
6271   if (get_opd_info (sec) != NULL)
6272     return rsec;
6273
6274   if (h != NULL)
6275     {
6276       enum elf_ppc64_reloc_type r_type;
6277       struct ppc_link_hash_entry *eh, *fh, *fdh;
6278
6279       r_type = ELF64_R_TYPE (rel->r_info);
6280       switch (r_type)
6281         {
6282         case R_PPC64_GNU_VTINHERIT:
6283         case R_PPC64_GNU_VTENTRY:
6284           break;
6285
6286         default:
6287           switch (h->root.type)
6288             {
6289             case bfd_link_hash_defined:
6290             case bfd_link_hash_defweak:
6291               eh = (struct ppc_link_hash_entry *) h;
6292               fdh = defined_func_desc (eh);
6293               if (fdh != NULL)
6294                 eh = fdh;
6295
6296               /* Function descriptor syms cause the associated
6297                  function code sym section to be marked.  */
6298               fh = defined_code_entry (eh);
6299               if (fh != NULL)
6300                 {
6301                   /* They also mark their opd section.  */
6302                   eh->elf.root.u.def.section->gc_mark = 1;
6303
6304                   rsec = fh->elf.root.u.def.section;
6305                 }
6306               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6307                        && opd_entry_value (eh->elf.root.u.def.section,
6308                                            eh->elf.root.u.def.value,
6309                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6310                 eh->elf.root.u.def.section->gc_mark = 1;
6311               else
6312                 rsec = h->root.u.def.section;
6313               break;
6314
6315             case bfd_link_hash_common:
6316               rsec = h->root.u.c.p->section;
6317               break;
6318
6319             default:
6320               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6321             }
6322         }
6323     }
6324   else
6325     {
6326       struct _opd_sec_data *opd;
6327
6328       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6329       opd = get_opd_info (rsec);
6330       if (opd != NULL && opd->func_sec != NULL)
6331         {
6332           rsec->gc_mark = 1;
6333
6334           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6335         }
6336     }
6337
6338   return rsec;
6339 }
6340
6341 /* Update the .got, .plt. and dynamic reloc reference counts for the
6342    section being removed.  */
6343
6344 static bfd_boolean
6345 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6346                          asection *sec, const Elf_Internal_Rela *relocs)
6347 {
6348   struct ppc_link_hash_table *htab;
6349   Elf_Internal_Shdr *symtab_hdr;
6350   struct elf_link_hash_entry **sym_hashes;
6351   struct got_entry **local_got_ents;
6352   const Elf_Internal_Rela *rel, *relend;
6353
6354   if (info->relocatable)
6355     return TRUE;
6356
6357   if ((sec->flags & SEC_ALLOC) == 0)
6358     return TRUE;
6359
6360   elf_section_data (sec)->local_dynrel = NULL;
6361
6362   htab = ppc_hash_table (info);
6363   if (htab == NULL)
6364     return FALSE;
6365
6366   symtab_hdr = &elf_symtab_hdr (abfd);
6367   sym_hashes = elf_sym_hashes (abfd);
6368   local_got_ents = elf_local_got_ents (abfd);
6369
6370   relend = relocs + sec->reloc_count;
6371   for (rel = relocs; rel < relend; rel++)
6372     {
6373       unsigned long r_symndx;
6374       enum elf_ppc64_reloc_type r_type;
6375       struct elf_link_hash_entry *h = NULL;
6376       unsigned char tls_type = 0;
6377
6378       r_symndx = ELF64_R_SYM (rel->r_info);
6379       r_type = ELF64_R_TYPE (rel->r_info);
6380       if (r_symndx >= symtab_hdr->sh_info)
6381         {
6382           struct ppc_link_hash_entry *eh;
6383           struct elf_dyn_relocs **pp;
6384           struct elf_dyn_relocs *p;
6385
6386           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6387           h = elf_follow_link (h);
6388           eh = (struct ppc_link_hash_entry *) h;
6389
6390           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6391             if (p->sec == sec)
6392               {
6393                 /* Everything must go for SEC.  */
6394                 *pp = p->next;
6395                 break;
6396               }
6397         }
6398
6399       if (is_branch_reloc (r_type))
6400         {
6401           struct plt_entry **ifunc = NULL;
6402           if (h != NULL)
6403             {
6404               if (h->type == STT_GNU_IFUNC)
6405                 ifunc = &h->plt.plist;
6406             }
6407           else if (local_got_ents != NULL)
6408             {
6409               struct plt_entry **local_plt = (struct plt_entry **)
6410                 (local_got_ents + symtab_hdr->sh_info);
6411               unsigned char *local_got_tls_masks = (unsigned char *)
6412                 (local_plt + symtab_hdr->sh_info);
6413               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6414                 ifunc = local_plt + r_symndx;
6415             }
6416           if (ifunc != NULL)
6417             {
6418               struct plt_entry *ent;
6419
6420               for (ent = *ifunc; ent != NULL; ent = ent->next)
6421                 if (ent->addend == rel->r_addend)
6422                   break;
6423               if (ent == NULL)
6424                 abort ();
6425               if (ent->plt.refcount > 0)
6426                 ent->plt.refcount -= 1;
6427               continue;
6428             }
6429         }
6430
6431       switch (r_type)
6432         {
6433         case R_PPC64_GOT_TLSLD16:
6434         case R_PPC64_GOT_TLSLD16_LO:
6435         case R_PPC64_GOT_TLSLD16_HI:
6436         case R_PPC64_GOT_TLSLD16_HA:
6437           tls_type = TLS_TLS | TLS_LD;
6438           goto dogot;
6439
6440         case R_PPC64_GOT_TLSGD16:
6441         case R_PPC64_GOT_TLSGD16_LO:
6442         case R_PPC64_GOT_TLSGD16_HI:
6443         case R_PPC64_GOT_TLSGD16_HA:
6444           tls_type = TLS_TLS | TLS_GD;
6445           goto dogot;
6446
6447         case R_PPC64_GOT_TPREL16_DS:
6448         case R_PPC64_GOT_TPREL16_LO_DS:
6449         case R_PPC64_GOT_TPREL16_HI:
6450         case R_PPC64_GOT_TPREL16_HA:
6451           tls_type = TLS_TLS | TLS_TPREL;
6452           goto dogot;
6453
6454         case R_PPC64_GOT_DTPREL16_DS:
6455         case R_PPC64_GOT_DTPREL16_LO_DS:
6456         case R_PPC64_GOT_DTPREL16_HI:
6457         case R_PPC64_GOT_DTPREL16_HA:
6458           tls_type = TLS_TLS | TLS_DTPREL;
6459           goto dogot;
6460
6461         case R_PPC64_GOT16:
6462         case R_PPC64_GOT16_DS:
6463         case R_PPC64_GOT16_HA:
6464         case R_PPC64_GOT16_HI:
6465         case R_PPC64_GOT16_LO:
6466         case R_PPC64_GOT16_LO_DS:
6467         dogot:
6468           {
6469             struct got_entry *ent;
6470
6471             if (h != NULL)
6472               ent = h->got.glist;
6473             else
6474               ent = local_got_ents[r_symndx];
6475
6476             for (; ent != NULL; ent = ent->next)
6477               if (ent->addend == rel->r_addend
6478                   && ent->owner == abfd
6479                   && ent->tls_type == tls_type)
6480                 break;
6481             if (ent == NULL)
6482               abort ();
6483             if (ent->got.refcount > 0)
6484               ent->got.refcount -= 1;
6485           }
6486           break;
6487
6488         case R_PPC64_PLT16_HA:
6489         case R_PPC64_PLT16_HI:
6490         case R_PPC64_PLT16_LO:
6491         case R_PPC64_PLT32:
6492         case R_PPC64_PLT64:
6493         case R_PPC64_REL14:
6494         case R_PPC64_REL14_BRNTAKEN:
6495         case R_PPC64_REL14_BRTAKEN:
6496         case R_PPC64_REL24:
6497           if (h != NULL)
6498             {
6499               struct plt_entry *ent;
6500
6501               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6502                 if (ent->addend == rel->r_addend)
6503                   break;
6504               if (ent != NULL && ent->plt.refcount > 0)
6505                 ent->plt.refcount -= 1;
6506             }
6507           break;
6508
6509         default:
6510           break;
6511         }
6512     }
6513   return TRUE;
6514 }
6515
6516 /* The maximum size of .sfpr.  */
6517 #define SFPR_MAX (218*4)
6518
6519 struct sfpr_def_parms
6520 {
6521   const char name[12];
6522   unsigned char lo, hi;
6523   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6524   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6525 };
6526
6527 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6528
6529 static bfd_boolean
6530 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6531 {
6532   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6533   unsigned int i;
6534   size_t len = strlen (parm->name);
6535   bfd_boolean writing = FALSE;
6536   char sym[16];
6537
6538   if (htab == NULL)
6539     return FALSE;
6540
6541   memcpy (sym, parm->name, len);
6542   sym[len + 2] = 0;
6543
6544   for (i = parm->lo; i <= parm->hi; i++)
6545     {
6546       struct elf_link_hash_entry *h;
6547
6548       sym[len + 0] = i / 10 + '0';
6549       sym[len + 1] = i % 10 + '0';
6550       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6551       if (h != NULL
6552           && !h->def_regular)
6553         {
6554           h->root.type = bfd_link_hash_defined;
6555           h->root.u.def.section = htab->sfpr;
6556           h->root.u.def.value = htab->sfpr->size;
6557           h->type = STT_FUNC;
6558           h->def_regular = 1;
6559           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6560           writing = TRUE;
6561           if (htab->sfpr->contents == NULL)
6562             {
6563               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6564               if (htab->sfpr->contents == NULL)
6565                 return FALSE;
6566             }
6567         }
6568       if (writing)
6569         {
6570           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6571           if (i != parm->hi)
6572             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6573           else
6574             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6575           htab->sfpr->size = p - htab->sfpr->contents;
6576         }
6577     }
6578
6579   return TRUE;
6580 }
6581
6582 static bfd_byte *
6583 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6584 {
6585   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6586   return p + 4;
6587 }
6588
6589 static bfd_byte *
6590 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6591 {
6592   p = savegpr0 (abfd, p, r);
6593   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6594   p = p + 4;
6595   bfd_put_32 (abfd, BLR, p);
6596   return p + 4;
6597 }
6598
6599 static bfd_byte *
6600 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6601 {
6602   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6603   return p + 4;
6604 }
6605
6606 static bfd_byte *
6607 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6608 {
6609   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6610   p = p + 4;
6611   p = restgpr0 (abfd, p, r);
6612   bfd_put_32 (abfd, MTLR_R0, p);
6613   p = p + 4;
6614   if (r == 29)
6615     {
6616       p = restgpr0 (abfd, p, 30);
6617       p = restgpr0 (abfd, p, 31);
6618     }
6619   bfd_put_32 (abfd, BLR, p);
6620   return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6625 {
6626   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = savegpr1 (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6642   return p + 4;
6643 }
6644
6645 static bfd_byte *
6646 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6647 {
6648   p = restgpr1 (abfd, p, r);
6649   bfd_put_32 (abfd, BLR, p);
6650   return p + 4;
6651 }
6652
6653 static bfd_byte *
6654 savefpr (bfd *abfd, bfd_byte *p, int r)
6655 {
6656   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6657   return p + 4;
6658 }
6659
6660 static bfd_byte *
6661 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6662 {
6663   p = savefpr (abfd, p, r);
6664   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6665   p = p + 4;
6666   bfd_put_32 (abfd, BLR, p);
6667   return p + 4;
6668 }
6669
6670 static bfd_byte *
6671 restfpr (bfd *abfd, bfd_byte *p, int r)
6672 {
6673   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6674   return p + 4;
6675 }
6676
6677 static bfd_byte *
6678 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6679 {
6680   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6681   p = p + 4;
6682   p = restfpr (abfd, p, r);
6683   bfd_put_32 (abfd, MTLR_R0, p);
6684   p = p + 4;
6685   if (r == 29)
6686     {
6687       p = restfpr (abfd, p, 30);
6688       p = restfpr (abfd, p, 31);
6689     }
6690   bfd_put_32 (abfd, BLR, p);
6691   return p + 4;
6692 }
6693
6694 static bfd_byte *
6695 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6696 {
6697   p = savefpr (abfd, p, r);
6698   bfd_put_32 (abfd, BLR, p);
6699   return p + 4;
6700 }
6701
6702 static bfd_byte *
6703 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6704 {
6705   p = restfpr (abfd, p, r);
6706   bfd_put_32 (abfd, BLR, p);
6707   return p + 4;
6708 }
6709
6710 static bfd_byte *
6711 savevr (bfd *abfd, bfd_byte *p, int r)
6712 {
6713   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6714   p = p + 4;
6715   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6716   return p + 4;
6717 }
6718
6719 static bfd_byte *
6720 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6721 {
6722   p = savevr (abfd, p, r);
6723   bfd_put_32 (abfd, BLR, p);
6724   return p + 4;
6725 }
6726
6727 static bfd_byte *
6728 restvr (bfd *abfd, bfd_byte *p, int r)
6729 {
6730   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6731   p = p + 4;
6732   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6733   return p + 4;
6734 }
6735
6736 static bfd_byte *
6737 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6738 {
6739   p = restvr (abfd, p, r);
6740   bfd_put_32 (abfd, BLR, p);
6741   return p + 4;
6742 }
6743
6744 /* Called via elf_link_hash_traverse to transfer dynamic linking
6745    information on function code symbol entries to their corresponding
6746    function descriptor symbol entries.  */
6747
6748 static bfd_boolean
6749 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6750 {
6751   struct bfd_link_info *info;
6752   struct ppc_link_hash_table *htab;
6753   struct plt_entry *ent;
6754   struct ppc_link_hash_entry *fh;
6755   struct ppc_link_hash_entry *fdh;
6756   bfd_boolean force_local;
6757
6758   fh = (struct ppc_link_hash_entry *) h;
6759   if (fh->elf.root.type == bfd_link_hash_indirect)
6760     return TRUE;
6761
6762   info = inf;
6763   htab = ppc_hash_table (info);
6764   if (htab == NULL)
6765     return FALSE;
6766
6767   /* Resolve undefined references to dot-symbols as the value
6768      in the function descriptor, if we have one in a regular object.
6769      This is to satisfy cases like ".quad .foo".  Calls to functions
6770      in dynamic objects are handled elsewhere.  */
6771   if (fh->elf.root.type == bfd_link_hash_undefweak
6772       && fh->was_undefined
6773       && (fdh = defined_func_desc (fh)) != NULL
6774       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6775       && opd_entry_value (fdh->elf.root.u.def.section,
6776                           fdh->elf.root.u.def.value,
6777                           &fh->elf.root.u.def.section,
6778                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6779     {
6780       fh->elf.root.type = fdh->elf.root.type;
6781       fh->elf.forced_local = 1;
6782       fh->elf.def_regular = fdh->elf.def_regular;
6783       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6784     }
6785
6786   /* If this is a function code symbol, transfer dynamic linking
6787      information to the function descriptor symbol.  */
6788   if (!fh->is_func)
6789     return TRUE;
6790
6791   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6792     if (ent->plt.refcount > 0)
6793       break;
6794   if (ent == NULL
6795       || fh->elf.root.root.string[0] != '.'
6796       || fh->elf.root.root.string[1] == '\0')
6797     return TRUE;
6798
6799   /* Find the corresponding function descriptor symbol.  Create it
6800      as undefined if necessary.  */
6801
6802   fdh = lookup_fdh (fh, htab);
6803   if (fdh == NULL
6804       && !info->executable
6805       && (fh->elf.root.type == bfd_link_hash_undefined
6806           || fh->elf.root.type == bfd_link_hash_undefweak))
6807     {
6808       fdh = make_fdh (info, fh);
6809       if (fdh == NULL)
6810         return FALSE;
6811     }
6812
6813   /* Fake function descriptors are made undefweak.  If the function
6814      code symbol is strong undefined, make the fake sym the same.
6815      If the function code symbol is defined, then force the fake
6816      descriptor local;  We can't support overriding of symbols in a
6817      shared library on a fake descriptor.  */
6818
6819   if (fdh != NULL
6820       && fdh->fake
6821       && fdh->elf.root.type == bfd_link_hash_undefweak)
6822     {
6823       if (fh->elf.root.type == bfd_link_hash_undefined)
6824         {
6825           fdh->elf.root.type = bfd_link_hash_undefined;
6826           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6827         }
6828       else if (fh->elf.root.type == bfd_link_hash_defined
6829                || fh->elf.root.type == bfd_link_hash_defweak)
6830         {
6831           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6832         }
6833     }
6834
6835   if (fdh != NULL
6836       && !fdh->elf.forced_local
6837       && (!info->executable
6838           || fdh->elf.def_dynamic
6839           || fdh->elf.ref_dynamic
6840           || (fdh->elf.root.type == bfd_link_hash_undefweak
6841               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6842     {
6843       if (fdh->elf.dynindx == -1)
6844         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6845           return FALSE;
6846       fdh->elf.ref_regular |= fh->elf.ref_regular;
6847       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6848       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6849       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6850       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6851         {
6852           move_plt_plist (fh, fdh);
6853           fdh->elf.needs_plt = 1;
6854         }
6855       fdh->is_func_descriptor = 1;
6856       fdh->oh = fh;
6857       fh->oh = fdh;
6858     }
6859
6860   /* Now that the info is on the function descriptor, clear the
6861      function code sym info.  Any function code syms for which we
6862      don't have a definition in a regular file, we force local.
6863      This prevents a shared library from exporting syms that have
6864      been imported from another library.  Function code syms that
6865      are really in the library we must leave global to prevent the
6866      linker dragging in a definition from a static library.  */
6867   force_local = (!fh->elf.def_regular
6868                  || fdh == NULL
6869                  || !fdh->elf.def_regular
6870                  || fdh->elf.forced_local);
6871   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6872
6873   return TRUE;
6874 }
6875
6876 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6877    this hook to a) provide some gcc support functions, and b) transfer
6878    dynamic linking information gathered so far on function code symbol
6879    entries, to their corresponding function descriptor symbol entries.  */
6880
6881 static bfd_boolean
6882 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6883                             struct bfd_link_info *info)
6884 {
6885   struct ppc_link_hash_table *htab;
6886   unsigned int i;
6887   static const struct sfpr_def_parms funcs[] =
6888     {
6889       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6890       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6891       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6892       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6893       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6894       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6895       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6896       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6897       { "._savef", 14, 31, savefpr, savefpr1_tail },
6898       { "._restf", 14, 31, restfpr, restfpr1_tail },
6899       { "_savevr_", 20, 31, savevr, savevr_tail },
6900       { "_restvr_", 20, 31, restvr, restvr_tail }
6901     };
6902
6903   htab = ppc_hash_table (info);
6904   if (htab == NULL)
6905     return FALSE;
6906
6907   if (!info->relocatable
6908       && htab->elf.hgot != NULL)
6909     {
6910       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6911       /* Make .TOC. defined so as to prevent it being made dynamic.
6912          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6913       htab->elf.hgot->type = STT_OBJECT;
6914       htab->elf.hgot->root.type = bfd_link_hash_defined;
6915       htab->elf.hgot->root.u.def.value = 0;
6916       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6917       htab->elf.hgot->def_regular = 1;
6918       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6919                                | STV_HIDDEN);
6920     }
6921
6922   if (htab->sfpr == NULL)
6923     /* We don't have any relocs.  */
6924     return TRUE;
6925
6926   /* Provide any missing _save* and _rest* functions.  */
6927   htab->sfpr->size = 0;
6928   if (htab->params->save_restore_funcs)
6929     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6930       if (!sfpr_define (info, &funcs[i]))
6931         return FALSE;
6932
6933   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6934
6935   if (htab->sfpr->size == 0)
6936     htab->sfpr->flags |= SEC_EXCLUDE;
6937
6938   return TRUE;
6939 }
6940
6941 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6942
6943 static bfd_boolean
6944 readonly_dynrelocs (struct elf_link_hash_entry *h)
6945 {
6946   struct ppc_link_hash_entry *eh;
6947   struct elf_dyn_relocs *p;
6948
6949   eh = (struct ppc_link_hash_entry *) h;
6950   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6951     {
6952       asection *s = p->sec->output_section;
6953
6954       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6955         return TRUE;
6956     }
6957   return FALSE;
6958 }
6959
6960 /* Adjust a symbol defined by a dynamic object and referenced by a
6961    regular object.  The current definition is in some section of the
6962    dynamic object, but we're not including those sections.  We have to
6963    change the definition to something the rest of the link can
6964    understand.  */
6965
6966 static bfd_boolean
6967 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6968                                  struct elf_link_hash_entry *h)
6969 {
6970   struct ppc_link_hash_table *htab;
6971   asection *s;
6972
6973   htab = ppc_hash_table (info);
6974   if (htab == NULL)
6975     return FALSE;
6976
6977   /* Deal with function syms.  */
6978   if (h->type == STT_FUNC
6979       || h->type == STT_GNU_IFUNC
6980       || h->needs_plt)
6981     {
6982       /* Clear procedure linkage table information for any symbol that
6983          won't need a .plt entry.  */
6984       struct plt_entry *ent;
6985       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6986         if (ent->plt.refcount > 0)
6987           break;
6988       if (ent == NULL
6989           || (h->type != STT_GNU_IFUNC
6990               && (SYMBOL_CALLS_LOCAL (info, h)
6991                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6992                       && h->root.type == bfd_link_hash_undefweak))))
6993         {
6994           h->plt.plist = NULL;
6995           h->needs_plt = 0;
6996           h->pointer_equality_needed = 0;
6997         }
6998       else if (abiversion (info->output_bfd) == 2)
6999         {
7000           /* Taking a function's address in a read/write section
7001              doesn't require us to define the function symbol in the
7002              executable on a global entry stub.  A dynamic reloc can
7003              be used instead.  */
7004           if (h->pointer_equality_needed
7005               && h->type != STT_GNU_IFUNC
7006               && !readonly_dynrelocs (h))
7007             {
7008               h->pointer_equality_needed = 0;
7009               h->non_got_ref = 0;
7010             }
7011
7012           /* After adjust_dynamic_symbol, non_got_ref set in the
7013              non-shared case means that we have allocated space in
7014              .dynbss for the symbol and thus dyn_relocs for this
7015              symbol should be discarded.
7016              If we get here we know we are making a PLT entry for this
7017              symbol, and in an executable we'd normally resolve
7018              relocations against this symbol to the PLT entry.  Allow
7019              dynamic relocs if the reference is weak, and the dynamic
7020              relocs will not cause text relocation.  */
7021           else if (!h->ref_regular_nonweak
7022                    && h->non_got_ref
7023                    && h->type != STT_GNU_IFUNC
7024                    && !readonly_dynrelocs (h))
7025             h->non_got_ref = 0;
7026
7027           /* If making a plt entry, then we don't need copy relocs.  */
7028           return TRUE;
7029         }
7030     }
7031   else
7032     h->plt.plist = NULL;
7033
7034   /* If this is a weak symbol, and there is a real definition, the
7035      processor independent code will have arranged for us to see the
7036      real definition first, and we can just use the same value.  */
7037   if (h->u.weakdef != NULL)
7038     {
7039       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7040                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
7041       h->root.u.def.section = h->u.weakdef->root.u.def.section;
7042       h->root.u.def.value = h->u.weakdef->root.u.def.value;
7043       if (ELIMINATE_COPY_RELOCS)
7044         h->non_got_ref = h->u.weakdef->non_got_ref;
7045       return TRUE;
7046     }
7047
7048   /* If we are creating a shared library, we must presume that the
7049      only references to the symbol are via the global offset table.
7050      For such cases we need not do anything here; the relocations will
7051      be handled correctly by relocate_section.  */
7052   if (info->shared)
7053     return TRUE;
7054
7055   /* If there are no references to this symbol that do not use the
7056      GOT, we don't need to generate a copy reloc.  */
7057   if (!h->non_got_ref)
7058     return TRUE;
7059
7060   /* Don't generate a copy reloc for symbols defined in the executable.  */
7061   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7062     return TRUE;
7063
7064   /* If we didn't find any dynamic relocs in read-only sections, then
7065      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
7066   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7067     {
7068       h->non_got_ref = 0;
7069       return TRUE;
7070     }
7071
7072   if (h->plt.plist != NULL)
7073     {
7074       /* We should never get here, but unfortunately there are versions
7075          of gcc out there that improperly (for this ABI) put initialized
7076          function pointers, vtable refs and suchlike in read-only
7077          sections.  Allow them to proceed, but warn that this might
7078          break at runtime.  */
7079       info->callbacks->einfo
7080         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7081            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7082          h->root.root.string);
7083     }
7084
7085   /* This is a reference to a symbol defined by a dynamic object which
7086      is not a function.  */
7087
7088   /* We must allocate the symbol in our .dynbss section, which will
7089      become part of the .bss section of the executable.  There will be
7090      an entry for this symbol in the .dynsym section.  The dynamic
7091      object will contain position independent code, so all references
7092      from the dynamic object to this symbol will go through the global
7093      offset table.  The dynamic linker will use the .dynsym entry to
7094      determine the address it must put in the global offset table, so
7095      both the dynamic object and the regular object will refer to the
7096      same memory location for the variable.  */
7097
7098   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7099      to copy the initial value out of the dynamic object and into the
7100      runtime process image.  We need to remember the offset into the
7101      .rela.bss section we are going to use.  */
7102   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7103     {
7104       htab->relbss->size += sizeof (Elf64_External_Rela);
7105       h->needs_copy = 1;
7106     }
7107
7108   s = htab->dynbss;
7109
7110   return _bfd_elf_adjust_dynamic_copy (h, s);
7111 }
7112
7113 /* If given a function descriptor symbol, hide both the function code
7114    sym and the descriptor.  */
7115 static void
7116 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7117                        struct elf_link_hash_entry *h,
7118                        bfd_boolean force_local)
7119 {
7120   struct ppc_link_hash_entry *eh;
7121   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7122
7123   eh = (struct ppc_link_hash_entry *) h;
7124   if (eh->is_func_descriptor)
7125     {
7126       struct ppc_link_hash_entry *fh = eh->oh;
7127
7128       if (fh == NULL)
7129         {
7130           const char *p, *q;
7131           struct ppc_link_hash_table *htab;
7132           char save;
7133
7134           /* We aren't supposed to use alloca in BFD because on
7135              systems which do not have alloca the version in libiberty
7136              calls xmalloc, which might cause the program to crash
7137              when it runs out of memory.  This function doesn't have a
7138              return status, so there's no way to gracefully return an
7139              error.  So cheat.  We know that string[-1] can be safely
7140              accessed;  It's either a string in an ELF string table,
7141              or allocated in an objalloc structure.  */
7142
7143           p = eh->elf.root.root.string - 1;
7144           save = *p;
7145           *(char *) p = '.';
7146           htab = ppc_hash_table (info);
7147           if (htab == NULL)
7148             return;
7149
7150           fh = (struct ppc_link_hash_entry *)
7151             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7152           *(char *) p = save;
7153
7154           /* Unfortunately, if it so happens that the string we were
7155              looking for was allocated immediately before this string,
7156              then we overwrote the string terminator.  That's the only
7157              reason the lookup should fail.  */
7158           if (fh == NULL)
7159             {
7160               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7161               while (q >= eh->elf.root.root.string && *q == *p)
7162                 --q, --p;
7163               if (q < eh->elf.root.root.string && *p == '.')
7164                 fh = (struct ppc_link_hash_entry *)
7165                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7166             }
7167           if (fh != NULL)
7168             {
7169               eh->oh = fh;
7170               fh->oh = eh;
7171             }
7172         }
7173       if (fh != NULL)
7174         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7175     }
7176 }
7177
7178 static bfd_boolean
7179 get_sym_h (struct elf_link_hash_entry **hp,
7180            Elf_Internal_Sym **symp,
7181            asection **symsecp,
7182            unsigned char **tls_maskp,
7183            Elf_Internal_Sym **locsymsp,
7184            unsigned long r_symndx,
7185            bfd *ibfd)
7186 {
7187   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7188
7189   if (r_symndx >= symtab_hdr->sh_info)
7190     {
7191       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7192       struct elf_link_hash_entry *h;
7193
7194       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7195       h = elf_follow_link (h);
7196
7197       if (hp != NULL)
7198         *hp = h;
7199
7200       if (symp != NULL)
7201         *symp = NULL;
7202
7203       if (symsecp != NULL)
7204         {
7205           asection *symsec = NULL;
7206           if (h->root.type == bfd_link_hash_defined
7207               || h->root.type == bfd_link_hash_defweak)
7208             symsec = h->root.u.def.section;
7209           *symsecp = symsec;
7210         }
7211
7212       if (tls_maskp != NULL)
7213         {
7214           struct ppc_link_hash_entry *eh;
7215
7216           eh = (struct ppc_link_hash_entry *) h;
7217           *tls_maskp = &eh->tls_mask;
7218         }
7219     }
7220   else
7221     {
7222       Elf_Internal_Sym *sym;
7223       Elf_Internal_Sym *locsyms = *locsymsp;
7224
7225       if (locsyms == NULL)
7226         {
7227           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7228           if (locsyms == NULL)
7229             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7230                                             symtab_hdr->sh_info,
7231                                             0, NULL, NULL, NULL);
7232           if (locsyms == NULL)
7233             return FALSE;
7234           *locsymsp = locsyms;
7235         }
7236       sym = locsyms + r_symndx;
7237
7238       if (hp != NULL)
7239         *hp = NULL;
7240
7241       if (symp != NULL)
7242         *symp = sym;
7243
7244       if (symsecp != NULL)
7245         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7246
7247       if (tls_maskp != NULL)
7248         {
7249           struct got_entry **lgot_ents;
7250           unsigned char *tls_mask;
7251
7252           tls_mask = NULL;
7253           lgot_ents = elf_local_got_ents (ibfd);
7254           if (lgot_ents != NULL)
7255             {
7256               struct plt_entry **local_plt = (struct plt_entry **)
7257                 (lgot_ents + symtab_hdr->sh_info);
7258               unsigned char *lgot_masks = (unsigned char *)
7259                 (local_plt + symtab_hdr->sh_info);
7260               tls_mask = &lgot_masks[r_symndx];
7261             }
7262           *tls_maskp = tls_mask;
7263         }
7264     }
7265   return TRUE;
7266 }
7267
7268 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7269    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7270    type suitable for optimization, and 1 otherwise.  */
7271
7272 static int
7273 get_tls_mask (unsigned char **tls_maskp,
7274               unsigned long *toc_symndx,
7275               bfd_vma *toc_addend,
7276               Elf_Internal_Sym **locsymsp,
7277               const Elf_Internal_Rela *rel,
7278               bfd *ibfd)
7279 {
7280   unsigned long r_symndx;
7281   int next_r;
7282   struct elf_link_hash_entry *h;
7283   Elf_Internal_Sym *sym;
7284   asection *sec;
7285   bfd_vma off;
7286
7287   r_symndx = ELF64_R_SYM (rel->r_info);
7288   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7289     return 0;
7290
7291   if ((*tls_maskp != NULL && **tls_maskp != 0)
7292       || sec == NULL
7293       || ppc64_elf_section_data (sec) == NULL
7294       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7295     return 1;
7296
7297   /* Look inside a TOC section too.  */
7298   if (h != NULL)
7299     {
7300       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7301       off = h->root.u.def.value;
7302     }
7303   else
7304     off = sym->st_value;
7305   off += rel->r_addend;
7306   BFD_ASSERT (off % 8 == 0);
7307   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7308   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7309   if (toc_symndx != NULL)
7310     *toc_symndx = r_symndx;
7311   if (toc_addend != NULL)
7312     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7313   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7314     return 0;
7315   if ((h == NULL || is_static_defined (h))
7316       && (next_r == -1 || next_r == -2))
7317     return 1 - next_r;
7318   return 1;
7319 }
7320
7321 /* Find (or create) an entry in the tocsave hash table.  */
7322
7323 static struct tocsave_entry *
7324 tocsave_find (struct ppc_link_hash_table *htab,
7325               enum insert_option insert,
7326               Elf_Internal_Sym **local_syms,
7327               const Elf_Internal_Rela *irela,
7328               bfd *ibfd)
7329 {
7330   unsigned long r_indx;
7331   struct elf_link_hash_entry *h;
7332   Elf_Internal_Sym *sym;
7333   struct tocsave_entry ent, *p;
7334   hashval_t hash;
7335   struct tocsave_entry **slot;
7336
7337   r_indx = ELF64_R_SYM (irela->r_info);
7338   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7339     return NULL;
7340   if (ent.sec == NULL || ent.sec->output_section == NULL)
7341     {
7342       (*_bfd_error_handler)
7343         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7344       return NULL;
7345     }
7346
7347   if (h != NULL)
7348     ent.offset = h->root.u.def.value;
7349   else
7350     ent.offset = sym->st_value;
7351   ent.offset += irela->r_addend;
7352
7353   hash = tocsave_htab_hash (&ent);
7354   slot = ((struct tocsave_entry **)
7355           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7356   if (slot == NULL)
7357     return NULL;
7358
7359   if (*slot == NULL)
7360     {
7361       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7362       if (p == NULL)
7363         return NULL;
7364       *p = ent;
7365       *slot = p;
7366     }
7367   return *slot;
7368 }
7369
7370 /* Adjust all global syms defined in opd sections.  In gcc generated
7371    code for the old ABI, these will already have been done.  */
7372
7373 static bfd_boolean
7374 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7375 {
7376   struct ppc_link_hash_entry *eh;
7377   asection *sym_sec;
7378   struct _opd_sec_data *opd;
7379
7380   if (h->root.type == bfd_link_hash_indirect)
7381     return TRUE;
7382
7383   if (h->root.type != bfd_link_hash_defined
7384       && h->root.type != bfd_link_hash_defweak)
7385     return TRUE;
7386
7387   eh = (struct ppc_link_hash_entry *) h;
7388   if (eh->adjust_done)
7389     return TRUE;
7390
7391   sym_sec = eh->elf.root.u.def.section;
7392   opd = get_opd_info (sym_sec);
7393   if (opd != NULL && opd->adjust != NULL)
7394     {
7395       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7396       if (adjust == -1)
7397         {
7398           /* This entry has been deleted.  */
7399           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7400           if (dsec == NULL)
7401             {
7402               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7403                 if (discarded_section (dsec))
7404                   {
7405                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7406                     break;
7407                   }
7408             }
7409           eh->elf.root.u.def.value = 0;
7410           eh->elf.root.u.def.section = dsec;
7411         }
7412       else
7413         eh->elf.root.u.def.value += adjust;
7414       eh->adjust_done = 1;
7415     }
7416   return TRUE;
7417 }
7418
7419 /* Handles decrementing dynamic reloc counts for the reloc specified by
7420    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7421    have already been determined.  */
7422
7423 static bfd_boolean
7424 dec_dynrel_count (bfd_vma r_info,
7425                   asection *sec,
7426                   struct bfd_link_info *info,
7427                   Elf_Internal_Sym **local_syms,
7428                   struct elf_link_hash_entry *h,
7429                   Elf_Internal_Sym *sym)
7430 {
7431   enum elf_ppc64_reloc_type r_type;
7432   asection *sym_sec = NULL;
7433
7434   /* Can this reloc be dynamic?  This switch, and later tests here
7435      should be kept in sync with the code in check_relocs.  */
7436   r_type = ELF64_R_TYPE (r_info);
7437   switch (r_type)
7438     {
7439     default:
7440       return TRUE;
7441
7442     case R_PPC64_TPREL16:
7443     case R_PPC64_TPREL16_LO:
7444     case R_PPC64_TPREL16_HI:
7445     case R_PPC64_TPREL16_HA:
7446     case R_PPC64_TPREL16_DS:
7447     case R_PPC64_TPREL16_LO_DS:
7448     case R_PPC64_TPREL16_HIGH:
7449     case R_PPC64_TPREL16_HIGHA:
7450     case R_PPC64_TPREL16_HIGHER:
7451     case R_PPC64_TPREL16_HIGHERA:
7452     case R_PPC64_TPREL16_HIGHEST:
7453     case R_PPC64_TPREL16_HIGHESTA:
7454       if (!info->shared)
7455         return TRUE;
7456
7457     case R_PPC64_TPREL64:
7458     case R_PPC64_DTPMOD64:
7459     case R_PPC64_DTPREL64:
7460     case R_PPC64_ADDR64:
7461     case R_PPC64_REL30:
7462     case R_PPC64_REL32:
7463     case R_PPC64_REL64:
7464     case R_PPC64_ADDR14:
7465     case R_PPC64_ADDR14_BRNTAKEN:
7466     case R_PPC64_ADDR14_BRTAKEN:
7467     case R_PPC64_ADDR16:
7468     case R_PPC64_ADDR16_DS:
7469     case R_PPC64_ADDR16_HA:
7470     case R_PPC64_ADDR16_HI:
7471     case R_PPC64_ADDR16_HIGH:
7472     case R_PPC64_ADDR16_HIGHA:
7473     case R_PPC64_ADDR16_HIGHER:
7474     case R_PPC64_ADDR16_HIGHERA:
7475     case R_PPC64_ADDR16_HIGHEST:
7476     case R_PPC64_ADDR16_HIGHESTA:
7477     case R_PPC64_ADDR16_LO:
7478     case R_PPC64_ADDR16_LO_DS:
7479     case R_PPC64_ADDR24:
7480     case R_PPC64_ADDR32:
7481     case R_PPC64_UADDR16:
7482     case R_PPC64_UADDR32:
7483     case R_PPC64_UADDR64:
7484     case R_PPC64_TOC:
7485       break;
7486     }
7487
7488   if (local_syms != NULL)
7489     {
7490       unsigned long r_symndx;
7491       bfd *ibfd = sec->owner;
7492
7493       r_symndx = ELF64_R_SYM (r_info);
7494       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7495         return FALSE;
7496     }
7497
7498   if ((info->shared
7499        && (must_be_dyn_reloc (info, r_type)
7500            || (h != NULL
7501                && (!SYMBOLIC_BIND (info, h)
7502                    || h->root.type == bfd_link_hash_defweak
7503                    || !h->def_regular))))
7504       || (ELIMINATE_COPY_RELOCS
7505           && !info->shared
7506           && h != NULL
7507           && (h->root.type == bfd_link_hash_defweak
7508               || !h->def_regular)))
7509     ;
7510   else
7511     return TRUE;
7512
7513   if (h != NULL)
7514     {
7515       struct elf_dyn_relocs *p;
7516       struct elf_dyn_relocs **pp;
7517       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7518
7519       /* elf_gc_sweep may have already removed all dyn relocs associated
7520          with local syms for a given section.  Also, symbol flags are
7521          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7522          report a dynreloc miscount.  */
7523       if (*pp == NULL && info->gc_sections)
7524         return TRUE;
7525
7526       while ((p = *pp) != NULL)
7527         {
7528           if (p->sec == sec)
7529             {
7530               if (!must_be_dyn_reloc (info, r_type))
7531                 p->pc_count -= 1;
7532               p->count -= 1;
7533               if (p->count == 0)
7534                 *pp = p->next;
7535               return TRUE;
7536             }
7537           pp = &p->next;
7538         }
7539     }
7540   else
7541     {
7542       struct ppc_dyn_relocs *p;
7543       struct ppc_dyn_relocs **pp;
7544       void *vpp;
7545       bfd_boolean is_ifunc;
7546
7547       if (local_syms == NULL)
7548         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7549       if (sym_sec == NULL)
7550         sym_sec = sec;
7551
7552       vpp = &elf_section_data (sym_sec)->local_dynrel;
7553       pp = (struct ppc_dyn_relocs **) vpp;
7554
7555       if (*pp == NULL && info->gc_sections)
7556         return TRUE;
7557
7558       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7559       while ((p = *pp) != NULL)
7560         {
7561           if (p->sec == sec && p->ifunc == is_ifunc)
7562             {
7563               p->count -= 1;
7564               if (p->count == 0)
7565                 *pp = p->next;
7566               return TRUE;
7567             }
7568           pp = &p->next;
7569         }
7570     }
7571
7572   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7573                           sec->owner, sec);
7574   bfd_set_error (bfd_error_bad_value);
7575   return FALSE;
7576 }
7577
7578 /* Remove unused Official Procedure Descriptor entries.  Currently we
7579    only remove those associated with functions in discarded link-once
7580    sections, or weakly defined functions that have been overridden.  It
7581    would be possible to remove many more entries for statically linked
7582    applications.  */
7583
7584 bfd_boolean
7585 ppc64_elf_edit_opd (struct bfd_link_info *info)
7586 {
7587   bfd *ibfd;
7588   bfd_boolean some_edited = FALSE;
7589   asection *need_pad = NULL;
7590   struct ppc_link_hash_table *htab;
7591
7592   htab = ppc_hash_table (info);
7593   if (htab == NULL)
7594     return FALSE;
7595
7596   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7597     {
7598       asection *sec;
7599       Elf_Internal_Rela *relstart, *rel, *relend;
7600       Elf_Internal_Shdr *symtab_hdr;
7601       Elf_Internal_Sym *local_syms;
7602       bfd_vma offset;
7603       struct _opd_sec_data *opd;
7604       bfd_boolean need_edit, add_aux_fields;
7605       bfd_size_type cnt_16b = 0;
7606
7607       if (!is_ppc64_elf (ibfd))
7608         continue;
7609
7610       sec = bfd_get_section_by_name (ibfd, ".opd");
7611       if (sec == NULL || sec->size == 0)
7612         continue;
7613
7614       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7615         continue;
7616
7617       if (sec->output_section == bfd_abs_section_ptr)
7618         continue;
7619
7620       /* Look through the section relocs.  */
7621       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7622         continue;
7623
7624       local_syms = NULL;
7625       symtab_hdr = &elf_symtab_hdr (ibfd);
7626
7627       /* Read the relocations.  */
7628       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7629                                             info->keep_memory);
7630       if (relstart == NULL)
7631         return FALSE;
7632
7633       /* First run through the relocs to check they are sane, and to
7634          determine whether we need to edit this opd section.  */
7635       need_edit = FALSE;
7636       need_pad = sec;
7637       offset = 0;
7638       relend = relstart + sec->reloc_count;
7639       for (rel = relstart; rel < relend; )
7640         {
7641           enum elf_ppc64_reloc_type r_type;
7642           unsigned long r_symndx;
7643           asection *sym_sec;
7644           struct elf_link_hash_entry *h;
7645           Elf_Internal_Sym *sym;
7646
7647           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7648              only interested in the reloc pointing to a function entry
7649              point.  */
7650           if (rel->r_offset != offset
7651               || rel + 1 >= relend
7652               || (rel + 1)->r_offset != offset + 8)
7653             {
7654               /* If someone messes with .opd alignment then after a
7655                  "ld -r" we might have padding in the middle of .opd.
7656                  Also, there's nothing to prevent someone putting
7657                  something silly in .opd with the assembler.  No .opd
7658                  optimization for them!  */
7659             broken_opd:
7660               (*_bfd_error_handler)
7661                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7662               need_edit = FALSE;
7663               break;
7664             }
7665
7666           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7667               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7668             {
7669               (*_bfd_error_handler)
7670                 (_("%B: unexpected reloc type %u in .opd section"),
7671                  ibfd, r_type);
7672               need_edit = FALSE;
7673               break;
7674             }
7675
7676           r_symndx = ELF64_R_SYM (rel->r_info);
7677           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7678                           r_symndx, ibfd))
7679             goto error_ret;
7680
7681           if (sym_sec == NULL || sym_sec->owner == NULL)
7682             {
7683               const char *sym_name;
7684               if (h != NULL)
7685                 sym_name = h->root.root.string;
7686               else
7687                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7688                                              sym_sec);
7689
7690               (*_bfd_error_handler)
7691                 (_("%B: undefined sym `%s' in .opd section"),
7692                  ibfd, sym_name);
7693               need_edit = FALSE;
7694               break;
7695             }
7696
7697           /* opd entries are always for functions defined in the
7698              current input bfd.  If the symbol isn't defined in the
7699              input bfd, then we won't be using the function in this
7700              bfd;  It must be defined in a linkonce section in another
7701              bfd, or is weak.  It's also possible that we are
7702              discarding the function due to a linker script /DISCARD/,
7703              which we test for via the output_section.  */
7704           if (sym_sec->owner != ibfd
7705               || sym_sec->output_section == bfd_abs_section_ptr)
7706             need_edit = TRUE;
7707
7708           rel += 2;
7709           if (rel == relend
7710               || (rel + 1 == relend && rel->r_offset == offset + 16))
7711             {
7712               if (sec->size == offset + 24)
7713                 {
7714                   need_pad = NULL;
7715                   break;
7716                 }
7717               if (rel == relend && sec->size == offset + 16)
7718                 {
7719                   cnt_16b++;
7720                   break;
7721                 }
7722               goto broken_opd;
7723             }
7724
7725           if (rel->r_offset == offset + 24)
7726             offset += 24;
7727           else if (rel->r_offset != offset + 16)
7728             goto broken_opd;
7729           else if (rel + 1 < relend
7730                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7731                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7732             {
7733               offset += 16;
7734               cnt_16b++;
7735             }
7736           else if (rel + 2 < relend
7737                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7738                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7739             {
7740               offset += 24;
7741               rel += 1;
7742             }
7743           else
7744             goto broken_opd;
7745         }
7746
7747       add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7748
7749       if (need_edit || add_aux_fields)
7750         {
7751           Elf_Internal_Rela *write_rel;
7752           Elf_Internal_Shdr *rel_hdr;
7753           bfd_byte *rptr, *wptr;
7754           bfd_byte *new_contents;
7755           bfd_boolean skip;
7756           long opd_ent_size;
7757           bfd_size_type amt;
7758
7759           new_contents = NULL;
7760           amt = sec->size * sizeof (long) / 8;
7761           opd = &ppc64_elf_section_data (sec)->u.opd;
7762           opd->adjust = bfd_zalloc (sec->owner, amt);
7763           if (opd->adjust == NULL)
7764             return FALSE;
7765           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7766
7767           /* This seems a waste of time as input .opd sections are all
7768              zeros as generated by gcc, but I suppose there's no reason
7769              this will always be so.  We might start putting something in
7770              the third word of .opd entries.  */
7771           if ((sec->flags & SEC_IN_MEMORY) == 0)
7772             {
7773               bfd_byte *loc;
7774               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7775                 {
7776                   if (loc != NULL)
7777                     free (loc);
7778                 error_ret:
7779                   if (local_syms != NULL
7780                       && symtab_hdr->contents != (unsigned char *) local_syms)
7781                     free (local_syms);
7782                   if (elf_section_data (sec)->relocs != relstart)
7783                     free (relstart);
7784                   return FALSE;
7785                 }
7786               sec->contents = loc;
7787               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7788             }
7789
7790           elf_section_data (sec)->relocs = relstart;
7791
7792           new_contents = sec->contents;
7793           if (add_aux_fields)
7794             {
7795               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7796               if (new_contents == NULL)
7797                 return FALSE;
7798               need_pad = FALSE;
7799             }
7800           wptr = new_contents;
7801           rptr = sec->contents;
7802
7803           write_rel = relstart;
7804           skip = FALSE;
7805           offset = 0;
7806           opd_ent_size = 0;
7807           for (rel = relstart; rel < relend; rel++)
7808             {
7809               unsigned long r_symndx;
7810               asection *sym_sec;
7811               struct elf_link_hash_entry *h;
7812               Elf_Internal_Sym *sym;
7813
7814               r_symndx = ELF64_R_SYM (rel->r_info);
7815               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7816                               r_symndx, ibfd))
7817                 goto error_ret;
7818
7819               if (rel->r_offset == offset)
7820                 {
7821                   struct ppc_link_hash_entry *fdh = NULL;
7822
7823                   /* See if the .opd entry is full 24 byte or
7824                      16 byte (with fd_aux entry overlapped with next
7825                      fd_func).  */
7826                   opd_ent_size = 24;
7827                   if ((rel + 2 == relend && sec->size == offset + 16)
7828                       || (rel + 3 < relend
7829                           && rel[2].r_offset == offset + 16
7830                           && rel[3].r_offset == offset + 24
7831                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7832                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7833                     opd_ent_size = 16;
7834
7835                   if (h != NULL
7836                       && h->root.root.string[0] == '.')
7837                     {
7838                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7839                       if (fdh != NULL
7840                           && fdh->elf.root.type != bfd_link_hash_defined
7841                           && fdh->elf.root.type != bfd_link_hash_defweak)
7842                         fdh = NULL;
7843                     }
7844
7845                   skip = (sym_sec->owner != ibfd
7846                           || sym_sec->output_section == bfd_abs_section_ptr);
7847                   if (skip)
7848                     {
7849                       if (fdh != NULL && sym_sec->owner == ibfd)
7850                         {
7851                           /* Arrange for the function descriptor sym
7852                              to be dropped.  */
7853                           fdh->elf.root.u.def.value = 0;
7854                           fdh->elf.root.u.def.section = sym_sec;
7855                         }
7856                       opd->adjust[rel->r_offset / 8] = -1;
7857                     }
7858                   else
7859                     {
7860                       /* We'll be keeping this opd entry.  */
7861
7862                       if (fdh != NULL)
7863                         {
7864                           /* Redefine the function descriptor symbol to
7865                              this location in the opd section.  It is
7866                              necessary to update the value here rather
7867                              than using an array of adjustments as we do
7868                              for local symbols, because various places
7869                              in the generic ELF code use the value
7870                              stored in u.def.value.  */
7871                           fdh->elf.root.u.def.value = wptr - new_contents;
7872                           fdh->adjust_done = 1;
7873                         }
7874
7875                       /* Local syms are a bit tricky.  We could
7876                          tweak them as they can be cached, but
7877                          we'd need to look through the local syms
7878                          for the function descriptor sym which we
7879                          don't have at the moment.  So keep an
7880                          array of adjustments.  */
7881                       opd->adjust[rel->r_offset / 8]
7882                         = (wptr - new_contents) - (rptr - sec->contents);
7883
7884                       if (wptr != rptr)
7885                         memcpy (wptr, rptr, opd_ent_size);
7886                       wptr += opd_ent_size;
7887                       if (add_aux_fields && opd_ent_size == 16)
7888                         {
7889                           memset (wptr, '\0', 8);
7890                           wptr += 8;
7891                         }
7892                     }
7893                   rptr += opd_ent_size;
7894                   offset += opd_ent_size;
7895                 }
7896
7897               if (skip)
7898                 {
7899                   if (!NO_OPD_RELOCS
7900                       && !info->relocatable
7901                       && !dec_dynrel_count (rel->r_info, sec, info,
7902                                             NULL, h, sym))
7903                     goto error_ret;
7904                 }
7905               else
7906                 {
7907                   /* We need to adjust any reloc offsets to point to the
7908                      new opd entries.  While we're at it, we may as well
7909                      remove redundant relocs.  */
7910                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7911                   if (write_rel != rel)
7912                     memcpy (write_rel, rel, sizeof (*rel));
7913                   ++write_rel;
7914                 }
7915             }
7916
7917           sec->size = wptr - new_contents;
7918           sec->reloc_count = write_rel - relstart;
7919           if (add_aux_fields)
7920             {
7921               free (sec->contents);
7922               sec->contents = new_contents;
7923             }
7924
7925           /* Fudge the header size too, as this is used later in
7926              elf_bfd_final_link if we are emitting relocs.  */
7927           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7928           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7929           some_edited = TRUE;
7930         }
7931       else if (elf_section_data (sec)->relocs != relstart)
7932         free (relstart);
7933
7934       if (local_syms != NULL
7935           && symtab_hdr->contents != (unsigned char *) local_syms)
7936         {
7937           if (!info->keep_memory)
7938             free (local_syms);
7939           else
7940             symtab_hdr->contents = (unsigned char *) local_syms;
7941         }
7942     }
7943
7944   if (some_edited)
7945     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7946
7947   /* If we are doing a final link and the last .opd entry is just 16 byte
7948      long, add a 8 byte padding after it.  */
7949   if (need_pad != NULL && !info->relocatable)
7950     {
7951       bfd_byte *p;
7952
7953       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7954         {
7955           BFD_ASSERT (need_pad->size > 0);
7956
7957           p = bfd_malloc (need_pad->size + 8);
7958           if (p == NULL)
7959             return FALSE;
7960
7961           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7962                                           p, 0, need_pad->size))
7963             return FALSE;
7964
7965           need_pad->contents = p;
7966           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7967         }
7968       else
7969         {
7970           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7971           if (p == NULL)
7972             return FALSE;
7973
7974           need_pad->contents = p;
7975         }
7976
7977       memset (need_pad->contents + need_pad->size, 0, 8);
7978       need_pad->size += 8;
7979     }
7980
7981   return TRUE;
7982 }
7983
7984 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7985
7986 asection *
7987 ppc64_elf_tls_setup (struct bfd_link_info *info)
7988 {
7989   struct ppc_link_hash_table *htab;
7990
7991   htab = ppc_hash_table (info);
7992   if (htab == NULL)
7993     return NULL;
7994
7995   if (abiversion (info->output_bfd) == 1)
7996     htab->opd_abi = 1;
7997
7998   if (htab->params->no_multi_toc)
7999     htab->do_multi_toc = 0;
8000   else if (!htab->do_multi_toc)
8001     htab->params->no_multi_toc = 1;
8002
8003   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8004                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8005                                               FALSE, FALSE, TRUE));
8006   /* Move dynamic linking info to the function descriptor sym.  */
8007   if (htab->tls_get_addr != NULL)
8008     func_desc_adjust (&htab->tls_get_addr->elf, info);
8009   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8010                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8011                                                  FALSE, FALSE, TRUE));
8012   if (!htab->params->no_tls_get_addr_opt)
8013     {
8014       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8015
8016       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8017                                   FALSE, FALSE, TRUE);
8018       if (opt != NULL)
8019         func_desc_adjust (opt, info);
8020       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8021                                      FALSE, FALSE, TRUE);
8022       if (opt_fd != NULL
8023           && (opt_fd->root.type == bfd_link_hash_defined
8024               || opt_fd->root.type == bfd_link_hash_defweak))
8025         {
8026           /* If glibc supports an optimized __tls_get_addr call stub,
8027              signalled by the presence of __tls_get_addr_opt, and we'll
8028              be calling __tls_get_addr via a plt call stub, then
8029              make __tls_get_addr point to __tls_get_addr_opt.  */
8030           tga_fd = &htab->tls_get_addr_fd->elf;
8031           if (htab->elf.dynamic_sections_created
8032               && tga_fd != NULL
8033               && (tga_fd->type == STT_FUNC
8034                   || tga_fd->needs_plt)
8035               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8036                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8037                        && tga_fd->root.type == bfd_link_hash_undefweak)))
8038             {
8039               struct plt_entry *ent;
8040
8041               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8042                 if (ent->plt.refcount > 0)
8043                   break;
8044               if (ent != NULL)
8045                 {
8046                   tga_fd->root.type = bfd_link_hash_indirect;
8047                   tga_fd->root.u.i.link = &opt_fd->root;
8048                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8049                   if (opt_fd->dynindx != -1)
8050                     {
8051                       /* Use __tls_get_addr_opt in dynamic relocations.  */
8052                       opt_fd->dynindx = -1;
8053                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8054                                               opt_fd->dynstr_index);
8055                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8056                         return NULL;
8057                     }
8058                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8059                   tga = &htab->tls_get_addr->elf;
8060                   if (opt != NULL && tga != NULL)
8061                     {
8062                       tga->root.type = bfd_link_hash_indirect;
8063                       tga->root.u.i.link = &opt->root;
8064                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
8065                       _bfd_elf_link_hash_hide_symbol (info, opt,
8066                                                       tga->forced_local);
8067                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8068                     }
8069                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8070                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8071                   if (htab->tls_get_addr != NULL)
8072                     {
8073                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8074                       htab->tls_get_addr->is_func = 1;
8075                     }
8076                 }
8077             }
8078         }
8079       else
8080         htab->params->no_tls_get_addr_opt = TRUE;
8081     }
8082   return _bfd_elf_tls_setup (info->output_bfd, info);
8083 }
8084
8085 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8086    HASH1 or HASH2.  */
8087
8088 static bfd_boolean
8089 branch_reloc_hash_match (const bfd *ibfd,
8090                          const Elf_Internal_Rela *rel,
8091                          const struct ppc_link_hash_entry *hash1,
8092                          const struct ppc_link_hash_entry *hash2)
8093 {
8094   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8095   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8096   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8097
8098   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8099     {
8100       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8101       struct elf_link_hash_entry *h;
8102
8103       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8104       h = elf_follow_link (h);
8105       if (h == &hash1->elf || h == &hash2->elf)
8106         return TRUE;
8107     }
8108   return FALSE;
8109 }
8110
8111 /* Run through all the TLS relocs looking for optimization
8112    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8113    a preliminary section layout so that we know the TLS segment
8114    offsets.  We can't optimize earlier because some optimizations need
8115    to know the tp offset, and we need to optimize before allocating
8116    dynamic relocations.  */
8117
8118 bfd_boolean
8119 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8120 {
8121   bfd *ibfd;
8122   asection *sec;
8123   struct ppc_link_hash_table *htab;
8124   unsigned char *toc_ref;
8125   int pass;
8126
8127   if (info->relocatable || !info->executable)
8128     return TRUE;
8129
8130   htab = ppc_hash_table (info);
8131   if (htab == NULL)
8132     return FALSE;
8133
8134   /* Make two passes over the relocs.  On the first pass, mark toc
8135      entries involved with tls relocs, and check that tls relocs
8136      involved in setting up a tls_get_addr call are indeed followed by
8137      such a call.  If they are not, we can't do any tls optimization.
8138      On the second pass twiddle tls_mask flags to notify
8139      relocate_section that optimization can be done, and adjust got
8140      and plt refcounts.  */
8141   toc_ref = NULL;
8142   for (pass = 0; pass < 2; ++pass)
8143     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8144       {
8145         Elf_Internal_Sym *locsyms = NULL;
8146         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8147
8148         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8149           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8150             {
8151               Elf_Internal_Rela *relstart, *rel, *relend;
8152               bfd_boolean found_tls_get_addr_arg = 0;
8153
8154               /* Read the relocations.  */
8155               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8156                                                     info->keep_memory);
8157               if (relstart == NULL)
8158                 {
8159                   free (toc_ref);
8160                   return FALSE;
8161                 }
8162
8163               relend = relstart + sec->reloc_count;
8164               for (rel = relstart; rel < relend; rel++)
8165                 {
8166                   enum elf_ppc64_reloc_type r_type;
8167                   unsigned long r_symndx;
8168                   struct elf_link_hash_entry *h;
8169                   Elf_Internal_Sym *sym;
8170                   asection *sym_sec;
8171                   unsigned char *tls_mask;
8172                   unsigned char tls_set, tls_clear, tls_type = 0;
8173                   bfd_vma value;
8174                   bfd_boolean ok_tprel, is_local;
8175                   long toc_ref_index = 0;
8176                   int expecting_tls_get_addr = 0;
8177                   bfd_boolean ret = FALSE;
8178
8179                   r_symndx = ELF64_R_SYM (rel->r_info);
8180                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8181                                   r_symndx, ibfd))
8182                     {
8183                     err_free_rel:
8184                       if (elf_section_data (sec)->relocs != relstart)
8185                         free (relstart);
8186                       if (toc_ref != NULL)
8187                         free (toc_ref);
8188                       if (locsyms != NULL
8189                           && (elf_symtab_hdr (ibfd).contents
8190                               != (unsigned char *) locsyms))
8191                         free (locsyms);
8192                       return ret;
8193                     }
8194
8195                   if (h != NULL)
8196                     {
8197                       if (h->root.type == bfd_link_hash_defined
8198                           || h->root.type == bfd_link_hash_defweak)
8199                         value = h->root.u.def.value;
8200                       else if (h->root.type == bfd_link_hash_undefweak)
8201                         value = 0;
8202                       else
8203                         {
8204                           found_tls_get_addr_arg = 0;
8205                           continue;
8206                         }
8207                     }
8208                   else
8209                     /* Symbols referenced by TLS relocs must be of type
8210                        STT_TLS.  So no need for .opd local sym adjust.  */
8211                     value = sym->st_value;
8212
8213                   ok_tprel = FALSE;
8214                   is_local = FALSE;
8215                   if (h == NULL
8216                       || !h->def_dynamic)
8217                     {
8218                       is_local = TRUE;
8219                       if (h != NULL
8220                           && h->root.type == bfd_link_hash_undefweak)
8221                         ok_tprel = TRUE;
8222                       else
8223                         {
8224                           value += sym_sec->output_offset;
8225                           value += sym_sec->output_section->vma;
8226                           value -= htab->elf.tls_sec->vma;
8227                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8228                                       < (bfd_vma) 1 << 32);
8229                         }
8230                     }
8231
8232                   r_type = ELF64_R_TYPE (rel->r_info);
8233                   /* If this section has old-style __tls_get_addr calls
8234                      without marker relocs, then check that each
8235                      __tls_get_addr call reloc is preceded by a reloc
8236                      that conceivably belongs to the __tls_get_addr arg
8237                      setup insn.  If we don't find matching arg setup
8238                      relocs, don't do any tls optimization.  */
8239                   if (pass == 0
8240                       && sec->has_tls_get_addr_call
8241                       && h != NULL
8242                       && (h == &htab->tls_get_addr->elf
8243                           || h == &htab->tls_get_addr_fd->elf)
8244                       && !found_tls_get_addr_arg
8245                       && is_branch_reloc (r_type))
8246                     {
8247                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8248                                                 "TLS optimization disabled\n"),
8249                                               ibfd, sec, rel->r_offset);
8250                       ret = TRUE;
8251                       goto err_free_rel;
8252                     }
8253
8254                   found_tls_get_addr_arg = 0;
8255                   switch (r_type)
8256                     {
8257                     case R_PPC64_GOT_TLSLD16:
8258                     case R_PPC64_GOT_TLSLD16_LO:
8259                       expecting_tls_get_addr = 1;
8260                       found_tls_get_addr_arg = 1;
8261                       /* Fall thru */
8262
8263                     case R_PPC64_GOT_TLSLD16_HI:
8264                     case R_PPC64_GOT_TLSLD16_HA:
8265                       /* These relocs should never be against a symbol
8266                          defined in a shared lib.  Leave them alone if
8267                          that turns out to be the case.  */
8268                       if (!is_local)
8269                         continue;
8270
8271                       /* LD -> LE */
8272                       tls_set = 0;
8273                       tls_clear = TLS_LD;
8274                       tls_type = TLS_TLS | TLS_LD;
8275                       break;
8276
8277                     case R_PPC64_GOT_TLSGD16:
8278                     case R_PPC64_GOT_TLSGD16_LO:
8279                       expecting_tls_get_addr = 1;
8280                       found_tls_get_addr_arg = 1;
8281                       /* Fall thru */
8282
8283                     case R_PPC64_GOT_TLSGD16_HI:
8284                     case R_PPC64_GOT_TLSGD16_HA:
8285                       if (ok_tprel)
8286                         /* GD -> LE */
8287                         tls_set = 0;
8288                       else
8289                         /* GD -> IE */
8290                         tls_set = TLS_TLS | TLS_TPRELGD;
8291                       tls_clear = TLS_GD;
8292                       tls_type = TLS_TLS | TLS_GD;
8293                       break;
8294
8295                     case R_PPC64_GOT_TPREL16_DS:
8296                     case R_PPC64_GOT_TPREL16_LO_DS:
8297                     case R_PPC64_GOT_TPREL16_HI:
8298                     case R_PPC64_GOT_TPREL16_HA:
8299                       if (ok_tprel)
8300                         {
8301                           /* IE -> LE */
8302                           tls_set = 0;
8303                           tls_clear = TLS_TPREL;
8304                           tls_type = TLS_TLS | TLS_TPREL;
8305                           break;
8306                         }
8307                       continue;
8308
8309                     case R_PPC64_TLSGD:
8310                     case R_PPC64_TLSLD:
8311                       found_tls_get_addr_arg = 1;
8312                       /* Fall thru */
8313
8314                     case R_PPC64_TLS:
8315                     case R_PPC64_TOC16:
8316                     case R_PPC64_TOC16_LO:
8317                       if (sym_sec == NULL || sym_sec != toc)
8318                         continue;
8319
8320                       /* Mark this toc entry as referenced by a TLS
8321                          code sequence.  We can do that now in the
8322                          case of R_PPC64_TLS, and after checking for
8323                          tls_get_addr for the TOC16 relocs.  */
8324                       if (toc_ref == NULL)
8325                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8326                       if (toc_ref == NULL)
8327                         goto err_free_rel;
8328
8329                       if (h != NULL)
8330                         value = h->root.u.def.value;
8331                       else
8332                         value = sym->st_value;
8333                       value += rel->r_addend;
8334                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8335                       toc_ref_index = (value + toc->output_offset) / 8;
8336                       if (r_type == R_PPC64_TLS
8337                           || r_type == R_PPC64_TLSGD
8338                           || r_type == R_PPC64_TLSLD)
8339                         {
8340                           toc_ref[toc_ref_index] = 1;
8341                           continue;
8342                         }
8343
8344                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8345                         continue;
8346
8347                       tls_set = 0;
8348                       tls_clear = 0;
8349                       expecting_tls_get_addr = 2;
8350                       break;
8351
8352                     case R_PPC64_TPREL64:
8353                       if (pass == 0
8354                           || sec != toc
8355                           || toc_ref == NULL
8356                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8357                         continue;
8358                       if (ok_tprel)
8359                         {
8360                           /* IE -> LE */
8361                           tls_set = TLS_EXPLICIT;
8362                           tls_clear = TLS_TPREL;
8363                           break;
8364                         }
8365                       continue;
8366
8367                     case R_PPC64_DTPMOD64:
8368                       if (pass == 0
8369                           || sec != toc
8370                           || toc_ref == NULL
8371                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8372                         continue;
8373                       if (rel + 1 < relend
8374                           && (rel[1].r_info
8375                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8376                           && rel[1].r_offset == rel->r_offset + 8)
8377                         {
8378                           if (ok_tprel)
8379                             /* GD -> LE */
8380                             tls_set = TLS_EXPLICIT | TLS_GD;
8381                           else
8382                             /* GD -> IE */
8383                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8384                           tls_clear = TLS_GD;
8385                         }
8386                       else
8387                         {
8388                           if (!is_local)
8389                             continue;
8390
8391                           /* LD -> LE */
8392                           tls_set = TLS_EXPLICIT;
8393                           tls_clear = TLS_LD;
8394                         }
8395                       break;
8396
8397                     default:
8398                       continue;
8399                     }
8400
8401                   if (pass == 0)
8402                     {
8403                       if (!expecting_tls_get_addr
8404                           || !sec->has_tls_get_addr_call)
8405                         continue;
8406
8407                       if (rel + 1 < relend
8408                           && branch_reloc_hash_match (ibfd, rel + 1,
8409                                                       htab->tls_get_addr,
8410                                                       htab->tls_get_addr_fd))
8411                         {
8412                           if (expecting_tls_get_addr == 2)
8413                             {
8414                               /* Check for toc tls entries.  */
8415                               unsigned char *toc_tls;
8416                               int retval;
8417
8418                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8419                                                      &locsyms,
8420                                                      rel, ibfd);
8421                               if (retval == 0)
8422                                 goto err_free_rel;
8423                               if (toc_tls != NULL)
8424                                 {
8425                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8426                                     found_tls_get_addr_arg = 1;
8427                                   if (retval > 1)
8428                                     toc_ref[toc_ref_index] = 1;
8429                                 }
8430                             }
8431                           continue;
8432                         }
8433
8434                       if (expecting_tls_get_addr != 1)
8435                         continue;
8436
8437                       /* Uh oh, we didn't find the expected call.  We
8438                          could just mark this symbol to exclude it
8439                          from tls optimization but it's safer to skip
8440                          the entire optimization.  */
8441                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8442                                                 "TLS optimization disabled\n"),
8443                                               ibfd, sec, rel->r_offset);
8444                       ret = TRUE;
8445                       goto err_free_rel;
8446                     }
8447
8448                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8449                     {
8450                       struct plt_entry *ent;
8451                       for (ent = htab->tls_get_addr->elf.plt.plist;
8452                            ent != NULL;
8453                            ent = ent->next)
8454                         if (ent->addend == 0)
8455                           {
8456                             if (ent->plt.refcount > 0)
8457                               {
8458                                 ent->plt.refcount -= 1;
8459                                 expecting_tls_get_addr = 0;
8460                               }
8461                             break;
8462                           }
8463                     }
8464
8465                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8466                     {
8467                       struct plt_entry *ent;
8468                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8469                            ent != NULL;
8470                            ent = ent->next)
8471                         if (ent->addend == 0)
8472                           {
8473                             if (ent->plt.refcount > 0)
8474                               ent->plt.refcount -= 1;
8475                             break;
8476                           }
8477                     }
8478
8479                   if (tls_clear == 0)
8480                     continue;
8481
8482                   if ((tls_set & TLS_EXPLICIT) == 0)
8483                     {
8484                       struct got_entry *ent;
8485
8486                       /* Adjust got entry for this reloc.  */
8487                       if (h != NULL)
8488                         ent = h->got.glist;
8489                       else
8490                         ent = elf_local_got_ents (ibfd)[r_symndx];
8491
8492                       for (; ent != NULL; ent = ent->next)
8493                         if (ent->addend == rel->r_addend
8494                             && ent->owner == ibfd
8495                             && ent->tls_type == tls_type)
8496                           break;
8497                       if (ent == NULL)
8498                         abort ();
8499
8500                       if (tls_set == 0)
8501                         {
8502                           /* We managed to get rid of a got entry.  */
8503                           if (ent->got.refcount > 0)
8504                             ent->got.refcount -= 1;
8505                         }
8506                     }
8507                   else
8508                     {
8509                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8510                          we'll lose one or two dyn relocs.  */
8511                       if (!dec_dynrel_count (rel->r_info, sec, info,
8512                                              NULL, h, sym))
8513                         return FALSE;
8514
8515                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8516                         {
8517                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8518                                                  NULL, h, sym))
8519                             return FALSE;
8520                         }
8521                     }
8522
8523                   *tls_mask |= tls_set;
8524                   *tls_mask &= ~tls_clear;
8525                 }
8526
8527               if (elf_section_data (sec)->relocs != relstart)
8528                 free (relstart);
8529             }
8530
8531         if (locsyms != NULL
8532             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8533           {
8534             if (!info->keep_memory)
8535               free (locsyms);
8536             else
8537               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8538           }
8539       }
8540
8541   if (toc_ref != NULL)
8542     free (toc_ref);
8543   return TRUE;
8544 }
8545
8546 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8547    the values of any global symbols in a toc section that has been
8548    edited.  Globals in toc sections should be a rarity, so this function
8549    sets a flag if any are found in toc sections other than the one just
8550    edited, so that futher hash table traversals can be avoided.  */
8551
8552 struct adjust_toc_info
8553 {
8554   asection *toc;
8555   unsigned long *skip;
8556   bfd_boolean global_toc_syms;
8557 };
8558
8559 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8560
8561 static bfd_boolean
8562 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8563 {
8564   struct ppc_link_hash_entry *eh;
8565   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8566   unsigned long i;
8567
8568   if (h->root.type != bfd_link_hash_defined
8569       && h->root.type != bfd_link_hash_defweak)
8570     return TRUE;
8571
8572   eh = (struct ppc_link_hash_entry *) h;
8573   if (eh->adjust_done)
8574     return TRUE;
8575
8576   if (eh->elf.root.u.def.section == toc_inf->toc)
8577     {
8578       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8579         i = toc_inf->toc->rawsize >> 3;
8580       else
8581         i = eh->elf.root.u.def.value >> 3;
8582
8583       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8584         {
8585           (*_bfd_error_handler)
8586             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8587           do
8588             ++i;
8589           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8590           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8591         }
8592
8593       eh->elf.root.u.def.value -= toc_inf->skip[i];
8594       eh->adjust_done = 1;
8595     }
8596   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8597     toc_inf->global_toc_syms = TRUE;
8598
8599   return TRUE;
8600 }
8601
8602 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8603
8604 static bfd_boolean
8605 ok_lo_toc_insn (unsigned int insn)
8606 {
8607   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8608           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8609           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8610           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8611           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8612           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8613           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8614           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8615           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8616           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8617           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8618           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8619           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8620           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8621           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8622               && (insn & 3) != 1)
8623           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8624               && ((insn & 3) == 0 || (insn & 3) == 3))
8625           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8626 }
8627
8628 /* Examine all relocs referencing .toc sections in order to remove
8629    unused .toc entries.  */
8630
8631 bfd_boolean
8632 ppc64_elf_edit_toc (struct bfd_link_info *info)
8633 {
8634   bfd *ibfd;
8635   struct adjust_toc_info toc_inf;
8636   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8637
8638   htab->do_toc_opt = 1;
8639   toc_inf.global_toc_syms = TRUE;
8640   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8641     {
8642       asection *toc, *sec;
8643       Elf_Internal_Shdr *symtab_hdr;
8644       Elf_Internal_Sym *local_syms;
8645       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8646       unsigned long *skip, *drop;
8647       unsigned char *used;
8648       unsigned char *keep, last, some_unused;
8649
8650       if (!is_ppc64_elf (ibfd))
8651         continue;
8652
8653       toc = bfd_get_section_by_name (ibfd, ".toc");
8654       if (toc == NULL
8655           || toc->size == 0
8656           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8657           || discarded_section (toc))
8658         continue;
8659
8660       toc_relocs = NULL;
8661       local_syms = NULL;
8662       symtab_hdr = &elf_symtab_hdr (ibfd);
8663
8664       /* Look at sections dropped from the final link.  */
8665       skip = NULL;
8666       relstart = NULL;
8667       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8668         {
8669           if (sec->reloc_count == 0
8670               || !discarded_section (sec)
8671               || get_opd_info (sec)
8672               || (sec->flags & SEC_ALLOC) == 0
8673               || (sec->flags & SEC_DEBUGGING) != 0)
8674             continue;
8675
8676           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8677           if (relstart == NULL)
8678             goto error_ret;
8679
8680           /* Run through the relocs to see which toc entries might be
8681              unused.  */
8682           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8683             {
8684               enum elf_ppc64_reloc_type r_type;
8685               unsigned long r_symndx;
8686               asection *sym_sec;
8687               struct elf_link_hash_entry *h;
8688               Elf_Internal_Sym *sym;
8689               bfd_vma val;
8690
8691               r_type = ELF64_R_TYPE (rel->r_info);
8692               switch (r_type)
8693                 {
8694                 default:
8695                   continue;
8696
8697                 case R_PPC64_TOC16:
8698                 case R_PPC64_TOC16_LO:
8699                 case R_PPC64_TOC16_HI:
8700                 case R_PPC64_TOC16_HA:
8701                 case R_PPC64_TOC16_DS:
8702                 case R_PPC64_TOC16_LO_DS:
8703                   break;
8704                 }
8705
8706               r_symndx = ELF64_R_SYM (rel->r_info);
8707               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8708                               r_symndx, ibfd))
8709                 goto error_ret;
8710
8711               if (sym_sec != toc)
8712                 continue;
8713
8714               if (h != NULL)
8715                 val = h->root.u.def.value;
8716               else
8717                 val = sym->st_value;
8718               val += rel->r_addend;
8719
8720               if (val >= toc->size)
8721                 continue;
8722
8723               /* Anything in the toc ought to be aligned to 8 bytes.
8724                  If not, don't mark as unused.  */
8725               if (val & 7)
8726                 continue;
8727
8728               if (skip == NULL)
8729                 {
8730                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8731                   if (skip == NULL)
8732                     goto error_ret;
8733                 }
8734
8735               skip[val >> 3] = ref_from_discarded;
8736             }
8737
8738           if (elf_section_data (sec)->relocs != relstart)
8739             free (relstart);
8740         }
8741
8742       /* For largetoc loads of address constants, we can convert
8743          .  addis rx,2,addr@got@ha
8744          .  ld ry,addr@got@l(rx)
8745          to
8746          .  addis rx,2,addr@toc@ha
8747          .  addi ry,rx,addr@toc@l
8748          when addr is within 2G of the toc pointer.  This then means
8749          that the word storing "addr" in the toc is no longer needed.  */
8750
8751       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8752           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8753           && toc->reloc_count != 0)
8754         {
8755           /* Read toc relocs.  */
8756           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8757                                                   info->keep_memory);
8758           if (toc_relocs == NULL)
8759             goto error_ret;
8760
8761           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8762             {
8763               enum elf_ppc64_reloc_type r_type;
8764               unsigned long r_symndx;
8765               asection *sym_sec;
8766               struct elf_link_hash_entry *h;
8767               Elf_Internal_Sym *sym;
8768               bfd_vma val, addr;
8769
8770               r_type = ELF64_R_TYPE (rel->r_info);
8771               if (r_type != R_PPC64_ADDR64)
8772                 continue;
8773
8774               r_symndx = ELF64_R_SYM (rel->r_info);
8775               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8776                               r_symndx, ibfd))
8777                 goto error_ret;
8778
8779               if (sym_sec == NULL
8780                   || discarded_section (sym_sec))
8781                 continue;
8782
8783               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8784                 continue;
8785
8786               if (h != NULL)
8787                 {
8788                   if (h->type == STT_GNU_IFUNC)
8789                     continue;
8790                   val = h->root.u.def.value;
8791                 }
8792               else
8793                 {
8794                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8795                     continue;
8796                   val = sym->st_value;
8797                 }
8798               val += rel->r_addend;
8799               val += sym_sec->output_section->vma + sym_sec->output_offset;
8800
8801               /* We don't yet know the exact toc pointer value, but we
8802                  know it will be somewhere in the toc section.  Don't
8803                  optimize if the difference from any possible toc
8804                  pointer is outside [ff..f80008000, 7fff7fff].  */
8805               addr = toc->output_section->vma + TOC_BASE_OFF;
8806               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8807                 continue;
8808
8809               addr = toc->output_section->vma + toc->output_section->rawsize;
8810               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8811                 continue;
8812
8813               if (skip == NULL)
8814                 {
8815                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8816                   if (skip == NULL)
8817                     goto error_ret;
8818                 }
8819
8820               skip[rel->r_offset >> 3]
8821                 |= can_optimize | ((rel - toc_relocs) << 2);
8822             }
8823         }
8824
8825       if (skip == NULL)
8826         continue;
8827
8828       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8829       if (used == NULL)
8830         {
8831         error_ret:
8832           if (local_syms != NULL
8833               && symtab_hdr->contents != (unsigned char *) local_syms)
8834             free (local_syms);
8835           if (sec != NULL
8836               && relstart != NULL
8837               && elf_section_data (sec)->relocs != relstart)
8838             free (relstart);
8839           if (toc_relocs != NULL
8840               && elf_section_data (toc)->relocs != toc_relocs)
8841             free (toc_relocs);
8842           if (skip != NULL)
8843             free (skip);
8844           return FALSE;
8845         }
8846
8847       /* Now check all kept sections that might reference the toc.
8848          Check the toc itself last.  */
8849       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8850                   : ibfd->sections);
8851            sec != NULL;
8852            sec = (sec == toc ? NULL
8853                   : sec->next == NULL ? toc
8854                   : sec->next == toc && toc->next ? toc->next
8855                   : sec->next))
8856         {
8857           int repeat;
8858
8859           if (sec->reloc_count == 0
8860               || discarded_section (sec)
8861               || get_opd_info (sec)
8862               || (sec->flags & SEC_ALLOC) == 0
8863               || (sec->flags & SEC_DEBUGGING) != 0)
8864             continue;
8865
8866           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8867                                                 info->keep_memory);
8868           if (relstart == NULL)
8869             {
8870               free (used);
8871               goto error_ret;
8872             }
8873
8874           /* Mark toc entries referenced as used.  */
8875           do
8876             {
8877               repeat = 0;
8878               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8879                 {
8880                   enum elf_ppc64_reloc_type r_type;
8881                   unsigned long r_symndx;
8882                   asection *sym_sec;
8883                   struct elf_link_hash_entry *h;
8884                   Elf_Internal_Sym *sym;
8885                   bfd_vma val;
8886                   enum {no_check, check_lo, check_ha} insn_check;
8887
8888                   r_type = ELF64_R_TYPE (rel->r_info);
8889                   switch (r_type)
8890                     {
8891                     default:
8892                       insn_check = no_check;
8893                       break;
8894
8895                     case R_PPC64_GOT_TLSLD16_HA:
8896                     case R_PPC64_GOT_TLSGD16_HA:
8897                     case R_PPC64_GOT_TPREL16_HA:
8898                     case R_PPC64_GOT_DTPREL16_HA:
8899                     case R_PPC64_GOT16_HA:
8900                     case R_PPC64_TOC16_HA:
8901                       insn_check = check_ha;
8902                       break;
8903
8904                     case R_PPC64_GOT_TLSLD16_LO:
8905                     case R_PPC64_GOT_TLSGD16_LO:
8906                     case R_PPC64_GOT_TPREL16_LO_DS:
8907                     case R_PPC64_GOT_DTPREL16_LO_DS:
8908                     case R_PPC64_GOT16_LO:
8909                     case R_PPC64_GOT16_LO_DS:
8910                     case R_PPC64_TOC16_LO:
8911                     case R_PPC64_TOC16_LO_DS:
8912                       insn_check = check_lo;
8913                       break;
8914                     }
8915
8916                   if (insn_check != no_check)
8917                     {
8918                       bfd_vma off = rel->r_offset & ~3;
8919                       unsigned char buf[4];
8920                       unsigned int insn;
8921
8922                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8923                         {
8924                           free (used);
8925                           goto error_ret;
8926                         }
8927                       insn = bfd_get_32 (ibfd, buf);
8928                       if (insn_check == check_lo
8929                           ? !ok_lo_toc_insn (insn)
8930                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8931                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8932                         {
8933                           char str[12];
8934
8935                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8936                           sprintf (str, "%#08x", insn);
8937                           info->callbacks->einfo
8938                             (_("%P: %H: toc optimization is not supported for"
8939                                " %s instruction.\n"),
8940                              ibfd, sec, rel->r_offset & ~3, str);
8941                         }
8942                     }
8943
8944                   switch (r_type)
8945                     {
8946                     case R_PPC64_TOC16:
8947                     case R_PPC64_TOC16_LO:
8948                     case R_PPC64_TOC16_HI:
8949                     case R_PPC64_TOC16_HA:
8950                     case R_PPC64_TOC16_DS:
8951                     case R_PPC64_TOC16_LO_DS:
8952                       /* In case we're taking addresses of toc entries.  */
8953                     case R_PPC64_ADDR64:
8954                       break;
8955
8956                     default:
8957                       continue;
8958                     }
8959
8960                   r_symndx = ELF64_R_SYM (rel->r_info);
8961                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8962                                   r_symndx, ibfd))
8963                     {
8964                       free (used);
8965                       goto error_ret;
8966                     }
8967
8968                   if (sym_sec != toc)
8969                     continue;
8970
8971                   if (h != NULL)
8972                     val = h->root.u.def.value;
8973                   else
8974                     val = sym->st_value;
8975                   val += rel->r_addend;
8976
8977                   if (val >= toc->size)
8978                     continue;
8979
8980                   if ((skip[val >> 3] & can_optimize) != 0)
8981                     {
8982                       bfd_vma off;
8983                       unsigned char opc;
8984
8985                       switch (r_type)
8986                         {
8987                         case R_PPC64_TOC16_HA:
8988                           break;
8989
8990                         case R_PPC64_TOC16_LO_DS:
8991                           off = rel->r_offset;
8992                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8993                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8994                                                          off, 1))
8995                             {
8996                               free (used);
8997                               goto error_ret;
8998                             }
8999                           if ((opc & (0x3f << 2)) == (58u << 2))
9000                             break;
9001                           /* Fall thru */
9002
9003                         default:
9004                           /* Wrong sort of reloc, or not a ld.  We may
9005                              as well clear ref_from_discarded too.  */
9006                           skip[val >> 3] = 0;
9007                         }
9008                     }
9009
9010                   if (sec != toc)
9011                     used[val >> 3] = 1;
9012                   /* For the toc section, we only mark as used if this
9013                      entry itself isn't unused.  */
9014                   else if ((used[rel->r_offset >> 3]
9015                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9016                            && !used[val >> 3])
9017                     {
9018                       /* Do all the relocs again, to catch reference
9019                          chains.  */
9020                       repeat = 1;
9021                       used[val >> 3] = 1;
9022                     }
9023                 }
9024             }
9025           while (repeat);
9026
9027           if (elf_section_data (sec)->relocs != relstart)
9028             free (relstart);
9029         }
9030
9031       /* Merge the used and skip arrays.  Assume that TOC
9032          doublewords not appearing as either used or unused belong
9033          to to an entry more than one doubleword in size.  */
9034       for (drop = skip, keep = used, last = 0, some_unused = 0;
9035            drop < skip + (toc->size + 7) / 8;
9036            ++drop, ++keep)
9037         {
9038           if (*keep)
9039             {
9040               *drop &= ~ref_from_discarded;
9041               if ((*drop & can_optimize) != 0)
9042                 some_unused = 1;
9043               last = 0;
9044             }
9045           else if ((*drop & ref_from_discarded) != 0)
9046             {
9047               some_unused = 1;
9048               last = ref_from_discarded;
9049             }
9050           else
9051             *drop = last;
9052         }
9053
9054       free (used);
9055
9056       if (some_unused)
9057         {
9058           bfd_byte *contents, *src;
9059           unsigned long off;
9060           Elf_Internal_Sym *sym;
9061           bfd_boolean local_toc_syms = FALSE;
9062
9063           /* Shuffle the toc contents, and at the same time convert the
9064              skip array from booleans into offsets.  */
9065           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9066             goto error_ret;
9067
9068           elf_section_data (toc)->this_hdr.contents = contents;
9069
9070           for (src = contents, off = 0, drop = skip;
9071                src < contents + toc->size;
9072                src += 8, ++drop)
9073             {
9074               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9075                 off += 8;
9076               else if (off != 0)
9077                 {
9078                   *drop = off;
9079                   memcpy (src - off, src, 8);
9080                 }
9081             }
9082           *drop = off;
9083           toc->rawsize = toc->size;
9084           toc->size = src - contents - off;
9085
9086           /* Adjust addends for relocs against the toc section sym,
9087              and optimize any accesses we can.  */
9088           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9089             {
9090               if (sec->reloc_count == 0
9091                   || discarded_section (sec))
9092                 continue;
9093
9094               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9095                                                     info->keep_memory);
9096               if (relstart == NULL)
9097                 goto error_ret;
9098
9099               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9100                 {
9101                   enum elf_ppc64_reloc_type r_type;
9102                   unsigned long r_symndx;
9103                   asection *sym_sec;
9104                   struct elf_link_hash_entry *h;
9105                   bfd_vma val;
9106
9107                   r_type = ELF64_R_TYPE (rel->r_info);
9108                   switch (r_type)
9109                     {
9110                     default:
9111                       continue;
9112
9113                     case R_PPC64_TOC16:
9114                     case R_PPC64_TOC16_LO:
9115                     case R_PPC64_TOC16_HI:
9116                     case R_PPC64_TOC16_HA:
9117                     case R_PPC64_TOC16_DS:
9118                     case R_PPC64_TOC16_LO_DS:
9119                     case R_PPC64_ADDR64:
9120                       break;
9121                     }
9122
9123                   r_symndx = ELF64_R_SYM (rel->r_info);
9124                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9125                                   r_symndx, ibfd))
9126                     goto error_ret;
9127
9128                   if (sym_sec != toc)
9129                     continue;
9130
9131                   if (h != NULL)
9132                     val = h->root.u.def.value;
9133                   else
9134                     {
9135                       val = sym->st_value;
9136                       if (val != 0)
9137                         local_toc_syms = TRUE;
9138                     }
9139
9140                   val += rel->r_addend;
9141
9142                   if (val > toc->rawsize)
9143                     val = toc->rawsize;
9144                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9145                     continue;
9146                   else if ((skip[val >> 3] & can_optimize) != 0)
9147                     {
9148                       Elf_Internal_Rela *tocrel
9149                         = toc_relocs + (skip[val >> 3] >> 2);
9150                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9151
9152                       switch (r_type)
9153                         {
9154                         case R_PPC64_TOC16_HA:
9155                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9156                           break;
9157
9158                         case R_PPC64_TOC16_LO_DS:
9159                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9160                           break;
9161
9162                         default:
9163                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9164                             ppc_howto_init ();
9165                           info->callbacks->einfo
9166                             (_("%P: %H: %s references "
9167                                "optimized away TOC entry\n"),
9168                              ibfd, sec, rel->r_offset,
9169                              ppc64_elf_howto_table[r_type]->name);
9170                           bfd_set_error (bfd_error_bad_value);
9171                           goto error_ret;
9172                         }
9173                       rel->r_addend = tocrel->r_addend;
9174                       elf_section_data (sec)->relocs = relstart;
9175                       continue;
9176                     }
9177
9178                   if (h != NULL || sym->st_value != 0)
9179                     continue;
9180
9181                   rel->r_addend -= skip[val >> 3];
9182                   elf_section_data (sec)->relocs = relstart;
9183                 }
9184
9185               if (elf_section_data (sec)->relocs != relstart)
9186                 free (relstart);
9187             }
9188
9189           /* We shouldn't have local or global symbols defined in the TOC,
9190              but handle them anyway.  */
9191           if (local_syms != NULL)
9192             for (sym = local_syms;
9193                  sym < local_syms + symtab_hdr->sh_info;
9194                  ++sym)
9195               if (sym->st_value != 0
9196                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9197                 {
9198                   unsigned long i;
9199
9200                   if (sym->st_value > toc->rawsize)
9201                     i = toc->rawsize >> 3;
9202                   else
9203                     i = sym->st_value >> 3;
9204
9205                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9206                     {
9207                       if (local_toc_syms)
9208                         (*_bfd_error_handler)
9209                           (_("%s defined on removed toc entry"),
9210                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9211                       do
9212                         ++i;
9213                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9214                       sym->st_value = (bfd_vma) i << 3;
9215                     }
9216
9217                   sym->st_value -= skip[i];
9218                   symtab_hdr->contents = (unsigned char *) local_syms;
9219                 }
9220
9221           /* Adjust any global syms defined in this toc input section.  */
9222           if (toc_inf.global_toc_syms)
9223             {
9224               toc_inf.toc = toc;
9225               toc_inf.skip = skip;
9226               toc_inf.global_toc_syms = FALSE;
9227               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9228                                       &toc_inf);
9229             }
9230
9231           if (toc->reloc_count != 0)
9232             {
9233               Elf_Internal_Shdr *rel_hdr;
9234               Elf_Internal_Rela *wrel;
9235               bfd_size_type sz;
9236
9237               /* Remove unused toc relocs, and adjust those we keep.  */
9238               if (toc_relocs == NULL)
9239                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9240                                                         info->keep_memory);
9241               if (toc_relocs == NULL)
9242                 goto error_ret;
9243
9244               wrel = toc_relocs;
9245               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9246                 if ((skip[rel->r_offset >> 3]
9247                      & (ref_from_discarded | can_optimize)) == 0)
9248                   {
9249                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9250                     wrel->r_info = rel->r_info;
9251                     wrel->r_addend = rel->r_addend;
9252                     ++wrel;
9253                   }
9254                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9255                                             &local_syms, NULL, NULL))
9256                   goto error_ret;
9257
9258               elf_section_data (toc)->relocs = toc_relocs;
9259               toc->reloc_count = wrel - toc_relocs;
9260               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9261               sz = rel_hdr->sh_entsize;
9262               rel_hdr->sh_size = toc->reloc_count * sz;
9263             }
9264         }
9265       else if (toc_relocs != NULL
9266                && elf_section_data (toc)->relocs != toc_relocs)
9267         free (toc_relocs);
9268
9269       if (local_syms != NULL
9270           && symtab_hdr->contents != (unsigned char *) local_syms)
9271         {
9272           if (!info->keep_memory)
9273             free (local_syms);
9274           else
9275             symtab_hdr->contents = (unsigned char *) local_syms;
9276         }
9277       free (skip);
9278     }
9279
9280   return TRUE;
9281 }
9282
9283 /* Return true iff input section I references the TOC using
9284    instructions limited to +/-32k offsets.  */
9285
9286 bfd_boolean
9287 ppc64_elf_has_small_toc_reloc (asection *i)
9288 {
9289   return (is_ppc64_elf (i->owner)
9290           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9291 }
9292
9293 /* Allocate space for one GOT entry.  */
9294
9295 static void
9296 allocate_got (struct elf_link_hash_entry *h,
9297               struct bfd_link_info *info,
9298               struct got_entry *gent)
9299 {
9300   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9301   bfd_boolean dyn;
9302   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9303   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9304                  ? 16 : 8);
9305   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9306                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9307   asection *got = ppc64_elf_tdata (gent->owner)->got;
9308
9309   gent->got.offset = got->size;
9310   got->size += entsize;
9311
9312   dyn = htab->elf.dynamic_sections_created;
9313   if (h->type == STT_GNU_IFUNC)
9314     {
9315       htab->elf.irelplt->size += rentsize;
9316       htab->got_reli_size += rentsize;
9317     }
9318   else if ((info->shared
9319             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9320            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9321                || h->root.type != bfd_link_hash_undefweak))
9322     {
9323       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9324       relgot->size += rentsize;
9325     }
9326 }
9327
9328 /* This function merges got entries in the same toc group.  */
9329
9330 static void
9331 merge_got_entries (struct got_entry **pent)
9332 {
9333   struct got_entry *ent, *ent2;
9334
9335   for (ent = *pent; ent != NULL; ent = ent->next)
9336     if (!ent->is_indirect)
9337       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9338         if (!ent2->is_indirect
9339             && ent2->addend == ent->addend
9340             && ent2->tls_type == ent->tls_type
9341             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9342           {
9343             ent2->is_indirect = TRUE;
9344             ent2->got.ent = ent;
9345           }
9346 }
9347
9348 /* Allocate space in .plt, .got and associated reloc sections for
9349    dynamic relocs.  */
9350
9351 static bfd_boolean
9352 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9353 {
9354   struct bfd_link_info *info;
9355   struct ppc_link_hash_table *htab;
9356   asection *s;
9357   struct ppc_link_hash_entry *eh;
9358   struct elf_dyn_relocs *p;
9359   struct got_entry **pgent, *gent;
9360
9361   if (h->root.type == bfd_link_hash_indirect)
9362     return TRUE;
9363
9364   info = (struct bfd_link_info *) inf;
9365   htab = ppc_hash_table (info);
9366   if (htab == NULL)
9367     return FALSE;
9368
9369   if ((htab->elf.dynamic_sections_created
9370        && h->dynindx != -1
9371        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9372       || h->type == STT_GNU_IFUNC)
9373     {
9374       struct plt_entry *pent;
9375       bfd_boolean doneone = FALSE;
9376       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9377         if (pent->plt.refcount > 0)
9378           {
9379             if (!htab->elf.dynamic_sections_created
9380                 || h->dynindx == -1)
9381               {
9382                 s = htab->elf.iplt;
9383                 pent->plt.offset = s->size;
9384                 s->size += PLT_ENTRY_SIZE (htab);
9385                 s = htab->elf.irelplt;
9386               }
9387             else
9388               {
9389                 /* If this is the first .plt entry, make room for the special
9390                    first entry.  */
9391                 s = htab->elf.splt;
9392                 if (s->size == 0)
9393                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9394
9395                 pent->plt.offset = s->size;
9396
9397                 /* Make room for this entry.  */
9398                 s->size += PLT_ENTRY_SIZE (htab);
9399
9400                 /* Make room for the .glink code.  */
9401                 s = htab->glink;
9402                 if (s->size == 0)
9403                   s->size += GLINK_CALL_STUB_SIZE;
9404                 if (htab->opd_abi)
9405                   {
9406                     /* We need bigger stubs past index 32767.  */
9407                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9408                       s->size += 4;
9409                     s->size += 2*4;
9410                   }
9411                 else
9412                   s->size += 4;
9413
9414                 /* We also need to make an entry in the .rela.plt section.  */
9415                 s = htab->elf.srelplt;
9416               }
9417             s->size += sizeof (Elf64_External_Rela);
9418             doneone = TRUE;
9419           }
9420         else
9421           pent->plt.offset = (bfd_vma) -1;
9422       if (!doneone)
9423         {
9424           h->plt.plist = NULL;
9425           h->needs_plt = 0;
9426         }
9427     }
9428   else
9429     {
9430       h->plt.plist = NULL;
9431       h->needs_plt = 0;
9432     }
9433
9434   eh = (struct ppc_link_hash_entry *) h;
9435   /* Run through the TLS GD got entries first if we're changing them
9436      to TPREL.  */
9437   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9438     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9439       if (gent->got.refcount > 0
9440           && (gent->tls_type & TLS_GD) != 0)
9441         {
9442           /* This was a GD entry that has been converted to TPREL.  If
9443              there happens to be a TPREL entry we can use that one.  */
9444           struct got_entry *ent;
9445           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9446             if (ent->got.refcount > 0
9447                 && (ent->tls_type & TLS_TPREL) != 0
9448                 && ent->addend == gent->addend
9449                 && ent->owner == gent->owner)
9450               {
9451                 gent->got.refcount = 0;
9452                 break;
9453               }
9454
9455           /* If not, then we'll be using our own TPREL entry.  */
9456           if (gent->got.refcount != 0)
9457             gent->tls_type = TLS_TLS | TLS_TPREL;
9458         }
9459
9460   /* Remove any list entry that won't generate a word in the GOT before
9461      we call merge_got_entries.  Otherwise we risk merging to empty
9462      entries.  */
9463   pgent = &h->got.glist;
9464   while ((gent = *pgent) != NULL)
9465     if (gent->got.refcount > 0)
9466       {
9467         if ((gent->tls_type & TLS_LD) != 0
9468             && !h->def_dynamic)
9469           {
9470             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9471             *pgent = gent->next;
9472           }
9473         else
9474           pgent = &gent->next;
9475       }
9476     else
9477       *pgent = gent->next;
9478
9479   if (!htab->do_multi_toc)
9480     merge_got_entries (&h->got.glist);
9481
9482   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9483     if (!gent->is_indirect)
9484       {
9485         /* Make sure this symbol is output as a dynamic symbol.
9486            Undefined weak syms won't yet be marked as dynamic,
9487            nor will all TLS symbols.  */
9488         if (h->dynindx == -1
9489             && !h->forced_local
9490             && h->type != STT_GNU_IFUNC
9491             && htab->elf.dynamic_sections_created)
9492           {
9493             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9494               return FALSE;
9495           }
9496
9497         if (!is_ppc64_elf (gent->owner))
9498           abort ();
9499
9500         allocate_got (h, info, gent);
9501       }
9502
9503   if (eh->dyn_relocs == NULL
9504       || (!htab->elf.dynamic_sections_created
9505           && h->type != STT_GNU_IFUNC))
9506     return TRUE;
9507
9508   /* In the shared -Bsymbolic case, discard space allocated for
9509      dynamic pc-relative relocs against symbols which turn out to be
9510      defined in regular objects.  For the normal shared case, discard
9511      space for relocs that have become local due to symbol visibility
9512      changes.  */
9513
9514   if (info->shared)
9515     {
9516       /* Relocs that use pc_count are those that appear on a call insn,
9517          or certain REL relocs (see must_be_dyn_reloc) that can be
9518          generated via assembly.  We want calls to protected symbols to
9519          resolve directly to the function rather than going via the plt.
9520          If people want function pointer comparisons to work as expected
9521          then they should avoid writing weird assembly.  */
9522       if (SYMBOL_CALLS_LOCAL (info, h))
9523         {
9524           struct elf_dyn_relocs **pp;
9525
9526           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9527             {
9528               p->count -= p->pc_count;
9529               p->pc_count = 0;
9530               if (p->count == 0)
9531                 *pp = p->next;
9532               else
9533                 pp = &p->next;
9534             }
9535         }
9536
9537       /* Also discard relocs on undefined weak syms with non-default
9538          visibility.  */
9539       if (eh->dyn_relocs != NULL
9540           && h->root.type == bfd_link_hash_undefweak)
9541         {
9542           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9543             eh->dyn_relocs = NULL;
9544
9545           /* Make sure this symbol is output as a dynamic symbol.
9546              Undefined weak syms won't yet be marked as dynamic.  */
9547           else if (h->dynindx == -1
9548                    && !h->forced_local)
9549             {
9550               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9551                 return FALSE;
9552             }
9553         }
9554     }
9555   else if (h->type == STT_GNU_IFUNC)
9556     {
9557       if (!h->non_got_ref)
9558         eh->dyn_relocs = NULL;
9559     }
9560   else if (ELIMINATE_COPY_RELOCS)
9561     {
9562       /* For the non-shared case, discard space for relocs against
9563          symbols which turn out to need copy relocs or are not
9564          dynamic.  */
9565
9566       if (!h->non_got_ref
9567           && !h->def_regular)
9568         {
9569           /* Make sure this symbol is output as a dynamic symbol.
9570              Undefined weak syms won't yet be marked as dynamic.  */
9571           if (h->dynindx == -1
9572               && !h->forced_local)
9573             {
9574               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9575                 return FALSE;
9576             }
9577
9578           /* If that succeeded, we know we'll be keeping all the
9579              relocs.  */
9580           if (h->dynindx != -1)
9581             goto keep;
9582         }
9583
9584       eh->dyn_relocs = NULL;
9585
9586     keep: ;
9587     }
9588
9589   /* Finally, allocate space.  */
9590   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9591     {
9592       asection *sreloc = elf_section_data (p->sec)->sreloc;
9593       if (eh->elf.type == STT_GNU_IFUNC)
9594         sreloc = htab->elf.irelplt;
9595       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9596     }
9597
9598   return TRUE;
9599 }
9600
9601 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9602    to set up space for global entry stubs.  These are put in glink,
9603    after the branch table.  */
9604
9605 static bfd_boolean
9606 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9607 {
9608   struct bfd_link_info *info;
9609   struct ppc_link_hash_table *htab;
9610   struct plt_entry *pent;
9611   asection *s;
9612
9613   if (h->root.type == bfd_link_hash_indirect)
9614     return TRUE;
9615
9616   if (!h->pointer_equality_needed)
9617     return TRUE;
9618
9619   if (h->def_regular)
9620     return TRUE;
9621
9622   info = inf;
9623   htab = ppc_hash_table (info);
9624   if (htab == NULL)
9625     return FALSE;
9626
9627   s = htab->glink;
9628   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9629     if (pent->plt.offset != (bfd_vma) -1
9630         && pent->addend == 0)
9631       {
9632         /* For ELFv2, if this symbol is not defined in a regular file
9633            and we are not generating a shared library or pie, then we
9634            need to define the symbol in the executable on a call stub.
9635            This is to avoid text relocations.  */
9636         s->size = (s->size + 15) & -16;
9637         h->root.u.def.section = s;
9638         h->root.u.def.value = s->size;
9639         s->size += 16;
9640         break;
9641       }
9642   return TRUE;
9643 }
9644
9645 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9646    read-only sections.  */
9647
9648 static bfd_boolean
9649 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9650 {
9651   if (h->root.type == bfd_link_hash_indirect)
9652     return TRUE;
9653
9654   if (readonly_dynrelocs (h))
9655     {
9656       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9657
9658       /* Not an error, just cut short the traversal.  */
9659       return FALSE;
9660     }
9661   return TRUE;
9662 }
9663
9664 /* Set the sizes of the dynamic sections.  */
9665
9666 static bfd_boolean
9667 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9668                                  struct bfd_link_info *info)
9669 {
9670   struct ppc_link_hash_table *htab;
9671   bfd *dynobj;
9672   asection *s;
9673   bfd_boolean relocs;
9674   bfd *ibfd;
9675   struct got_entry *first_tlsld;
9676
9677   htab = ppc_hash_table (info);
9678   if (htab == NULL)
9679     return FALSE;
9680
9681   dynobj = htab->elf.dynobj;
9682   if (dynobj == NULL)
9683     abort ();
9684
9685   if (htab->elf.dynamic_sections_created)
9686     {
9687       /* Set the contents of the .interp section to the interpreter.  */
9688       if (info->executable)
9689         {
9690           s = bfd_get_linker_section (dynobj, ".interp");
9691           if (s == NULL)
9692             abort ();
9693           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9694           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9695         }
9696     }
9697
9698   /* Set up .got offsets for local syms, and space for local dynamic
9699      relocs.  */
9700   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9701     {
9702       struct got_entry **lgot_ents;
9703       struct got_entry **end_lgot_ents;
9704       struct plt_entry **local_plt;
9705       struct plt_entry **end_local_plt;
9706       unsigned char *lgot_masks;
9707       bfd_size_type locsymcount;
9708       Elf_Internal_Shdr *symtab_hdr;
9709
9710       if (!is_ppc64_elf (ibfd))
9711         continue;
9712
9713       for (s = ibfd->sections; s != NULL; s = s->next)
9714         {
9715           struct ppc_dyn_relocs *p;
9716
9717           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9718             {
9719               if (!bfd_is_abs_section (p->sec)
9720                   && bfd_is_abs_section (p->sec->output_section))
9721                 {
9722                   /* Input section has been discarded, either because
9723                      it is a copy of a linkonce section or due to
9724                      linker script /DISCARD/, so we'll be discarding
9725                      the relocs too.  */
9726                 }
9727               else if (p->count != 0)
9728                 {
9729                   asection *srel = elf_section_data (p->sec)->sreloc;
9730                   if (p->ifunc)
9731                     srel = htab->elf.irelplt;
9732                   srel->size += p->count * sizeof (Elf64_External_Rela);
9733                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9734                     info->flags |= DF_TEXTREL;
9735                 }
9736             }
9737         }
9738
9739       lgot_ents = elf_local_got_ents (ibfd);
9740       if (!lgot_ents)
9741         continue;
9742
9743       symtab_hdr = &elf_symtab_hdr (ibfd);
9744       locsymcount = symtab_hdr->sh_info;
9745       end_lgot_ents = lgot_ents + locsymcount;
9746       local_plt = (struct plt_entry **) end_lgot_ents;
9747       end_local_plt = local_plt + locsymcount;
9748       lgot_masks = (unsigned char *) end_local_plt;
9749       s = ppc64_elf_tdata (ibfd)->got;
9750       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9751         {
9752           struct got_entry **pent, *ent;
9753
9754           pent = lgot_ents;
9755           while ((ent = *pent) != NULL)
9756             if (ent->got.refcount > 0)
9757               {
9758                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9759                   {
9760                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9761                     *pent = ent->next;
9762                   }
9763                 else
9764                   {
9765                     unsigned int ent_size = 8;
9766                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9767
9768                     ent->got.offset = s->size;
9769                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9770                       {
9771                         ent_size *= 2;
9772                         rel_size *= 2;
9773                       }
9774                     s->size += ent_size;
9775                     if ((*lgot_masks & PLT_IFUNC) != 0)
9776                       {
9777                         htab->elf.irelplt->size += rel_size;
9778                         htab->got_reli_size += rel_size;
9779                       }
9780                     else if (info->shared)
9781                       {
9782                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9783                         srel->size += rel_size;
9784                       }
9785                     pent = &ent->next;
9786                   }
9787               }
9788             else
9789               *pent = ent->next;
9790         }
9791
9792       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9793       for (; local_plt < end_local_plt; ++local_plt)
9794         {
9795           struct plt_entry *ent;
9796
9797           for (ent = *local_plt; ent != NULL; ent = ent->next)
9798             if (ent->plt.refcount > 0)
9799               {
9800                 s = htab->elf.iplt;
9801                 ent->plt.offset = s->size;
9802                 s->size += PLT_ENTRY_SIZE (htab);
9803
9804                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9805               }
9806             else
9807               ent->plt.offset = (bfd_vma) -1;
9808         }
9809     }
9810
9811   /* Allocate global sym .plt and .got entries, and space for global
9812      sym dynamic relocs.  */
9813   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9814   /* Stash the end of glink branch table.  */
9815   if (htab->glink != NULL)
9816     htab->glink->rawsize = htab->glink->size;
9817
9818   if (!htab->opd_abi && !info->shared)
9819     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9820
9821   first_tlsld = NULL;
9822   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9823     {
9824       struct got_entry *ent;
9825
9826       if (!is_ppc64_elf (ibfd))
9827         continue;
9828
9829       ent = ppc64_tlsld_got (ibfd);
9830       if (ent->got.refcount > 0)
9831         {
9832           if (!htab->do_multi_toc && first_tlsld != NULL)
9833             {
9834               ent->is_indirect = TRUE;
9835               ent->got.ent = first_tlsld;
9836             }
9837           else
9838             {
9839               if (first_tlsld == NULL)
9840                 first_tlsld = ent;
9841               s = ppc64_elf_tdata (ibfd)->got;
9842               ent->got.offset = s->size;
9843               ent->owner = ibfd;
9844               s->size += 16;
9845               if (info->shared)
9846                 {
9847                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9848                   srel->size += sizeof (Elf64_External_Rela);
9849                 }
9850             }
9851         }
9852       else
9853         ent->got.offset = (bfd_vma) -1;
9854     }
9855
9856   /* We now have determined the sizes of the various dynamic sections.
9857      Allocate memory for them.  */
9858   relocs = FALSE;
9859   for (s = dynobj->sections; s != NULL; s = s->next)
9860     {
9861       if ((s->flags & SEC_LINKER_CREATED) == 0)
9862         continue;
9863
9864       if (s == htab->brlt || s == htab->relbrlt)
9865         /* These haven't been allocated yet;  don't strip.  */
9866         continue;
9867       else if (s == htab->elf.sgot
9868                || s == htab->elf.splt
9869                || s == htab->elf.iplt
9870                || s == htab->glink
9871                || s == htab->dynbss)
9872         {
9873           /* Strip this section if we don't need it; see the
9874              comment below.  */
9875         }
9876       else if (s == htab->glink_eh_frame)
9877         {
9878           if (!bfd_is_abs_section (s->output_section))
9879             /* Not sized yet.  */
9880             continue;
9881         }
9882       else if (CONST_STRNEQ (s->name, ".rela"))
9883         {
9884           if (s->size != 0)
9885             {
9886               if (s != htab->elf.srelplt)
9887                 relocs = TRUE;
9888
9889               /* We use the reloc_count field as a counter if we need
9890                  to copy relocs into the output file.  */
9891               s->reloc_count = 0;
9892             }
9893         }
9894       else
9895         {
9896           /* It's not one of our sections, so don't allocate space.  */
9897           continue;
9898         }
9899
9900       if (s->size == 0)
9901         {
9902           /* If we don't need this section, strip it from the
9903              output file.  This is mostly to handle .rela.bss and
9904              .rela.plt.  We must create both sections in
9905              create_dynamic_sections, because they must be created
9906              before the linker maps input sections to output
9907              sections.  The linker does that before
9908              adjust_dynamic_symbol is called, and it is that
9909              function which decides whether anything needs to go
9910              into these sections.  */
9911           s->flags |= SEC_EXCLUDE;
9912           continue;
9913         }
9914
9915       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9916         continue;
9917
9918       /* Allocate memory for the section contents.  We use bfd_zalloc
9919          here in case unused entries are not reclaimed before the
9920          section's contents are written out.  This should not happen,
9921          but this way if it does we get a R_PPC64_NONE reloc in .rela
9922          sections instead of garbage.
9923          We also rely on the section contents being zero when writing
9924          the GOT.  */
9925       s->contents = bfd_zalloc (dynobj, s->size);
9926       if (s->contents == NULL)
9927         return FALSE;
9928     }
9929
9930   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9931     {
9932       if (!is_ppc64_elf (ibfd))
9933         continue;
9934
9935       s = ppc64_elf_tdata (ibfd)->got;
9936       if (s != NULL && s != htab->elf.sgot)
9937         {
9938           if (s->size == 0)
9939             s->flags |= SEC_EXCLUDE;
9940           else
9941             {
9942               s->contents = bfd_zalloc (ibfd, s->size);
9943               if (s->contents == NULL)
9944                 return FALSE;
9945             }
9946         }
9947       s = ppc64_elf_tdata (ibfd)->relgot;
9948       if (s != NULL)
9949         {
9950           if (s->size == 0)
9951             s->flags |= SEC_EXCLUDE;
9952           else
9953             {
9954               s->contents = bfd_zalloc (ibfd, s->size);
9955               if (s->contents == NULL)
9956                 return FALSE;
9957               relocs = TRUE;
9958               s->reloc_count = 0;
9959             }
9960         }
9961     }
9962
9963   if (htab->elf.dynamic_sections_created)
9964     {
9965       bfd_boolean tls_opt;
9966
9967       /* Add some entries to the .dynamic section.  We fill in the
9968          values later, in ppc64_elf_finish_dynamic_sections, but we
9969          must add the entries now so that we get the correct size for
9970          the .dynamic section.  The DT_DEBUG entry is filled in by the
9971          dynamic linker and used by the debugger.  */
9972 #define add_dynamic_entry(TAG, VAL) \
9973   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9974
9975       if (info->executable)
9976         {
9977           if (!add_dynamic_entry (DT_DEBUG, 0))
9978             return FALSE;
9979         }
9980
9981       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9982         {
9983           if (!add_dynamic_entry (DT_PLTGOT, 0)
9984               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9985               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9986               || !add_dynamic_entry (DT_JMPREL, 0)
9987               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9988             return FALSE;
9989         }
9990
9991       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9992         {
9993           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9994               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9995             return FALSE;
9996         }
9997
9998       tls_opt = (!htab->params->no_tls_get_addr_opt
9999                  && htab->tls_get_addr_fd != NULL
10000                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10001       if (tls_opt || !htab->opd_abi)
10002         {
10003           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10004             return FALSE;
10005         }
10006
10007       if (relocs)
10008         {
10009           if (!add_dynamic_entry (DT_RELA, 0)
10010               || !add_dynamic_entry (DT_RELASZ, 0)
10011               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10012             return FALSE;
10013
10014           /* If any dynamic relocs apply to a read-only section,
10015              then we need a DT_TEXTREL entry.  */
10016           if ((info->flags & DF_TEXTREL) == 0)
10017             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10018
10019           if ((info->flags & DF_TEXTREL) != 0)
10020             {
10021               if (!add_dynamic_entry (DT_TEXTREL, 0))
10022                 return FALSE;
10023             }
10024         }
10025     }
10026 #undef add_dynamic_entry
10027
10028   return TRUE;
10029 }
10030
10031 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
10032
10033 static bfd_boolean
10034 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10035 {
10036   if (h->plt.plist != NULL
10037       && !h->def_regular
10038       && !h->pointer_equality_needed)
10039     return FALSE;
10040
10041   return _bfd_elf_hash_symbol (h);
10042 }
10043
10044 /* Determine the type of stub needed, if any, for a call.  */
10045
10046 static inline enum ppc_stub_type
10047 ppc_type_of_stub (asection *input_sec,
10048                   const Elf_Internal_Rela *rel,
10049                   struct ppc_link_hash_entry **hash,
10050                   struct plt_entry **plt_ent,
10051                   bfd_vma destination,
10052                   unsigned long local_off)
10053 {
10054   struct ppc_link_hash_entry *h = *hash;
10055   bfd_vma location;
10056   bfd_vma branch_offset;
10057   bfd_vma max_branch_offset;
10058   enum elf_ppc64_reloc_type r_type;
10059
10060   if (h != NULL)
10061     {
10062       struct plt_entry *ent;
10063       struct ppc_link_hash_entry *fdh = h;
10064       if (h->oh != NULL
10065           && h->oh->is_func_descriptor)
10066         {
10067           fdh = ppc_follow_link (h->oh);
10068           *hash = fdh;
10069         }
10070
10071       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10072         if (ent->addend == rel->r_addend
10073             && ent->plt.offset != (bfd_vma) -1)
10074           {
10075             *plt_ent = ent;
10076             return ppc_stub_plt_call;
10077           }
10078
10079       /* Here, we know we don't have a plt entry.  If we don't have a
10080          either a defined function descriptor or a defined entry symbol
10081          in a regular object file, then it is pointless trying to make
10082          any other type of stub.  */
10083       if (!is_static_defined (&fdh->elf)
10084           && !is_static_defined (&h->elf))
10085         return ppc_stub_none;
10086     }
10087   else if (elf_local_got_ents (input_sec->owner) != NULL)
10088     {
10089       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10090       struct plt_entry **local_plt = (struct plt_entry **)
10091         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10092       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10093
10094       if (local_plt[r_symndx] != NULL)
10095         {
10096           struct plt_entry *ent;
10097
10098           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10099             if (ent->addend == rel->r_addend
10100                 && ent->plt.offset != (bfd_vma) -1)
10101               {
10102                 *plt_ent = ent;
10103                 return ppc_stub_plt_call;
10104               }
10105         }
10106     }
10107
10108   /* Determine where the call point is.  */
10109   location = (input_sec->output_offset
10110               + input_sec->output_section->vma
10111               + rel->r_offset);
10112
10113   branch_offset = destination - location;
10114   r_type = ELF64_R_TYPE (rel->r_info);
10115
10116   /* Determine if a long branch stub is needed.  */
10117   max_branch_offset = 1 << 25;
10118   if (r_type != R_PPC64_REL24)
10119     max_branch_offset = 1 << 15;
10120
10121   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10122     /* We need a stub.  Figure out whether a long_branch or plt_branch
10123        is needed later.  */
10124     return ppc_stub_long_branch;
10125
10126   return ppc_stub_none;
10127 }
10128
10129 /* With power7 weakly ordered memory model, it is possible for ld.so
10130    to update a plt entry in one thread and have another thread see a
10131    stale zero toc entry.  To avoid this we need some sort of acquire
10132    barrier in the call stub.  One solution is to make the load of the
10133    toc word seem to appear to depend on the load of the function entry
10134    word.  Another solution is to test for r2 being zero, and branch to
10135    the appropriate glink entry if so.
10136
10137    .    fake dep barrier        compare
10138    .    ld 12,xxx(2)            ld 12,xxx(2)
10139    .    mtctr 12                mtctr 12
10140    .    xor 11,12,12            ld 2,xxx+8(2)
10141    .    add 2,2,11              cmpldi 2,0
10142    .    ld 2,xxx+8(2)           bnectr+
10143    .    bctr                    b <glink_entry>
10144
10145    The solution involving the compare turns out to be faster, so
10146    that's what we use unless the branch won't reach.  */
10147
10148 #define ALWAYS_USE_FAKE_DEP 0
10149 #define ALWAYS_EMIT_R2SAVE 0
10150
10151 #define PPC_LO(v) ((v) & 0xffff)
10152 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10153 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10154
10155 static inline unsigned int
10156 plt_stub_size (struct ppc_link_hash_table *htab,
10157                struct ppc_stub_hash_entry *stub_entry,
10158                bfd_vma off)
10159 {
10160   unsigned size = 12;
10161
10162   if (ALWAYS_EMIT_R2SAVE
10163       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10164     size += 4;
10165   if (PPC_HA (off) != 0)
10166     size += 4;
10167   if (htab->opd_abi)
10168     {
10169       size += 4;
10170       if (htab->params->plt_static_chain)
10171         size += 4;
10172       if (htab->params->plt_thread_safe)
10173         size += 8;
10174       if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10175         size += 4;
10176     }
10177   if (stub_entry->h != NULL
10178       && (stub_entry->h == htab->tls_get_addr_fd
10179           || stub_entry->h == htab->tls_get_addr)
10180       && !htab->params->no_tls_get_addr_opt)
10181     size += 13 * 4;
10182   return size;
10183 }
10184
10185 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10186    then return the padding needed to do so.  */
10187 static inline unsigned int
10188 plt_stub_pad (struct ppc_link_hash_table *htab,
10189               struct ppc_stub_hash_entry *stub_entry,
10190               bfd_vma plt_off)
10191 {
10192   int stub_align = 1 << htab->params->plt_stub_align;
10193   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10194   bfd_vma stub_off = stub_entry->stub_sec->size;
10195
10196   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10197       > (stub_size & -stub_align))
10198     return stub_align - (stub_off & (stub_align - 1));
10199   return 0;
10200 }
10201
10202 /* Build a .plt call stub.  */
10203
10204 static inline bfd_byte *
10205 build_plt_stub (struct ppc_link_hash_table *htab,
10206                 struct ppc_stub_hash_entry *stub_entry,
10207                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10208 {
10209   bfd *obfd = htab->params->stub_bfd;
10210   bfd_boolean plt_load_toc = htab->opd_abi;
10211   bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10212   bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10213   bfd_boolean use_fake_dep = plt_thread_safe;
10214   bfd_vma cmp_branch_off = 0;
10215
10216   if (!ALWAYS_USE_FAKE_DEP
10217       && plt_load_toc
10218       && plt_thread_safe
10219       && !(stub_entry->h != NULL
10220            && (stub_entry->h == htab->tls_get_addr_fd
10221                || stub_entry->h == htab->tls_get_addr)
10222            && !htab->params->no_tls_get_addr_opt))
10223     {
10224       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10225       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10226                           / PLT_ENTRY_SIZE (htab));
10227       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10228       bfd_vma to, from;
10229
10230       if (pltindex > 32768)
10231         glinkoff += (pltindex - 32768) * 4;
10232       to = (glinkoff
10233             + htab->glink->output_offset
10234             + htab->glink->output_section->vma);
10235       from = (p - stub_entry->stub_sec->contents
10236               + 4 * (ALWAYS_EMIT_R2SAVE
10237                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10238               + 4 * (PPC_HA (offset) != 0)
10239               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10240                      != PPC_HA (offset))
10241               + 4 * (plt_static_chain != 0)
10242               + 20
10243               + stub_entry->stub_sec->output_offset
10244               + stub_entry->stub_sec->output_section->vma);
10245       cmp_branch_off = to - from;
10246       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10247     }
10248
10249   if (PPC_HA (offset) != 0)
10250     {
10251       if (r != NULL)
10252         {
10253           if (ALWAYS_EMIT_R2SAVE
10254               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10255             r[0].r_offset += 4;
10256           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10257           r[1].r_offset = r[0].r_offset + 4;
10258           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10259           r[1].r_addend = r[0].r_addend;
10260           if (plt_load_toc)
10261             {
10262               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10263                 {
10264                   r[2].r_offset = r[1].r_offset + 4;
10265                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10266                   r[2].r_addend = r[0].r_addend;
10267                 }
10268               else
10269                 {
10270                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10271                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10272                   r[2].r_addend = r[0].r_addend + 8;
10273                   if (plt_static_chain)
10274                     {
10275                       r[3].r_offset = r[2].r_offset + 4;
10276                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10277                       r[3].r_addend = r[0].r_addend + 16;
10278                     }
10279                 }
10280             }
10281         }
10282       if (ALWAYS_EMIT_R2SAVE
10283           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10284         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10285       if (plt_load_toc)
10286         {
10287           bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10288           bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),  p += 4;
10289         }
10290       else
10291         {
10292           bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10293           bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p),  p += 4;
10294         }
10295       if (plt_load_toc
10296           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10297         {
10298           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10299           offset = 0;
10300         }
10301       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10302       if (plt_load_toc)
10303         {
10304           if (use_fake_dep)
10305             {
10306               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10307               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10308             }
10309           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10310           if (plt_static_chain)
10311             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10312         }
10313     }
10314   else
10315     {
10316       if (r != NULL)
10317         {
10318           if (ALWAYS_EMIT_R2SAVE
10319               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10320             r[0].r_offset += 4;
10321           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10322           if (plt_load_toc)
10323             {
10324               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10325                 {
10326                   r[1].r_offset = r[0].r_offset + 4;
10327                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10328                   r[1].r_addend = r[0].r_addend;
10329                 }
10330               else
10331                 {
10332                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10333                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10334                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10335                   if (plt_static_chain)
10336                     {
10337                       r[2].r_offset = r[1].r_offset + 4;
10338                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10339                       r[2].r_addend = r[0].r_addend + 8;
10340                     }
10341                 }
10342             }
10343         }
10344       if (ALWAYS_EMIT_R2SAVE
10345           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10346         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10347       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10348       if (plt_load_toc
10349           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10350         {
10351           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10352           offset = 0;
10353         }
10354       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10355       if (plt_load_toc)
10356         {
10357           if (use_fake_dep)
10358             {
10359               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10360               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10361             }
10362           if (plt_static_chain)
10363             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10364           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10365         }
10366     }
10367   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10368     {
10369       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10370       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10371       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10372     }
10373   else
10374     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10375   return p;
10376 }
10377
10378 /* Build a special .plt call stub for __tls_get_addr.  */
10379
10380 #define LD_R11_0R3      0xe9630000
10381 #define LD_R12_0R3      0xe9830000
10382 #define MR_R0_R3        0x7c601b78
10383 #define CMPDI_R11_0     0x2c2b0000
10384 #define ADD_R3_R12_R13  0x7c6c6a14
10385 #define BEQLR           0x4d820020
10386 #define MR_R3_R0        0x7c030378
10387 #define STD_R11_0R1     0xf9610000
10388 #define BCTRL           0x4e800421
10389 #define LD_R11_0R1      0xe9610000
10390 #define MTLR_R11        0x7d6803a6
10391
10392 static inline bfd_byte *
10393 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10394                          struct ppc_stub_hash_entry *stub_entry,
10395                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10396 {
10397   bfd *obfd = htab->params->stub_bfd;
10398
10399   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10400   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10401   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10402   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10403   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10404   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10405   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10406   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10407   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10408
10409   if (r != NULL)
10410     r[0].r_offset += 9 * 4;
10411   p = build_plt_stub (htab, stub_entry, p, offset, r);
10412   bfd_put_32 (obfd, BCTRL, p - 4);
10413
10414   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10415   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10416   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10417   bfd_put_32 (obfd, BLR, p),                    p += 4;
10418
10419   return p;
10420 }
10421
10422 static Elf_Internal_Rela *
10423 get_relocs (asection *sec, int count)
10424 {
10425   Elf_Internal_Rela *relocs;
10426   struct bfd_elf_section_data *elfsec_data;
10427
10428   elfsec_data = elf_section_data (sec);
10429   relocs = elfsec_data->relocs;
10430   if (relocs == NULL)
10431     {
10432       bfd_size_type relsize;
10433       relsize = sec->reloc_count * sizeof (*relocs);
10434       relocs = bfd_alloc (sec->owner, relsize);
10435       if (relocs == NULL)
10436         return NULL;
10437       elfsec_data->relocs = relocs;
10438       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10439                                           sizeof (Elf_Internal_Shdr));
10440       if (elfsec_data->rela.hdr == NULL)
10441         return NULL;
10442       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10443                                         * sizeof (Elf64_External_Rela));
10444       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10445       sec->reloc_count = 0;
10446     }
10447   relocs += sec->reloc_count;
10448   sec->reloc_count += count;
10449   return relocs;
10450 }
10451
10452 static bfd_vma
10453 get_r2off (struct bfd_link_info *info,
10454            struct ppc_stub_hash_entry *stub_entry)
10455 {
10456   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10457   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10458
10459   if (r2off == 0)
10460     {
10461       /* Support linking -R objects.  Get the toc pointer from the
10462          opd entry.  */
10463       char buf[8];
10464       if (!htab->opd_abi)
10465         return r2off;
10466       asection *opd = stub_entry->h->elf.root.u.def.section;
10467       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10468
10469       if (strcmp (opd->name, ".opd") != 0
10470           || opd->reloc_count != 0)
10471         {
10472           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10473                                   stub_entry->h->elf.root.root.string);
10474           bfd_set_error (bfd_error_bad_value);
10475           return 0;
10476         }
10477       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10478         return 0;
10479       r2off = bfd_get_64 (opd->owner, buf);
10480       r2off -= elf_gp (info->output_bfd);
10481     }
10482   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10483   return r2off;
10484 }
10485
10486 static bfd_boolean
10487 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10488 {
10489   struct ppc_stub_hash_entry *stub_entry;
10490   struct ppc_branch_hash_entry *br_entry;
10491   struct bfd_link_info *info;
10492   struct ppc_link_hash_table *htab;
10493   bfd_byte *loc;
10494   bfd_byte *p;
10495   bfd_vma dest, off;
10496   int size;
10497   Elf_Internal_Rela *r;
10498   asection *plt;
10499
10500   /* Massage our args to the form they really have.  */
10501   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10502   info = in_arg;
10503
10504   htab = ppc_hash_table (info);
10505   if (htab == NULL)
10506     return FALSE;
10507
10508   /* Make a note of the offset within the stubs for this entry.  */
10509   stub_entry->stub_offset = stub_entry->stub_sec->size;
10510   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10511
10512   htab->stub_count[stub_entry->stub_type - 1] += 1;
10513   switch (stub_entry->stub_type)
10514     {
10515     case ppc_stub_long_branch:
10516     case ppc_stub_long_branch_r2off:
10517       /* Branches are relative.  This is where we are going to.  */
10518       dest = (stub_entry->target_value
10519               + stub_entry->target_section->output_offset
10520               + stub_entry->target_section->output_section->vma);
10521       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10522       off = dest;
10523
10524       /* And this is where we are coming from.  */
10525       off -= (stub_entry->stub_offset
10526               + stub_entry->stub_sec->output_offset
10527               + stub_entry->stub_sec->output_section->vma);
10528
10529       size = 4;
10530       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10531         {
10532           bfd_vma r2off = get_r2off (info, stub_entry);
10533
10534           if (r2off == 0)
10535             {
10536               htab->stub_error = TRUE;
10537               return FALSE;
10538             }
10539           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10540           loc += 4;
10541           size = 12;
10542           if (PPC_HA (r2off) != 0)
10543             {
10544               size = 16;
10545               bfd_put_32 (htab->params->stub_bfd,
10546                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10547               loc += 4;
10548             }
10549           bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10550           loc += 4;
10551           off -= size - 4;
10552         }
10553       bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10554
10555       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10556         {
10557           info->callbacks->einfo
10558             (_("%P: long branch stub `%s' offset overflow\n"),
10559              stub_entry->root.string);
10560           htab->stub_error = TRUE;
10561           return FALSE;
10562         }
10563
10564       if (info->emitrelocations)
10565         {
10566           r = get_relocs (stub_entry->stub_sec, 1);
10567           if (r == NULL)
10568             return FALSE;
10569           r->r_offset = loc - stub_entry->stub_sec->contents;
10570           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10571           r->r_addend = dest;
10572           if (stub_entry->h != NULL)
10573             {
10574               struct elf_link_hash_entry **hashes;
10575               unsigned long symndx;
10576               struct ppc_link_hash_entry *h;
10577
10578               hashes = elf_sym_hashes (htab->params->stub_bfd);
10579               if (hashes == NULL)
10580                 {
10581                   bfd_size_type hsize;
10582
10583                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10584                   hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10585                   if (hashes == NULL)
10586                     return FALSE;
10587                   elf_sym_hashes (htab->params->stub_bfd) = hashes;
10588                   htab->stub_globals = 1;
10589                 }
10590               symndx = htab->stub_globals++;
10591               h = stub_entry->h;
10592               hashes[symndx] = &h->elf;
10593               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10594               if (h->oh != NULL && h->oh->is_func)
10595                 h = ppc_follow_link (h->oh);
10596               if (h->elf.root.u.def.section != stub_entry->target_section)
10597                 /* H is an opd symbol.  The addend must be zero.  */
10598                 r->r_addend = 0;
10599               else
10600                 {
10601                   off = (h->elf.root.u.def.value
10602                          + h->elf.root.u.def.section->output_offset
10603                          + h->elf.root.u.def.section->output_section->vma);
10604                   r->r_addend -= off;
10605                 }
10606             }
10607         }
10608       break;
10609
10610     case ppc_stub_plt_branch:
10611     case ppc_stub_plt_branch_r2off:
10612       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10613                                          stub_entry->root.string + 9,
10614                                          FALSE, FALSE);
10615       if (br_entry == NULL)
10616         {
10617           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10618                                   stub_entry->root.string);
10619           htab->stub_error = TRUE;
10620           return FALSE;
10621         }
10622
10623       dest = (stub_entry->target_value
10624               + stub_entry->target_section->output_offset
10625               + stub_entry->target_section->output_section->vma);
10626       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10627         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10628
10629       bfd_put_64 (htab->brlt->owner, dest,
10630                   htab->brlt->contents + br_entry->offset);
10631
10632       if (br_entry->iter == htab->stub_iteration)
10633         {
10634           br_entry->iter = 0;
10635
10636           if (htab->relbrlt != NULL)
10637             {
10638               /* Create a reloc for the branch lookup table entry.  */
10639               Elf_Internal_Rela rela;
10640               bfd_byte *rl;
10641
10642               rela.r_offset = (br_entry->offset
10643                                + htab->brlt->output_offset
10644                                + htab->brlt->output_section->vma);
10645               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10646               rela.r_addend = dest;
10647
10648               rl = htab->relbrlt->contents;
10649               rl += (htab->relbrlt->reloc_count++
10650                      * sizeof (Elf64_External_Rela));
10651               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10652             }
10653           else if (info->emitrelocations)
10654             {
10655               r = get_relocs (htab->brlt, 1);
10656               if (r == NULL)
10657                 return FALSE;
10658               /* brlt, being SEC_LINKER_CREATED does not go through the
10659                  normal reloc processing.  Symbols and offsets are not
10660                  translated from input file to output file form, so
10661                  set up the offset per the output file.  */
10662               r->r_offset = (br_entry->offset
10663                              + htab->brlt->output_offset
10664                              + htab->brlt->output_section->vma);
10665               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10666               r->r_addend = dest;
10667             }
10668         }
10669
10670       dest = (br_entry->offset
10671               + htab->brlt->output_offset
10672               + htab->brlt->output_section->vma);
10673
10674       off = (dest
10675              - elf_gp (htab->brlt->output_section->owner)
10676              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10677
10678       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10679         {
10680           info->callbacks->einfo
10681             (_("%P: linkage table error against `%T'\n"),
10682              stub_entry->root.string);
10683           bfd_set_error (bfd_error_bad_value);
10684           htab->stub_error = TRUE;
10685           return FALSE;
10686         }
10687
10688       if (info->emitrelocations)
10689         {
10690           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10691           if (r == NULL)
10692             return FALSE;
10693           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10694           if (bfd_big_endian (info->output_bfd))
10695             r[0].r_offset += 2;
10696           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10697             r[0].r_offset += 4;
10698           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10699           r[0].r_addend = dest;
10700           if (PPC_HA (off) != 0)
10701             {
10702               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10703               r[1].r_offset = r[0].r_offset + 4;
10704               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10705               r[1].r_addend = r[0].r_addend;
10706             }
10707         }
10708
10709       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10710         {
10711           if (PPC_HA (off) != 0)
10712             {
10713               size = 16;
10714               bfd_put_32 (htab->params->stub_bfd,
10715                           ADDIS_R12_R2 | PPC_HA (off), loc);
10716               loc += 4;
10717               bfd_put_32 (htab->params->stub_bfd,
10718                           LD_R12_0R12 | PPC_LO (off), loc);
10719             }
10720           else
10721             {
10722               size = 12;
10723               bfd_put_32 (htab->params->stub_bfd,
10724                           LD_R12_0R2 | PPC_LO (off), loc);
10725             }
10726         }
10727       else
10728         {
10729           bfd_vma r2off = get_r2off (info, stub_entry);
10730
10731           if (r2off == 0 && htab->opd_abi)
10732             {
10733               htab->stub_error = TRUE;
10734               return FALSE;
10735             }
10736
10737           bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10738           loc += 4;
10739           size = 16;
10740           if (PPC_HA (off) != 0)
10741             {
10742               size += 4;
10743               bfd_put_32 (htab->params->stub_bfd,
10744                           ADDIS_R12_R2 | PPC_HA (off), loc);
10745               loc += 4;
10746               bfd_put_32 (htab->params->stub_bfd,
10747                           LD_R12_0R12 | PPC_LO (off), loc);
10748             }
10749           else
10750             bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10751
10752           if (PPC_HA (r2off) != 0)
10753             {
10754               size += 4;
10755               loc += 4;
10756               bfd_put_32 (htab->params->stub_bfd,
10757                           ADDIS_R2_R2 | PPC_HA (r2off), loc);
10758             }
10759           if (PPC_LO (r2off) != 0)
10760             {
10761               size += 4;
10762               loc += 4;
10763               bfd_put_32 (htab->params->stub_bfd,
10764                           ADDI_R2_R2 | PPC_LO (r2off), loc);
10765             }
10766         }
10767       loc += 4;
10768       bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10769       loc += 4;
10770       bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10771       break;
10772
10773     case ppc_stub_plt_call:
10774     case ppc_stub_plt_call_r2save:
10775       if (stub_entry->h != NULL
10776           && stub_entry->h->is_func_descriptor
10777           && stub_entry->h->oh != NULL)
10778         {
10779           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10780
10781           /* If the old-ABI "dot-symbol" is undefined make it weak so
10782              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10783              FIXME: We used to define the symbol on one of the call
10784              stubs instead, which is why we test symbol section id
10785              against htab->top_id in various places.  Likely all
10786              these checks could now disappear.  */
10787           if (fh->elf.root.type == bfd_link_hash_undefined)
10788             fh->elf.root.type = bfd_link_hash_undefweak;
10789           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10790           fh->was_undefined = 0;
10791         }
10792
10793       /* Now build the stub.  */
10794       dest = stub_entry->plt_ent->plt.offset & ~1;
10795       if (dest >= (bfd_vma) -2)
10796         abort ();
10797
10798       plt = htab->elf.splt;
10799       if (!htab->elf.dynamic_sections_created
10800           || stub_entry->h == NULL
10801           || stub_entry->h->elf.dynindx == -1)
10802         plt = htab->elf.iplt;
10803
10804       dest += plt->output_offset + plt->output_section->vma;
10805
10806       if (stub_entry->h == NULL
10807           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10808         {
10809           Elf_Internal_Rela rela;
10810           bfd_byte *rl;
10811
10812           rela.r_offset = dest;
10813           if (htab->opd_abi)
10814             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10815           else
10816             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10817           rela.r_addend = (stub_entry->target_value
10818                            + stub_entry->target_section->output_offset
10819                            + stub_entry->target_section->output_section->vma);
10820
10821           rl = (htab->elf.irelplt->contents
10822                 + (htab->elf.irelplt->reloc_count++
10823                    * sizeof (Elf64_External_Rela)));
10824           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10825           stub_entry->plt_ent->plt.offset |= 1;
10826         }
10827
10828       off = (dest
10829              - elf_gp (plt->output_section->owner)
10830              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10831
10832       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10833         {
10834           info->callbacks->einfo
10835             (_("%P: linkage table error against `%T'\n"),
10836              stub_entry->h != NULL
10837              ? stub_entry->h->elf.root.root.string
10838              : "<local sym>");
10839           bfd_set_error (bfd_error_bad_value);
10840           htab->stub_error = TRUE;
10841           return FALSE;
10842         }
10843
10844       if (htab->params->plt_stub_align != 0)
10845         {
10846           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10847
10848           stub_entry->stub_sec->size += pad;
10849           stub_entry->stub_offset = stub_entry->stub_sec->size;
10850           loc += pad;
10851         }
10852
10853       r = NULL;
10854       if (info->emitrelocations)
10855         {
10856           r = get_relocs (stub_entry->stub_sec,
10857                           ((PPC_HA (off) != 0)
10858                            + (htab->opd_abi
10859                               ? 2 + (htab->params->plt_static_chain
10860                                      && PPC_HA (off + 16) == PPC_HA (off))
10861                               : 1)));
10862           if (r == NULL)
10863             return FALSE;
10864           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10865           if (bfd_big_endian (info->output_bfd))
10866             r[0].r_offset += 2;
10867           r[0].r_addend = dest;
10868         }
10869       if (stub_entry->h != NULL
10870           && (stub_entry->h == htab->tls_get_addr_fd
10871               || stub_entry->h == htab->tls_get_addr)
10872           && !htab->params->no_tls_get_addr_opt)
10873         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10874       else
10875         p = build_plt_stub (htab, stub_entry, loc, off, r);
10876       size = p - loc;
10877       break;
10878
10879     default:
10880       BFD_FAIL ();
10881       return FALSE;
10882     }
10883
10884   stub_entry->stub_sec->size += size;
10885
10886   if (htab->params->emit_stub_syms)
10887     {
10888       struct elf_link_hash_entry *h;
10889       size_t len1, len2;
10890       char *name;
10891       const char *const stub_str[] = { "long_branch",
10892                                        "long_branch_r2off",
10893                                        "plt_branch",
10894                                        "plt_branch_r2off",
10895                                        "plt_call",
10896                                        "plt_call" };
10897
10898       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10899       len2 = strlen (stub_entry->root.string);
10900       name = bfd_malloc (len1 + len2 + 2);
10901       if (name == NULL)
10902         return FALSE;
10903       memcpy (name, stub_entry->root.string, 9);
10904       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10905       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10906       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10907       if (h == NULL)
10908         return FALSE;
10909       if (h->root.type == bfd_link_hash_new)
10910         {
10911           h->root.type = bfd_link_hash_defined;
10912           h->root.u.def.section = stub_entry->stub_sec;
10913           h->root.u.def.value = stub_entry->stub_offset;
10914           h->ref_regular = 1;
10915           h->def_regular = 1;
10916           h->ref_regular_nonweak = 1;
10917           h->forced_local = 1;
10918           h->non_elf = 0;
10919         }
10920     }
10921
10922   return TRUE;
10923 }
10924
10925 /* As above, but don't actually build the stub.  Just bump offset so
10926    we know stub section sizes, and select plt_branch stubs where
10927    long_branch stubs won't do.  */
10928
10929 static bfd_boolean
10930 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10931 {
10932   struct ppc_stub_hash_entry *stub_entry;
10933   struct bfd_link_info *info;
10934   struct ppc_link_hash_table *htab;
10935   bfd_vma off;
10936   int size;
10937
10938   /* Massage our args to the form they really have.  */
10939   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10940   info = in_arg;
10941
10942   htab = ppc_hash_table (info);
10943   if (htab == NULL)
10944     return FALSE;
10945
10946   if (stub_entry->stub_type == ppc_stub_plt_call
10947       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10948     {
10949       asection *plt;
10950       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10951       if (off >= (bfd_vma) -2)
10952         abort ();
10953       plt = htab->elf.splt;
10954       if (!htab->elf.dynamic_sections_created
10955           || stub_entry->h == NULL
10956           || stub_entry->h->elf.dynindx == -1)
10957         plt = htab->elf.iplt;
10958       off += (plt->output_offset
10959               + plt->output_section->vma
10960               - elf_gp (plt->output_section->owner)
10961               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10962
10963       size = plt_stub_size (htab, stub_entry, off);
10964       if (htab->params->plt_stub_align)
10965         size += plt_stub_pad (htab, stub_entry, off);
10966       if (info->emitrelocations)
10967         {
10968           stub_entry->stub_sec->reloc_count
10969             += ((PPC_HA (off) != 0)
10970                 + (htab->opd_abi
10971                    ? 2 + (htab->params->plt_static_chain
10972                           && PPC_HA (off + 16) == PPC_HA (off))
10973                    : 1));
10974           stub_entry->stub_sec->flags |= SEC_RELOC;
10975         }
10976     }
10977   else
10978     {
10979       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10980          variants.  */
10981       bfd_vma r2off = 0;
10982       bfd_vma local_off = 0;
10983
10984       off = (stub_entry->target_value
10985              + stub_entry->target_section->output_offset
10986              + stub_entry->target_section->output_section->vma);
10987       off -= (stub_entry->stub_sec->size
10988               + stub_entry->stub_sec->output_offset
10989               + stub_entry->stub_sec->output_section->vma);
10990
10991       /* Reset the stub type from the plt variant in case we now
10992          can reach with a shorter stub.  */
10993       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10994         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10995
10996       size = 4;
10997       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10998         {
10999           r2off = get_r2off (info, stub_entry);
11000           if (r2off == 0 && htab->opd_abi)
11001             {
11002               htab->stub_error = TRUE;
11003               return FALSE;
11004             }
11005           size = 12;
11006           if (PPC_HA (r2off) != 0)
11007             size = 16;
11008           off -= size - 4;
11009         }
11010
11011       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11012
11013       /* If the branch offset if too big, use a ppc_stub_plt_branch.
11014          Do the same for -R objects without function descriptors.  */
11015       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11016           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11017               && r2off == 0))
11018         {
11019           struct ppc_branch_hash_entry *br_entry;
11020
11021           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11022                                              stub_entry->root.string + 9,
11023                                              TRUE, FALSE);
11024           if (br_entry == NULL)
11025             {
11026               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11027                                       stub_entry->root.string);
11028               htab->stub_error = TRUE;
11029               return FALSE;
11030             }
11031
11032           if (br_entry->iter != htab->stub_iteration)
11033             {
11034               br_entry->iter = htab->stub_iteration;
11035               br_entry->offset = htab->brlt->size;
11036               htab->brlt->size += 8;
11037
11038               if (htab->relbrlt != NULL)
11039                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11040               else if (info->emitrelocations)
11041                 {
11042                   htab->brlt->reloc_count += 1;
11043                   htab->brlt->flags |= SEC_RELOC;
11044                 }
11045             }
11046
11047           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11048           off = (br_entry->offset
11049                  + htab->brlt->output_offset
11050                  + htab->brlt->output_section->vma
11051                  - elf_gp (htab->brlt->output_section->owner)
11052                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
11053
11054           if (info->emitrelocations)
11055             {
11056               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11057               stub_entry->stub_sec->flags |= SEC_RELOC;
11058             }
11059
11060           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11061             {
11062               size = 12;
11063               if (PPC_HA (off) != 0)
11064                 size = 16;
11065             }
11066           else
11067             {
11068               size = 16;
11069               if (PPC_HA (off) != 0)
11070                 size += 4;
11071
11072               if (PPC_HA (r2off) != 0)
11073                 size += 4;
11074               if (PPC_LO (r2off) != 0)
11075                 size += 4;
11076             }
11077         }
11078       else if (info->emitrelocations)
11079         {
11080           stub_entry->stub_sec->reloc_count += 1;
11081           stub_entry->stub_sec->flags |= SEC_RELOC;
11082         }
11083     }
11084
11085   stub_entry->stub_sec->size += size;
11086   return TRUE;
11087 }
11088
11089 /* Set up various things so that we can make a list of input sections
11090    for each output section included in the link.  Returns -1 on error,
11091    0 when no stubs will be needed, and 1 on success.  */
11092
11093 int
11094 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11095 {
11096   bfd *input_bfd;
11097   int top_id, top_index, id;
11098   asection *section;
11099   asection **input_list;
11100   bfd_size_type amt;
11101   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11102
11103   if (htab == NULL)
11104     return -1;
11105
11106   /* Find the top input section id.  */
11107   for (input_bfd = info->input_bfds, top_id = 3;
11108        input_bfd != NULL;
11109        input_bfd = input_bfd->link.next)
11110     {
11111       for (section = input_bfd->sections;
11112            section != NULL;
11113            section = section->next)
11114         {
11115           if (top_id < section->id)
11116             top_id = section->id;
11117         }
11118     }
11119
11120   htab->top_id = top_id;
11121   amt = sizeof (struct map_stub) * (top_id + 1);
11122   htab->stub_group = bfd_zmalloc (amt);
11123   if (htab->stub_group == NULL)
11124     return -1;
11125
11126   /* Set toc_off for com, und, abs and ind sections.  */
11127   for (id = 0; id < 3; id++)
11128     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11129
11130   /* We can't use output_bfd->section_count here to find the top output
11131      section index as some sections may have been removed, and
11132      strip_excluded_output_sections doesn't renumber the indices.  */
11133   for (section = info->output_bfd->sections, top_index = 0;
11134        section != NULL;
11135        section = section->next)
11136     {
11137       if (top_index < section->index)
11138         top_index = section->index;
11139     }
11140
11141   htab->top_index = top_index;
11142   amt = sizeof (asection *) * (top_index + 1);
11143   input_list = bfd_zmalloc (amt);
11144   htab->input_list = input_list;
11145   if (input_list == NULL)
11146     return -1;
11147
11148   return 1;
11149 }
11150
11151 /* Set up for first pass at multitoc partitioning.  */
11152
11153 void
11154 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11155 {
11156   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11157
11158   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11159   htab->toc_bfd = NULL;
11160   htab->toc_first_sec = NULL;
11161 }
11162
11163 /* The linker repeatedly calls this function for each TOC input section
11164    and linker generated GOT section.  Group input bfds such that the toc
11165    within a group is less than 64k in size.  */
11166
11167 bfd_boolean
11168 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11169 {
11170   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11171   bfd_vma addr, off, limit;
11172
11173   if (htab == NULL)
11174     return FALSE;
11175
11176   if (!htab->second_toc_pass)
11177     {
11178       /* Keep track of the first .toc or .got section for this input bfd.  */
11179       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11180
11181       if (new_bfd)
11182         {
11183           htab->toc_bfd = isec->owner;
11184           htab->toc_first_sec = isec;
11185         }
11186
11187       addr = isec->output_offset + isec->output_section->vma;
11188       off = addr - htab->toc_curr;
11189       limit = 0x80008000;
11190       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11191         limit = 0x10000;
11192       if (off + isec->size > limit)
11193         {
11194           addr = (htab->toc_first_sec->output_offset
11195                   + htab->toc_first_sec->output_section->vma);
11196           htab->toc_curr = addr;
11197         }
11198
11199       /* toc_curr is the base address of this toc group.  Set elf_gp
11200          for the input section to be the offset relative to the
11201          output toc base plus 0x8000.  Making the input elf_gp an
11202          offset allows us to move the toc as a whole without
11203          recalculating input elf_gp.  */
11204       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11205       off += TOC_BASE_OFF;
11206
11207       /* Die if someone uses a linker script that doesn't keep input
11208          file .toc and .got together.  */
11209       if (new_bfd
11210           && elf_gp (isec->owner) != 0
11211           && elf_gp (isec->owner) != off)
11212         return FALSE;
11213
11214       elf_gp (isec->owner) = off;
11215       return TRUE;
11216     }
11217
11218   /* During the second pass toc_first_sec points to the start of
11219      a toc group, and toc_curr is used to track the old elf_gp.
11220      We use toc_bfd to ensure we only look at each bfd once.  */
11221   if (htab->toc_bfd == isec->owner)
11222     return TRUE;
11223   htab->toc_bfd = isec->owner;
11224
11225   if (htab->toc_first_sec == NULL
11226       || htab->toc_curr != elf_gp (isec->owner))
11227     {
11228       htab->toc_curr = elf_gp (isec->owner);
11229       htab->toc_first_sec = isec;
11230     }
11231   addr = (htab->toc_first_sec->output_offset
11232           + htab->toc_first_sec->output_section->vma);
11233   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11234   elf_gp (isec->owner) = off;
11235
11236   return TRUE;
11237 }
11238
11239 /* Called via elf_link_hash_traverse to merge GOT entries for global
11240    symbol H.  */
11241
11242 static bfd_boolean
11243 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11244 {
11245   if (h->root.type == bfd_link_hash_indirect)
11246     return TRUE;
11247
11248   merge_got_entries (&h->got.glist);
11249
11250   return TRUE;
11251 }
11252
11253 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11254    symbol H.  */
11255
11256 static bfd_boolean
11257 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11258 {
11259   struct got_entry *gent;
11260
11261   if (h->root.type == bfd_link_hash_indirect)
11262     return TRUE;
11263
11264   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11265     if (!gent->is_indirect)
11266       allocate_got (h, (struct bfd_link_info *) inf, gent);
11267   return TRUE;
11268 }
11269
11270 /* Called on the first multitoc pass after the last call to
11271    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11272    entries.  */
11273
11274 bfd_boolean
11275 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11276 {
11277   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11278   struct bfd *ibfd, *ibfd2;
11279   bfd_boolean done_something;
11280
11281   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11282
11283   if (!htab->do_multi_toc)
11284     return FALSE;
11285
11286   /* Merge global sym got entries within a toc group.  */
11287   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11288
11289   /* And tlsld_got.  */
11290   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11291     {
11292       struct got_entry *ent, *ent2;
11293
11294       if (!is_ppc64_elf (ibfd))
11295         continue;
11296
11297       ent = ppc64_tlsld_got (ibfd);
11298       if (!ent->is_indirect
11299           && ent->got.offset != (bfd_vma) -1)
11300         {
11301           for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11302             {
11303               if (!is_ppc64_elf (ibfd2))
11304                 continue;
11305
11306               ent2 = ppc64_tlsld_got (ibfd2);
11307               if (!ent2->is_indirect
11308                   && ent2->got.offset != (bfd_vma) -1
11309                   && elf_gp (ibfd2) == elf_gp (ibfd))
11310                 {
11311                   ent2->is_indirect = TRUE;
11312                   ent2->got.ent = ent;
11313                 }
11314             }
11315         }
11316     }
11317
11318   /* Zap sizes of got sections.  */
11319   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11320   htab->elf.irelplt->size -= htab->got_reli_size;
11321   htab->got_reli_size = 0;
11322
11323   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11324     {
11325       asection *got, *relgot;
11326
11327       if (!is_ppc64_elf (ibfd))
11328         continue;
11329
11330       got = ppc64_elf_tdata (ibfd)->got;
11331       if (got != NULL)
11332         {
11333           got->rawsize = got->size;
11334           got->size = 0;
11335           relgot = ppc64_elf_tdata (ibfd)->relgot;
11336           relgot->rawsize = relgot->size;
11337           relgot->size = 0;
11338         }
11339     }
11340
11341   /* Now reallocate the got, local syms first.  We don't need to
11342      allocate section contents again since we never increase size.  */
11343   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11344     {
11345       struct got_entry **lgot_ents;
11346       struct got_entry **end_lgot_ents;
11347       struct plt_entry **local_plt;
11348       struct plt_entry **end_local_plt;
11349       unsigned char *lgot_masks;
11350       bfd_size_type locsymcount;
11351       Elf_Internal_Shdr *symtab_hdr;
11352       asection *s;
11353
11354       if (!is_ppc64_elf (ibfd))
11355         continue;
11356
11357       lgot_ents = elf_local_got_ents (ibfd);
11358       if (!lgot_ents)
11359         continue;
11360
11361       symtab_hdr = &elf_symtab_hdr (ibfd);
11362       locsymcount = symtab_hdr->sh_info;
11363       end_lgot_ents = lgot_ents + locsymcount;
11364       local_plt = (struct plt_entry **) end_lgot_ents;
11365       end_local_plt = local_plt + locsymcount;
11366       lgot_masks = (unsigned char *) end_local_plt;
11367       s = ppc64_elf_tdata (ibfd)->got;
11368       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11369         {
11370           struct got_entry *ent;
11371
11372           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11373             {
11374               unsigned int ent_size = 8;
11375               unsigned int rel_size = sizeof (Elf64_External_Rela);
11376
11377               ent->got.offset = s->size;
11378               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11379                 {
11380                   ent_size *= 2;
11381                   rel_size *= 2;
11382                 }
11383               s->size += ent_size;
11384               if ((*lgot_masks & PLT_IFUNC) != 0)
11385                 {
11386                   htab->elf.irelplt->size += rel_size;
11387                   htab->got_reli_size += rel_size;
11388                 }
11389               else if (info->shared)
11390                 {
11391                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11392                   srel->size += rel_size;
11393                 }
11394             }
11395         }
11396     }
11397
11398   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11399
11400   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11401     {
11402       struct got_entry *ent;
11403
11404       if (!is_ppc64_elf (ibfd))
11405         continue;
11406
11407       ent = ppc64_tlsld_got (ibfd);
11408       if (!ent->is_indirect
11409           && ent->got.offset != (bfd_vma) -1)
11410         {
11411           asection *s = ppc64_elf_tdata (ibfd)->got;
11412           ent->got.offset = s->size;
11413           s->size += 16;
11414           if (info->shared)
11415             {
11416               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11417               srel->size += sizeof (Elf64_External_Rela);
11418             }
11419         }
11420     }
11421
11422   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11423   if (!done_something)
11424     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11425       {
11426         asection *got;
11427
11428         if (!is_ppc64_elf (ibfd))
11429           continue;
11430
11431         got = ppc64_elf_tdata (ibfd)->got;
11432         if (got != NULL)
11433           {
11434             done_something = got->rawsize != got->size;
11435             if (done_something)
11436               break;
11437           }
11438       }
11439
11440   if (done_something)
11441     (*htab->params->layout_sections_again) ();
11442
11443   /* Set up for second pass over toc sections to recalculate elf_gp
11444      on input sections.  */
11445   htab->toc_bfd = NULL;
11446   htab->toc_first_sec = NULL;
11447   htab->second_toc_pass = TRUE;
11448   return done_something;
11449 }
11450
11451 /* Called after second pass of multitoc partitioning.  */
11452
11453 void
11454 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11455 {
11456   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11457
11458   /* After the second pass, toc_curr tracks the TOC offset used
11459      for code sections below in ppc64_elf_next_input_section.  */
11460   htab->toc_curr = TOC_BASE_OFF;
11461 }
11462
11463 /* No toc references were found in ISEC.  If the code in ISEC makes no
11464    calls, then there's no need to use toc adjusting stubs when branching
11465    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11466    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11467    needed, and 2 if a cyclical call-graph was found but no other reason
11468    for a stub was detected.  If called from the top level, a return of
11469    2 means the same as a return of 0.  */
11470
11471 static int
11472 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11473 {
11474   int ret;
11475
11476   /* Mark this section as checked.  */
11477   isec->call_check_done = 1;
11478
11479   /* We know none of our code bearing sections will need toc stubs.  */
11480   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11481     return 0;
11482
11483   if (isec->size == 0)
11484     return 0;
11485
11486   if (isec->output_section == NULL)
11487     return 0;
11488
11489   ret = 0;
11490   if (isec->reloc_count != 0)
11491     {
11492       Elf_Internal_Rela *relstart, *rel;
11493       Elf_Internal_Sym *local_syms;
11494       struct ppc_link_hash_table *htab;
11495
11496       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11497                                             info->keep_memory);
11498       if (relstart == NULL)
11499         return -1;
11500
11501       /* Look for branches to outside of this section.  */
11502       local_syms = NULL;
11503       htab = ppc_hash_table (info);
11504       if (htab == NULL)
11505         return -1;
11506
11507       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11508         {
11509           enum elf_ppc64_reloc_type r_type;
11510           unsigned long r_symndx;
11511           struct elf_link_hash_entry *h;
11512           struct ppc_link_hash_entry *eh;
11513           Elf_Internal_Sym *sym;
11514           asection *sym_sec;
11515           struct _opd_sec_data *opd;
11516           bfd_vma sym_value;
11517           bfd_vma dest;
11518
11519           r_type = ELF64_R_TYPE (rel->r_info);
11520           if (r_type != R_PPC64_REL24
11521               && r_type != R_PPC64_REL14
11522               && r_type != R_PPC64_REL14_BRTAKEN
11523               && r_type != R_PPC64_REL14_BRNTAKEN)
11524             continue;
11525
11526           r_symndx = ELF64_R_SYM (rel->r_info);
11527           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11528                           isec->owner))
11529             {
11530               ret = -1;
11531               break;
11532             }
11533
11534           /* Calls to dynamic lib functions go through a plt call stub
11535              that uses r2.  */
11536           eh = (struct ppc_link_hash_entry *) h;
11537           if (eh != NULL
11538               && (eh->elf.plt.plist != NULL
11539                   || (eh->oh != NULL
11540                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11541             {
11542               ret = 1;
11543               break;
11544             }
11545
11546           if (sym_sec == NULL)
11547             /* Ignore other undefined symbols.  */
11548             continue;
11549
11550           /* Assume branches to other sections not included in the
11551              link need stubs too, to cover -R and absolute syms.  */
11552           if (sym_sec->output_section == NULL)
11553             {
11554               ret = 1;
11555               break;
11556             }
11557
11558           if (h == NULL)
11559             sym_value = sym->st_value;
11560           else
11561             {
11562               if (h->root.type != bfd_link_hash_defined
11563                   && h->root.type != bfd_link_hash_defweak)
11564                 abort ();
11565               sym_value = h->root.u.def.value;
11566             }
11567           sym_value += rel->r_addend;
11568
11569           /* If this branch reloc uses an opd sym, find the code section.  */
11570           opd = get_opd_info (sym_sec);
11571           if (opd != NULL)
11572             {
11573               if (h == NULL && opd->adjust != NULL)
11574                 {
11575                   long adjust;
11576
11577                   adjust = opd->adjust[sym->st_value / 8];
11578                   if (adjust == -1)
11579                     /* Assume deleted functions won't ever be called.  */
11580                     continue;
11581                   sym_value += adjust;
11582                 }
11583
11584               dest = opd_entry_value (sym_sec, sym_value,
11585                                       &sym_sec, NULL, FALSE);
11586               if (dest == (bfd_vma) -1)
11587                 continue;
11588             }
11589           else
11590             dest = (sym_value
11591                     + sym_sec->output_offset
11592                     + sym_sec->output_section->vma);
11593
11594           /* Ignore branch to self.  */
11595           if (sym_sec == isec)
11596             continue;
11597
11598           /* If the called function uses the toc, we need a stub.  */
11599           if (sym_sec->has_toc_reloc
11600               || sym_sec->makes_toc_func_call)
11601             {
11602               ret = 1;
11603               break;
11604             }
11605
11606           /* Assume any branch that needs a long branch stub might in fact
11607              need a plt_branch stub.  A plt_branch stub uses r2.  */
11608           else if (dest - (isec->output_offset
11609                            + isec->output_section->vma
11610                            + rel->r_offset) + (1 << 25)
11611                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11612                                                              ? h->other
11613                                                              : sym->st_other))
11614             {
11615               ret = 1;
11616               break;
11617             }
11618
11619           /* If calling back to a section in the process of being
11620              tested, we can't say for sure that no toc adjusting stubs
11621              are needed, so don't return zero.  */
11622           else if (sym_sec->call_check_in_progress)
11623             ret = 2;
11624
11625           /* Branches to another section that itself doesn't have any TOC
11626              references are OK.  Recursively call ourselves to check.  */
11627           else if (!sym_sec->call_check_done)
11628             {
11629               int recur;
11630
11631               /* Mark current section as indeterminate, so that other
11632                  sections that call back to current won't be marked as
11633                  known.  */
11634               isec->call_check_in_progress = 1;
11635               recur = toc_adjusting_stub_needed (info, sym_sec);
11636               isec->call_check_in_progress = 0;
11637
11638               if (recur != 0)
11639                 {
11640                   ret = recur;
11641                   if (recur != 2)
11642                     break;
11643                 }
11644             }
11645         }
11646
11647       if (local_syms != NULL
11648           && (elf_symtab_hdr (isec->owner).contents
11649               != (unsigned char *) local_syms))
11650         free (local_syms);
11651       if (elf_section_data (isec)->relocs != relstart)
11652         free (relstart);
11653     }
11654
11655   if ((ret & 1) == 0
11656       && isec->map_head.s != NULL
11657       && (strcmp (isec->output_section->name, ".init") == 0
11658           || strcmp (isec->output_section->name, ".fini") == 0))
11659     {
11660       if (isec->map_head.s->has_toc_reloc
11661           || isec->map_head.s->makes_toc_func_call)
11662         ret = 1;
11663       else if (!isec->map_head.s->call_check_done)
11664         {
11665           int recur;
11666           isec->call_check_in_progress = 1;
11667           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11668           isec->call_check_in_progress = 0;
11669           if (recur != 0)
11670             ret = recur;
11671         }
11672     }
11673
11674   if (ret == 1)
11675     isec->makes_toc_func_call = 1;
11676
11677   return ret;
11678 }
11679
11680 /* The linker repeatedly calls this function for each input section,
11681    in the order that input sections are linked into output sections.
11682    Build lists of input sections to determine groupings between which
11683    we may insert linker stubs.  */
11684
11685 bfd_boolean
11686 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11687 {
11688   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11689
11690   if (htab == NULL)
11691     return FALSE;
11692
11693   if ((isec->output_section->flags & SEC_CODE) != 0
11694       && isec->output_section->index <= htab->top_index)
11695     {
11696       asection **list = htab->input_list + isec->output_section->index;
11697       /* Steal the link_sec pointer for our list.  */
11698 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11699       /* This happens to make the list in reverse order,
11700          which is what we want.  */
11701       PREV_SEC (isec) = *list;
11702       *list = isec;
11703     }
11704
11705   if (htab->multi_toc_needed)
11706     {
11707       /* Analyse sections that aren't already flagged as needing a
11708          valid toc pointer.  Exclude .fixup for the linux kernel.
11709          .fixup contains branches, but only back to the function that
11710          hit an exception.  */
11711       if (!(isec->has_toc_reloc
11712             || (isec->flags & SEC_CODE) == 0
11713             || strcmp (isec->name, ".fixup") == 0
11714             || isec->call_check_done))
11715         {
11716           if (toc_adjusting_stub_needed (info, isec) < 0)
11717             return FALSE;
11718         }
11719       /* Make all sections use the TOC assigned for this object file.
11720          This will be wrong for pasted sections;  We fix that in
11721          check_pasted_section().  */
11722       if (elf_gp (isec->owner) != 0)
11723         htab->toc_curr = elf_gp (isec->owner);
11724     }
11725
11726   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11727   return TRUE;
11728 }
11729
11730 /* Check that all .init and .fini sections use the same toc, if they
11731    have toc relocs.  */
11732
11733 static bfd_boolean
11734 check_pasted_section (struct bfd_link_info *info, const char *name)
11735 {
11736   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11737
11738   if (o != NULL)
11739     {
11740       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11741       bfd_vma toc_off = 0;
11742       asection *i;
11743
11744       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11745         if (i->has_toc_reloc)
11746           {
11747             if (toc_off == 0)
11748               toc_off = htab->stub_group[i->id].toc_off;
11749             else if (toc_off != htab->stub_group[i->id].toc_off)
11750               return FALSE;
11751           }
11752
11753       if (toc_off == 0)
11754         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11755           if (i->makes_toc_func_call)
11756             {
11757               toc_off = htab->stub_group[i->id].toc_off;
11758               break;
11759             }
11760
11761       /* Make sure the whole pasted function uses the same toc offset.  */
11762       if (toc_off != 0)
11763         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11764           htab->stub_group[i->id].toc_off = toc_off;
11765     }
11766   return TRUE;
11767 }
11768
11769 bfd_boolean
11770 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11771 {
11772   return (check_pasted_section (info, ".init")
11773           & check_pasted_section (info, ".fini"));
11774 }
11775
11776 /* See whether we can group stub sections together.  Grouping stub
11777    sections may result in fewer stubs.  More importantly, we need to
11778    put all .init* and .fini* stubs at the beginning of the .init or
11779    .fini output sections respectively, because glibc splits the
11780    _init and _fini functions into multiple parts.  Putting a stub in
11781    the middle of a function is not a good idea.  */
11782
11783 static void
11784 group_sections (struct ppc_link_hash_table *htab,
11785                 bfd_size_type stub_group_size,
11786                 bfd_boolean stubs_always_before_branch)
11787 {
11788   asection **list;
11789   bfd_size_type stub14_group_size;
11790   bfd_boolean suppress_size_errors;
11791
11792   suppress_size_errors = FALSE;
11793   stub14_group_size = stub_group_size;
11794   if (stub_group_size == 1)
11795     {
11796       /* Default values.  */
11797       if (stubs_always_before_branch)
11798         {
11799           stub_group_size = 0x1e00000;
11800           stub14_group_size = 0x7800;
11801         }
11802       else
11803         {
11804           stub_group_size = 0x1c00000;
11805           stub14_group_size = 0x7000;
11806         }
11807       suppress_size_errors = TRUE;
11808     }
11809
11810   list = htab->input_list + htab->top_index;
11811   do
11812     {
11813       asection *tail = *list;
11814       while (tail != NULL)
11815         {
11816           asection *curr;
11817           asection *prev;
11818           bfd_size_type total;
11819           bfd_boolean big_sec;
11820           bfd_vma curr_toc;
11821
11822           curr = tail;
11823           total = tail->size;
11824           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11825                              && ppc64_elf_section_data (tail)->has_14bit_branch
11826                              ? stub14_group_size : stub_group_size);
11827           if (big_sec && !suppress_size_errors)
11828             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11829                                      tail->owner, tail);
11830           curr_toc = htab->stub_group[tail->id].toc_off;
11831
11832           while ((prev = PREV_SEC (curr)) != NULL
11833                  && ((total += curr->output_offset - prev->output_offset)
11834                      < (ppc64_elf_section_data (prev) != NULL
11835                         && ppc64_elf_section_data (prev)->has_14bit_branch
11836                         ? stub14_group_size : stub_group_size))
11837                  && htab->stub_group[prev->id].toc_off == curr_toc)
11838             curr = prev;
11839
11840           /* OK, the size from the start of CURR to the end is less
11841              than stub_group_size and thus can be handled by one stub
11842              section.  (or the tail section is itself larger than
11843              stub_group_size, in which case we may be toast.)  We
11844              should really be keeping track of the total size of stubs
11845              added here, as stubs contribute to the final output
11846              section size.  That's a little tricky, and this way will
11847              only break if stubs added make the total size more than
11848              2^25, ie. for the default stub_group_size, if stubs total
11849              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11850           do
11851             {
11852               prev = PREV_SEC (tail);
11853               /* Set up this stub group.  */
11854               htab->stub_group[tail->id].link_sec = curr;
11855             }
11856           while (tail != curr && (tail = prev) != NULL);
11857
11858           /* But wait, there's more!  Input sections up to stub_group_size
11859              bytes before the stub section can be handled by it too.
11860              Don't do this if we have a really large section after the
11861              stubs, as adding more stubs increases the chance that
11862              branches may not reach into the stub section.  */
11863           if (!stubs_always_before_branch && !big_sec)
11864             {
11865               total = 0;
11866               while (prev != NULL
11867                      && ((total += tail->output_offset - prev->output_offset)
11868                          < (ppc64_elf_section_data (prev) != NULL
11869                             && ppc64_elf_section_data (prev)->has_14bit_branch
11870                             ? stub14_group_size : stub_group_size))
11871                      && htab->stub_group[prev->id].toc_off == curr_toc)
11872                 {
11873                   tail = prev;
11874                   prev = PREV_SEC (tail);
11875                   htab->stub_group[tail->id].link_sec = curr;
11876                 }
11877             }
11878           tail = prev;
11879         }
11880     }
11881   while (list-- != htab->input_list);
11882   free (htab->input_list);
11883 #undef PREV_SEC
11884 }
11885
11886 static const unsigned char glink_eh_frame_cie[] =
11887 {
11888   0, 0, 0, 16,                          /* length.  */
11889   0, 0, 0, 0,                           /* id.  */
11890   1,                                    /* CIE version.  */
11891   'z', 'R', 0,                          /* Augmentation string.  */
11892   4,                                    /* Code alignment.  */
11893   0x78,                                 /* Data alignment.  */
11894   65,                                   /* RA reg.  */
11895   1,                                    /* Augmentation size.  */
11896   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11897   DW_CFA_def_cfa, 1, 0,                 /* def_cfa: r1 offset 0.  */
11898   0, 0, 0, 0
11899 };
11900
11901 /* Stripping output sections is normally done before dynamic section
11902    symbols have been allocated.  This function is called later, and
11903    handles cases like htab->brlt which is mapped to its own output
11904    section.  */
11905
11906 static void
11907 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11908 {
11909   if (isec->size == 0
11910       && isec->output_section->size == 0
11911       && !(isec->output_section->flags & SEC_KEEP)
11912       && !bfd_section_removed_from_list (info->output_bfd,
11913                                          isec->output_section)
11914       && elf_section_data (isec->output_section)->dynindx == 0)
11915     {
11916       isec->output_section->flags |= SEC_EXCLUDE;
11917       bfd_section_list_remove (info->output_bfd, isec->output_section);
11918       info->output_bfd->section_count--;
11919     }
11920 }
11921
11922 /* Determine and set the size of the stub section for a final link.
11923
11924    The basic idea here is to examine all the relocations looking for
11925    PC-relative calls to a target that is unreachable with a "bl"
11926    instruction.  */
11927
11928 bfd_boolean
11929 ppc64_elf_size_stubs (struct bfd_link_info *info)
11930 {
11931   bfd_size_type stub_group_size;
11932   bfd_boolean stubs_always_before_branch;
11933   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11934
11935   if (htab == NULL)
11936     return FALSE;
11937
11938   if (htab->params->plt_thread_safe == -1 && !info->executable)
11939     htab->params->plt_thread_safe = 1;
11940   if (!htab->opd_abi)
11941     htab->params->plt_thread_safe = 0;
11942   else if (htab->params->plt_thread_safe == -1)
11943     {
11944       static const char *const thread_starter[] =
11945         {
11946           "pthread_create",
11947           /* libstdc++ */
11948           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11949           /* librt */
11950           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11951           "mq_notify", "create_timer",
11952           /* libanl */
11953           "getaddrinfo_a",
11954           /* libgomp */
11955           "GOMP_parallel_start",
11956           "GOMP_parallel_loop_static_start",
11957           "GOMP_parallel_loop_dynamic_start",
11958           "GOMP_parallel_loop_guided_start",
11959           "GOMP_parallel_loop_runtime_start",
11960           "GOMP_parallel_sections_start",
11961         };
11962       unsigned i;
11963
11964       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11965         {
11966           struct elf_link_hash_entry *h;
11967           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11968                                     FALSE, FALSE, TRUE);
11969           htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11970           if (htab->params->plt_thread_safe)
11971             break;
11972         }
11973     }
11974   stubs_always_before_branch = htab->params->group_size < 0;
11975   if (htab->params->group_size < 0)
11976     stub_group_size = -htab->params->group_size;
11977   else
11978     stub_group_size = htab->params->group_size;
11979
11980   group_sections (htab, stub_group_size, stubs_always_before_branch);
11981
11982   while (1)
11983     {
11984       bfd *input_bfd;
11985       unsigned int bfd_indx;
11986       asection *stub_sec;
11987
11988       htab->stub_iteration += 1;
11989
11990       for (input_bfd = info->input_bfds, bfd_indx = 0;
11991            input_bfd != NULL;
11992            input_bfd = input_bfd->link.next, bfd_indx++)
11993         {
11994           Elf_Internal_Shdr *symtab_hdr;
11995           asection *section;
11996           Elf_Internal_Sym *local_syms = NULL;
11997
11998           if (!is_ppc64_elf (input_bfd))
11999             continue;
12000
12001           /* We'll need the symbol table in a second.  */
12002           symtab_hdr = &elf_symtab_hdr (input_bfd);
12003           if (symtab_hdr->sh_info == 0)
12004             continue;
12005
12006           /* Walk over each section attached to the input bfd.  */
12007           for (section = input_bfd->sections;
12008                section != NULL;
12009                section = section->next)
12010             {
12011               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12012
12013               /* If there aren't any relocs, then there's nothing more
12014                  to do.  */
12015               if ((section->flags & SEC_RELOC) == 0
12016                   || (section->flags & SEC_ALLOC) == 0
12017                   || (section->flags & SEC_LOAD) == 0
12018                   || (section->flags & SEC_CODE) == 0
12019                   || section->reloc_count == 0)
12020                 continue;
12021
12022               /* If this section is a link-once section that will be
12023                  discarded, then don't create any stubs.  */
12024               if (section->output_section == NULL
12025                   || section->output_section->owner != info->output_bfd)
12026                 continue;
12027
12028               /* Get the relocs.  */
12029               internal_relocs
12030                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12031                                              info->keep_memory);
12032               if (internal_relocs == NULL)
12033                 goto error_ret_free_local;
12034
12035               /* Now examine each relocation.  */
12036               irela = internal_relocs;
12037               irelaend = irela + section->reloc_count;
12038               for (; irela < irelaend; irela++)
12039                 {
12040                   enum elf_ppc64_reloc_type r_type;
12041                   unsigned int r_indx;
12042                   enum ppc_stub_type stub_type;
12043                   struct ppc_stub_hash_entry *stub_entry;
12044                   asection *sym_sec, *code_sec;
12045                   bfd_vma sym_value, code_value;
12046                   bfd_vma destination;
12047                   unsigned long local_off;
12048                   bfd_boolean ok_dest;
12049                   struct ppc_link_hash_entry *hash;
12050                   struct ppc_link_hash_entry *fdh;
12051                   struct elf_link_hash_entry *h;
12052                   Elf_Internal_Sym *sym;
12053                   char *stub_name;
12054                   const asection *id_sec;
12055                   struct _opd_sec_data *opd;
12056                   struct plt_entry *plt_ent;
12057
12058                   r_type = ELF64_R_TYPE (irela->r_info);
12059                   r_indx = ELF64_R_SYM (irela->r_info);
12060
12061                   if (r_type >= R_PPC64_max)
12062                     {
12063                       bfd_set_error (bfd_error_bad_value);
12064                       goto error_ret_free_internal;
12065                     }
12066
12067                   /* Only look for stubs on branch instructions.  */
12068                   if (r_type != R_PPC64_REL24
12069                       && r_type != R_PPC64_REL14
12070                       && r_type != R_PPC64_REL14_BRTAKEN
12071                       && r_type != R_PPC64_REL14_BRNTAKEN)
12072                     continue;
12073
12074                   /* Now determine the call target, its name, value,
12075                      section.  */
12076                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12077                                   r_indx, input_bfd))
12078                     goto error_ret_free_internal;
12079                   hash = (struct ppc_link_hash_entry *) h;
12080
12081                   ok_dest = FALSE;
12082                   fdh = NULL;
12083                   sym_value = 0;
12084                   if (hash == NULL)
12085                     {
12086                       sym_value = sym->st_value;
12087                       ok_dest = TRUE;
12088                     }
12089                   else if (hash->elf.root.type == bfd_link_hash_defined
12090                            || hash->elf.root.type == bfd_link_hash_defweak)
12091                     {
12092                       sym_value = hash->elf.root.u.def.value;
12093                       if (sym_sec->output_section != NULL)
12094                         ok_dest = TRUE;
12095                     }
12096                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12097                            || hash->elf.root.type == bfd_link_hash_undefined)
12098                     {
12099                       /* Recognise an old ABI func code entry sym, and
12100                          use the func descriptor sym instead if it is
12101                          defined.  */
12102                       if (hash->elf.root.root.string[0] == '.'
12103                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12104                         {
12105                           if (fdh->elf.root.type == bfd_link_hash_defined
12106                               || fdh->elf.root.type == bfd_link_hash_defweak)
12107                             {
12108                               sym_sec = fdh->elf.root.u.def.section;
12109                               sym_value = fdh->elf.root.u.def.value;
12110                               if (sym_sec->output_section != NULL)
12111                                 ok_dest = TRUE;
12112                             }
12113                           else
12114                             fdh = NULL;
12115                         }
12116                     }
12117                   else
12118                     {
12119                       bfd_set_error (bfd_error_bad_value);
12120                       goto error_ret_free_internal;
12121                     }
12122
12123                   destination = 0;
12124                   local_off = 0;
12125                   if (ok_dest)
12126                     {
12127                       sym_value += irela->r_addend;
12128                       destination = (sym_value
12129                                      + sym_sec->output_offset
12130                                      + sym_sec->output_section->vma);
12131                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12132                                                             ? hash->elf.other
12133                                                             : sym->st_other);
12134                     }
12135
12136                   code_sec = sym_sec;
12137                   code_value = sym_value;
12138                   opd = get_opd_info (sym_sec);
12139                   if (opd != NULL)
12140                     {
12141                       bfd_vma dest;
12142
12143                       if (hash == NULL && opd->adjust != NULL)
12144                         {
12145                           long adjust = opd->adjust[sym_value / 8];
12146                           if (adjust == -1)
12147                             continue;
12148                           code_value += adjust;
12149                           sym_value += adjust;
12150                         }
12151                       dest = opd_entry_value (sym_sec, sym_value,
12152                                               &code_sec, &code_value, FALSE);
12153                       if (dest != (bfd_vma) -1)
12154                         {
12155                           destination = dest;
12156                           if (fdh != NULL)
12157                             {
12158                               /* Fixup old ABI sym to point at code
12159                                  entry.  */
12160                               hash->elf.root.type = bfd_link_hash_defweak;
12161                               hash->elf.root.u.def.section = code_sec;
12162                               hash->elf.root.u.def.value = code_value;
12163                             }
12164                         }
12165                     }
12166
12167                   /* Determine what (if any) linker stub is needed.  */
12168                   plt_ent = NULL;
12169                   stub_type = ppc_type_of_stub (section, irela, &hash,
12170                                                 &plt_ent, destination,
12171                                                 local_off);
12172
12173                   if (stub_type != ppc_stub_plt_call)
12174                     {
12175                       /* Check whether we need a TOC adjusting stub.
12176                          Since the linker pastes together pieces from
12177                          different object files when creating the
12178                          _init and _fini functions, it may be that a
12179                          call to what looks like a local sym is in
12180                          fact a call needing a TOC adjustment.  */
12181                       if (code_sec != NULL
12182                           && code_sec->output_section != NULL
12183                           && (htab->stub_group[code_sec->id].toc_off
12184                               != htab->stub_group[section->id].toc_off)
12185                           && (code_sec->has_toc_reloc
12186                               || code_sec->makes_toc_func_call))
12187                         stub_type = ppc_stub_long_branch_r2off;
12188                     }
12189
12190                   if (stub_type == ppc_stub_none)
12191                     continue;
12192
12193                   /* __tls_get_addr calls might be eliminated.  */
12194                   if (stub_type != ppc_stub_plt_call
12195                       && hash != NULL
12196                       && (hash == htab->tls_get_addr
12197                           || hash == htab->tls_get_addr_fd)
12198                       && section->has_tls_reloc
12199                       && irela != internal_relocs)
12200                     {
12201                       /* Get tls info.  */
12202                       unsigned char *tls_mask;
12203
12204                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12205                                          irela - 1, input_bfd))
12206                         goto error_ret_free_internal;
12207                       if (*tls_mask != 0)
12208                         continue;
12209                     }
12210
12211                   if (stub_type == ppc_stub_plt_call
12212                       && irela + 1 < irelaend
12213                       && irela[1].r_offset == irela->r_offset + 4
12214                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12215                     {
12216                       if (!tocsave_find (htab, INSERT,
12217                                          &local_syms, irela + 1, input_bfd))
12218                         goto error_ret_free_internal;
12219                     }
12220                   else if (stub_type == ppc_stub_plt_call)
12221                     stub_type = ppc_stub_plt_call_r2save;
12222
12223                   /* Support for grouping stub sections.  */
12224                   id_sec = htab->stub_group[section->id].link_sec;
12225
12226                   /* Get the name of this stub.  */
12227                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12228                   if (!stub_name)
12229                     goto error_ret_free_internal;
12230
12231                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12232                                                      stub_name, FALSE, FALSE);
12233                   if (stub_entry != NULL)
12234                     {
12235                       /* The proper stub has already been created.  */
12236                       free (stub_name);
12237                       if (stub_type == ppc_stub_plt_call_r2save)
12238                         stub_entry->stub_type = stub_type;
12239                       continue;
12240                     }
12241
12242                   stub_entry = ppc_add_stub (stub_name, section, info);
12243                   if (stub_entry == NULL)
12244                     {
12245                       free (stub_name);
12246                     error_ret_free_internal:
12247                       if (elf_section_data (section)->relocs == NULL)
12248                         free (internal_relocs);
12249                     error_ret_free_local:
12250                       if (local_syms != NULL
12251                           && (symtab_hdr->contents
12252                               != (unsigned char *) local_syms))
12253                         free (local_syms);
12254                       return FALSE;
12255                     }
12256
12257                   stub_entry->stub_type = stub_type;
12258                   if (stub_type != ppc_stub_plt_call
12259                       && stub_type != ppc_stub_plt_call_r2save)
12260                     {
12261                       stub_entry->target_value = code_value;
12262                       stub_entry->target_section = code_sec;
12263                     }
12264                   else
12265                     {
12266                       stub_entry->target_value = sym_value;
12267                       stub_entry->target_section = sym_sec;
12268                     }
12269                   stub_entry->h = hash;
12270                   stub_entry->plt_ent = plt_ent;
12271                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12272
12273                   if (stub_entry->h != NULL)
12274                     htab->stub_globals += 1;
12275                 }
12276
12277               /* We're done with the internal relocs, free them.  */
12278               if (elf_section_data (section)->relocs != internal_relocs)
12279                 free (internal_relocs);
12280             }
12281
12282           if (local_syms != NULL
12283               && symtab_hdr->contents != (unsigned char *) local_syms)
12284             {
12285               if (!info->keep_memory)
12286                 free (local_syms);
12287               else
12288                 symtab_hdr->contents = (unsigned char *) local_syms;
12289             }
12290         }
12291
12292       /* We may have added some stubs.  Find out the new size of the
12293          stub sections.  */
12294       for (stub_sec = htab->params->stub_bfd->sections;
12295            stub_sec != NULL;
12296            stub_sec = stub_sec->next)
12297         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12298           {
12299             stub_sec->rawsize = stub_sec->size;
12300             stub_sec->size = 0;
12301             stub_sec->reloc_count = 0;
12302             stub_sec->flags &= ~SEC_RELOC;
12303           }
12304
12305       htab->brlt->size = 0;
12306       htab->brlt->reloc_count = 0;
12307       htab->brlt->flags &= ~SEC_RELOC;
12308       if (htab->relbrlt != NULL)
12309         htab->relbrlt->size = 0;
12310
12311       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12312
12313       if (info->emitrelocations
12314           && htab->glink != NULL && htab->glink->size != 0)
12315         {
12316           htab->glink->reloc_count = 1;
12317           htab->glink->flags |= SEC_RELOC;
12318         }
12319
12320       if (htab->glink_eh_frame != NULL
12321           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12322           && htab->glink_eh_frame->output_section->size != 0)
12323         {
12324           size_t size = 0, align;
12325
12326           for (stub_sec = htab->params->stub_bfd->sections;
12327                stub_sec != NULL;
12328                stub_sec = stub_sec->next)
12329             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12330               size += 24;
12331           if (htab->glink != NULL && htab->glink->size != 0)
12332             size += 24;
12333           if (size != 0)
12334             size += sizeof (glink_eh_frame_cie);
12335           align = 1;
12336           align <<= htab->glink_eh_frame->output_section->alignment_power;
12337           align -= 1;
12338           size = (size + align) & ~align;
12339           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12340           htab->glink_eh_frame->size = size;
12341         }
12342
12343       if (htab->params->plt_stub_align != 0)
12344         for (stub_sec = htab->params->stub_bfd->sections;
12345              stub_sec != NULL;
12346              stub_sec = stub_sec->next)
12347           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12348             stub_sec->size = ((stub_sec->size
12349                                + (1 << htab->params->plt_stub_align) - 1)
12350                               & (-1 << htab->params->plt_stub_align));
12351
12352       for (stub_sec = htab->params->stub_bfd->sections;
12353            stub_sec != NULL;
12354            stub_sec = stub_sec->next)
12355         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12356             && stub_sec->rawsize != stub_sec->size)
12357           break;
12358
12359       /* Exit from this loop when no stubs have been added, and no stubs
12360          have changed size.  */
12361       if (stub_sec == NULL
12362           && (htab->glink_eh_frame == NULL
12363               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12364         break;
12365
12366       /* Ask the linker to do its stuff.  */
12367       (*htab->params->layout_sections_again) ();
12368     }
12369
12370   if (htab->glink_eh_frame != NULL
12371       && htab->glink_eh_frame->size != 0)
12372     {
12373       bfd_vma val;
12374       bfd_byte *p, *last_fde;
12375       size_t last_fde_len, size, align, pad;
12376       asection *stub_sec;
12377
12378       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12379       if (p == NULL)
12380         return FALSE;
12381       htab->glink_eh_frame->contents = p;
12382       last_fde = p;
12383
12384       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12385       /* CIE length (rewrite in case little-endian).  */
12386       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12387       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12388       p += sizeof (glink_eh_frame_cie);
12389
12390       for (stub_sec = htab->params->stub_bfd->sections;
12391            stub_sec != NULL;
12392            stub_sec = stub_sec->next)
12393         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12394           {
12395             last_fde = p;
12396             last_fde_len = 20;
12397             /* FDE length.  */
12398             bfd_put_32 (htab->elf.dynobj, 20, p);
12399             p += 4;
12400             /* CIE pointer.  */
12401             val = p - htab->glink_eh_frame->contents;
12402             bfd_put_32 (htab->elf.dynobj, val, p);
12403             p += 4;
12404             /* Offset to stub section, written later.  */
12405             p += 4;
12406             /* stub section size.  */
12407             bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12408             p += 4;
12409             /* Augmentation.  */
12410             p += 1;
12411             /* Pad.  */
12412             p += 7;
12413           }
12414       if (htab->glink != NULL && htab->glink->size != 0)
12415         {
12416           last_fde = p;
12417           last_fde_len = 20;
12418           /* FDE length.  */
12419           bfd_put_32 (htab->elf.dynobj, 20, p);
12420           p += 4;
12421           /* CIE pointer.  */
12422           val = p - htab->glink_eh_frame->contents;
12423           bfd_put_32 (htab->elf.dynobj, val, p);
12424           p += 4;
12425           /* Offset to .glink, written later.  */
12426           p += 4;
12427           /* .glink size.  */
12428           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12429           p += 4;
12430           /* Augmentation.  */
12431           p += 1;
12432
12433           *p++ = DW_CFA_advance_loc + 1;
12434           *p++ = DW_CFA_register;
12435           *p++ = 65;
12436           *p++ = 12;
12437           *p++ = DW_CFA_advance_loc + 4;
12438           *p++ = DW_CFA_restore_extended;
12439           *p++ = 65;
12440         }
12441       /* Subsume any padding into the last FDE if user .eh_frame
12442          sections are aligned more than glink_eh_frame.  Otherwise any
12443          zero padding will be seen as a terminator.  */
12444       size = p - htab->glink_eh_frame->contents;
12445       align = 1;
12446       align <<= htab->glink_eh_frame->output_section->alignment_power;
12447       align -= 1;
12448       pad = ((size + align) & ~align) - size;
12449       htab->glink_eh_frame->size = size + pad;
12450       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12451     }
12452
12453   maybe_strip_output (info, htab->brlt);
12454   if (htab->glink_eh_frame != NULL)
12455     maybe_strip_output (info, htab->glink_eh_frame);
12456
12457   return TRUE;
12458 }
12459
12460 /* Called after we have determined section placement.  If sections
12461    move, we'll be called again.  Provide a value for TOCstart.  */
12462
12463 bfd_vma
12464 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12465 {
12466   asection *s;
12467   bfd_vma TOCstart;
12468
12469   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12470      order.  The TOC starts where the first of these sections starts.  */
12471   s = bfd_get_section_by_name (obfd, ".got");
12472   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12473     s = bfd_get_section_by_name (obfd, ".toc");
12474   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12475     s = bfd_get_section_by_name (obfd, ".tocbss");
12476   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12477     s = bfd_get_section_by_name (obfd, ".plt");
12478   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12479     {
12480       /* This may happen for
12481          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12482          .toc directive
12483          o  bad linker script
12484          o --gc-sections and empty TOC sections
12485
12486          FIXME: Warn user?  */
12487
12488       /* Look for a likely section.  We probably won't even be
12489          using TOCstart.  */
12490       for (s = obfd->sections; s != NULL; s = s->next)
12491         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12492                          | SEC_EXCLUDE))
12493             == (SEC_ALLOC | SEC_SMALL_DATA))
12494           break;
12495       if (s == NULL)
12496         for (s = obfd->sections; s != NULL; s = s->next)
12497           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12498               == (SEC_ALLOC | SEC_SMALL_DATA))
12499             break;
12500       if (s == NULL)
12501         for (s = obfd->sections; s != NULL; s = s->next)
12502           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12503               == SEC_ALLOC)
12504             break;
12505       if (s == NULL)
12506         for (s = obfd->sections; s != NULL; s = s->next)
12507           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12508             break;
12509     }
12510
12511   TOCstart = 0;
12512   if (s != NULL)
12513     TOCstart = s->output_section->vma + s->output_offset;
12514
12515   _bfd_set_gp_value (obfd, TOCstart);
12516
12517   if (info != NULL && s != NULL)
12518     {
12519       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12520
12521       if (htab != NULL)
12522         {
12523           if (htab->elf.hgot != NULL)
12524             {
12525               htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12526               htab->elf.hgot->root.u.def.section = s;
12527             }
12528         }
12529       else
12530         {
12531           struct bfd_link_hash_entry *bh = NULL;
12532           _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12533                                             s, TOC_BASE_OFF, NULL, FALSE,
12534                                             FALSE, &bh);
12535         }
12536     }
12537   return TOCstart;
12538 }
12539
12540 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12541    write out any global entry stubs.  */
12542
12543 static bfd_boolean
12544 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12545 {
12546   struct bfd_link_info *info;
12547   struct ppc_link_hash_table *htab;
12548   struct plt_entry *pent;
12549   asection *s;
12550
12551   if (h->root.type == bfd_link_hash_indirect)
12552     return TRUE;
12553
12554   if (!h->pointer_equality_needed)
12555     return TRUE;
12556
12557   if (h->def_regular)
12558     return TRUE;
12559
12560   info = inf;
12561   htab = ppc_hash_table (info);
12562   if (htab == NULL)
12563     return FALSE;
12564
12565   s = htab->glink;
12566   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12567     if (pent->plt.offset != (bfd_vma) -1
12568         && pent->addend == 0)
12569       {
12570         bfd_byte *p;
12571         asection *plt;
12572         bfd_vma off;
12573
12574         p = s->contents + h->root.u.def.value;
12575         plt = htab->elf.splt;
12576         if (!htab->elf.dynamic_sections_created
12577             || h->dynindx == -1)
12578           plt = htab->elf.iplt;
12579         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12580         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12581
12582         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12583           {
12584             info->callbacks->einfo
12585               (_("%P: linkage table error against `%T'\n"),
12586                h->root.root.string);
12587             bfd_set_error (bfd_error_bad_value);
12588             htab->stub_error = TRUE;
12589           }
12590
12591         htab->stub_count[ppc_stub_global_entry - 1] += 1;
12592         if (htab->params->emit_stub_syms)
12593           {
12594             size_t len = strlen (h->root.root.string);
12595             char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12596
12597             if (name == NULL)
12598               return FALSE;
12599
12600             sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12601             h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12602             if (h == NULL)
12603               return FALSE;
12604             if (h->root.type == bfd_link_hash_new)
12605               {
12606                 h->root.type = bfd_link_hash_defined;
12607                 h->root.u.def.section = s;
12608                 h->root.u.def.value = p - s->contents;
12609                 h->ref_regular = 1;
12610                 h->def_regular = 1;
12611                 h->ref_regular_nonweak = 1;
12612                 h->forced_local = 1;
12613                 h->non_elf = 0;
12614               }
12615           }
12616
12617         if (PPC_HA (off) != 0)
12618           {
12619             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12620             p += 4;
12621           }
12622         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12623         p += 4;
12624         bfd_put_32 (s->owner, MTCTR_R12, p);
12625         p += 4;
12626         bfd_put_32 (s->owner, BCTR, p);
12627         break;
12628       }
12629   return TRUE;
12630 }
12631
12632 /* Build all the stubs associated with the current output file.
12633    The stubs are kept in a hash table attached to the main linker
12634    hash table.  This function is called via gldelf64ppc_finish.  */
12635
12636 bfd_boolean
12637 ppc64_elf_build_stubs (struct bfd_link_info *info,
12638                        char **stats)
12639 {
12640   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12641   asection *stub_sec;
12642   bfd_byte *p;
12643   int stub_sec_count = 0;
12644
12645   if (htab == NULL)
12646     return FALSE;
12647
12648   /* Allocate memory to hold the linker stubs.  */
12649   for (stub_sec = htab->params->stub_bfd->sections;
12650        stub_sec != NULL;
12651        stub_sec = stub_sec->next)
12652     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12653         && stub_sec->size != 0)
12654       {
12655         stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12656         if (stub_sec->contents == NULL)
12657           return FALSE;
12658         /* We want to check that built size is the same as calculated
12659            size.  rawsize is a convenient location to use.  */
12660         stub_sec->rawsize = stub_sec->size;
12661         stub_sec->size = 0;
12662       }
12663
12664   if (htab->glink != NULL && htab->glink->size != 0)
12665     {
12666       unsigned int indx;
12667       bfd_vma plt0;
12668
12669       /* Build the .glink plt call stub.  */
12670       if (htab->params->emit_stub_syms)
12671         {
12672           struct elf_link_hash_entry *h;
12673           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12674                                     TRUE, FALSE, FALSE);
12675           if (h == NULL)
12676             return FALSE;
12677           if (h->root.type == bfd_link_hash_new)
12678             {
12679               h->root.type = bfd_link_hash_defined;
12680               h->root.u.def.section = htab->glink;
12681               h->root.u.def.value = 8;
12682               h->ref_regular = 1;
12683               h->def_regular = 1;
12684               h->ref_regular_nonweak = 1;
12685               h->forced_local = 1;
12686               h->non_elf = 0;
12687             }
12688         }
12689       plt0 = (htab->elf.splt->output_section->vma
12690               + htab->elf.splt->output_offset
12691               - 16);
12692       if (info->emitrelocations)
12693         {
12694           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12695           if (r == NULL)
12696             return FALSE;
12697           r->r_offset = (htab->glink->output_offset
12698                          + htab->glink->output_section->vma);
12699           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12700           r->r_addend = plt0;
12701         }
12702       p = htab->glink->contents;
12703       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12704       bfd_put_64 (htab->glink->owner, plt0, p);
12705       p += 8;
12706       if (htab->opd_abi)
12707         {
12708           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12709           p += 4;
12710           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12711           p += 4;
12712           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12713           p += 4;
12714           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12715           p += 4;
12716           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12717           p += 4;
12718           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12719           p += 4;
12720           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12721           p += 4;
12722           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12723           p += 4;
12724           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12725           p += 4;
12726           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12727           p += 4;
12728         }
12729       else
12730         {
12731           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12732           p += 4;
12733           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12734           p += 4;
12735           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12736           p += 4;
12737           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12738           p += 4;
12739           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12740           p += 4;
12741           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12742           p += 4;
12743           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12744           p += 4;
12745           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12746           p += 4;
12747           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12748           p += 4;
12749           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12750           p += 4;
12751           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12752           p += 4;
12753           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12754           p += 4;
12755         }
12756       bfd_put_32 (htab->glink->owner, BCTR, p);
12757       p += 4;
12758       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12759         {
12760           bfd_put_32 (htab->glink->owner, NOP, p);
12761           p += 4;
12762         }
12763
12764       /* Build the .glink lazy link call stubs.  */
12765       indx = 0;
12766       while (p < htab->glink->contents + htab->glink->rawsize)
12767         {
12768           if (htab->opd_abi)
12769             {
12770               if (indx < 0x8000)
12771                 {
12772                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12773                   p += 4;
12774                 }
12775               else
12776                 {
12777                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12778                   p += 4;
12779                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12780                               p);
12781                   p += 4;
12782                 }
12783             }
12784           bfd_put_32 (htab->glink->owner,
12785                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12786           indx++;
12787           p += 4;
12788         }
12789
12790       /* Build .glink global entry stubs.  */
12791       if (htab->glink->size > htab->glink->rawsize)
12792         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12793     }
12794
12795   if (htab->brlt != NULL && htab->brlt->size != 0)
12796     {
12797       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12798                                          htab->brlt->size);
12799       if (htab->brlt->contents == NULL)
12800         return FALSE;
12801     }
12802   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12803     {
12804       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12805                                             htab->relbrlt->size);
12806       if (htab->relbrlt->contents == NULL)
12807         return FALSE;
12808     }
12809
12810   /* Build the stubs as directed by the stub hash table.  */
12811   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12812
12813   if (htab->relbrlt != NULL)
12814     htab->relbrlt->reloc_count = 0;
12815
12816   if (htab->params->plt_stub_align != 0)
12817     for (stub_sec = htab->params->stub_bfd->sections;
12818          stub_sec != NULL;
12819          stub_sec = stub_sec->next)
12820       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12821         stub_sec->size = ((stub_sec->size
12822                            + (1 << htab->params->plt_stub_align) - 1)
12823                           & (-1 << htab->params->plt_stub_align));
12824
12825   for (stub_sec = htab->params->stub_bfd->sections;
12826        stub_sec != NULL;
12827        stub_sec = stub_sec->next)
12828     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12829       {
12830         stub_sec_count += 1;
12831         if (stub_sec->rawsize != stub_sec->size)
12832           break;
12833       }
12834
12835   /* Note that the glink_eh_frame check here is not only testing that
12836      the generated size matched the calculated size but also that
12837      bfd_elf_discard_info didn't make any changes to the section.  */
12838   if (stub_sec != NULL
12839       || (htab->glink_eh_frame != NULL
12840           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12841     {
12842       htab->stub_error = TRUE;
12843       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12844     }
12845
12846   if (htab->stub_error)
12847     return FALSE;
12848
12849   if (stats != NULL)
12850     {
12851       *stats = bfd_malloc (500);
12852       if (*stats == NULL)
12853         return FALSE;
12854
12855       sprintf (*stats, _("linker stubs in %u group%s\n"
12856                          "  branch       %lu\n"
12857                          "  toc adjust   %lu\n"
12858                          "  long branch  %lu\n"
12859                          "  long toc adj %lu\n"
12860                          "  plt call     %lu\n"
12861                          "  plt call toc %lu\n"
12862                          "  global entry %lu"),
12863                stub_sec_count,
12864                stub_sec_count == 1 ? "" : "s",
12865                htab->stub_count[ppc_stub_long_branch - 1],
12866                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12867                htab->stub_count[ppc_stub_plt_branch - 1],
12868                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12869                htab->stub_count[ppc_stub_plt_call - 1],
12870                htab->stub_count[ppc_stub_plt_call_r2save - 1],
12871                htab->stub_count[ppc_stub_global_entry - 1]);
12872     }
12873   return TRUE;
12874 }
12875
12876 /* This function undoes the changes made by add_symbol_adjust.  */
12877
12878 static bfd_boolean
12879 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12880 {
12881   struct ppc_link_hash_entry *eh;
12882
12883   if (h->root.type == bfd_link_hash_indirect)
12884     return TRUE;
12885
12886   eh = (struct ppc_link_hash_entry *) h;
12887   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12888     return TRUE;
12889
12890   eh->elf.root.type = bfd_link_hash_undefined;
12891   return TRUE;
12892 }
12893
12894 void
12895 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12896 {
12897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12898
12899   if (htab != NULL)
12900     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12901 }
12902
12903 /* What to do when ld finds relocations against symbols defined in
12904    discarded sections.  */
12905
12906 static unsigned int
12907 ppc64_elf_action_discarded (asection *sec)
12908 {
12909   if (strcmp (".opd", sec->name) == 0)
12910     return 0;
12911
12912   if (strcmp (".toc", sec->name) == 0)
12913     return 0;
12914
12915   if (strcmp (".toc1", sec->name) == 0)
12916     return 0;
12917
12918   return _bfd_elf_default_action_discarded (sec);
12919 }
12920
12921 /* The RELOCATE_SECTION function is called by the ELF backend linker
12922    to handle the relocations for a section.
12923
12924    The relocs are always passed as Rela structures; if the section
12925    actually uses Rel structures, the r_addend field will always be
12926    zero.
12927
12928    This function is responsible for adjust the section contents as
12929    necessary, and (if using Rela relocs and generating a
12930    relocatable output file) adjusting the reloc addend as
12931    necessary.
12932
12933    This function does not have to worry about setting the reloc
12934    address or the reloc symbol index.
12935
12936    LOCAL_SYMS is a pointer to the swapped in local symbols.
12937
12938    LOCAL_SECTIONS is an array giving the section in the input file
12939    corresponding to the st_shndx field of each local symbol.
12940
12941    The global hash table entry for the global symbols can be found
12942    via elf_sym_hashes (input_bfd).
12943
12944    When generating relocatable output, this function must handle
12945    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12946    going to be the section symbol corresponding to the output
12947    section, which means that the addend must be adjusted
12948    accordingly.  */
12949
12950 static bfd_boolean
12951 ppc64_elf_relocate_section (bfd *output_bfd,
12952                             struct bfd_link_info *info,
12953                             bfd *input_bfd,
12954                             asection *input_section,
12955                             bfd_byte *contents,
12956                             Elf_Internal_Rela *relocs,
12957                             Elf_Internal_Sym *local_syms,
12958                             asection **local_sections)
12959 {
12960   struct ppc_link_hash_table *htab;
12961   Elf_Internal_Shdr *symtab_hdr;
12962   struct elf_link_hash_entry **sym_hashes;
12963   Elf_Internal_Rela *rel;
12964   Elf_Internal_Rela *relend;
12965   Elf_Internal_Rela outrel;
12966   bfd_byte *loc;
12967   struct got_entry **local_got_ents;
12968   bfd_vma TOCstart;
12969   bfd_boolean ret = TRUE;
12970   bfd_boolean is_opd;
12971   /* Assume 'at' branch hints.  */
12972   bfd_boolean is_isa_v2 = TRUE;
12973   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12974
12975   /* Initialize howto table if needed.  */
12976   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12977     ppc_howto_init ();
12978
12979   htab = ppc_hash_table (info);
12980   if (htab == NULL)
12981     return FALSE;
12982
12983   /* Don't relocate stub sections.  */
12984   if (input_section->owner == htab->params->stub_bfd)
12985     return TRUE;
12986
12987   BFD_ASSERT (is_ppc64_elf (input_bfd));
12988
12989   local_got_ents = elf_local_got_ents (input_bfd);
12990   TOCstart = elf_gp (output_bfd);
12991   symtab_hdr = &elf_symtab_hdr (input_bfd);
12992   sym_hashes = elf_sym_hashes (input_bfd);
12993   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12994
12995   rel = relocs;
12996   relend = relocs + input_section->reloc_count;
12997   for (; rel < relend; rel++)
12998     {
12999       enum elf_ppc64_reloc_type r_type;
13000       bfd_vma addend;
13001       bfd_reloc_status_type r;
13002       Elf_Internal_Sym *sym;
13003       asection *sec;
13004       struct elf_link_hash_entry *h_elf;
13005       struct ppc_link_hash_entry *h;
13006       struct ppc_link_hash_entry *fdh;
13007       const char *sym_name;
13008       unsigned long r_symndx, toc_symndx;
13009       bfd_vma toc_addend;
13010       unsigned char tls_mask, tls_gd, tls_type;
13011       unsigned char sym_type;
13012       bfd_vma relocation;
13013       bfd_boolean unresolved_reloc;
13014       bfd_boolean warned;
13015       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13016       unsigned int insn;
13017       unsigned int mask;
13018       struct ppc_stub_hash_entry *stub_entry;
13019       bfd_vma max_br_offset;
13020       bfd_vma from;
13021       const Elf_Internal_Rela orig_rel = *rel;
13022       reloc_howto_type *howto;
13023       struct reloc_howto_struct alt_howto;
13024
13025       r_type = ELF64_R_TYPE (rel->r_info);
13026       r_symndx = ELF64_R_SYM (rel->r_info);
13027
13028       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13029          symbol of the previous ADDR64 reloc.  The symbol gives us the
13030          proper TOC base to use.  */
13031       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13032           && rel != relocs
13033           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13034           && is_opd)
13035         r_symndx = ELF64_R_SYM (rel[-1].r_info);
13036
13037       sym = NULL;
13038       sec = NULL;
13039       h_elf = NULL;
13040       sym_name = NULL;
13041       unresolved_reloc = FALSE;
13042       warned = FALSE;
13043
13044       if (r_symndx < symtab_hdr->sh_info)
13045         {
13046           /* It's a local symbol.  */
13047           struct _opd_sec_data *opd;
13048
13049           sym = local_syms + r_symndx;
13050           sec = local_sections[r_symndx];
13051           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13052           sym_type = ELF64_ST_TYPE (sym->st_info);
13053           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13054           opd = get_opd_info (sec);
13055           if (opd != NULL && opd->adjust != NULL)
13056             {
13057               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13058               if (adjust == -1)
13059                 relocation = 0;
13060               else
13061                 {
13062                   /* If this is a relocation against the opd section sym
13063                      and we have edited .opd, adjust the reloc addend so
13064                      that ld -r and ld --emit-relocs output is correct.
13065                      If it is a reloc against some other .opd symbol,
13066                      then the symbol value will be adjusted later.  */
13067                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13068                     rel->r_addend += adjust;
13069                   else
13070                     relocation += adjust;
13071                 }
13072             }
13073         }
13074       else
13075         {
13076           bfd_boolean ignored;
13077
13078           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13079                                    r_symndx, symtab_hdr, sym_hashes,
13080                                    h_elf, sec, relocation,
13081                                    unresolved_reloc, warned, ignored);
13082           sym_name = h_elf->root.root.string;
13083           sym_type = h_elf->type;
13084           if (sec != NULL
13085               && sec->owner == output_bfd
13086               && strcmp (sec->name, ".opd") == 0)
13087             {
13088               /* This is a symbol defined in a linker script.  All
13089                  such are defined in output sections, even those
13090                  defined by simple assignment from a symbol defined in
13091                  an input section.  Transfer the symbol to an
13092                  appropriate input .opd section, so that a branch to
13093                  this symbol will be mapped to the location specified
13094                  by the opd entry.  */
13095               struct bfd_link_order *lo;
13096               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13097                 if (lo->type == bfd_indirect_link_order)
13098                   {
13099                     asection *isec = lo->u.indirect.section;
13100                     if (h_elf->root.u.def.value >= isec->output_offset
13101                         && h_elf->root.u.def.value < (isec->output_offset
13102                                                       + isec->size))
13103                       {
13104                         h_elf->root.u.def.value -= isec->output_offset;
13105                         h_elf->root.u.def.section = isec;
13106                         sec = isec;
13107                         break;
13108                       }
13109                   }
13110             }
13111         }
13112       h = (struct ppc_link_hash_entry *) h_elf;
13113
13114       if (sec != NULL && discarded_section (sec))
13115         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13116                                          rel, 1, relend,
13117                                          ppc64_elf_howto_table[r_type], 0,
13118                                          contents);
13119
13120       if (info->relocatable)
13121         continue;
13122
13123       if (h != NULL && &h->elf == htab->elf.hgot)
13124         {
13125           relocation = (TOCstart
13126                         + htab->stub_group[input_section->id].toc_off);
13127           sec = bfd_abs_section_ptr;
13128           unresolved_reloc = FALSE;
13129         }
13130
13131       /* TLS optimizations.  Replace instruction sequences and relocs
13132          based on information we collected in tls_optimize.  We edit
13133          RELOCS so that --emit-relocs will output something sensible
13134          for the final instruction stream.  */
13135       tls_mask = 0;
13136       tls_gd = 0;
13137       toc_symndx = 0;
13138       if (h != NULL)
13139         tls_mask = h->tls_mask;
13140       else if (local_got_ents != NULL)
13141         {
13142           struct plt_entry **local_plt = (struct plt_entry **)
13143             (local_got_ents + symtab_hdr->sh_info);
13144           unsigned char *lgot_masks = (unsigned char *)
13145             (local_plt + symtab_hdr->sh_info);
13146           tls_mask = lgot_masks[r_symndx];
13147         }
13148       if (tls_mask == 0
13149           && (r_type == R_PPC64_TLS
13150               || r_type == R_PPC64_TLSGD
13151               || r_type == R_PPC64_TLSLD))
13152         {
13153           /* Check for toc tls entries.  */
13154           unsigned char *toc_tls;
13155
13156           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13157                              &local_syms, rel, input_bfd))
13158             return FALSE;
13159
13160           if (toc_tls)
13161             tls_mask = *toc_tls;
13162         }
13163
13164       /* Check that tls relocs are used with tls syms, and non-tls
13165          relocs are used with non-tls syms.  */
13166       if (r_symndx != STN_UNDEF
13167           && r_type != R_PPC64_NONE
13168           && (h == NULL
13169               || h->elf.root.type == bfd_link_hash_defined
13170               || h->elf.root.type == bfd_link_hash_defweak)
13171           && (IS_PPC64_TLS_RELOC (r_type)
13172               != (sym_type == STT_TLS
13173                   || (sym_type == STT_SECTION
13174                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13175         {
13176           if (tls_mask != 0
13177               && (r_type == R_PPC64_TLS
13178                   || r_type == R_PPC64_TLSGD
13179                   || r_type == R_PPC64_TLSLD))
13180             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13181             ;
13182           else
13183             info->callbacks->einfo
13184               (!IS_PPC64_TLS_RELOC (r_type)
13185                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13186                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13187                input_bfd, input_section, rel->r_offset,
13188                ppc64_elf_howto_table[r_type]->name,
13189                sym_name);
13190         }
13191
13192       /* Ensure reloc mapping code below stays sane.  */
13193       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13194           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13195           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13196           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13197           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13198           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13199           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13200           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13201           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13202           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13203         abort ();
13204
13205       switch (r_type)
13206         {
13207         default:
13208           break;
13209
13210         case R_PPC64_LO_DS_OPT:
13211           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13212           if ((insn & (0x3f << 26)) != 58u << 26)
13213             abort ();
13214           insn += (14u << 26) - (58u << 26);
13215           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13216           r_type = R_PPC64_TOC16_LO;
13217           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13218           break;
13219
13220         case R_PPC64_TOC16:
13221         case R_PPC64_TOC16_LO:
13222         case R_PPC64_TOC16_DS:
13223         case R_PPC64_TOC16_LO_DS:
13224           {
13225             /* Check for toc tls entries.  */
13226             unsigned char *toc_tls;
13227             int retval;
13228
13229             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13230                                    &local_syms, rel, input_bfd);
13231             if (retval == 0)
13232               return FALSE;
13233
13234             if (toc_tls)
13235               {
13236                 tls_mask = *toc_tls;
13237                 if (r_type == R_PPC64_TOC16_DS
13238                     || r_type == R_PPC64_TOC16_LO_DS)
13239                   {
13240                     if (tls_mask != 0
13241                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13242                       goto toctprel;
13243                   }
13244                 else
13245                   {
13246                     /* If we found a GD reloc pair, then we might be
13247                        doing a GD->IE transition.  */
13248                     if (retval == 2)
13249                       {
13250                         tls_gd = TLS_TPRELGD;
13251                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13252                           goto tls_ldgd_opt;
13253                       }
13254                     else if (retval == 3)
13255                       {
13256                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13257                           goto tls_ldgd_opt;
13258                       }
13259                   }
13260               }
13261           }
13262           break;
13263
13264         case R_PPC64_GOT_TPREL16_HI:
13265         case R_PPC64_GOT_TPREL16_HA:
13266           if (tls_mask != 0
13267               && (tls_mask & TLS_TPREL) == 0)
13268             {
13269               rel->r_offset -= d_offset;
13270               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13271               r_type = R_PPC64_NONE;
13272               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13273             }
13274           break;
13275
13276         case R_PPC64_GOT_TPREL16_DS:
13277         case R_PPC64_GOT_TPREL16_LO_DS:
13278           if (tls_mask != 0
13279               && (tls_mask & TLS_TPREL) == 0)
13280             {
13281             toctprel:
13282               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13283               insn &= 31 << 21;
13284               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13285               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13286               r_type = R_PPC64_TPREL16_HA;
13287               if (toc_symndx != 0)
13288                 {
13289                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13290                   rel->r_addend = toc_addend;
13291                   /* We changed the symbol.  Start over in order to
13292                      get h, sym, sec etc. right.  */
13293                   rel--;
13294                   continue;
13295                 }
13296               else
13297                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13298             }
13299           break;
13300
13301         case R_PPC64_TLS:
13302           if (tls_mask != 0
13303               && (tls_mask & TLS_TPREL) == 0)
13304             {
13305               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13306               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13307               if (insn == 0)
13308                 abort ();
13309               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13310               /* Was PPC64_TLS which sits on insn boundary, now
13311                  PPC64_TPREL16_LO which is at low-order half-word.  */
13312               rel->r_offset += d_offset;
13313               r_type = R_PPC64_TPREL16_LO;
13314               if (toc_symndx != 0)
13315                 {
13316                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13317                   rel->r_addend = toc_addend;
13318                   /* We changed the symbol.  Start over in order to
13319                      get h, sym, sec etc. right.  */
13320                   rel--;
13321                   continue;
13322                 }
13323               else
13324                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13325             }
13326           break;
13327
13328         case R_PPC64_GOT_TLSGD16_HI:
13329         case R_PPC64_GOT_TLSGD16_HA:
13330           tls_gd = TLS_TPRELGD;
13331           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13332             goto tls_gdld_hi;
13333           break;
13334
13335         case R_PPC64_GOT_TLSLD16_HI:
13336         case R_PPC64_GOT_TLSLD16_HA:
13337           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13338             {
13339             tls_gdld_hi:
13340               if ((tls_mask & tls_gd) != 0)
13341                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13342                           + R_PPC64_GOT_TPREL16_DS);
13343               else
13344                 {
13345                   rel->r_offset -= d_offset;
13346                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13347                   r_type = R_PPC64_NONE;
13348                 }
13349               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13350             }
13351           break;
13352
13353         case R_PPC64_GOT_TLSGD16:
13354         case R_PPC64_GOT_TLSGD16_LO:
13355           tls_gd = TLS_TPRELGD;
13356           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13357             goto tls_ldgd_opt;
13358           break;
13359
13360         case R_PPC64_GOT_TLSLD16:
13361         case R_PPC64_GOT_TLSLD16_LO:
13362           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13363             {
13364               unsigned int insn1, insn2, insn3;
13365               bfd_vma offset;
13366
13367             tls_ldgd_opt:
13368               offset = (bfd_vma) -1;
13369               /* If not using the newer R_PPC64_TLSGD/LD to mark
13370                  __tls_get_addr calls, we must trust that the call
13371                  stays with its arg setup insns, ie. that the next
13372                  reloc is the __tls_get_addr call associated with
13373                  the current reloc.  Edit both insns.  */
13374               if (input_section->has_tls_get_addr_call
13375                   && rel + 1 < relend
13376                   && branch_reloc_hash_match (input_bfd, rel + 1,
13377                                               htab->tls_get_addr,
13378                                               htab->tls_get_addr_fd))
13379                 offset = rel[1].r_offset;
13380               if ((tls_mask & tls_gd) != 0)
13381                 {
13382                   /* IE */
13383                   insn1 = bfd_get_32 (output_bfd,
13384                                       contents + rel->r_offset - d_offset);
13385                   insn1 &= (1 << 26) - (1 << 2);
13386                   insn1 |= 58 << 26;    /* ld */
13387                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13388                   if (offset != (bfd_vma) -1)
13389                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13390                   if ((tls_mask & TLS_EXPLICIT) == 0)
13391                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13392                               + R_PPC64_GOT_TPREL16_DS);
13393                   else
13394                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13395                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13396                 }
13397               else
13398                 {
13399                   /* LE */
13400                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13401                   insn2 = 0x38630000;   /* addi 3,3,0 */
13402                   if (tls_gd == 0)
13403                     {
13404                       /* Was an LD reloc.  */
13405                       if (toc_symndx)
13406                         sec = local_sections[toc_symndx];
13407                       for (r_symndx = 0;
13408                            r_symndx < symtab_hdr->sh_info;
13409                            r_symndx++)
13410                         if (local_sections[r_symndx] == sec)
13411                           break;
13412                       if (r_symndx >= symtab_hdr->sh_info)
13413                         r_symndx = STN_UNDEF;
13414                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13415                       if (r_symndx != STN_UNDEF)
13416                         rel->r_addend -= (local_syms[r_symndx].st_value
13417                                           + sec->output_offset
13418                                           + sec->output_section->vma);
13419                     }
13420                   else if (toc_symndx != 0)
13421                     {
13422                       r_symndx = toc_symndx;
13423                       rel->r_addend = toc_addend;
13424                     }
13425                   r_type = R_PPC64_TPREL16_HA;
13426                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13427                   if (offset != (bfd_vma) -1)
13428                     {
13429                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13430                                                     R_PPC64_TPREL16_LO);
13431                       rel[1].r_offset = offset + d_offset;
13432                       rel[1].r_addend = rel->r_addend;
13433                     }
13434                 }
13435               bfd_put_32 (output_bfd, insn1,
13436                           contents + rel->r_offset - d_offset);
13437               if (offset != (bfd_vma) -1)
13438                 {
13439                   insn3 = bfd_get_32 (output_bfd,
13440                                       contents + offset + 4);
13441                   if (insn3 == NOP
13442                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13443                     {
13444                       rel[1].r_offset += 4;
13445                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13446                       insn2 = NOP;
13447                     }
13448                   bfd_put_32 (output_bfd, insn2, contents + offset);
13449                 }
13450               if ((tls_mask & tls_gd) == 0
13451                   && (tls_gd == 0 || toc_symndx != 0))
13452                 {
13453                   /* We changed the symbol.  Start over in order
13454                      to get h, sym, sec etc. right.  */
13455                   rel--;
13456                   continue;
13457                 }
13458             }
13459           break;
13460
13461         case R_PPC64_TLSGD:
13462           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13463             {
13464               unsigned int insn2, insn3;
13465               bfd_vma offset = rel->r_offset;
13466
13467               if ((tls_mask & TLS_TPRELGD) != 0)
13468                 {
13469                   /* IE */
13470                   r_type = R_PPC64_NONE;
13471                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13472                 }
13473               else
13474                 {
13475                   /* LE */
13476                   if (toc_symndx != 0)
13477                     {
13478                       r_symndx = toc_symndx;
13479                       rel->r_addend = toc_addend;
13480                     }
13481                   r_type = R_PPC64_TPREL16_LO;
13482                   rel->r_offset = offset + d_offset;
13483                   insn2 = 0x38630000;   /* addi 3,3,0 */
13484                 }
13485               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13486               /* Zap the reloc on the _tls_get_addr call too.  */
13487               BFD_ASSERT (offset == rel[1].r_offset);
13488               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13489               insn3 = bfd_get_32 (output_bfd,
13490                                   contents + offset + 4);
13491               if (insn3 == NOP
13492                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13493                 {
13494                   rel->r_offset += 4;
13495                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13496                   insn2 = NOP;
13497                 }
13498               bfd_put_32 (output_bfd, insn2, contents + offset);
13499               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13500                 {
13501                   rel--;
13502                   continue;
13503                 }
13504             }
13505           break;
13506
13507         case R_PPC64_TLSLD:
13508           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13509             {
13510               unsigned int insn2, insn3;
13511               bfd_vma offset = rel->r_offset;
13512
13513               if (toc_symndx)
13514                 sec = local_sections[toc_symndx];
13515               for (r_symndx = 0;
13516                    r_symndx < symtab_hdr->sh_info;
13517                    r_symndx++)
13518                 if (local_sections[r_symndx] == sec)
13519                   break;
13520               if (r_symndx >= symtab_hdr->sh_info)
13521                 r_symndx = STN_UNDEF;
13522               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13523               if (r_symndx != STN_UNDEF)
13524                 rel->r_addend -= (local_syms[r_symndx].st_value
13525                                   + sec->output_offset
13526                                   + sec->output_section->vma);
13527
13528               r_type = R_PPC64_TPREL16_LO;
13529               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13530               rel->r_offset = offset + d_offset;
13531               /* Zap the reloc on the _tls_get_addr call too.  */
13532               BFD_ASSERT (offset == rel[1].r_offset);
13533               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13534               insn2 = 0x38630000;       /* addi 3,3,0 */
13535               insn3 = bfd_get_32 (output_bfd,
13536                                   contents + offset + 4);
13537               if (insn3 == NOP
13538                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13539                 {
13540                   rel->r_offset += 4;
13541                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13542                   insn2 = NOP;
13543                 }
13544               bfd_put_32 (output_bfd, insn2, contents + offset);
13545               rel--;
13546               continue;
13547             }
13548           break;
13549
13550         case R_PPC64_DTPMOD64:
13551           if (rel + 1 < relend
13552               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13553               && rel[1].r_offset == rel->r_offset + 8)
13554             {
13555               if ((tls_mask & TLS_GD) == 0)
13556                 {
13557                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13558                   if ((tls_mask & TLS_TPRELGD) != 0)
13559                     r_type = R_PPC64_TPREL64;
13560                   else
13561                     {
13562                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13563                       r_type = R_PPC64_NONE;
13564                     }
13565                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13566                 }
13567             }
13568           else
13569             {
13570               if ((tls_mask & TLS_LD) == 0)
13571                 {
13572                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13573                   r_type = R_PPC64_NONE;
13574                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13575                 }
13576             }
13577           break;
13578
13579         case R_PPC64_TPREL64:
13580           if ((tls_mask & TLS_TPREL) == 0)
13581             {
13582               r_type = R_PPC64_NONE;
13583               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13584             }
13585           break;
13586
13587         case R_PPC64_REL16_HA:
13588           /* If we are generating a non-PIC executable, edit
13589              .  0:      addis 2,12,.TOC.-0b@ha
13590              .          addi 2,2,.TOC.-0b@l
13591              used by ELFv2 global entry points to set up r2, to
13592              .          lis 2,.TOC.@ha
13593              .          addi 2,2,.TOC.@l
13594              if .TOC. is in range.  */
13595           if (!info->shared
13596               && !info->traditional_format
13597               && h != NULL && &h->elf == htab->elf.hgot
13598               && rel + 1 < relend
13599               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13600               && rel[1].r_offset == rel->r_offset + 4
13601               && rel[1].r_addend == rel->r_addend + 4
13602               && relocation + 0x80008000 <= 0xffffffff)
13603             {
13604               unsigned int insn1, insn2;
13605               bfd_vma offset = rel->r_offset - d_offset;
13606               insn1 = bfd_get_32 (output_bfd, contents + offset);
13607               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13608               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13609                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13610                 {
13611                   r_type = R_PPC64_ADDR16_HA;
13612                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13613                   rel->r_addend -= d_offset;
13614                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13615                   rel[1].r_addend -= d_offset + 4;
13616                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13617                 }
13618             }
13619           break;
13620         }
13621
13622       /* Handle other relocations that tweak non-addend part of insn.  */
13623       insn = 0;
13624       max_br_offset = 1 << 25;
13625       addend = rel->r_addend;
13626       reloc_dest = DEST_NORMAL;
13627       switch (r_type)
13628         {
13629         default:
13630           break;
13631
13632         case R_PPC64_TOCSAVE:
13633           if (relocation + addend == (rel->r_offset
13634                                       + input_section->output_offset
13635                                       + input_section->output_section->vma)
13636               && tocsave_find (htab, NO_INSERT,
13637                                &local_syms, rel, input_bfd))
13638             {
13639               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13640               if (insn == NOP
13641                   || insn == CROR_151515 || insn == CROR_313131)
13642                 bfd_put_32 (input_bfd,
13643                             STD_R2_0R1 + STK_TOC (htab),
13644                             contents + rel->r_offset);
13645             }
13646           break;
13647
13648           /* Branch taken prediction relocations.  */
13649         case R_PPC64_ADDR14_BRTAKEN:
13650         case R_PPC64_REL14_BRTAKEN:
13651           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13652           /* Fall thru.  */
13653
13654           /* Branch not taken prediction relocations.  */
13655         case R_PPC64_ADDR14_BRNTAKEN:
13656         case R_PPC64_REL14_BRNTAKEN:
13657           insn |= bfd_get_32 (output_bfd,
13658                               contents + rel->r_offset) & ~(0x01 << 21);
13659           /* Fall thru.  */
13660
13661         case R_PPC64_REL14:
13662           max_br_offset = 1 << 15;
13663           /* Fall thru.  */
13664
13665         case R_PPC64_REL24:
13666           /* Calls to functions with a different TOC, such as calls to
13667              shared objects, need to alter the TOC pointer.  This is
13668              done using a linkage stub.  A REL24 branching to these
13669              linkage stubs needs to be followed by a nop, as the nop
13670              will be replaced with an instruction to restore the TOC
13671              base pointer.  */
13672           fdh = h;
13673           if (h != NULL
13674               && h->oh != NULL
13675               && h->oh->is_func_descriptor)
13676             fdh = ppc_follow_link (h->oh);
13677           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13678                                            htab);
13679           if (stub_entry != NULL
13680               && (stub_entry->stub_type == ppc_stub_plt_call
13681                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13682                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13683                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13684             {
13685               bfd_boolean can_plt_call = FALSE;
13686
13687               /* All of these stubs will modify r2, so there must be a
13688                  branch and link followed by a nop.  The nop is
13689                  replaced by an insn to restore r2.  */
13690               if (rel->r_offset + 8 <= input_section->size)
13691                 {
13692                   unsigned long br;
13693
13694                   br = bfd_get_32 (input_bfd,
13695                                    contents + rel->r_offset);
13696                   if ((br & 1) != 0)
13697                     {
13698                       unsigned long nop;
13699
13700                       nop = bfd_get_32 (input_bfd,
13701                                         contents + rel->r_offset + 4);
13702                       if (nop == NOP
13703                           || nop == CROR_151515 || nop == CROR_313131)
13704                         {
13705                           if (h != NULL
13706                               && (h == htab->tls_get_addr_fd
13707                                   || h == htab->tls_get_addr)
13708                               && !htab->params->no_tls_get_addr_opt)
13709                             {
13710                               /* Special stub used, leave nop alone.  */
13711                             }
13712                           else
13713                             bfd_put_32 (input_bfd,
13714                                         LD_R2_0R1 + STK_TOC (htab),
13715                                         contents + rel->r_offset + 4);
13716                           can_plt_call = TRUE;
13717                         }
13718                     }
13719                 }
13720
13721               if (!can_plt_call && h != NULL)
13722                 {
13723                   const char *name = h->elf.root.root.string;
13724
13725                   if (*name == '.')
13726                     ++name;
13727
13728                   if (strncmp (name, "__libc_start_main", 17) == 0
13729                       && (name[17] == 0 || name[17] == '@'))
13730                     {
13731                       /* Allow crt1 branch to go via a toc adjusting
13732                          stub.  Other calls that never return could do
13733                          the same, if we could detect such.  */
13734                       can_plt_call = TRUE;
13735                     }
13736                 }
13737
13738               if (!can_plt_call)
13739                 {
13740                   /* g++ as of 20130507 emits self-calls without a
13741                      following nop.  This is arguably wrong since we
13742                      have conflicting information.  On the one hand a
13743                      global symbol and on the other a local call
13744                      sequence, but don't error for this special case.
13745                      It isn't possible to cheaply verify we have
13746                      exactly such a call.  Allow all calls to the same
13747                      section.  */
13748                   asection *code_sec = sec;
13749
13750                   if (get_opd_info (sec) != NULL)
13751                     {
13752                       bfd_vma off = (relocation + addend
13753                                      - sec->output_section->vma
13754                                      - sec->output_offset);
13755
13756                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13757                     }
13758                   if (code_sec == input_section)
13759                     can_plt_call = TRUE;
13760                 }
13761
13762               if (!can_plt_call)
13763                 {
13764                   if (stub_entry->stub_type == ppc_stub_plt_call
13765                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13766                     info->callbacks->einfo
13767                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13768                          "recompile with -fPIC\n"),
13769                        input_bfd, input_section, rel->r_offset, sym_name);
13770                   else
13771                     info->callbacks->einfo
13772                       (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13773                          "(-mcmodel=small toc adjust stub)\n"),
13774                        input_bfd, input_section, rel->r_offset, sym_name);
13775
13776                   bfd_set_error (bfd_error_bad_value);
13777                   ret = FALSE;
13778                 }
13779
13780               if (can_plt_call
13781                   && (stub_entry->stub_type == ppc_stub_plt_call
13782                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13783                 unresolved_reloc = FALSE;
13784             }
13785
13786           if ((stub_entry == NULL
13787                || stub_entry->stub_type == ppc_stub_long_branch
13788                || stub_entry->stub_type == ppc_stub_plt_branch)
13789               && get_opd_info (sec) != NULL)
13790             {
13791               /* The branch destination is the value of the opd entry. */
13792               bfd_vma off = (relocation + addend
13793                              - sec->output_section->vma
13794                              - sec->output_offset);
13795               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13796               if (dest != (bfd_vma) -1)
13797                 {
13798                   relocation = dest;
13799                   addend = 0;
13800                   reloc_dest = DEST_OPD;
13801                 }
13802             }
13803
13804           /* If the branch is out of reach we ought to have a long
13805              branch stub.  */
13806           from = (rel->r_offset
13807                   + input_section->output_offset
13808                   + input_section->output_section->vma);
13809
13810           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13811                                                   ? fdh->elf.other
13812                                                   : sym->st_other);
13813
13814           if (stub_entry != NULL
13815               && (stub_entry->stub_type == ppc_stub_long_branch
13816                   || stub_entry->stub_type == ppc_stub_plt_branch)
13817               && (r_type == R_PPC64_ADDR14_BRTAKEN
13818                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13819                   || (relocation + addend - from + max_br_offset
13820                       < 2 * max_br_offset)))
13821             /* Don't use the stub if this branch is in range.  */
13822             stub_entry = NULL;
13823
13824           if (stub_entry != NULL)
13825             {
13826               /* Munge up the value and addend so that we call the stub
13827                  rather than the procedure directly.  */
13828               relocation = (stub_entry->stub_offset
13829                             + stub_entry->stub_sec->output_offset
13830                             + stub_entry->stub_sec->output_section->vma);
13831               addend = 0;
13832               reloc_dest = DEST_STUB;
13833
13834               if ((stub_entry->stub_type == ppc_stub_plt_call
13835                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13836                   && (ALWAYS_EMIT_R2SAVE
13837                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13838                   && rel + 1 < relend
13839                   && rel[1].r_offset == rel->r_offset + 4
13840                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13841                 relocation += 4;
13842             }
13843
13844           if (insn != 0)
13845             {
13846               if (is_isa_v2)
13847                 {
13848                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13849                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13850                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13851                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13852                     insn |= 0x02 << 21;
13853                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13854                     insn |= 0x08 << 21;
13855                   else
13856                     break;
13857                 }
13858               else
13859                 {
13860                   /* Invert 'y' bit if not the default.  */
13861                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13862                     insn ^= 0x01 << 21;
13863                 }
13864
13865               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13866             }
13867
13868           /* NOP out calls to undefined weak functions.
13869              We can thus call a weak function without first
13870              checking whether the function is defined.  */
13871           else if (h != NULL
13872                    && h->elf.root.type == bfd_link_hash_undefweak
13873                    && h->elf.dynindx == -1
13874                    && r_type == R_PPC64_REL24
13875                    && relocation == 0
13876                    && addend == 0)
13877             {
13878               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13879               continue;
13880             }
13881           break;
13882         }
13883
13884       /* Set `addend'.  */
13885       tls_type = 0;
13886       switch (r_type)
13887         {
13888         default:
13889           info->callbacks->einfo
13890             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13891              input_bfd, (int) r_type, sym_name);
13892
13893           bfd_set_error (bfd_error_bad_value);
13894           ret = FALSE;
13895           continue;
13896
13897         case R_PPC64_NONE:
13898         case R_PPC64_TLS:
13899         case R_PPC64_TLSGD:
13900         case R_PPC64_TLSLD:
13901         case R_PPC64_TOCSAVE:
13902         case R_PPC64_GNU_VTINHERIT:
13903         case R_PPC64_GNU_VTENTRY:
13904           continue;
13905
13906           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13907              address in the GOT as relocation value instead of the
13908              symbol's value itself.  Also, create a GOT entry for the
13909              symbol and put the symbol value there.  */
13910         case R_PPC64_GOT_TLSGD16:
13911         case R_PPC64_GOT_TLSGD16_LO:
13912         case R_PPC64_GOT_TLSGD16_HI:
13913         case R_PPC64_GOT_TLSGD16_HA:
13914           tls_type = TLS_TLS | TLS_GD;
13915           goto dogot;
13916
13917         case R_PPC64_GOT_TLSLD16:
13918         case R_PPC64_GOT_TLSLD16_LO:
13919         case R_PPC64_GOT_TLSLD16_HI:
13920         case R_PPC64_GOT_TLSLD16_HA:
13921           tls_type = TLS_TLS | TLS_LD;
13922           goto dogot;
13923
13924         case R_PPC64_GOT_TPREL16_DS:
13925         case R_PPC64_GOT_TPREL16_LO_DS:
13926         case R_PPC64_GOT_TPREL16_HI:
13927         case R_PPC64_GOT_TPREL16_HA:
13928           tls_type = TLS_TLS | TLS_TPREL;
13929           goto dogot;
13930
13931         case R_PPC64_GOT_DTPREL16_DS:
13932         case R_PPC64_GOT_DTPREL16_LO_DS:
13933         case R_PPC64_GOT_DTPREL16_HI:
13934         case R_PPC64_GOT_DTPREL16_HA:
13935           tls_type = TLS_TLS | TLS_DTPREL;
13936           goto dogot;
13937
13938         case R_PPC64_GOT16:
13939         case R_PPC64_GOT16_LO:
13940         case R_PPC64_GOT16_HI:
13941         case R_PPC64_GOT16_HA:
13942         case R_PPC64_GOT16_DS:
13943         case R_PPC64_GOT16_LO_DS:
13944         dogot:
13945           {
13946             /* Relocation is to the entry for this symbol in the global
13947                offset table.  */
13948             asection *got;
13949             bfd_vma *offp;
13950             bfd_vma off;
13951             unsigned long indx = 0;
13952             struct got_entry *ent;
13953
13954             if (tls_type == (TLS_TLS | TLS_LD)
13955                 && (h == NULL
13956                     || !h->elf.def_dynamic))
13957               ent = ppc64_tlsld_got (input_bfd);
13958             else
13959               {
13960
13961                 if (h != NULL)
13962                   {
13963                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13964                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13965                                                           &h->elf)
13966                         || (info->shared
13967                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13968                       /* This is actually a static link, or it is a
13969                          -Bsymbolic link and the symbol is defined
13970                          locally, or the symbol was forced to be local
13971                          because of a version file.  */
13972                       ;
13973                     else
13974                       {
13975                         BFD_ASSERT (h->elf.dynindx != -1);
13976                         indx = h->elf.dynindx;
13977                         unresolved_reloc = FALSE;
13978                       }
13979                     ent = h->elf.got.glist;
13980                   }
13981                 else
13982                   {
13983                     if (local_got_ents == NULL)
13984                       abort ();
13985                     ent = local_got_ents[r_symndx];
13986                   }
13987
13988                 for (; ent != NULL; ent = ent->next)
13989                   if (ent->addend == orig_rel.r_addend
13990                       && ent->owner == input_bfd
13991                       && ent->tls_type == tls_type)
13992                     break;
13993               }
13994
13995             if (ent == NULL)
13996               abort ();
13997             if (ent->is_indirect)
13998               ent = ent->got.ent;
13999             offp = &ent->got.offset;
14000             got = ppc64_elf_tdata (ent->owner)->got;
14001             if (got == NULL)
14002               abort ();
14003
14004             /* The offset must always be a multiple of 8.  We use the
14005                least significant bit to record whether we have already
14006                processed this entry.  */
14007             off = *offp;
14008             if ((off & 1) != 0)
14009               off &= ~1;
14010             else
14011               {
14012                 /* Generate relocs for the dynamic linker, except in
14013                    the case of TLSLD where we'll use one entry per
14014                    module.  */
14015                 asection *relgot;
14016                 bfd_boolean ifunc;
14017
14018                 *offp = off | 1;
14019                 relgot = NULL;
14020                 ifunc = (h != NULL
14021                          ? h->elf.type == STT_GNU_IFUNC
14022                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14023                 if (ifunc)
14024                   relgot = htab->elf.irelplt;
14025                 else if ((info->shared || indx != 0)
14026                          && (h == NULL
14027                              || (tls_type == (TLS_TLS | TLS_LD)
14028                                  && !h->elf.def_dynamic)
14029                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14030                              || h->elf.root.type != bfd_link_hash_undefweak))
14031                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
14032                 if (relgot != NULL)
14033                   {
14034                     outrel.r_offset = (got->output_section->vma
14035                                        + got->output_offset
14036                                        + off);
14037                     outrel.r_addend = addend;
14038                     if (tls_type & (TLS_LD | TLS_GD))
14039                       {
14040                         outrel.r_addend = 0;
14041                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14042                         if (tls_type == (TLS_TLS | TLS_GD))
14043                           {
14044                             loc = relgot->contents;
14045                             loc += (relgot->reloc_count++
14046                                     * sizeof (Elf64_External_Rela));
14047                             bfd_elf64_swap_reloca_out (output_bfd,
14048                                                        &outrel, loc);
14049                             outrel.r_offset += 8;
14050                             outrel.r_addend = addend;
14051                             outrel.r_info
14052                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14053                           }
14054                       }
14055                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
14056                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14057                     else if (tls_type == (TLS_TLS | TLS_TPREL))
14058                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14059                     else if (indx != 0)
14060                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14061                     else
14062                       {
14063                         if (ifunc)
14064                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14065                         else
14066                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14067
14068                         /* Write the .got section contents for the sake
14069                            of prelink.  */
14070                         loc = got->contents + off;
14071                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14072                                     loc);
14073                       }
14074
14075                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14076                       {
14077                         outrel.r_addend += relocation;
14078                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14079                           outrel.r_addend -= htab->elf.tls_sec->vma;
14080                       }
14081                     loc = relgot->contents;
14082                     loc += (relgot->reloc_count++
14083                             * sizeof (Elf64_External_Rela));
14084                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14085                   }
14086
14087                 /* Init the .got section contents here if we're not
14088                    emitting a reloc.  */
14089                 else
14090                   {
14091                     relocation += addend;
14092                     if (tls_type == (TLS_TLS | TLS_LD))
14093                       relocation = 1;
14094                     else if (tls_type != 0)
14095                       {
14096                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14097                         if (tls_type == (TLS_TLS | TLS_TPREL))
14098                           relocation += DTP_OFFSET - TP_OFFSET;
14099
14100                         if (tls_type == (TLS_TLS | TLS_GD))
14101                           {
14102                             bfd_put_64 (output_bfd, relocation,
14103                                         got->contents + off + 8);
14104                             relocation = 1;
14105                           }
14106                       }
14107
14108                     bfd_put_64 (output_bfd, relocation,
14109                                 got->contents + off);
14110                   }
14111               }
14112
14113             if (off >= (bfd_vma) -2)
14114               abort ();
14115
14116             relocation = got->output_section->vma + got->output_offset + off;
14117             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14118           }
14119           break;
14120
14121         case R_PPC64_PLT16_HA:
14122         case R_PPC64_PLT16_HI:
14123         case R_PPC64_PLT16_LO:
14124         case R_PPC64_PLT32:
14125         case R_PPC64_PLT64:
14126           /* Relocation is to the entry for this symbol in the
14127              procedure linkage table.  */
14128
14129           /* Resolve a PLT reloc against a local symbol directly,
14130              without using the procedure linkage table.  */
14131           if (h == NULL)
14132             break;
14133
14134           /* It's possible that we didn't make a PLT entry for this
14135              symbol.  This happens when statically linking PIC code,
14136              or when using -Bsymbolic.  Go find a match if there is a
14137              PLT entry.  */
14138           if (htab->elf.splt != NULL)
14139             {
14140               struct plt_entry *ent;
14141               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14142                 if (ent->plt.offset != (bfd_vma) -1
14143                     && ent->addend == orig_rel.r_addend)
14144                   {
14145                     relocation = (htab->elf.splt->output_section->vma
14146                                   + htab->elf.splt->output_offset
14147                                   + ent->plt.offset);
14148                     unresolved_reloc = FALSE;
14149                     break;
14150                   }
14151             }
14152           break;
14153
14154         case R_PPC64_TOC:
14155           /* Relocation value is TOC base.  */
14156           relocation = TOCstart;
14157           if (r_symndx == STN_UNDEF)
14158             relocation += htab->stub_group[input_section->id].toc_off;
14159           else if (unresolved_reloc)
14160             ;
14161           else if (sec != NULL && sec->id <= htab->top_id)
14162             relocation += htab->stub_group[sec->id].toc_off;
14163           else
14164             unresolved_reloc = TRUE;
14165           goto dodyn;
14166
14167           /* TOC16 relocs.  We want the offset relative to the TOC base,
14168              which is the address of the start of the TOC plus 0x8000.
14169              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14170              in this order.  */
14171         case R_PPC64_TOC16:
14172         case R_PPC64_TOC16_LO:
14173         case R_PPC64_TOC16_HI:
14174         case R_PPC64_TOC16_DS:
14175         case R_PPC64_TOC16_LO_DS:
14176         case R_PPC64_TOC16_HA:
14177           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14178           break;
14179
14180           /* Relocate against the beginning of the section.  */
14181         case R_PPC64_SECTOFF:
14182         case R_PPC64_SECTOFF_LO:
14183         case R_PPC64_SECTOFF_HI:
14184         case R_PPC64_SECTOFF_DS:
14185         case R_PPC64_SECTOFF_LO_DS:
14186         case R_PPC64_SECTOFF_HA:
14187           if (sec != NULL)
14188             addend -= sec->output_section->vma;
14189           break;
14190
14191         case R_PPC64_REL16:
14192         case R_PPC64_REL16_LO:
14193         case R_PPC64_REL16_HI:
14194         case R_PPC64_REL16_HA:
14195           break;
14196
14197         case R_PPC64_REL14:
14198         case R_PPC64_REL14_BRNTAKEN:
14199         case R_PPC64_REL14_BRTAKEN:
14200         case R_PPC64_REL24:
14201           break;
14202
14203         case R_PPC64_TPREL16:
14204         case R_PPC64_TPREL16_LO:
14205         case R_PPC64_TPREL16_HI:
14206         case R_PPC64_TPREL16_HA:
14207         case R_PPC64_TPREL16_DS:
14208         case R_PPC64_TPREL16_LO_DS:
14209         case R_PPC64_TPREL16_HIGH:
14210         case R_PPC64_TPREL16_HIGHA:
14211         case R_PPC64_TPREL16_HIGHER:
14212         case R_PPC64_TPREL16_HIGHERA:
14213         case R_PPC64_TPREL16_HIGHEST:
14214         case R_PPC64_TPREL16_HIGHESTA:
14215           if (h != NULL
14216               && h->elf.root.type == bfd_link_hash_undefweak
14217               && h->elf.dynindx == -1)
14218             {
14219               /* Make this relocation against an undefined weak symbol
14220                  resolve to zero.  This is really just a tweak, since
14221                  code using weak externs ought to check that they are
14222                  defined before using them.  */
14223               bfd_byte *p = contents + rel->r_offset - d_offset;
14224
14225               insn = bfd_get_32 (output_bfd, p);
14226               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14227               if (insn != 0)
14228                 bfd_put_32 (output_bfd, insn, p);
14229               break;
14230             }
14231           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14232           if (info->shared)
14233             /* The TPREL16 relocs shouldn't really be used in shared
14234                libs as they will result in DT_TEXTREL being set, but
14235                support them anyway.  */
14236             goto dodyn;
14237           break;
14238
14239         case R_PPC64_DTPREL16:
14240         case R_PPC64_DTPREL16_LO:
14241         case R_PPC64_DTPREL16_HI:
14242         case R_PPC64_DTPREL16_HA:
14243         case R_PPC64_DTPREL16_DS:
14244         case R_PPC64_DTPREL16_LO_DS:
14245         case R_PPC64_DTPREL16_HIGH:
14246         case R_PPC64_DTPREL16_HIGHA:
14247         case R_PPC64_DTPREL16_HIGHER:
14248         case R_PPC64_DTPREL16_HIGHERA:
14249         case R_PPC64_DTPREL16_HIGHEST:
14250         case R_PPC64_DTPREL16_HIGHESTA:
14251           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14252           break;
14253
14254         case R_PPC64_ADDR64_LOCAL:
14255           addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14256                                               ? h->elf.other
14257                                               : sym->st_other);
14258           break;
14259
14260         case R_PPC64_DTPMOD64:
14261           relocation = 1;
14262           addend = 0;
14263           goto dodyn;
14264
14265         case R_PPC64_TPREL64:
14266           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14267           goto dodyn;
14268
14269         case R_PPC64_DTPREL64:
14270           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14271           /* Fall thru */
14272
14273           /* Relocations that may need to be propagated if this is a
14274              dynamic object.  */
14275         case R_PPC64_REL30:
14276         case R_PPC64_REL32:
14277         case R_PPC64_REL64:
14278         case R_PPC64_ADDR14:
14279         case R_PPC64_ADDR14_BRNTAKEN:
14280         case R_PPC64_ADDR14_BRTAKEN:
14281         case R_PPC64_ADDR16:
14282         case R_PPC64_ADDR16_DS:
14283         case R_PPC64_ADDR16_HA:
14284         case R_PPC64_ADDR16_HI:
14285         case R_PPC64_ADDR16_HIGH:
14286         case R_PPC64_ADDR16_HIGHA:
14287         case R_PPC64_ADDR16_HIGHER:
14288         case R_PPC64_ADDR16_HIGHERA:
14289         case R_PPC64_ADDR16_HIGHEST:
14290         case R_PPC64_ADDR16_HIGHESTA:
14291         case R_PPC64_ADDR16_LO:
14292         case R_PPC64_ADDR16_LO_DS:
14293         case R_PPC64_ADDR24:
14294         case R_PPC64_ADDR32:
14295         case R_PPC64_ADDR64:
14296         case R_PPC64_UADDR16:
14297         case R_PPC64_UADDR32:
14298         case R_PPC64_UADDR64:
14299         dodyn:
14300           if ((input_section->flags & SEC_ALLOC) == 0)
14301             break;
14302
14303           if (NO_OPD_RELOCS && is_opd)
14304             break;
14305
14306           if ((info->shared
14307                && (h == NULL
14308                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14309                    || h->elf.root.type != bfd_link_hash_undefweak)
14310                && (must_be_dyn_reloc (info, r_type)
14311                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14312               || (ELIMINATE_COPY_RELOCS
14313                   && !info->shared
14314                   && h != NULL
14315                   && h->elf.dynindx != -1
14316                   && !h->elf.non_got_ref
14317                   && !h->elf.def_regular)
14318               || (!info->shared
14319                   && (h != NULL
14320                       ? h->elf.type == STT_GNU_IFUNC
14321                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14322             {
14323               bfd_boolean skip, relocate;
14324               asection *sreloc;
14325               bfd_vma out_off;
14326
14327               /* When generating a dynamic object, these relocations
14328                  are copied into the output file to be resolved at run
14329                  time.  */
14330
14331               skip = FALSE;
14332               relocate = FALSE;
14333
14334               out_off = _bfd_elf_section_offset (output_bfd, info,
14335                                                  input_section, rel->r_offset);
14336               if (out_off == (bfd_vma) -1)
14337                 skip = TRUE;
14338               else if (out_off == (bfd_vma) -2)
14339                 skip = TRUE, relocate = TRUE;
14340               out_off += (input_section->output_section->vma
14341                           + input_section->output_offset);
14342               outrel.r_offset = out_off;
14343               outrel.r_addend = rel->r_addend;
14344
14345               /* Optimize unaligned reloc use.  */
14346               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14347                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14348                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14349               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14350                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14351                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14352               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14353                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14354                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14355
14356               if (skip)
14357                 memset (&outrel, 0, sizeof outrel);
14358               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14359                        && !is_opd
14360                        && r_type != R_PPC64_TOC)
14361                 {
14362                   BFD_ASSERT (h->elf.dynindx != -1);
14363                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14364                 }
14365               else
14366                 {
14367                   /* This symbol is local, or marked to become local,
14368                      or this is an opd section reloc which must point
14369                      at a local function.  */
14370                   outrel.r_addend += relocation;
14371                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14372                     {
14373                       if (is_opd && h != NULL)
14374                         {
14375                           /* Lie about opd entries.  This case occurs
14376                              when building shared libraries and we
14377                              reference a function in another shared
14378                              lib.  The same thing happens for a weak
14379                              definition in an application that's
14380                              overridden by a strong definition in a
14381                              shared lib.  (I believe this is a generic
14382                              bug in binutils handling of weak syms.)
14383                              In these cases we won't use the opd
14384                              entry in this lib.  */
14385                           unresolved_reloc = FALSE;
14386                         }
14387                       if (!is_opd
14388                           && r_type == R_PPC64_ADDR64
14389                           && (h != NULL
14390                               ? h->elf.type == STT_GNU_IFUNC
14391                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14392                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14393                       else
14394                         {
14395                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14396
14397                           /* We need to relocate .opd contents for ld.so.
14398                              Prelink also wants simple and consistent rules
14399                              for relocs.  This make all RELATIVE relocs have
14400                              *r_offset equal to r_addend.  */
14401                           relocate = TRUE;
14402                         }
14403                     }
14404                   else
14405                     {
14406                       long indx = 0;
14407
14408                       if (h != NULL
14409                           ? h->elf.type == STT_GNU_IFUNC
14410                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14411                         {
14412                           info->callbacks->einfo
14413                             (_("%P: %H: %s for indirect "
14414                                "function `%T' unsupported\n"),
14415                              input_bfd, input_section, rel->r_offset,
14416                              ppc64_elf_howto_table[r_type]->name,
14417                              sym_name);
14418                           ret = FALSE;
14419                         }
14420                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14421                         ;
14422                       else if (sec == NULL || sec->owner == NULL)
14423                         {
14424                           bfd_set_error (bfd_error_bad_value);
14425                           return FALSE;
14426                         }
14427                       else
14428                         {
14429                           asection *osec;
14430
14431                           osec = sec->output_section;
14432                           indx = elf_section_data (osec)->dynindx;
14433
14434                           if (indx == 0)
14435                             {
14436                               if ((osec->flags & SEC_READONLY) == 0
14437                                   && htab->elf.data_index_section != NULL)
14438                                 osec = htab->elf.data_index_section;
14439                               else
14440                                 osec = htab->elf.text_index_section;
14441                               indx = elf_section_data (osec)->dynindx;
14442                             }
14443                           BFD_ASSERT (indx != 0);
14444
14445                           /* We are turning this relocation into one
14446                              against a section symbol, so subtract out
14447                              the output section's address but not the
14448                              offset of the input section in the output
14449                              section.  */
14450                           outrel.r_addend -= osec->vma;
14451                         }
14452
14453                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14454                     }
14455                 }
14456
14457               sreloc = elf_section_data (input_section)->sreloc;
14458               if (h != NULL
14459                   ? h->elf.type == STT_GNU_IFUNC
14460                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14461                 sreloc = htab->elf.irelplt;
14462               if (sreloc == NULL)
14463                 abort ();
14464
14465               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14466                   >= sreloc->size)
14467                 abort ();
14468               loc = sreloc->contents;
14469               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14470               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14471
14472               /* If this reloc is against an external symbol, it will
14473                  be computed at runtime, so there's no need to do
14474                  anything now.  However, for the sake of prelink ensure
14475                  that the section contents are a known value.  */
14476               if (! relocate)
14477                 {
14478                   unresolved_reloc = FALSE;
14479                   /* The value chosen here is quite arbitrary as ld.so
14480                      ignores section contents except for the special
14481                      case of .opd where the contents might be accessed
14482                      before relocation.  Choose zero, as that won't
14483                      cause reloc overflow.  */
14484                   relocation = 0;
14485                   addend = 0;
14486                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14487                      to improve backward compatibility with older
14488                      versions of ld.  */
14489                   if (r_type == R_PPC64_ADDR64)
14490                     addend = outrel.r_addend;
14491                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14492                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14493                     addend = (input_section->output_section->vma
14494                               + input_section->output_offset
14495                               + rel->r_offset);
14496                 }
14497             }
14498           break;
14499
14500         case R_PPC64_COPY:
14501         case R_PPC64_GLOB_DAT:
14502         case R_PPC64_JMP_SLOT:
14503         case R_PPC64_JMP_IREL:
14504         case R_PPC64_RELATIVE:
14505           /* We shouldn't ever see these dynamic relocs in relocatable
14506              files.  */
14507           /* Fall through.  */
14508
14509         case R_PPC64_PLTGOT16:
14510         case R_PPC64_PLTGOT16_DS:
14511         case R_PPC64_PLTGOT16_HA:
14512         case R_PPC64_PLTGOT16_HI:
14513         case R_PPC64_PLTGOT16_LO:
14514         case R_PPC64_PLTGOT16_LO_DS:
14515         case R_PPC64_PLTREL32:
14516         case R_PPC64_PLTREL64:
14517           /* These ones haven't been implemented yet.  */
14518
14519           info->callbacks->einfo
14520             (_("%P: %B: %s is not supported for `%T'\n"),
14521              input_bfd,
14522              ppc64_elf_howto_table[r_type]->name, sym_name);
14523
14524           bfd_set_error (bfd_error_invalid_operation);
14525           ret = FALSE;
14526           continue;
14527         }
14528
14529       /* Multi-instruction sequences that access the TOC can be
14530          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14531          to             nop;           addi rb,r2,x;  */
14532       switch (r_type)
14533         {
14534         default:
14535           break;
14536
14537         case R_PPC64_GOT_TLSLD16_HI:
14538         case R_PPC64_GOT_TLSGD16_HI:
14539         case R_PPC64_GOT_TPREL16_HI:
14540         case R_PPC64_GOT_DTPREL16_HI:
14541         case R_PPC64_GOT16_HI:
14542         case R_PPC64_TOC16_HI:
14543           /* These relocs would only be useful if building up an
14544              offset to later add to r2, perhaps in an indexed
14545              addressing mode instruction.  Don't try to optimize.
14546              Unfortunately, the possibility of someone building up an
14547              offset like this or even with the HA relocs, means that
14548              we need to check the high insn when optimizing the low
14549              insn.  */
14550           break;
14551
14552         case R_PPC64_GOT_TLSLD16_HA:
14553         case R_PPC64_GOT_TLSGD16_HA:
14554         case R_PPC64_GOT_TPREL16_HA:
14555         case R_PPC64_GOT_DTPREL16_HA:
14556         case R_PPC64_GOT16_HA:
14557         case R_PPC64_TOC16_HA:
14558           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14559               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14560             {
14561               bfd_byte *p = contents + (rel->r_offset & ~3);
14562               bfd_put_32 (input_bfd, NOP, p);
14563             }
14564           break;
14565
14566         case R_PPC64_GOT_TLSLD16_LO:
14567         case R_PPC64_GOT_TLSGD16_LO:
14568         case R_PPC64_GOT_TPREL16_LO_DS:
14569         case R_PPC64_GOT_DTPREL16_LO_DS:
14570         case R_PPC64_GOT16_LO:
14571         case R_PPC64_GOT16_LO_DS:
14572         case R_PPC64_TOC16_LO:
14573         case R_PPC64_TOC16_LO_DS:
14574           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14575               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14576             {
14577               bfd_byte *p = contents + (rel->r_offset & ~3);
14578               insn = bfd_get_32 (input_bfd, p);
14579               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14580                 {
14581                   /* Transform addic to addi when we change reg.  */
14582                   insn &= ~((0x3f << 26) | (0x1f << 16));
14583                   insn |= (14u << 26) | (2 << 16);
14584                 }
14585               else
14586                 {
14587                   insn &= ~(0x1f << 16);
14588                   insn |= 2 << 16;
14589                 }
14590               bfd_put_32 (input_bfd, insn, p);
14591             }
14592           break;
14593         }
14594
14595       /* Do any further special processing.  */
14596       howto = ppc64_elf_howto_table[(int) r_type];
14597       switch (r_type)
14598         {
14599         default:
14600           break;
14601
14602         case R_PPC64_REL16_HA:
14603         case R_PPC64_ADDR16_HA:
14604         case R_PPC64_ADDR16_HIGHA:
14605         case R_PPC64_ADDR16_HIGHERA:
14606         case R_PPC64_ADDR16_HIGHESTA:
14607         case R_PPC64_TOC16_HA:
14608         case R_PPC64_SECTOFF_HA:
14609         case R_PPC64_TPREL16_HA:
14610         case R_PPC64_TPREL16_HIGHA:
14611         case R_PPC64_TPREL16_HIGHERA:
14612         case R_PPC64_TPREL16_HIGHESTA:
14613         case R_PPC64_DTPREL16_HA:
14614         case R_PPC64_DTPREL16_HIGHA:
14615         case R_PPC64_DTPREL16_HIGHERA:
14616         case R_PPC64_DTPREL16_HIGHESTA:
14617           /* It's just possible that this symbol is a weak symbol
14618              that's not actually defined anywhere. In that case,
14619              'sec' would be NULL, and we should leave the symbol
14620              alone (it will be set to zero elsewhere in the link).  */
14621           if (sec == NULL)
14622             break;
14623           /* Fall thru */
14624
14625         case R_PPC64_GOT16_HA:
14626         case R_PPC64_PLTGOT16_HA:
14627         case R_PPC64_PLT16_HA:
14628         case R_PPC64_GOT_TLSGD16_HA:
14629         case R_PPC64_GOT_TLSLD16_HA:
14630         case R_PPC64_GOT_TPREL16_HA:
14631         case R_PPC64_GOT_DTPREL16_HA:
14632           /* Add 0x10000 if sign bit in 0:15 is set.
14633              Bits 0:15 are not used.  */
14634           addend += 0x8000;
14635           break;
14636
14637         case R_PPC64_ADDR16_DS:
14638         case R_PPC64_ADDR16_LO_DS:
14639         case R_PPC64_GOT16_DS:
14640         case R_PPC64_GOT16_LO_DS:
14641         case R_PPC64_PLT16_LO_DS:
14642         case R_PPC64_SECTOFF_DS:
14643         case R_PPC64_SECTOFF_LO_DS:
14644         case R_PPC64_TOC16_DS:
14645         case R_PPC64_TOC16_LO_DS:
14646         case R_PPC64_PLTGOT16_DS:
14647         case R_PPC64_PLTGOT16_LO_DS:
14648         case R_PPC64_GOT_TPREL16_DS:
14649         case R_PPC64_GOT_TPREL16_LO_DS:
14650         case R_PPC64_GOT_DTPREL16_DS:
14651         case R_PPC64_GOT_DTPREL16_LO_DS:
14652         case R_PPC64_TPREL16_DS:
14653         case R_PPC64_TPREL16_LO_DS:
14654         case R_PPC64_DTPREL16_DS:
14655         case R_PPC64_DTPREL16_LO_DS:
14656           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14657           mask = 3;
14658           /* If this reloc is against an lq insn, then the value must be
14659              a multiple of 16.  This is somewhat of a hack, but the
14660              "correct" way to do this by defining _DQ forms of all the
14661              _DS relocs bloats all reloc switches in this file.  It
14662              doesn't seem to make much sense to use any of these relocs
14663              in data, so testing the insn should be safe.  */
14664           if ((insn & (0x3f << 26)) == (56u << 26))
14665             mask = 15;
14666           if (((relocation + addend) & mask) != 0)
14667             {
14668               info->callbacks->einfo
14669                 (_("%P: %H: error: %s not a multiple of %u\n"),
14670                  input_bfd, input_section, rel->r_offset,
14671                  howto->name,
14672                  mask + 1);
14673               bfd_set_error (bfd_error_bad_value);
14674               ret = FALSE;
14675               continue;
14676             }
14677           break;
14678         }
14679
14680       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14681          because such sections are not SEC_ALLOC and thus ld.so will
14682          not process them.  */
14683       if (unresolved_reloc
14684           && !((input_section->flags & SEC_DEBUGGING) != 0
14685                && h->elf.def_dynamic)
14686           && _bfd_elf_section_offset (output_bfd, info, input_section,
14687                                       rel->r_offset) != (bfd_vma) -1)
14688         {
14689           info->callbacks->einfo
14690             (_("%P: %H: unresolvable %s against `%T'\n"),
14691              input_bfd, input_section, rel->r_offset,
14692              howto->name,
14693              h->elf.root.root.string);
14694           ret = FALSE;
14695         }
14696
14697       /* 16-bit fields in insns mostly have signed values, but a
14698          few insns have 16-bit unsigned values.  Really, we should
14699          have different reloc types.  */
14700       if (howto->complain_on_overflow != complain_overflow_dont
14701           && howto->dst_mask == 0xffff
14702           && (input_section->flags & SEC_CODE) != 0)
14703         {
14704           enum complain_overflow complain = complain_overflow_signed;
14705
14706           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14707           if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14708             complain = complain_overflow_bitfield;
14709           else if (howto->rightshift == 0
14710                    ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14711                       || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14712                       || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14713                    : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14714                       || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14715                       || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14716             complain = complain_overflow_unsigned;
14717           if (howto->complain_on_overflow != complain)
14718             {
14719               alt_howto = *howto;
14720               alt_howto.complain_on_overflow = complain;
14721               howto = &alt_howto;
14722             }
14723         }
14724
14725       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14726                                     rel->r_offset, relocation, addend);
14727
14728       if (r != bfd_reloc_ok)
14729         {
14730           char *more_info = NULL;
14731           const char *reloc_name = howto->name;
14732
14733           if (reloc_dest != DEST_NORMAL)
14734             {
14735               more_info = bfd_malloc (strlen (reloc_name) + 8);
14736               if (more_info != NULL)
14737                 {
14738                   strcpy (more_info, reloc_name);
14739                   strcat (more_info, (reloc_dest == DEST_OPD
14740                                       ? " (OPD)" : " (stub)"));
14741                   reloc_name = more_info;
14742                 }
14743             }
14744
14745           if (r == bfd_reloc_overflow)
14746             {
14747               if (warned)
14748                 continue;
14749               if (h != NULL
14750                   && h->elf.root.type == bfd_link_hash_undefweak
14751                   && howto->pc_relative)
14752                 {
14753                   /* Assume this is a call protected by other code that
14754                      detects the symbol is undefined.  If this is the case,
14755                      we can safely ignore the overflow.  If not, the
14756                      program is hosed anyway, and a little warning isn't
14757                      going to help.  */
14758
14759                   continue;
14760                 }
14761
14762               if (!((*info->callbacks->reloc_overflow)
14763                     (info, &h->elf.root, sym_name,
14764                      reloc_name, orig_rel.r_addend,
14765                      input_bfd, input_section, rel->r_offset)))
14766                 return FALSE;
14767             }
14768           else
14769             {
14770               info->callbacks->einfo
14771                 (_("%P: %H: %s against `%T': error %d\n"),
14772                  input_bfd, input_section, rel->r_offset,
14773                  reloc_name, sym_name, (int) r);
14774               ret = FALSE;
14775             }
14776           if (more_info != NULL)
14777             free (more_info);
14778         }
14779     }
14780
14781   /* If we're emitting relocations, then shortly after this function
14782      returns, reloc offsets and addends for this section will be
14783      adjusted.  Worse, reloc symbol indices will be for the output
14784      file rather than the input.  Save a copy of the relocs for
14785      opd_entry_value.  */
14786   if (is_opd && (info->emitrelocations || info->relocatable))
14787     {
14788       bfd_size_type amt;
14789       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14790       rel = bfd_alloc (input_bfd, amt);
14791       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14792       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14793       if (rel == NULL)
14794         return FALSE;
14795       memcpy (rel, relocs, amt);
14796     }
14797   return ret;
14798 }
14799
14800 /* Adjust the value of any local symbols in opd sections.  */
14801
14802 static int
14803 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14804                               const char *name ATTRIBUTE_UNUSED,
14805                               Elf_Internal_Sym *elfsym,
14806                               asection *input_sec,
14807                               struct elf_link_hash_entry *h)
14808 {
14809   struct _opd_sec_data *opd;
14810   long adjust;
14811   bfd_vma value;
14812
14813   if (h != NULL)
14814     return 1;
14815
14816   opd = get_opd_info (input_sec);
14817   if (opd == NULL || opd->adjust == NULL)
14818     return 1;
14819
14820   value = elfsym->st_value - input_sec->output_offset;
14821   if (!info->relocatable)
14822     value -= input_sec->output_section->vma;
14823
14824   adjust = opd->adjust[value / 8];
14825   if (adjust == -1)
14826     return 2;
14827
14828   elfsym->st_value += adjust;
14829   return 1;
14830 }
14831
14832 /* Finish up dynamic symbol handling.  We set the contents of various
14833    dynamic sections here.  */
14834
14835 static bfd_boolean
14836 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14837                                  struct bfd_link_info *info,
14838                                  struct elf_link_hash_entry *h,
14839                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14840 {
14841   struct ppc_link_hash_table *htab;
14842   struct plt_entry *ent;
14843   Elf_Internal_Rela rela;
14844   bfd_byte *loc;
14845
14846   htab = ppc_hash_table (info);
14847   if (htab == NULL)
14848     return FALSE;
14849
14850   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14851     if (ent->plt.offset != (bfd_vma) -1)
14852       {
14853         /* This symbol has an entry in the procedure linkage
14854            table.  Set it up.  */
14855         if (!htab->elf.dynamic_sections_created
14856             || h->dynindx == -1)
14857           {
14858             BFD_ASSERT (h->type == STT_GNU_IFUNC
14859                         && h->def_regular
14860                         && (h->root.type == bfd_link_hash_defined
14861                             || h->root.type == bfd_link_hash_defweak));
14862             rela.r_offset = (htab->elf.iplt->output_section->vma
14863                              + htab->elf.iplt->output_offset
14864                              + ent->plt.offset);
14865             if (htab->opd_abi)
14866               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14867             else
14868               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14869             rela.r_addend = (h->root.u.def.value
14870                              + h->root.u.def.section->output_offset
14871                              + h->root.u.def.section->output_section->vma
14872                              + ent->addend);
14873             loc = (htab->elf.irelplt->contents
14874                    + (htab->elf.irelplt->reloc_count++
14875                       * sizeof (Elf64_External_Rela)));
14876           }
14877         else
14878           {
14879             rela.r_offset = (htab->elf.splt->output_section->vma
14880                              + htab->elf.splt->output_offset
14881                              + ent->plt.offset);
14882             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14883             rela.r_addend = ent->addend;
14884             loc = (htab->elf.srelplt->contents
14885                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14886                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14887           }
14888         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14889
14890         if (!htab->opd_abi)
14891           {
14892             if (!h->def_regular)
14893               {
14894                 /* Mark the symbol as undefined, rather than as
14895                    defined in glink.  Leave the value if there were
14896                    any relocations where pointer equality matters
14897                    (this is a clue for the dynamic linker, to make
14898                    function pointer comparisons work between an
14899                    application and shared library), otherwise set it
14900                    to zero.  */
14901                 sym->st_shndx = SHN_UNDEF;
14902                 if (!h->pointer_equality_needed)
14903                   sym->st_value = 0;
14904                 else if (!h->ref_regular_nonweak)
14905                   {
14906                     /* This breaks function pointer comparisons, but
14907                        that is better than breaking tests for a NULL
14908                        function pointer.  */
14909                     sym->st_value = 0;
14910                   }
14911               }
14912           }
14913       }
14914
14915   if (h->needs_copy)
14916     {
14917       /* This symbol needs a copy reloc.  Set it up.  */
14918
14919       if (h->dynindx == -1
14920           || (h->root.type != bfd_link_hash_defined
14921               && h->root.type != bfd_link_hash_defweak)
14922           || htab->relbss == NULL)
14923         abort ();
14924
14925       rela.r_offset = (h->root.u.def.value
14926                        + h->root.u.def.section->output_section->vma
14927                        + h->root.u.def.section->output_offset);
14928       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14929       rela.r_addend = 0;
14930       loc = htab->relbss->contents;
14931       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14932       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14933     }
14934
14935   return TRUE;
14936 }
14937
14938 /* Used to decide how to sort relocs in an optimal manner for the
14939    dynamic linker, before writing them out.  */
14940
14941 static enum elf_reloc_type_class
14942 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14943                             const asection *rel_sec,
14944                             const Elf_Internal_Rela *rela)
14945 {
14946   enum elf_ppc64_reloc_type r_type;
14947   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14948
14949   if (rel_sec == htab->elf.irelplt)
14950     return reloc_class_ifunc;
14951
14952   r_type = ELF64_R_TYPE (rela->r_info);
14953   switch (r_type)
14954     {
14955     case R_PPC64_RELATIVE:
14956       return reloc_class_relative;
14957     case R_PPC64_JMP_SLOT:
14958       return reloc_class_plt;
14959     case R_PPC64_COPY:
14960       return reloc_class_copy;
14961     default:
14962       return reloc_class_normal;
14963     }
14964 }
14965
14966 /* Finish up the dynamic sections.  */
14967
14968 static bfd_boolean
14969 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14970                                    struct bfd_link_info *info)
14971 {
14972   struct ppc_link_hash_table *htab;
14973   bfd *dynobj;
14974   asection *sdyn;
14975
14976   htab = ppc_hash_table (info);
14977   if (htab == NULL)
14978     return FALSE;
14979
14980   dynobj = htab->elf.dynobj;
14981   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14982
14983   if (htab->elf.dynamic_sections_created)
14984     {
14985       Elf64_External_Dyn *dyncon, *dynconend;
14986
14987       if (sdyn == NULL || htab->elf.sgot == NULL)
14988         abort ();
14989
14990       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14991       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14992       for (; dyncon < dynconend; dyncon++)
14993         {
14994           Elf_Internal_Dyn dyn;
14995           asection *s;
14996
14997           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14998
14999           switch (dyn.d_tag)
15000             {
15001             default:
15002               continue;
15003
15004             case DT_PPC64_GLINK:
15005               s = htab->glink;
15006               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15007               /* We stupidly defined DT_PPC64_GLINK to be the start
15008                  of glink rather than the first entry point, which is
15009                  what ld.so needs, and now have a bigger stub to
15010                  support automatic multiple TOCs.  */
15011               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15012               break;
15013
15014             case DT_PPC64_OPD:
15015               s = bfd_get_section_by_name (output_bfd, ".opd");
15016               if (s == NULL)
15017                 continue;
15018               dyn.d_un.d_ptr = s->vma;
15019               break;
15020
15021             case DT_PPC64_OPT:
15022               if (htab->do_multi_toc && htab->multi_toc_needed)
15023                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15024               break;
15025
15026             case DT_PPC64_OPDSZ:
15027               s = bfd_get_section_by_name (output_bfd, ".opd");
15028               if (s == NULL)
15029                 continue;
15030               dyn.d_un.d_val = s->size;
15031               break;
15032
15033             case DT_PLTGOT:
15034               s = htab->elf.splt;
15035               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15036               break;
15037
15038             case DT_JMPREL:
15039               s = htab->elf.srelplt;
15040               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15041               break;
15042
15043             case DT_PLTRELSZ:
15044               dyn.d_un.d_val = htab->elf.srelplt->size;
15045               break;
15046
15047             case DT_RELASZ:
15048               /* Don't count procedure linkage table relocs in the
15049                  overall reloc count.  */
15050               s = htab->elf.srelplt;
15051               if (s == NULL)
15052                 continue;
15053               dyn.d_un.d_val -= s->size;
15054               break;
15055
15056             case DT_RELA:
15057               /* We may not be using the standard ELF linker script.
15058                  If .rela.plt is the first .rela section, we adjust
15059                  DT_RELA to not include it.  */
15060               s = htab->elf.srelplt;
15061               if (s == NULL)
15062                 continue;
15063               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15064                 continue;
15065               dyn.d_un.d_ptr += s->size;
15066               break;
15067             }
15068
15069           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15070         }
15071     }
15072
15073   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15074     {
15075       /* Fill in the first entry in the global offset table.
15076          We use it to hold the link-time TOCbase.  */
15077       bfd_put_64 (output_bfd,
15078                   elf_gp (output_bfd) + TOC_BASE_OFF,
15079                   htab->elf.sgot->contents);
15080
15081       /* Set .got entry size.  */
15082       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15083     }
15084
15085   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15086     {
15087       /* Set .plt entry size.  */
15088       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15089         = PLT_ENTRY_SIZE (htab);
15090     }
15091
15092   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15093      brlt ourselves if emitrelocations.  */
15094   if (htab->brlt != NULL
15095       && htab->brlt->reloc_count != 0
15096       && !_bfd_elf_link_output_relocs (output_bfd,
15097                                        htab->brlt,
15098                                        elf_section_data (htab->brlt)->rela.hdr,
15099                                        elf_section_data (htab->brlt)->relocs,
15100                                        NULL))
15101     return FALSE;
15102
15103   if (htab->glink != NULL
15104       && htab->glink->reloc_count != 0
15105       && !_bfd_elf_link_output_relocs (output_bfd,
15106                                        htab->glink,
15107                                        elf_section_data (htab->glink)->rela.hdr,
15108                                        elf_section_data (htab->glink)->relocs,
15109                                        NULL))
15110     return FALSE;
15111
15112   if (htab->glink_eh_frame != NULL
15113       && htab->glink_eh_frame->size != 0)
15114     {
15115       bfd_vma val;
15116       bfd_byte *p;
15117       asection *stub_sec;
15118
15119       p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15120       for (stub_sec = htab->params->stub_bfd->sections;
15121            stub_sec != NULL;
15122            stub_sec = stub_sec->next)
15123         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15124           {
15125             /* FDE length.  */
15126             p += 4;
15127             /* CIE pointer.  */
15128             p += 4;
15129             /* Offset to stub section.  */
15130             val = (stub_sec->output_section->vma
15131                    + stub_sec->output_offset);
15132             val -= (htab->glink_eh_frame->output_section->vma
15133                     + htab->glink_eh_frame->output_offset
15134                     + (p - htab->glink_eh_frame->contents));
15135             if (val + 0x80000000 > 0xffffffff)
15136               {
15137                 info->callbacks->einfo
15138                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15139                    stub_sec->name);
15140                 return FALSE;
15141               }
15142             bfd_put_32 (dynobj, val, p);
15143             p += 4;
15144             /* stub section size.  */
15145             p += 4;
15146             /* Augmentation.  */
15147             p += 1;
15148             /* Pad.  */
15149             p += 7;
15150           }
15151       if (htab->glink != NULL && htab->glink->size != 0)
15152         {
15153           /* FDE length.  */
15154           p += 4;
15155           /* CIE pointer.  */
15156           p += 4;
15157           /* Offset to .glink.  */
15158           val = (htab->glink->output_section->vma
15159                  + htab->glink->output_offset
15160                  + 8);
15161           val -= (htab->glink_eh_frame->output_section->vma
15162                   + htab->glink_eh_frame->output_offset
15163                   + (p - htab->glink_eh_frame->contents));
15164           if (val + 0x80000000 > 0xffffffff)
15165             {
15166               info->callbacks->einfo
15167                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15168                  htab->glink->name);
15169               return FALSE;
15170             }
15171           bfd_put_32 (dynobj, val, p);
15172           p += 4;
15173           /* .glink size.  */
15174           p += 4;
15175           /* Augmentation.  */
15176           p += 1;
15177           /* Ops.  */
15178           p += 7;
15179         }
15180
15181       if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15182           && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15183                                                htab->glink_eh_frame,
15184                                                htab->glink_eh_frame->contents))
15185         return FALSE;
15186     }
15187
15188   /* We need to handle writing out multiple GOT sections ourselves,
15189      since we didn't add them to DYNOBJ.  We know dynobj is the first
15190      bfd.  */
15191   while ((dynobj = dynobj->link.next) != NULL)
15192     {
15193       asection *s;
15194
15195       if (!is_ppc64_elf (dynobj))
15196         continue;
15197
15198       s = ppc64_elf_tdata (dynobj)->got;
15199       if (s != NULL
15200           && s->size != 0
15201           && s->output_section != bfd_abs_section_ptr
15202           && !bfd_set_section_contents (output_bfd, s->output_section,
15203                                         s->contents, s->output_offset,
15204                                         s->size))
15205         return FALSE;
15206       s = ppc64_elf_tdata (dynobj)->relgot;
15207       if (s != NULL
15208           && s->size != 0
15209           && s->output_section != bfd_abs_section_ptr
15210           && !bfd_set_section_contents (output_bfd, s->output_section,
15211                                         s->contents, s->output_offset,
15212                                         s->size))
15213         return FALSE;
15214     }
15215
15216   return TRUE;
15217 }
15218
15219 #include "elf64-target.h"
15220
15221 /* FreeBSD support */
15222
15223 #undef  TARGET_LITTLE_SYM
15224 #undef  TARGET_LITTLE_NAME
15225
15226 #undef  TARGET_BIG_SYM
15227 #define TARGET_BIG_SYM  powerpc_elf64_fbsd_vec
15228 #undef  TARGET_BIG_NAME
15229 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15230
15231 #undef  ELF_OSABI
15232 #define ELF_OSABI       ELFOSABI_FREEBSD
15233
15234 #undef  elf64_bed
15235 #define elf64_bed       elf64_powerpc_fbsd_bed
15236
15237 #include "elf64-target.h"
15238