bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37 #include "dwarf2.h"
  38
  39 static bfd_reloc_status_type ppc64_elf_ha_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_branch_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_toc_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57 static bfd_vma opd_entry_value
  58   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  59
  60 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  61 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  62 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  63 #define TARGET_BIG_NAME         "elf64-powerpc"
  64 #define ELF_ARCH                bfd_arch_powerpc
  65 #define ELF_TARGET_ID           PPC64_ELF_DATA
  66 #define ELF_MACHINE_CODE        EM_PPC64
  67 #define ELF_MAXPAGESIZE         0x10000
  68 #define ELF_COMMONPAGESIZE      0x1000
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  85 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  86 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  87 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  88 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91
  92 #define elf_backend_object_p                  ppc64_elf_object_p
  93 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  94 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  95 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  96 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  97 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  98 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  99 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
 100 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 101 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 102 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 103 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 104 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 105 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 106 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 107 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 108 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 109 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 110 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 111 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 112 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 113 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 114 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 115 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 116 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 117 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 118 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 119 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 120 #define elf_backend_special_sections          ppc64_elf_special_sections
 121 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 122
 123 /* The name of the dynamic interpreter.  This is put in the .interp
 124    section.  */
 125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 126
 127 /* The size in bytes of an entry in the procedure linkage table.  */
 128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 129
 130 /* The initial size of the plt reserved for the dynamic linker.  */
 131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 132
 133 /* Offsets to some stack save slots.  */
 134 #define STK_LR 16
 135 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 136 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 137    CR save slot.  Used only by optimised __tls_get_addr call stub,
 138    relying on __tls_get_addr_opt not saving CR..  */
 139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 140
 141 /* TOC base pointers offset from start of TOC.  */
 142 #define TOC_BASE_OFF    0x8000
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176
 177 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 178 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 179
 180 /* glink call stub instructions.  We enter with the index in R0.  */
 181 #define GLINK_CALL_STUB_SIZE (16*4)
 182                                         /* 0:                           */
 183                                         /*  .quad plt0-1f               */
 184                                         /* __glink:                     */
 185 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 186 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 187                                         /* 1:                           */
 188 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 189                                         /*  ld %2,(0b-1b)(%11)          */
 190 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 191 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 192                                         /*  ld %12,0(%11)               */
 193                                         /*  ld %2,8(%11)                */
 194                                         /*  mtctr %12                   */
 195                                         /*  ld %11,16(%11)              */
 196                                         /*  bctr                        */
 197 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 198 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 199 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 200 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 201 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 202
 203 /* Pad with this.  */
 204 #define NOP             0x60000000
 205
 206 /* Some other nops.  */
 207 #define CROR_151515     0x4def7b82
 208 #define CROR_313131     0x4ffffb82
 209
 210 /* .glink entries for the first 32k functions are two instructions.  */
 211 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 212 #define B_DOT           0x48000000      /* b     .              */
 213
 214 /* After that, we need two instructions to load the index, followed by
 215    a branch.  */
 216 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 217 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 218
 219 /* Instructions used by the save and restore reg functions.  */
 220 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 221 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 222 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 223 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 224 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 225 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 226 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 227 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 228 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 229 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 230 #define BLR             0x4e800020      /* blr                  */
 231
 232 /* Since .opd is an array of descriptors and each entry will end up
 233    with identical R_PPC64_RELATIVE relocs, there is really no need to
 234    propagate .opd relocs;  The dynamic linker should be taught to
 235    relocate .opd without reloc entries.  */
 236 #ifndef NO_OPD_RELOCS
 237 #define NO_OPD_RELOCS 0
 238 #endif
 239 \f
 240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 241
 242 /* Relocation HOWTO's.  */
 243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 244
 245 static reloc_howto_type ppc64_elf_howto_raw[] = {
 246   /* This reloc does nothing.  */
 247   HOWTO (R_PPC64_NONE,          /* type */
 248          0,                     /* rightshift */
 249          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          32,                    /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_dont, /* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_PPC64_NONE",        /* name */
 256          FALSE,                 /* partial_inplace */
 257          0,                     /* src_mask */
 258          0,                     /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* A standard 32 bit relocation.  */
 262   HOWTO (R_PPC64_ADDR32,        /* type */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          32,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield, /* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_PPC64_ADDR32",      /* name */
 271          FALSE,                 /* partial_inplace */
 272          0,                     /* src_mask */
 273          0xffffffff,            /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* An absolute 26 bit branch; the lower two bits must be zero.
 277      FIXME: we don't check that, we just clear them.  */
 278   HOWTO (R_PPC64_ADDR24,        /* type */
 279          0,                     /* rightshift */
 280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          26,                    /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_bitfield, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_ADDR24",      /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0x03fffffc,            /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 16 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR16,        /* type */
 294          0,                     /* rightshift */
 295          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          16,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR16",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffff,                /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* A 16 bit relocation without overflow.  */
 308   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 309          0,                     /* rightshift */
 310          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          16,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_dont,/* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_PPC64_ADDR16_LO",   /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0xffff,                /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   /* Bits 16-31 of an address.  */
 323   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 324          16,                    /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_signed, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_PPC64_ADDR16_HI",   /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 338      bits, treated as a signed number, is negative.  */
 339   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 340          16,                    /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_signed, /* complain_on_overflow */
 346          ppc64_elf_ha_reloc,    /* special_function */
 347          "R_PPC64_ADDR16_HA",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* An absolute 16 bit branch; the lower two bits must be zero.
 354      FIXME: we don't check that, we just clear them.  */
 355   HOWTO (R_PPC64_ADDR14,        /* type */
 356          0,                     /* rightshift */
 357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          FALSE,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_bitfield, /* complain_on_overflow */
 362          ppc64_elf_branch_reloc, /* special_function */
 363          "R_PPC64_ADDR14",      /* name */
 364          FALSE,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0x0000fffc,            /* dst_mask */
 367          FALSE),                /* pcrel_offset */
 368
 369   /* An absolute 16 bit branch, for which bit 10 should be set to
 370      indicate that the branch is expected to be taken.  The lower two
 371      bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          16,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_bitfield, /* complain_on_overflow */
 379          ppc64_elf_brtaken_reloc, /* special_function */
 380          "R_PPC64_ADDR14_BRTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* An absolute 16 bit branch, for which bit 10 should be set to
 387      indicate that the branch is not expected to be taken.  The lower
 388      two bits must be zero.  */
 389   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 390          0,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          16,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_bitfield, /* complain_on_overflow */
 396          ppc64_elf_brtaken_reloc, /* special_function */
 397          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 398          FALSE,                 /* partial_inplace */
 399          0,                     /* src_mask */
 400          0x0000fffc,            /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403   /* A relative 26 bit branch; the lower two bits must be zero.  */
 404   HOWTO (R_PPC64_REL24,         /* type */
 405          0,                     /* rightshift */
 406          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          26,                    /* bitsize */
 408          TRUE,                  /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_signed, /* complain_on_overflow */
 411          ppc64_elf_branch_reloc, /* special_function */
 412          "R_PPC64_REL24",       /* name */
 413          FALSE,                 /* partial_inplace */
 414          0,                     /* src_mask */
 415          0x03fffffc,            /* dst_mask */
 416          TRUE),                 /* pcrel_offset */
 417
 418   /* A relative 16 bit branch; the lower two bits must be zero.  */
 419   HOWTO (R_PPC64_REL14,         /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          TRUE,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_branch_reloc, /* special_function */
 427          "R_PPC64_REL14",       /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          TRUE),                 /* pcrel_offset */
 432
 433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 434      the branch is expected to be taken.  The lower two bits must be
 435      zero.  */
 436   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          ppc64_elf_brtaken_reloc, /* special_function */
 444          "R_PPC64_REL14_BRTAKEN", /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 451      the branch is not expected to be taken.  The lower two bits must
 452      be zero.  */
 453   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          16,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          ppc64_elf_brtaken_reloc, /* special_function */
 461          "R_PPC64_REL14_BRNTAKEN",/* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0x0000fffc,            /* dst_mask */
 465          TRUE),                 /* pcrel_offset */
 466
 467   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 468      symbol.  */
 469   HOWTO (R_PPC64_GOT16,         /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_signed, /* complain_on_overflow */
 476          ppc64_elf_unhandled_reloc, /* special_function */
 477          "R_PPC64_GOT16",       /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0xffff,                /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 484      the symbol.  */
 485   HOWTO (R_PPC64_GOT16_LO,      /* type */
 486          0,                     /* rightshift */
 487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          ppc64_elf_unhandled_reloc, /* special_function */
 493          "R_PPC64_GOT16_LO",    /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 500      the symbol.  */
 501   HOWTO (R_PPC64_GOT16_HI,      /* type */
 502          16,                    /* rightshift */
 503          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_signed,/* complain_on_overflow */
 508          ppc64_elf_unhandled_reloc, /* special_function */
 509          "R_PPC64_GOT16_HI",    /* name */
 510          FALSE,                 /* partial_inplace */
 511          0,                     /* src_mask */
 512          0xffff,                /* dst_mask */
 513          FALSE),                /* pcrel_offset */
 514
 515   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 516      the symbol.  */
 517   HOWTO (R_PPC64_GOT16_HA,      /* type */
 518          16,                    /* rightshift */
 519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 520          16,                    /* bitsize */
 521          FALSE,                 /* pc_relative */
 522          0,                     /* bitpos */
 523          complain_overflow_signed,/* complain_on_overflow */
 524          ppc64_elf_unhandled_reloc, /* special_function */
 525          "R_PPC64_GOT16_HA",    /* name */
 526          FALSE,                 /* partial_inplace */
 527          0,                     /* src_mask */
 528          0xffff,                /* dst_mask */
 529          FALSE),                /* pcrel_offset */
 530
 531   /* This is used only by the dynamic linker.  The symbol should exist
 532      both in the object being run and in some shared library.  The
 533      dynamic linker copies the data addressed by the symbol from the
 534      shared library into the object, because the object being
 535      run has to have the data at some particular address.  */
 536   HOWTO (R_PPC64_COPY,          /* type */
 537          0,                     /* rightshift */
 538          0,                     /* this one is variable size */
 539          0,                     /* bitsize */
 540          FALSE,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont, /* complain_on_overflow */
 543          ppc64_elf_unhandled_reloc, /* special_function */
 544          "R_PPC64_COPY",        /* name */
 545          FALSE,                 /* partial_inplace */
 546          0,                     /* src_mask */
 547          0,                     /* dst_mask */
 548          FALSE),                /* pcrel_offset */
 549
 550   /* Like R_PPC64_ADDR64, but used when setting global offset table
 551      entries.  */
 552   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 553          0,                     /* rightshift */
 554          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 555          64,                    /* bitsize */
 556          FALSE,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          ppc64_elf_unhandled_reloc,  /* special_function */
 560          "R_PPC64_GLOB_DAT",    /* name */
 561          FALSE,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          ONES (64),             /* dst_mask */
 564          FALSE),                /* pcrel_offset */
 565
 566   /* Created by the link editor.  Marks a procedure linkage table
 567      entry for a symbol.  */
 568   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 569          0,                     /* rightshift */
 570          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          0,                     /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          ppc64_elf_unhandled_reloc, /* special_function */
 576          "R_PPC64_JMP_SLOT",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          0,                     /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Used only by the dynamic linker.  When the object is run, this
 583      doubleword64 is set to the load address of the object, plus the
 584      addend.  */
 585   HOWTO (R_PPC64_RELATIVE,      /* type */
 586          0,                     /* rightshift */
 587          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 588          64,                    /* bitsize */
 589          FALSE,                 /* pc_relative */
 590          0,                     /* bitpos */
 591          complain_overflow_dont, /* complain_on_overflow */
 592          bfd_elf_generic_reloc, /* special_function */
 593          "R_PPC64_RELATIVE",    /* name */
 594          FALSE,                 /* partial_inplace */
 595          0,                     /* src_mask */
 596          ONES (64),             /* dst_mask */
 597          FALSE),                /* pcrel_offset */
 598
 599   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 600   HOWTO (R_PPC64_UADDR32,       /* type */
 601          0,                     /* rightshift */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 603          32,                    /* bitsize */
 604          FALSE,                 /* pc_relative */
 605          0,                     /* bitpos */
 606          complain_overflow_bitfield, /* complain_on_overflow */
 607          bfd_elf_generic_reloc, /* special_function */
 608          "R_PPC64_UADDR32",     /* name */
 609          FALSE,                 /* partial_inplace */
 610          0,                     /* src_mask */
 611          0xffffffff,            /* dst_mask */
 612          FALSE),                /* pcrel_offset */
 613
 614   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 615   HOWTO (R_PPC64_UADDR16,       /* type */
 616          0,                     /* rightshift */
 617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 618          16,                    /* bitsize */
 619          FALSE,                 /* pc_relative */
 620          0,                     /* bitpos */
 621          complain_overflow_bitfield, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_UADDR16",     /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          0xffff,                /* dst_mask */
 627          FALSE),                /* pcrel_offset */
 628
 629   /* 32-bit PC relative.  */
 630   HOWTO (R_PPC64_REL32,         /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          TRUE,                  /* pc_relative */
 635          0,                     /* bitpos */
 636          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 637          complain_overflow_signed, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_REL32",       /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          TRUE),                 /* pcrel_offset */
 644
 645   /* 32-bit relocation to the symbol's procedure linkage table.  */
 646   HOWTO (R_PPC64_PLT32,         /* type */
 647          0,                     /* rightshift */
 648          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          32,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          ppc64_elf_unhandled_reloc, /* special_function */
 654          "R_PPC64_PLT32",       /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffffffff,            /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 661      FIXME: R_PPC64_PLTREL32 not supported.  */
 662   HOWTO (R_PPC64_PLTREL32,      /* type */
 663          0,                     /* rightshift */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          32,                    /* bitsize */
 666          TRUE,                  /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_signed, /* complain_on_overflow */
 669          bfd_elf_generic_reloc, /* special_function */
 670          "R_PPC64_PLTREL32",    /* name */
 671          FALSE,                 /* partial_inplace */
 672          0,                     /* src_mask */
 673          0xffffffff,            /* dst_mask */
 674          TRUE),                 /* pcrel_offset */
 675
 676   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 677      the symbol.  */
 678   HOWTO (R_PPC64_PLT16_LO,      /* type */
 679          0,                     /* rightshift */
 680          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          16,                    /* bitsize */
 682          FALSE,                 /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_dont, /* complain_on_overflow */
 685          ppc64_elf_unhandled_reloc, /* special_function */
 686          "R_PPC64_PLT16_LO",    /* name */
 687          FALSE,                 /* partial_inplace */
 688          0,                     /* src_mask */
 689          0xffff,                /* dst_mask */
 690          FALSE),                /* pcrel_offset */
 691
 692   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 693      the symbol.  */
 694   HOWTO (R_PPC64_PLT16_HI,      /* type */
 695          16,                    /* rightshift */
 696          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          16,                    /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_signed, /* complain_on_overflow */
 701          ppc64_elf_unhandled_reloc, /* special_function */
 702          "R_PPC64_PLT16_HI",    /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0xffff,                /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 709      the symbol.  */
 710   HOWTO (R_PPC64_PLT16_HA,      /* type */
 711          16,                    /* rightshift */
 712          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          16,                    /* bitsize */
 714          FALSE,                 /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_signed, /* complain_on_overflow */
 717          ppc64_elf_unhandled_reloc, /* special_function */
 718          "R_PPC64_PLT16_HA",    /* name */
 719          FALSE,                 /* partial_inplace */
 720          0,                     /* src_mask */
 721          0xffff,                /* dst_mask */
 722          FALSE),                /* pcrel_offset */
 723
 724   /* 16-bit section relative relocation.  */
 725   HOWTO (R_PPC64_SECTOFF,       /* type */
 726          0,                     /* rightshift */
 727          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 728          16,                    /* bitsize */
 729          FALSE,                 /* pc_relative */
 730          0,                     /* bitpos */
 731          complain_overflow_bitfield, /* complain_on_overflow */
 732          ppc64_elf_sectoff_reloc, /* special_function */
 733          "R_PPC64_SECTOFF",     /* name */
 734          FALSE,                 /* partial_inplace */
 735          0,                     /* src_mask */
 736          0xffff,                /* dst_mask */
 737          FALSE),                /* pcrel_offset */
 738
 739   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 740   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 741          0,                     /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_dont, /* complain_on_overflow */
 747          ppc64_elf_sectoff_reloc, /* special_function */
 748          "R_PPC64_SECTOFF_LO",  /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit upper half section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 756          16,                    /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF_HI",  /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* 16-bit upper half adjusted section relative relocation.  */
 770   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 771          16,                    /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_signed, /* complain_on_overflow */
 777          ppc64_elf_sectoff_ha_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_HA",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 785   HOWTO (R_PPC64_REL30,         /* type */
 786          2,                     /* rightshift */
 787          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          30,                    /* bitsize */
 789          TRUE,                  /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_PPC64_REL30",       /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xfffffffc,            /* dst_mask */
 797          TRUE),                 /* pcrel_offset */
 798
 799   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 800
 801   /* A standard 64-bit relocation.  */
 802   HOWTO (R_PPC64_ADDR64,        /* type */
 803          0,                     /* rightshift */
 804          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 805          64,                    /* bitsize */
 806          FALSE,                 /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_dont, /* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_PPC64_ADDR64",      /* name */
 811          FALSE,                 /* partial_inplace */
 812          0,                     /* src_mask */
 813          ONES (64),             /* dst_mask */
 814          FALSE),                /* pcrel_offset */
 815
 816   /* The bits 32-47 of an address.  */
 817   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 818          32,                    /* rightshift */
 819          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 820          16,                    /* bitsize */
 821          FALSE,                 /* pc_relative */
 822          0,                     /* bitpos */
 823          complain_overflow_dont, /* complain_on_overflow */
 824          bfd_elf_generic_reloc, /* special_function */
 825          "R_PPC64_ADDR16_HIGHER", /* name */
 826          FALSE,                 /* partial_inplace */
 827          0,                     /* src_mask */
 828          0xffff,                /* dst_mask */
 829          FALSE),                /* pcrel_offset */
 830
 831   /* The bits 32-47 of an address, plus 1 if the contents of the low
 832      16 bits, treated as a signed number, is negative.  */
 833   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 834          32,                    /* rightshift */
 835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 836          16,                    /* bitsize */
 837          FALSE,                 /* pc_relative */
 838          0,                     /* bitpos */
 839          complain_overflow_dont, /* complain_on_overflow */
 840          ppc64_elf_ha_reloc,    /* special_function */
 841          "R_PPC64_ADDR16_HIGHERA", /* name */
 842          FALSE,                 /* partial_inplace */
 843          0,                     /* src_mask */
 844          0xffff,                /* dst_mask */
 845          FALSE),                /* pcrel_offset */
 846
 847   /* The bits 48-63 of an address.  */
 848   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 849          48,                    /* rightshift */
 850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 851          16,                    /* bitsize */
 852          FALSE,                 /* pc_relative */
 853          0,                     /* bitpos */
 854          complain_overflow_dont, /* complain_on_overflow */
 855          bfd_elf_generic_reloc, /* special_function */
 856          "R_PPC64_ADDR16_HIGHEST", /* name */
 857          FALSE,                 /* partial_inplace */
 858          0,                     /* src_mask */
 859          0xffff,                /* dst_mask */
 860          FALSE),                /* pcrel_offset */
 861
 862   /* The bits 48-63 of an address, plus 1 if the contents of the low
 863      16 bits, treated as a signed number, is negative.  */
 864   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 865          48,                    /* rightshift */
 866          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          16,                    /* bitsize */
 868          FALSE,                 /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_dont, /* complain_on_overflow */
 871          ppc64_elf_ha_reloc,    /* special_function */
 872          "R_PPC64_ADDR16_HIGHESTA", /* name */
 873          FALSE,                 /* partial_inplace */
 874          0,                     /* src_mask */
 875          0xffff,                /* dst_mask */
 876          FALSE),                /* pcrel_offset */
 877
 878   /* Like ADDR64, but may be unaligned.  */
 879   HOWTO (R_PPC64_UADDR64,       /* type */
 880          0,                     /* rightshift */
 881          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 882          64,                    /* bitsize */
 883          FALSE,                 /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_dont, /* complain_on_overflow */
 886          bfd_elf_generic_reloc, /* special_function */
 887          "R_PPC64_UADDR64",     /* name */
 888          FALSE,                 /* partial_inplace */
 889          0,                     /* src_mask */
 890          ONES (64),             /* dst_mask */
 891          FALSE),                /* pcrel_offset */
 892
 893   /* 64-bit relative relocation.  */
 894   HOWTO (R_PPC64_REL64,         /* type */
 895          0,                     /* rightshift */
 896          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 897          64,                    /* bitsize */
 898          TRUE,                  /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          bfd_elf_generic_reloc, /* special_function */
 902          "R_PPC64_REL64",       /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          ONES (64),             /* dst_mask */
 906          TRUE),                 /* pcrel_offset */
 907
 908   /* 64-bit relocation to the symbol's procedure linkage table.  */
 909   HOWTO (R_PPC64_PLT64,         /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          ppc64_elf_unhandled_reloc, /* special_function */
 917          "R_PPC64_PLT64",       /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit PC relative relocation to the symbol's procedure linkage
 924      table.  */
 925   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 926   HOWTO (R_PPC64_PLTREL64,      /* type */
 927          0,                     /* rightshift */
 928          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 929          64,                    /* bitsize */
 930          TRUE,                  /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_dont, /* complain_on_overflow */
 933          ppc64_elf_unhandled_reloc, /* special_function */
 934          "R_PPC64_PLTREL64",    /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          ONES (64),             /* dst_mask */
 938          TRUE),                 /* pcrel_offset */
 939
 940   /* 16 bit TOC-relative relocation.  */
 941
 942   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 943   HOWTO (R_PPC64_TOC16,         /* type */
 944          0,                     /* rightshift */
 945          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 946          16,                    /* bitsize */
 947          FALSE,                 /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_signed, /* complain_on_overflow */
 950          ppc64_elf_toc_reloc,   /* special_function */
 951          "R_PPC64_TOC16",       /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          0xffff,                /* dst_mask */
 955          FALSE),                /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation without overflow.  */
 958
 959   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 960   HOWTO (R_PPC64_TOC16_LO,      /* type */
 961          0,                     /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_dont, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16_LO",    /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation, high 16 bits.  */
 975
 976   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 977   HOWTO (R_PPC64_TOC16_HI,      /* type */
 978          16,                    /* rightshift */
 979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          16,                    /* bitsize */
 981          FALSE,                 /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_signed, /* complain_on_overflow */
 984          ppc64_elf_toc_reloc,   /* special_function */
 985          "R_PPC64_TOC16_HI",    /* name */
 986          FALSE,                 /* partial_inplace */
 987          0,                     /* src_mask */
 988          0xffff,                /* dst_mask */
 989          FALSE),                /* pcrel_offset */
 990
 991   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 992      contents of the low 16 bits, treated as a signed number, is
 993      negative.  */
 994
 995   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 996   HOWTO (R_PPC64_TOC16_HA,      /* type */
 997          16,                    /* rightshift */
 998          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 999          16,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_signed, /* complain_on_overflow */
1003          ppc64_elf_toc_ha_reloc, /* special_function */
1004          "R_PPC64_TOC16_HA",    /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          0xffff,                /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1011
1012   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1013   HOWTO (R_PPC64_TOC,           /* type */
1014          0,                     /* rightshift */
1015          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1016          64,                    /* bitsize */
1017          FALSE,                 /* pc_relative */
1018          0,                     /* bitpos */
1019          complain_overflow_bitfield, /* complain_on_overflow */
1020          ppc64_elf_toc64_reloc, /* special_function */
1021          "R_PPC64_TOC",         /* name */
1022          FALSE,                 /* partial_inplace */
1023          0,                     /* src_mask */
1024          ONES (64),             /* dst_mask */
1025          FALSE),                /* pcrel_offset */
1026
1027   /* Like R_PPC64_GOT16, but also informs the link editor that the
1028      value to relocate may (!) refer to a PLT entry which the link
1029      editor (a) may replace with the symbol value.  If the link editor
1030      is unable to fully resolve the symbol, it may (b) create a PLT
1031      entry and store the address to the new PLT entry in the GOT.
1032      This permits lazy resolution of function symbols at run time.
1033      The link editor may also skip all of this and just (c) emit a
1034      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1035   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1036     HOWTO (R_PPC64_PLTGOT16,    /* type */
1037          0,                     /* rightshift */
1038          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1039          16,                    /* bitsize */
1040          FALSE,                 /* pc_relative */
1041          0,                     /* bitpos */
1042          complain_overflow_signed, /* complain_on_overflow */
1043          ppc64_elf_unhandled_reloc, /* special_function */
1044          "R_PPC64_PLTGOT16",    /* name */
1045          FALSE,                 /* partial_inplace */
1046          0,                     /* src_mask */
1047          0xffff,                /* dst_mask */
1048          FALSE),                /* pcrel_offset */
1049
1050   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1051   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1052   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1053          0,                     /* rightshift */
1054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1055          16,                    /* bitsize */
1056          FALSE,                 /* pc_relative */
1057          0,                     /* bitpos */
1058          complain_overflow_dont, /* complain_on_overflow */
1059          ppc64_elf_unhandled_reloc, /* special_function */
1060          "R_PPC64_PLTGOT16_LO", /* name */
1061          FALSE,                 /* partial_inplace */
1062          0,                     /* src_mask */
1063          0xffff,                /* dst_mask */
1064          FALSE),                /* pcrel_offset */
1065
1066   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1067   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1068   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1069          16,                    /* rightshift */
1070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1071          16,                    /* bitsize */
1072          FALSE,                 /* pc_relative */
1073          0,                     /* bitpos */
1074          complain_overflow_signed, /* complain_on_overflow */
1075          ppc64_elf_unhandled_reloc, /* special_function */
1076          "R_PPC64_PLTGOT16_HI", /* name */
1077          FALSE,                 /* partial_inplace */
1078          0,                     /* src_mask */
1079          0xffff,                /* dst_mask */
1080          FALSE),                /* pcrel_offset */
1081
1082   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083      1 if the contents of the low 16 bits, treated as a signed number,
1084      is negative.  */
1085   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1086   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1087          16,                    /* rightshift */
1088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1089          16,                    /* bitsize */
1090          FALSE,                 /* pc_relative */
1091          0,                     /* bitpos */
1092          complain_overflow_signed, /* complain_on_overflow */
1093          ppc64_elf_unhandled_reloc, /* special_function */
1094          "R_PPC64_PLTGOT16_HA", /* name */
1095          FALSE,                 /* partial_inplace */
1096          0,                     /* src_mask */
1097          0xffff,                /* dst_mask */
1098          FALSE),                /* pcrel_offset */
1099
1100   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1101   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1102          0,                     /* rightshift */
1103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1104          16,                    /* bitsize */
1105          FALSE,                 /* pc_relative */
1106          0,                     /* bitpos */
1107          complain_overflow_bitfield, /* complain_on_overflow */
1108          bfd_elf_generic_reloc, /* special_function */
1109          "R_PPC64_ADDR16_DS",   /* name */
1110          FALSE,                 /* partial_inplace */
1111          0,                     /* src_mask */
1112          0xfffc,                /* dst_mask */
1113          FALSE),                /* pcrel_offset */
1114
1115   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1116   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1117          0,                     /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_dont,/* complain_on_overflow */
1123          bfd_elf_generic_reloc, /* special_function */
1124          "R_PPC64_ADDR16_LO_DS",/* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xfffc,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_GOT16_DS,      /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          ppc64_elf_unhandled_reloc, /* special_function */
1139          "R_PPC64_GOT16_DS",    /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont, /* complain_on_overflow */
1153          ppc64_elf_unhandled_reloc, /* special_function */
1154          "R_PPC64_GOT16_LO_DS", /* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_PLT16_LO_DS", /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_bitfield, /* complain_on_overflow */
1183          ppc64_elf_sectoff_reloc, /* special_function */
1184          "R_PPC64_SECTOFF_DS",  /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_sectoff_reloc, /* special_function */
1199          "R_PPC64_SECTOFF_LO_DS",/* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_TOC16_DS,      /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_toc_reloc,   /* special_function */
1214          "R_PPC64_TOC16_DS",    /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_toc_reloc,   /* special_function */
1229          "R_PPC64_TOC16_LO_DS", /* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1236   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1237   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1238          0,                     /* rightshift */
1239          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1240          16,                    /* bitsize */
1241          FALSE,                 /* pc_relative */
1242          0,                     /* bitpos */
1243          complain_overflow_signed, /* complain_on_overflow */
1244          ppc64_elf_unhandled_reloc, /* special_function */
1245          "R_PPC64_PLTGOT16_DS", /* name */
1246          FALSE,                 /* partial_inplace */
1247          0,                     /* src_mask */
1248          0xfffc,                /* dst_mask */
1249          FALSE),                /* pcrel_offset */
1250
1251   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1252   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1253   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1254          0,                     /* rightshift */
1255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1256          16,                    /* bitsize */
1257          FALSE,                 /* pc_relative */
1258          0,                     /* bitpos */
1259          complain_overflow_dont, /* complain_on_overflow */
1260          ppc64_elf_unhandled_reloc, /* special_function */
1261          "R_PPC64_PLTGOT16_LO_DS",/* name */
1262          FALSE,                 /* partial_inplace */
1263          0,                     /* src_mask */
1264          0xfffc,                /* dst_mask */
1265          FALSE),                /* pcrel_offset */
1266
1267   /* Marker relocs for TLS.  */
1268   HOWTO (R_PPC64_TLS,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLS",         /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   HOWTO (R_PPC64_TLSGD,
1283          0,                     /* rightshift */
1284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1285          32,                    /* bitsize */
1286          FALSE,                 /* pc_relative */
1287          0,                     /* bitpos */
1288          complain_overflow_dont, /* complain_on_overflow */
1289          bfd_elf_generic_reloc, /* special_function */
1290          "R_PPC64_TLSGD",       /* name */
1291          FALSE,                 /* partial_inplace */
1292          0,                     /* src_mask */
1293          0,                     /* dst_mask */
1294          FALSE),                /* pcrel_offset */
1295
1296   HOWTO (R_PPC64_TLSLD,
1297          0,                     /* rightshift */
1298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1299          32,                    /* bitsize */
1300          FALSE,                 /* pc_relative */
1301          0,                     /* bitpos */
1302          complain_overflow_dont, /* complain_on_overflow */
1303          bfd_elf_generic_reloc, /* special_function */
1304          "R_PPC64_TLSLD",       /* name */
1305          FALSE,                 /* partial_inplace */
1306          0,                     /* src_mask */
1307          0,                     /* dst_mask */
1308          FALSE),                /* pcrel_offset */
1309
1310   HOWTO (R_PPC64_TOCSAVE,
1311          0,                     /* rightshift */
1312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1313          32,                    /* bitsize */
1314          FALSE,                 /* pc_relative */
1315          0,                     /* bitpos */
1316          complain_overflow_dont, /* complain_on_overflow */
1317          bfd_elf_generic_reloc, /* special_function */
1318          "R_PPC64_TOCSAVE",     /* name */
1319          FALSE,                 /* partial_inplace */
1320          0,                     /* src_mask */
1321          0,                     /* dst_mask */
1322          FALSE),                /* pcrel_offset */
1323
1324   /* Computes the load module index of the load module that contains the
1325      definition of its TLS sym.  */
1326   HOWTO (R_PPC64_DTPMOD64,
1327          0,                     /* rightshift */
1328          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          64,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          ppc64_elf_unhandled_reloc, /* special_function */
1334          "R_PPC64_DTPMOD64",    /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          ONES (64),             /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Computes a dtv-relative displacement, the difference between the value
1341      of sym+add and the base address of the thread-local storage block that
1342      contains the definition of sym, minus 0x8000.  */
1343   HOWTO (R_PPC64_DTPREL64,
1344          0,                     /* rightshift */
1345          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          64,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont, /* complain_on_overflow */
1350          ppc64_elf_unhandled_reloc, /* special_function */
1351          "R_PPC64_DTPREL64",    /* name */
1352          FALSE,                 /* partial_inplace */
1353          0,                     /* src_mask */
1354          ONES (64),             /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* A 16 bit dtprel reloc.  */
1358   HOWTO (R_PPC64_DTPREL16,
1359          0,                     /* rightshift */
1360          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1361          16,                    /* bitsize */
1362          FALSE,                 /* pc_relative */
1363          0,                     /* bitpos */
1364          complain_overflow_signed, /* complain_on_overflow */
1365          ppc64_elf_unhandled_reloc, /* special_function */
1366          "R_PPC64_DTPREL16",    /* name */
1367          FALSE,                 /* partial_inplace */
1368          0,                     /* src_mask */
1369          0xffff,                /* dst_mask */
1370          FALSE),                /* pcrel_offset */
1371
1372   /* Like DTPREL16, but no overflow.  */
1373   HOWTO (R_PPC64_DTPREL16_LO,
1374          0,                     /* rightshift */
1375          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1376          16,                    /* bitsize */
1377          FALSE,                 /* pc_relative */
1378          0,                     /* bitpos */
1379          complain_overflow_dont, /* complain_on_overflow */
1380          ppc64_elf_unhandled_reloc, /* special_function */
1381          "R_PPC64_DTPREL16_LO", /* name */
1382          FALSE,                 /* partial_inplace */
1383          0,                     /* src_mask */
1384          0xffff,                /* dst_mask */
1385          FALSE),                /* pcrel_offset */
1386
1387   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1388   HOWTO (R_PPC64_DTPREL16_HI,
1389          16,                    /* rightshift */
1390          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1391          16,                    /* bitsize */
1392          FALSE,                 /* pc_relative */
1393          0,                     /* bitpos */
1394          complain_overflow_signed, /* complain_on_overflow */
1395          ppc64_elf_unhandled_reloc, /* special_function */
1396          "R_PPC64_DTPREL16_HI", /* name */
1397          FALSE,                 /* partial_inplace */
1398          0,                     /* src_mask */
1399          0xffff,                /* dst_mask */
1400          FALSE),                /* pcrel_offset */
1401
1402   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1403   HOWTO (R_PPC64_DTPREL16_HA,
1404          16,                    /* rightshift */
1405          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1406          16,                    /* bitsize */
1407          FALSE,                 /* pc_relative */
1408          0,                     /* bitpos */
1409          complain_overflow_signed, /* complain_on_overflow */
1410          ppc64_elf_unhandled_reloc, /* special_function */
1411          "R_PPC64_DTPREL16_HA", /* name */
1412          FALSE,                 /* partial_inplace */
1413          0,                     /* src_mask */
1414          0xffff,                /* dst_mask */
1415          FALSE),                /* pcrel_offset */
1416
1417   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1418   HOWTO (R_PPC64_DTPREL16_HIGHER,
1419          32,                    /* rightshift */
1420          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1421          16,                    /* bitsize */
1422          FALSE,                 /* pc_relative */
1423          0,                     /* bitpos */
1424          complain_overflow_dont, /* complain_on_overflow */
1425          ppc64_elf_unhandled_reloc, /* special_function */
1426          "R_PPC64_DTPREL16_HIGHER", /* name */
1427          FALSE,                 /* partial_inplace */
1428          0,                     /* src_mask */
1429          0xffff,                /* dst_mask */
1430          FALSE),                /* pcrel_offset */
1431
1432   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1433   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434          32,                    /* rightshift */
1435          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1436          16,                    /* bitsize */
1437          FALSE,                 /* pc_relative */
1438          0,                     /* bitpos */
1439          complain_overflow_dont, /* complain_on_overflow */
1440          ppc64_elf_unhandled_reloc, /* special_function */
1441          "R_PPC64_DTPREL16_HIGHERA", /* name */
1442          FALSE,                 /* partial_inplace */
1443          0,                     /* src_mask */
1444          0xffff,                /* dst_mask */
1445          FALSE),                /* pcrel_offset */
1446
1447   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1448   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449          48,                    /* rightshift */
1450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          16,                    /* bitsize */
1452          FALSE,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_dont, /* complain_on_overflow */
1455          ppc64_elf_unhandled_reloc, /* special_function */
1456          "R_PPC64_DTPREL16_HIGHEST", /* name */
1457          FALSE,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0xffff,                /* dst_mask */
1460          FALSE),                /* pcrel_offset */
1461
1462   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1463   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464          48,                    /* rightshift */
1465          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1466          16,                    /* bitsize */
1467          FALSE,                 /* pc_relative */
1468          0,                     /* bitpos */
1469          complain_overflow_dont, /* complain_on_overflow */
1470          ppc64_elf_unhandled_reloc, /* special_function */
1471          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472          FALSE,                 /* partial_inplace */
1473          0,                     /* src_mask */
1474          0xffff,                /* dst_mask */
1475          FALSE),                /* pcrel_offset */
1476
1477   /* Like DTPREL16, but for insns with a DS field.  */
1478   HOWTO (R_PPC64_DTPREL16_DS,
1479          0,                     /* rightshift */
1480          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1481          16,                    /* bitsize */
1482          FALSE,                 /* pc_relative */
1483          0,                     /* bitpos */
1484          complain_overflow_signed, /* complain_on_overflow */
1485          ppc64_elf_unhandled_reloc, /* special_function */
1486          "R_PPC64_DTPREL16_DS", /* name */
1487          FALSE,                 /* partial_inplace */
1488          0,                     /* src_mask */
1489          0xfffc,                /* dst_mask */
1490          FALSE),                /* pcrel_offset */
1491
1492   /* Like DTPREL16_DS, but no overflow.  */
1493   HOWTO (R_PPC64_DTPREL16_LO_DS,
1494          0,                     /* rightshift */
1495          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          16,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont, /* complain_on_overflow */
1500          ppc64_elf_unhandled_reloc, /* special_function */
1501          "R_PPC64_DTPREL16_LO_DS", /* name */
1502          FALSE,                 /* partial_inplace */
1503          0,                     /* src_mask */
1504          0xfffc,                /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   /* Computes a tp-relative displacement, the difference between the value of
1508      sym+add and the value of the thread pointer (r13).  */
1509   HOWTO (R_PPC64_TPREL64,
1510          0,                     /* rightshift */
1511          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          64,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_TPREL64",     /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          ONES (64),             /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* A 16 bit tprel reloc.  */
1524   HOWTO (R_PPC64_TPREL16,
1525          0,                     /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_signed, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_TPREL16",     /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like TPREL16, but no overflow.  */
1539   HOWTO (R_PPC64_TPREL16_LO,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_dont, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_TPREL16_LO",  /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xffff,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1554   HOWTO (R_PPC64_TPREL16_HI,
1555          16,                    /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_signed, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_TPREL16_HI",  /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xffff,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1569   HOWTO (R_PPC64_TPREL16_HA,
1570          16,                    /* rightshift */
1571          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          16,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_signed, /* complain_on_overflow */
1576          ppc64_elf_unhandled_reloc, /* special_function */
1577          "R_PPC64_TPREL16_HA",  /* name */
1578          FALSE,                 /* partial_inplace */
1579          0,                     /* src_mask */
1580          0xffff,                /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582
1583   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1584   HOWTO (R_PPC64_TPREL16_HIGHER,
1585          32,                    /* rightshift */
1586          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          16,                    /* bitsize */
1588          FALSE,                 /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_dont, /* complain_on_overflow */
1591          ppc64_elf_unhandled_reloc, /* special_function */
1592          "R_PPC64_TPREL16_HIGHER",      /* name */
1593          FALSE,                 /* partial_inplace */
1594          0,                     /* src_mask */
1595          0xffff,                /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1599   HOWTO (R_PPC64_TPREL16_HIGHERA,
1600          32,                    /* rightshift */
1601          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1602          16,                    /* bitsize */
1603          FALSE,                 /* pc_relative */
1604          0,                     /* bitpos */
1605          complain_overflow_dont, /* complain_on_overflow */
1606          ppc64_elf_unhandled_reloc, /* special_function */
1607          "R_PPC64_TPREL16_HIGHERA", /* name */
1608          FALSE,                 /* partial_inplace */
1609          0,                     /* src_mask */
1610          0xffff,                /* dst_mask */
1611          FALSE),                /* pcrel_offset */
1612
1613   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1614   HOWTO (R_PPC64_TPREL16_HIGHEST,
1615          48,                    /* rightshift */
1616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          16,                    /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_dont, /* complain_on_overflow */
1621          ppc64_elf_unhandled_reloc, /* special_function */
1622          "R_PPC64_TPREL16_HIGHEST", /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0xffff,                /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1629   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630          48,                    /* rightshift */
1631          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1632          16,                    /* bitsize */
1633          FALSE,                 /* pc_relative */
1634          0,                     /* bitpos */
1635          complain_overflow_dont, /* complain_on_overflow */
1636          ppc64_elf_unhandled_reloc, /* special_function */
1637          "R_PPC64_TPREL16_HIGHESTA", /* name */
1638          FALSE,                 /* partial_inplace */
1639          0,                     /* src_mask */
1640          0xffff,                /* dst_mask */
1641          FALSE),                /* pcrel_offset */
1642
1643   /* Like TPREL16, but for insns with a DS field.  */
1644   HOWTO (R_PPC64_TPREL16_DS,
1645          0,                     /* rightshift */
1646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          16,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_signed, /* complain_on_overflow */
1651          ppc64_elf_unhandled_reloc, /* special_function */
1652          "R_PPC64_TPREL16_DS",  /* name */
1653          FALSE,                 /* partial_inplace */
1654          0,                     /* src_mask */
1655          0xfffc,                /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   /* Like TPREL16_DS, but no overflow.  */
1659   HOWTO (R_PPC64_TPREL16_LO_DS,
1660          0,                     /* rightshift */
1661          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1662          16,                    /* bitsize */
1663          FALSE,                 /* pc_relative */
1664          0,                     /* bitpos */
1665          complain_overflow_dont, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_TPREL16_LO_DS", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xfffc,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675      to the first entry relative to the TOC base (r2).  */
1676   HOWTO (R_PPC64_GOT_TLSGD16,
1677          0,                     /* rightshift */
1678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1679          16,                    /* bitsize */
1680          FALSE,                 /* pc_relative */
1681          0,                     /* bitpos */
1682          complain_overflow_signed, /* complain_on_overflow */
1683          ppc64_elf_unhandled_reloc, /* special_function */
1684          "R_PPC64_GOT_TLSGD16", /* name */
1685          FALSE,                 /* partial_inplace */
1686          0,                     /* src_mask */
1687          0xffff,                /* dst_mask */
1688          FALSE),                /* pcrel_offset */
1689
1690   /* Like GOT_TLSGD16, but no overflow.  */
1691   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1692          0,                     /* rightshift */
1693          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1694          16,                    /* bitsize */
1695          FALSE,                 /* pc_relative */
1696          0,                     /* bitpos */
1697          complain_overflow_dont, /* complain_on_overflow */
1698          ppc64_elf_unhandled_reloc, /* special_function */
1699          "R_PPC64_GOT_TLSGD16_LO", /* name */
1700          FALSE,                 /* partial_inplace */
1701          0,                     /* src_mask */
1702          0xffff,                /* dst_mask */
1703          FALSE),                /* pcrel_offset */
1704
1705   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1706   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707          16,                    /* rightshift */
1708          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1709          16,                    /* bitsize */
1710          FALSE,                 /* pc_relative */
1711          0,                     /* bitpos */
1712          complain_overflow_signed, /* complain_on_overflow */
1713          ppc64_elf_unhandled_reloc, /* special_function */
1714          "R_PPC64_GOT_TLSGD16_HI", /* name */
1715          FALSE,                 /* partial_inplace */
1716          0,                     /* src_mask */
1717          0xffff,                /* dst_mask */
1718          FALSE),                /* pcrel_offset */
1719
1720   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1721   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722          16,                    /* rightshift */
1723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1724          16,                    /* bitsize */
1725          FALSE,                 /* pc_relative */
1726          0,                     /* bitpos */
1727          complain_overflow_signed, /* complain_on_overflow */
1728          ppc64_elf_unhandled_reloc, /* special_function */
1729          "R_PPC64_GOT_TLSGD16_HA", /* name */
1730          FALSE,                 /* partial_inplace */
1731          0,                     /* src_mask */
1732          0xffff,                /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736      with values (sym+add)@dtpmod and zero, and computes the offset to the
1737      first entry relative to the TOC base (r2).  */
1738   HOWTO (R_PPC64_GOT_TLSLD16,
1739          0,                     /* rightshift */
1740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1741          16,                    /* bitsize */
1742          FALSE,                 /* pc_relative */
1743          0,                     /* bitpos */
1744          complain_overflow_signed, /* complain_on_overflow */
1745          ppc64_elf_unhandled_reloc, /* special_function */
1746          "R_PPC64_GOT_TLSLD16", /* name */
1747          FALSE,                 /* partial_inplace */
1748          0,                     /* src_mask */
1749          0xffff,                /* dst_mask */
1750          FALSE),                /* pcrel_offset */
1751
1752   /* Like GOT_TLSLD16, but no overflow.  */
1753   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1754          0,                     /* rightshift */
1755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1756          16,                    /* bitsize */
1757          FALSE,                 /* pc_relative */
1758          0,                     /* bitpos */
1759          complain_overflow_dont, /* complain_on_overflow */
1760          ppc64_elf_unhandled_reloc, /* special_function */
1761          "R_PPC64_GOT_TLSLD16_LO", /* name */
1762          FALSE,                 /* partial_inplace */
1763          0,                     /* src_mask */
1764          0xffff,                /* dst_mask */
1765          FALSE),                /* pcrel_offset */
1766
1767   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1768   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769          16,                    /* rightshift */
1770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1771          16,                    /* bitsize */
1772          FALSE,                 /* pc_relative */
1773          0,                     /* bitpos */
1774          complain_overflow_signed, /* complain_on_overflow */
1775          ppc64_elf_unhandled_reloc, /* special_function */
1776          "R_PPC64_GOT_TLSLD16_HI", /* name */
1777          FALSE,                 /* partial_inplace */
1778          0,                     /* src_mask */
1779          0xffff,                /* dst_mask */
1780          FALSE),                /* pcrel_offset */
1781
1782   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1783   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784          16,                    /* rightshift */
1785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1786          16,                    /* bitsize */
1787          FALSE,                 /* pc_relative */
1788          0,                     /* bitpos */
1789          complain_overflow_signed, /* complain_on_overflow */
1790          ppc64_elf_unhandled_reloc, /* special_function */
1791          "R_PPC64_GOT_TLSLD16_HA", /* name */
1792          FALSE,                 /* partial_inplace */
1793          0,                     /* src_mask */
1794          0xffff,                /* dst_mask */
1795          FALSE),                /* pcrel_offset */
1796
1797   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798      the offset to the entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_DTPREL16_DS", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xfffc,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_DTPREL16_DS, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xfffc,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_DTPREL16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_DTPREL16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859      offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_TPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_TPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_TPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_TPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_TPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_TPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_TPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   HOWTO (R_PPC64_JMP_IREL,      /* type */
1920          0,                     /* rightshift */
1921          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1922          0,                     /* bitsize */
1923          FALSE,                 /* pc_relative */
1924          0,                     /* bitpos */
1925          complain_overflow_dont, /* complain_on_overflow */
1926          ppc64_elf_unhandled_reloc, /* special_function */
1927          "R_PPC64_JMP_IREL",    /* name */
1928          FALSE,                 /* partial_inplace */
1929          0,                     /* src_mask */
1930          0,                     /* dst_mask */
1931          FALSE),                /* pcrel_offset */
1932
1933   HOWTO (R_PPC64_IRELATIVE,     /* type */
1934          0,                     /* rightshift */
1935          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1936          64,                    /* bitsize */
1937          FALSE,                 /* pc_relative */
1938          0,                     /* bitpos */
1939          complain_overflow_dont, /* complain_on_overflow */
1940          bfd_elf_generic_reloc, /* special_function */
1941          "R_PPC64_IRELATIVE",   /* name */
1942          FALSE,                 /* partial_inplace */
1943          0,                     /* src_mask */
1944          ONES (64),             /* dst_mask */
1945          FALSE),                /* pcrel_offset */
1946
1947   /* A 16 bit relative relocation.  */
1948   HOWTO (R_PPC64_REL16,         /* type */
1949          0,                     /* rightshift */
1950          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1951          16,                    /* bitsize */
1952          TRUE,                  /* pc_relative */
1953          0,                     /* bitpos */
1954          complain_overflow_bitfield, /* complain_on_overflow */
1955          bfd_elf_generic_reloc, /* special_function */
1956          "R_PPC64_REL16",       /* name */
1957          FALSE,                 /* partial_inplace */
1958          0,                     /* src_mask */
1959          0xffff,                /* dst_mask */
1960          TRUE),                 /* pcrel_offset */
1961
1962   /* A 16 bit relative relocation without overflow.  */
1963   HOWTO (R_PPC64_REL16_LO,      /* type */
1964          0,                     /* rightshift */
1965          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1966          16,                    /* bitsize */
1967          TRUE,                  /* pc_relative */
1968          0,                     /* bitpos */
1969          complain_overflow_dont,/* complain_on_overflow */
1970          bfd_elf_generic_reloc, /* special_function */
1971          "R_PPC64_REL16_LO",    /* name */
1972          FALSE,                 /* partial_inplace */
1973          0,                     /* src_mask */
1974          0xffff,                /* dst_mask */
1975          TRUE),                 /* pcrel_offset */
1976
1977   /* The high order 16 bits of a relative address.  */
1978   HOWTO (R_PPC64_REL16_HI,      /* type */
1979          16,                    /* rightshift */
1980          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1981          16,                    /* bitsize */
1982          TRUE,                  /* pc_relative */
1983          0,                     /* bitpos */
1984          complain_overflow_signed, /* complain_on_overflow */
1985          bfd_elf_generic_reloc, /* special_function */
1986          "R_PPC64_REL16_HI",    /* name */
1987          FALSE,                 /* partial_inplace */
1988          0,                     /* src_mask */
1989          0xffff,                /* dst_mask */
1990          TRUE),                 /* pcrel_offset */
1991
1992   /* The high order 16 bits of a relative address, plus 1 if the contents of
1993      the low 16 bits, treated as a signed number, is negative.  */
1994   HOWTO (R_PPC64_REL16_HA,      /* type */
1995          16,                    /* rightshift */
1996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1997          16,                    /* bitsize */
1998          TRUE,                  /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_signed, /* complain_on_overflow */
2001          ppc64_elf_ha_reloc,    /* special_function */
2002          "R_PPC64_REL16_HA",    /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          0xffff,                /* dst_mask */
2006          TRUE),                 /* pcrel_offset */
2007
2008   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2009   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2010          16,                    /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          FALSE,                 /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_dont, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_ADDR16_HIGH", /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          FALSE),                /* pcrel_offset */
2022
2023   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2024   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2025          16,                    /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          FALSE,                 /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont, /* complain_on_overflow */
2031          ppc64_elf_ha_reloc,    /* special_function */
2032          "R_PPC64_ADDR16_HIGHA",        /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          FALSE),                /* pcrel_offset */
2037
2038   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2039   HOWTO (R_PPC64_DTPREL16_HIGH,
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          FALSE,                 /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_dont, /* complain_on_overflow */
2046          ppc64_elf_unhandled_reloc, /* special_function */
2047          "R_PPC64_DTPREL16_HIGH", /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          FALSE),                /* pcrel_offset */
2052
2053   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2054   HOWTO (R_PPC64_DTPREL16_HIGHA,
2055          16,                    /* rightshift */
2056          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2057          16,                    /* bitsize */
2058          FALSE,                 /* pc_relative */
2059          0,                     /* bitpos */
2060          complain_overflow_dont, /* complain_on_overflow */
2061          ppc64_elf_unhandled_reloc, /* special_function */
2062          "R_PPC64_DTPREL16_HIGHA", /* name */
2063          FALSE,                 /* partial_inplace */
2064          0,                     /* src_mask */
2065          0xffff,                /* dst_mask */
2066          FALSE),                /* pcrel_offset */
2067
2068   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2069   HOWTO (R_PPC64_TPREL16_HIGH,
2070          16,                    /* rightshift */
2071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2072          16,                    /* bitsize */
2073          FALSE,                 /* pc_relative */
2074          0,                     /* bitpos */
2075          complain_overflow_dont, /* complain_on_overflow */
2076          ppc64_elf_unhandled_reloc, /* special_function */
2077          "R_PPC64_TPREL16_HIGH",        /* name */
2078          FALSE,                 /* partial_inplace */
2079          0,                     /* src_mask */
2080          0xffff,                /* dst_mask */
2081          FALSE),                /* pcrel_offset */
2082
2083   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2084   HOWTO (R_PPC64_TPREL16_HIGHA,
2085          16,                    /* rightshift */
2086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2087          16,                    /* bitsize */
2088          FALSE,                 /* pc_relative */
2089          0,                     /* bitpos */
2090          complain_overflow_dont, /* complain_on_overflow */
2091          ppc64_elf_unhandled_reloc, /* special_function */
2092          "R_PPC64_TPREL16_HIGHA",       /* name */
2093          FALSE,                 /* partial_inplace */
2094          0,                     /* src_mask */
2095          0xffff,                /* dst_mask */
2096          FALSE),                /* pcrel_offset */
2097
2098   /* GNU extension to record C++ vtable hierarchy.  */
2099   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2100          0,                     /* rightshift */
2101          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2102          0,                     /* bitsize */
2103          FALSE,                 /* pc_relative */
2104          0,                     /* bitpos */
2105          complain_overflow_dont, /* complain_on_overflow */
2106          NULL,                  /* special_function */
2107          "R_PPC64_GNU_VTINHERIT", /* name */
2108          FALSE,                 /* partial_inplace */
2109          0,                     /* src_mask */
2110          0,                     /* dst_mask */
2111          FALSE),                /* pcrel_offset */
2112
2113   /* GNU extension to record C++ vtable member usage.  */
2114   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2115          0,                     /* rightshift */
2116          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2117          0,                     /* bitsize */
2118          FALSE,                 /* pc_relative */
2119          0,                     /* bitpos */
2120          complain_overflow_dont, /* complain_on_overflow */
2121          NULL,                  /* special_function */
2122          "R_PPC64_GNU_VTENTRY", /* name */
2123          FALSE,                 /* partial_inplace */
2124          0,                     /* src_mask */
2125          0,                     /* dst_mask */
2126          FALSE),                /* pcrel_offset */
2127 };
2128
2129 \f
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2131    be done.  */
2132
2133 static void
2134 ppc_howto_init (void)
2135 {
2136   unsigned int i, type;
2137
2138   for (i = 0;
2139        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2140        i++)
2141     {
2142       type = ppc64_elf_howto_raw[i].type;
2143       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144                           / sizeof (ppc64_elf_howto_table[0])));
2145       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2146     }
2147 }
2148
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151                              bfd_reloc_code_real_type code)
2152 {
2153   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2154
2155   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156     /* Initialize howto table if needed.  */
2157     ppc_howto_init ();
2158
2159   switch (code)
2160     {
2161     default:
2162       return NULL;
2163
2164     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2165       break;
2166     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2167       break;
2168     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2169       break;
2170     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2171       break;
2172     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2173       break;
2174     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2175       break;
2176     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2177       break;
2178     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2179       break;
2180     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2181       break;
2182     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2183       break;
2184     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2185       break;
2186     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2187       break;
2188     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2189       break;
2190     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2191       break;
2192     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2193       break;
2194     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2195       break;
2196     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2197       break;
2198     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2199       break;
2200     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2201       break;
2202     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2203       break;
2204     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2205       break;
2206     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2207       break;
2208     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2209       break;
2210     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2211       break;
2212     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2213       break;
2214     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2215       break;
2216     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2217       break;
2218     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2219       break;
2220     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2221       break;
2222     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2223       break;
2224     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2225       break;
2226     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2227       break;
2228     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2229       break;
2230     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2231       break;
2232     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2233       break;
2234     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2235       break;
2236     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2237       break;
2238     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2239       break;
2240     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2241       break;
2242     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2243       break;
2244     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2245       break;
2246     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2247       break;
2248     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2249       break;
2250     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2251       break;
2252     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2253       break;
2254     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2255       break;
2256     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2257       break;
2258     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2259       break;
2260     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2261       break;
2262     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2263       break;
2264     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2265       break;
2266     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2267       break;
2268     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2269       break;
2270     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2271       break;
2272     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2273       break;
2274     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2275       break;
2276     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2287       break;
2288     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2289       break;
2290     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2291       break;
2292     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2293       break;
2294     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2295       break;
2296     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2297       break;
2298     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2299       break;
2300     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2301       break;
2302     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2303       break;
2304     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2305       break;
2306     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2307       break;
2308     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2309       break;
2310     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2321       break;
2322     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2323       break;
2324     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2325       break;
2326     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2327       break;
2328     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2329       break;
2330     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2331       break;
2332     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2333       break;
2334     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2345       break;
2346     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2347       break;
2348     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2351       break;
2352     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2353       break;
2354     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2355       break;
2356     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2357       break;
2358     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2359       break;
2360     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2361       break;
2362     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2363       break;
2364     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2365       break;
2366     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2367       break;
2368     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2371       break;
2372     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2373       break;
2374     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2375       break;
2376     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2377       break;
2378     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2379       break;
2380     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2381       break;
2382     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2383       break;
2384     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2385       break;
2386     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2387       break;
2388     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2389       break;
2390     }
2391
2392   return ppc64_elf_howto_table[r];
2393 };
2394
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2397                              const char *r_name)
2398 {
2399   unsigned int i;
2400
2401   for (i = 0;
2402        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2403        i++)
2404     if (ppc64_elf_howto_raw[i].name != NULL
2405         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406       return &ppc64_elf_howto_raw[i];
2407
2408   return NULL;
2409 }
2410
2411 /* Set the howto pointer for a PowerPC ELF reloc.  */
2412
2413 static void
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415                          Elf_Internal_Rela *dst)
2416 {
2417   unsigned int type;
2418
2419   /* Initialize howto table if needed.  */
2420   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2421     ppc_howto_init ();
2422
2423   type = ELF64_R_TYPE (dst->r_info);
2424   if (type >= (sizeof (ppc64_elf_howto_table)
2425                / sizeof (ppc64_elf_howto_table[0])))
2426     {
2427       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2428                              abfd, (int) type);
2429       type = R_PPC64_NONE;
2430     }
2431   cache_ptr->howto = ppc64_elf_howto_table[type];
2432 }
2433
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2435
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438                     void *data, asection *input_section,
2439                     bfd *output_bfd, char **error_message)
2440 {
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   /* Adjust the addend for sign extension of the low 16 bits.
2449      We won't actually be using the low 16 bits, so trashing them
2450      doesn't matter.  */
2451   reloc_entry->addend += 0x8000;
2452   return bfd_reloc_continue;
2453 }
2454
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457                         void *data, asection *input_section,
2458                         bfd *output_bfd, char **error_message)
2459 {
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462                                   input_section, output_bfd, error_message);
2463
2464   if (strcmp (symbol->section->name, ".opd") == 0
2465       && (symbol->section->owner->flags & DYNAMIC) == 0)
2466     {
2467       bfd_vma dest = opd_entry_value (symbol->section,
2468                                       symbol->value + reloc_entry->addend,
2469                                       NULL, NULL, FALSE);
2470       if (dest != (bfd_vma) -1)
2471         reloc_entry->addend = dest - (symbol->value
2472                                       + symbol->section->output_section->vma
2473                                       + symbol->section->output_offset);
2474     }
2475   return bfd_reloc_continue;
2476 }
2477
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480                          void *data, asection *input_section,
2481                          bfd *output_bfd, char **error_message)
2482 {
2483   long insn;
2484   enum elf_ppc64_reloc_type r_type;
2485   bfd_size_type octets;
2486   /* Assume 'at' branch hints.  */
2487   bfd_boolean is_isa_v2 = TRUE;
2488
2489   /* If this is a relocatable link (output_bfd test tells us), just
2490      call the generic function.  Any adjustment will be done at final
2491      link time.  */
2492   if (output_bfd != NULL)
2493     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494                                   input_section, output_bfd, error_message);
2495
2496   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498   insn &= ~(0x01 << 21);
2499   r_type = reloc_entry->howto->type;
2500   if (r_type == R_PPC64_ADDR14_BRTAKEN
2501       || r_type == R_PPC64_REL14_BRTAKEN)
2502     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2503
2504   if (is_isa_v2)
2505     {
2506       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2507          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2509       if ((insn & (0x14 << 21)) == (0x04 << 21))
2510         insn |= 0x02 << 21;
2511       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2512         insn |= 0x08 << 21;
2513       else
2514         goto out;
2515     }
2516   else
2517     {
2518       bfd_vma target = 0;
2519       bfd_vma from;
2520
2521       if (!bfd_is_com_section (symbol->section))
2522         target = symbol->value;
2523       target += symbol->section->output_section->vma;
2524       target += symbol->section->output_offset;
2525       target += reloc_entry->addend;
2526
2527       from = (reloc_entry->address
2528               + input_section->output_offset
2529               + input_section->output_section->vma);
2530
2531       /* Invert 'y' bit if not the default.  */
2532       if ((bfd_signed_vma) (target - from) < 0)
2533         insn ^= 0x01 << 21;
2534     }
2535   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2536  out:
2537   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538                                  input_section, output_bfd, error_message);
2539 }
2540
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543                          void *data, asection *input_section,
2544                          bfd *output_bfd, char **error_message)
2545 {
2546   /* If this is a relocatable link (output_bfd test tells us), just
2547      call the generic function.  Any adjustment will be done at final
2548      link time.  */
2549   if (output_bfd != NULL)
2550     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551                                   input_section, output_bfd, error_message);
2552
2553   /* Subtract the symbol section base address.  */
2554   reloc_entry->addend -= symbol->section->output_section->vma;
2555   return bfd_reloc_continue;
2556 }
2557
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560                             void *data, asection *input_section,
2561                             bfd *output_bfd, char **error_message)
2562 {
2563   /* If this is a relocatable link (output_bfd test tells us), just
2564      call the generic function.  Any adjustment will be done at final
2565      link time.  */
2566   if (output_bfd != NULL)
2567     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568                                   input_section, output_bfd, error_message);
2569
2570   /* Subtract the symbol section base address.  */
2571   reloc_entry->addend -= symbol->section->output_section->vma;
2572
2573   /* Adjust the addend for sign extension of the low 16 bits.  */
2574   reloc_entry->addend += 0x8000;
2575   return bfd_reloc_continue;
2576 }
2577
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580                      void *data, asection *input_section,
2581                      bfd *output_bfd, char **error_message)
2582 {
2583   bfd_vma TOCstart;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2593   if (TOCstart == 0)
2594     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2595
2596   /* Subtract the TOC base address.  */
2597   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598   return bfd_reloc_continue;
2599 }
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603                         void *data, asection *input_section,
2604                         bfd *output_bfd, char **error_message)
2605 {
2606   bfd_vma TOCstart;
2607
2608   /* If this is a relocatable link (output_bfd test tells us), just
2609      call the generic function.  Any adjustment will be done at final
2610      link time.  */
2611   if (output_bfd != NULL)
2612     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613                                   input_section, output_bfd, error_message);
2614
2615   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2616   if (TOCstart == 0)
2617     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2618
2619   /* Subtract the TOC base address.  */
2620   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2621
2622   /* Adjust the addend for sign extension of the low 16 bits.  */
2623   reloc_entry->addend += 0x8000;
2624   return bfd_reloc_continue;
2625 }
2626
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629                        void *data, asection *input_section,
2630                        bfd *output_bfd, char **error_message)
2631 {
2632   bfd_vma TOCstart;
2633   bfd_size_type octets;
2634
2635   /* If this is a relocatable link (output_bfd test tells us), just
2636      call the generic function.  Any adjustment will be done at final
2637      link time.  */
2638   if (output_bfd != NULL)
2639     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640                                   input_section, output_bfd, error_message);
2641
2642   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2643   if (TOCstart == 0)
2644     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2645
2646   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648   return bfd_reloc_ok;
2649 }
2650
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653                            void *data, asection *input_section,
2654                            bfd *output_bfd, char **error_message)
2655 {
2656   /* If this is a relocatable link (output_bfd test tells us), just
2657      call the generic function.  Any adjustment will be done at final
2658      link time.  */
2659   if (output_bfd != NULL)
2660     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661                                   input_section, output_bfd, error_message);
2662
2663   if (error_message != NULL)
2664     {
2665       static char buf[60];
2666       sprintf (buf, "generic linker can't handle %s",
2667                reloc_entry->howto->name);
2668       *error_message = buf;
2669     }
2670   return bfd_reloc_dangerous;
2671 }
2672
2673 /* Track GOT entries needed for a given symbol.  We might need more
2674    than one got entry per symbol.  */
2675 struct got_entry
2676 {
2677   struct got_entry *next;
2678
2679   /* The symbol addend that we'll be placing in the GOT.  */
2680   bfd_vma addend;
2681
2682   /* Unlike other ELF targets, we use separate GOT entries for the same
2683      symbol referenced from different input files.  This is to support
2684      automatic multiple TOC/GOT sections, where the TOC base can vary
2685      from one input file to another.  After partitioning into TOC groups
2686      we merge entries within the group.
2687
2688      Point to the BFD owning this GOT entry.  */
2689   bfd *owner;
2690
2691   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692      TLS_TPREL or TLS_DTPREL for tls entries.  */
2693   unsigned char tls_type;
2694
2695   /* Non-zero if got.ent points to real entry.  */
2696   unsigned char is_indirect;
2697
2698   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2699   union
2700     {
2701       bfd_signed_vma refcount;
2702       bfd_vma offset;
2703       struct got_entry *ent;
2704     } got;
2705 };
2706
2707 /* The same for PLT.  */
2708 struct plt_entry
2709 {
2710   struct plt_entry *next;
2711
2712   bfd_vma addend;
2713
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718     } plt;
2719 };
2720
2721 struct ppc64_elf_obj_tdata
2722 {
2723   struct elf_obj_tdata elf;
2724
2725   /* Shortcuts to dynamic linker sections.  */
2726   asection *got;
2727   asection *relgot;
2728
2729   /* Used during garbage collection.  We attach global symbols defined
2730      on removed .opd entries to this section so that the sym is removed.  */
2731   asection *deleted_section;
2732
2733   /* TLS local dynamic got entry handling.  Support for multiple GOT
2734      sections means we potentially need one of these for each input bfd.  */
2735   struct got_entry tlsld_got;
2736
2737   union {
2738     /* A copy of relocs before they are modified for --emit-relocs.  */
2739     Elf_Internal_Rela *relocs;
2740
2741     /* Section contents.  */
2742     bfd_byte *contents;
2743   } opd;
2744
2745   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746      the reloc to be in the range -32768 to 32767.  */
2747   unsigned int has_small_toc_reloc : 1;
2748
2749   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750      instruction not one we handle.  */
2751   unsigned int unexpected_toc_insn : 1;
2752 };
2753
2754 #define ppc64_elf_tdata(bfd) \
2755   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2756
2757 #define ppc64_tlsld_got(bfd) \
2758   (&ppc64_elf_tdata (bfd)->tlsld_got)
2759
2760 #define is_ppc64_elf(bfd) \
2761   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762    && elf_object_id (bfd) == PPC64_ELF_DATA)
2763
2764 /* Override the generic function because we store some extras.  */
2765
2766 static bfd_boolean
2767 ppc64_elf_mkobject (bfd *abfd)
2768 {
2769   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2770                                   PPC64_ELF_DATA);
2771 }
2772
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774    default is 32 bit.  */
2775
2776 static bfd_boolean
2777 ppc64_elf_object_p (bfd *abfd)
2778 {
2779   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2780     {
2781       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2782
2783       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2784         {
2785           /* Relies on arch after 32 bit default being 64 bit default.  */
2786           abfd->arch_info = abfd->arch_info->next;
2787           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2788         }
2789     }
2790   return TRUE;
2791 }
2792
2793 /* Support for core dump NOTE sections.  */
2794
2795 static bfd_boolean
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2797 {
2798   size_t offset, size;
2799
2800   if (note->descsz != 504)
2801     return FALSE;
2802
2803   /* pr_cursig */
2804   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2805
2806   /* pr_pid */
2807   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2808
2809   /* pr_reg */
2810   offset = 112;
2811   size = 384;
2812
2813   /* Make a ".reg/999" section.  */
2814   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815                                           size, note->descpos + offset);
2816 }
2817
2818 static bfd_boolean
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2820 {
2821   if (note->descsz != 136)
2822     return FALSE;
2823
2824   elf_tdata (abfd)->core->pid
2825     = bfd_get_32 (abfd, note->descdata + 24);
2826   elf_tdata (abfd)->core->program
2827     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828   elf_tdata (abfd)->core->command
2829     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2830
2831   return TRUE;
2832 }
2833
2834 static char *
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2836                            ...)
2837 {
2838   switch (note_type)
2839     {
2840     default:
2841       return NULL;
2842
2843     case NT_PRPSINFO:
2844       {
2845         char data[136];
2846         va_list ap;
2847
2848         va_start (ap, note_type);
2849         memset (data, 0, sizeof (data));
2850         strncpy (data + 40, va_arg (ap, const char *), 16);
2851         strncpy (data + 56, va_arg (ap, const char *), 80);
2852         va_end (ap);
2853         return elfcore_write_note (abfd, buf, bufsiz,
2854                                    "CORE", note_type, data, sizeof (data));
2855       }
2856
2857     case NT_PRSTATUS:
2858       {
2859         char data[504];
2860         va_list ap;
2861         long pid;
2862         int cursig;
2863         const void *greg;
2864
2865         va_start (ap, note_type);
2866         memset (data, 0, 112);
2867         pid = va_arg (ap, long);
2868         bfd_put_32 (abfd, pid, data + 32);
2869         cursig = va_arg (ap, int);
2870         bfd_put_16 (abfd, cursig, data + 12);
2871         greg = va_arg (ap, const void *);
2872         memcpy (data + 112, greg, 384);
2873         memset (data + 496, 0, 8);
2874         va_end (ap);
2875         return elfcore_write_note (abfd, buf, bufsiz,
2876                                    "CORE", note_type, data, sizeof (data));
2877       }
2878     }
2879 }
2880
2881 /* Add extra PPC sections.  */
2882
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2884 {
2885   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2886   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2887   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2891   { NULL,                     0,  0, 0,            0 }
2892 };
2893
2894 enum _ppc64_sec_type {
2895   sec_normal = 0,
2896   sec_opd = 1,
2897   sec_toc = 2
2898 };
2899
2900 struct _ppc64_elf_section_data
2901 {
2902   struct bfd_elf_section_data elf;
2903
2904   union
2905   {
2906     /* An array with one entry for each opd function descriptor.  */
2907     struct _opd_sec_data
2908     {
2909       /* Points to the function code section for local opd entries.  */
2910       asection **func_sec;
2911
2912       /* After editing .opd, adjust references to opd local syms.  */
2913       long *adjust;
2914     } opd;
2915
2916     /* An array for toc sections, indexed by offset/8.  */
2917     struct _toc_sec_data
2918     {
2919       /* Specifies the relocation symbol index used at a given toc offset.  */
2920       unsigned *symndx;
2921
2922       /* And the relocation addend.  */
2923       bfd_vma *add;
2924     } toc;
2925   } u;
2926
2927   enum _ppc64_sec_type sec_type:2;
2928
2929   /* Flag set when small branches are detected.  Used to
2930      select suitable defaults for the stub group size.  */
2931   unsigned int has_14bit_branch:1;
2932 };
2933
2934 #define ppc64_elf_section_data(sec) \
2935   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2936
2937 static bfd_boolean
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2939 {
2940   if (!sec->used_by_bfd)
2941     {
2942       struct _ppc64_elf_section_data *sdata;
2943       bfd_size_type amt = sizeof (*sdata);
2944
2945       sdata = bfd_zalloc (abfd, amt);
2946       if (sdata == NULL)
2947         return FALSE;
2948       sec->used_by_bfd = sdata;
2949     }
2950
2951   return _bfd_elf_new_section_hook (abfd, sec);
2952 }
2953
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2956 {
2957   if (sec != NULL
2958       && ppc64_elf_section_data (sec) != NULL
2959       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960     return &ppc64_elf_section_data (sec)->u.opd;
2961   return NULL;
2962 }
2963
2964 static inline int
2965 abiversion (bfd *abfd)
2966 {
2967   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2968 }
2969
2970 static inline void
2971 set_abiversion (bfd *abfd, int ver)
2972 {
2973   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2975 }
2976 \f
2977 /* Parameters for the qsort hook.  */
2978 static bfd_boolean synthetic_relocatable;
2979
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2981
2982 static int
2983 compare_symbols (const void *ap, const void *bp)
2984 {
2985   const asymbol *a = * (const asymbol **) ap;
2986   const asymbol *b = * (const asymbol **) bp;
2987
2988   /* Section symbols first.  */
2989   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2990     return -1;
2991   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2992     return 1;
2993
2994   /* then .opd symbols.  */
2995   if (strcmp (a->section->name, ".opd") == 0
2996       && strcmp (b->section->name, ".opd") != 0)
2997     return -1;
2998   if (strcmp (a->section->name, ".opd") != 0
2999       && strcmp (b->section->name, ".opd") == 0)
3000     return 1;
3001
3002   /* then other code symbols.  */
3003   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004       == (SEC_CODE | SEC_ALLOC)
3005       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006          != (SEC_CODE | SEC_ALLOC))
3007     return -1;
3008
3009   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010       != (SEC_CODE | SEC_ALLOC)
3011       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012          == (SEC_CODE | SEC_ALLOC))
3013     return 1;
3014
3015   if (synthetic_relocatable)
3016     {
3017       if (a->section->id < b->section->id)
3018         return -1;
3019
3020       if (a->section->id > b->section->id)
3021         return 1;
3022     }
3023
3024   if (a->value + a->section->vma < b->value + b->section->vma)
3025     return -1;
3026
3027   if (a->value + a->section->vma > b->value + b->section->vma)
3028     return 1;
3029
3030   /* For syms with the same value, prefer strong dynamic global function
3031      syms over other syms.  */
3032   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3033     return -1;
3034
3035   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3036     return 1;
3037
3038   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3039     return -1;
3040
3041   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3042     return 1;
3043
3044   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3045     return -1;
3046
3047   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3048     return 1;
3049
3050   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3051     return -1;
3052
3053   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3054     return 1;
3055
3056   return 0;
3057 }
3058
3059 /* Search SYMS for a symbol of the given VALUE.  */
3060
3061 static asymbol *
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3063 {
3064   long mid;
3065
3066   if (id == -1)
3067     {
3068       while (lo < hi)
3069         {
3070           mid = (lo + hi) >> 1;
3071           if (syms[mid]->value + syms[mid]->section->vma < value)
3072             lo = mid + 1;
3073           else if (syms[mid]->value + syms[mid]->section->vma > value)
3074             hi = mid;
3075           else
3076             return syms[mid];
3077         }
3078     }
3079   else
3080     {
3081       while (lo < hi)
3082         {
3083           mid = (lo + hi) >> 1;
3084           if (syms[mid]->section->id < id)
3085             lo = mid + 1;
3086           else if (syms[mid]->section->id > id)
3087             hi = mid;
3088           else if (syms[mid]->value < value)
3089             lo = mid + 1;
3090           else if (syms[mid]->value > value)
3091             hi = mid;
3092           else
3093             return syms[mid];
3094         }
3095     }
3096   return NULL;
3097 }
3098
3099 static bfd_boolean
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3101 {
3102   bfd_vma vma = *(bfd_vma *) ptr;
3103   return ((section->flags & SEC_ALLOC) != 0
3104           && section->vma <= vma
3105           && vma < section->vma + section->size);
3106 }
3107
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109    entry syms.  Also generate @plt symbols for the glink branch table.  */
3110
3111 static long
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113                                 long static_count, asymbol **static_syms,
3114                                 long dyn_count, asymbol **dyn_syms,
3115                                 asymbol **ret)
3116 {
3117   asymbol *s;
3118   long i;
3119   long count;
3120   char *names;
3121   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122   asection *opd = NULL;
3123   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3124   asymbol **syms;
3125   int abi = abiversion (abfd);
3126
3127   *ret = NULL;
3128
3129   if (abi < 2)
3130     {
3131       opd = bfd_get_section_by_name (abfd, ".opd");
3132       if (opd == NULL && abi == 1)
3133         return 0;
3134     }
3135
3136   symcount = static_count;
3137   if (!relocatable)
3138     symcount += dyn_count;
3139   if (symcount == 0)
3140     return 0;
3141
3142   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3143   if (syms == NULL)
3144     return -1;
3145
3146   if (!relocatable && static_count != 0 && dyn_count != 0)
3147     {
3148       /* Use both symbol tables.  */
3149       memcpy (syms, static_syms, static_count * sizeof (*syms));
3150       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3151     }
3152   else if (!relocatable && static_count == 0)
3153     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3154   else
3155     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3156
3157   synthetic_relocatable = relocatable;
3158   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3159
3160   if (!relocatable && symcount > 1)
3161     {
3162       long j;
3163       /* Trim duplicate syms, since we may have merged the normal and
3164          dynamic symbols.  Actually, we only care about syms that have
3165          different values, so trim any with the same value.  */
3166       for (i = 1, j = 1; i < symcount; ++i)
3167         if (syms[i - 1]->value + syms[i - 1]->section->vma
3168             != syms[i]->value + syms[i]->section->vma)
3169           syms[j++] = syms[i];
3170       symcount = j;
3171     }
3172
3173   i = 0;
3174   if (strcmp (syms[i]->section->name, ".opd") == 0)
3175     ++i;
3176   codesecsym = i;
3177
3178   for (; i < symcount; ++i)
3179     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180          != (SEC_CODE | SEC_ALLOC))
3181         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3182       break;
3183   codesecsymend = i;
3184
3185   for (; i < symcount; ++i)
3186     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3187       break;
3188   secsymend = i;
3189
3190   for (; i < symcount; ++i)
3191     if (strcmp (syms[i]->section->name, ".opd") != 0)
3192       break;
3193   opdsymend = i;
3194
3195   for (; i < symcount; ++i)
3196     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197         != (SEC_CODE | SEC_ALLOC))
3198       break;
3199   symcount = i;
3200
3201   count = 0;
3202
3203   if (relocatable)
3204     {
3205       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3206       arelent *r;
3207       size_t size;
3208       long relcount;
3209
3210       if (opdsymend == secsymend)
3211         goto done;
3212
3213       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3215       if (relcount == 0)
3216         goto done;
3217
3218       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3219         {
3220           count = -1;
3221           goto done;
3222         }
3223
3224       size = 0;
3225       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3226         {
3227           asymbol *sym;
3228
3229           while (r < opd->relocation + relcount
3230                  && r->address < syms[i]->value + opd->vma)
3231             ++r;
3232
3233           if (r == opd->relocation + relcount)
3234             break;
3235
3236           if (r->address != syms[i]->value + opd->vma)
3237             continue;
3238
3239           if (r->howto->type != R_PPC64_ADDR64)
3240             continue;
3241
3242           sym = *r->sym_ptr_ptr;
3243           if (!sym_exists_at (syms, opdsymend, symcount,
3244                               sym->section->id, sym->value + r->addend))
3245             {
3246               ++count;
3247               size += sizeof (asymbol);
3248               size += strlen (syms[i]->name) + 2;
3249             }
3250         }
3251
3252       s = *ret = bfd_malloc (size);
3253       if (s == NULL)
3254         {
3255           count = -1;
3256           goto done;
3257         }
3258
3259       names = (char *) (s + count);
3260
3261       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3262         {
3263           asymbol *sym;
3264
3265           while (r < opd->relocation + relcount
3266                  && r->address < syms[i]->value + opd->vma)
3267             ++r;
3268
3269           if (r == opd->relocation + relcount)
3270             break;
3271
3272           if (r->address != syms[i]->value + opd->vma)
3273             continue;
3274
3275           if (r->howto->type != R_PPC64_ADDR64)
3276             continue;
3277
3278           sym = *r->sym_ptr_ptr;
3279           if (!sym_exists_at (syms, opdsymend, symcount,
3280                               sym->section->id, sym->value + r->addend))
3281             {
3282               size_t len;
3283
3284               *s = *syms[i];
3285               s->flags |= BSF_SYNTHETIC;
3286               s->section = sym->section;
3287               s->value = sym->value + r->addend;
3288               s->name = names;
3289               *names++ = '.';
3290               len = strlen (syms[i]->name);
3291               memcpy (names, syms[i]->name, len + 1);
3292               names += len + 1;
3293               /* Have udata.p point back to the original symbol this
3294                  synthetic symbol was derived from.  */
3295               s->udata.p = syms[i];
3296               s++;
3297             }
3298         }
3299     }
3300   else
3301     {
3302       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303       bfd_byte *contents = NULL;
3304       size_t size;
3305       long plt_count = 0;
3306       bfd_vma glink_vma = 0, resolv_vma = 0;
3307       asection *dynamic, *glink = NULL, *relplt = NULL;
3308       arelent *p;
3309
3310       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3311         {
3312         free_contents_and_exit:
3313           if (contents)
3314             free (contents);
3315           count = -1;
3316           goto done;
3317         }
3318
3319       size = 0;
3320       for (i = secsymend; i < opdsymend; ++i)
3321         {
3322           bfd_vma ent;
3323
3324           /* Ignore bogus symbols.  */
3325           if (syms[i]->value > opd->size - 8)
3326             continue;
3327
3328           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3330             {
3331               ++count;
3332               size += sizeof (asymbol);
3333               size += strlen (syms[i]->name) + 2;
3334             }
3335         }
3336
3337       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3338       if (dyn_count != 0
3339           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3340         {
3341           bfd_byte *dynbuf, *extdyn, *extdynend;
3342           size_t extdynsize;
3343           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3344
3345           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346             goto free_contents_and_exit;
3347
3348           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3350
3351           extdyn = dynbuf;
3352           extdynend = extdyn + dynamic->size;
3353           for (; extdyn < extdynend; extdyn += extdynsize)
3354             {
3355               Elf_Internal_Dyn dyn;
3356               (*swap_dyn_in) (abfd, extdyn, &dyn);
3357
3358               if (dyn.d_tag == DT_NULL)
3359                 break;
3360
3361               if (dyn.d_tag == DT_PPC64_GLINK)
3362                 {
3363                   /* The first glink stub starts at offset 32; see
3364                      comment in ppc64_elf_finish_dynamic_sections. */
3365                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366                   /* The .glink section usually does not survive the final
3367                      link; search for the section (usually .text) where the
3368                      glink stubs now reside.  */
3369                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3370                                                 &glink_vma);
3371                   break;
3372                 }
3373             }
3374
3375           free (dynbuf);
3376         }
3377
3378       if (glink != NULL)
3379         {
3380           /* Determine __glink trampoline by reading the relative branch
3381              from the first glink stub.  */
3382           bfd_byte buf[4];
3383           unsigned int off = 0;
3384
3385           while (bfd_get_section_contents (abfd, glink, buf,
3386                                            glink_vma + off - glink->vma, 4))
3387             {
3388               unsigned int insn = bfd_get_32 (abfd, buf);
3389               insn ^= B_DOT;
3390               if ((insn & ~0x3fffffc) == 0)
3391                 {
3392                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3393                   break;
3394                 }
3395               off += 4;
3396               if (off > 4)
3397                 break;
3398             }
3399
3400           if (resolv_vma)
3401             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3402
3403           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3404           if (relplt != NULL)
3405             {
3406               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408                 goto free_contents_and_exit;
3409
3410               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411               size += plt_count * sizeof (asymbol);
3412
3413               p = relplt->relocation;
3414               for (i = 0; i < plt_count; i++, p++)
3415                 {
3416                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3417                   if (p->addend != 0)
3418                     size += sizeof ("+0x") - 1 + 16;
3419                 }
3420             }
3421         }
3422
3423       s = *ret = bfd_malloc (size);
3424       if (s == NULL)
3425         goto free_contents_and_exit;
3426
3427       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3428
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           if (syms[i]->value > opd->size - 8)
3434             continue;
3435
3436           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3438             {
3439               long lo, hi;
3440               size_t len;
3441               asection *sec = abfd->sections;
3442
3443               *s = *syms[i];
3444               lo = codesecsym;
3445               hi = codesecsymend;
3446               while (lo < hi)
3447                 {
3448                   long mid = (lo + hi) >> 1;
3449                   if (syms[mid]->section->vma < ent)
3450                     lo = mid + 1;
3451                   else if (syms[mid]->section->vma > ent)
3452                     hi = mid;
3453                   else
3454                     {
3455                       sec = syms[mid]->section;
3456                       break;
3457                     }
3458                 }
3459
3460               if (lo >= hi && lo > codesecsym)
3461                 sec = syms[lo - 1]->section;
3462
3463               for (; sec != NULL; sec = sec->next)
3464                 {
3465                   if (sec->vma > ent)
3466                     break;
3467                   /* SEC_LOAD may not be set if SEC is from a separate debug
3468                      info file.  */
3469                   if ((sec->flags & SEC_ALLOC) == 0)
3470                     break;
3471                   if ((sec->flags & SEC_CODE) != 0)
3472                     s->section = sec;
3473                 }
3474               s->flags |= BSF_SYNTHETIC;
3475               s->value = ent - s->section->vma;
3476               s->name = names;
3477               *names++ = '.';
3478               len = strlen (syms[i]->name);
3479               memcpy (names, syms[i]->name, len + 1);
3480               names += len + 1;
3481               /* Have udata.p point back to the original symbol this
3482                  synthetic symbol was derived from.  */
3483               s->udata.p = syms[i];
3484               s++;
3485             }
3486         }
3487       free (contents);
3488
3489       if (glink != NULL && relplt != NULL)
3490         {
3491           if (resolv_vma)
3492             {
3493               /* Add a symbol for the main glink trampoline.  */
3494               memset (s, 0, sizeof *s);
3495               s->the_bfd = abfd;
3496               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3497               s->section = glink;
3498               s->value = resolv_vma - glink->vma;
3499               s->name = names;
3500               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501               names += sizeof ("__glink_PLTresolve");
3502               s++;
3503               count++;
3504             }
3505
3506           /* FIXME: It would be very much nicer to put sym@plt on the
3507              stub rather than on the glink branch table entry.  The
3508              objdump disassembler would then use a sensible symbol
3509              name on plt calls.  The difficulty in doing so is
3510              a) finding the stubs, and,
3511              b) matching stubs against plt entries, and,
3512              c) there can be multiple stubs for a given plt entry.
3513
3514              Solving (a) could be done by code scanning, but older
3515              ppc64 binaries used different stubs to current code.
3516              (b) is the tricky one since you need to known the toc
3517              pointer for at least one function that uses a pic stub to
3518              be able to calculate the plt address referenced.
3519              (c) means gdb would need to set multiple breakpoints (or
3520              find the glink branch itself) when setting breakpoints
3521              for pending shared library loads.  */
3522           p = relplt->relocation;
3523           for (i = 0; i < plt_count; i++, p++)
3524             {
3525               size_t len;
3526
3527               *s = **p->sym_ptr_ptr;
3528               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3529                  we are defining a symbol, ensure one of them is set.  */
3530               if ((s->flags & BSF_LOCAL) == 0)
3531                 s->flags |= BSF_GLOBAL;
3532               s->flags |= BSF_SYNTHETIC;
3533               s->section = glink;
3534               s->value = glink_vma - glink->vma;
3535               s->name = names;
3536               s->udata.p = NULL;
3537               len = strlen ((*p->sym_ptr_ptr)->name);
3538               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3539               names += len;
3540               if (p->addend != 0)
3541                 {
3542                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3543                   names += sizeof ("+0x") - 1;
3544                   bfd_sprintf_vma (abfd, names, p->addend);
3545                   names += strlen (names);
3546                 }
3547               memcpy (names, "@plt", sizeof ("@plt"));
3548               names += sizeof ("@plt");
3549               s++;
3550               if (abi < 2)
3551                 {
3552                   glink_vma += 8;
3553                   if (i >= 0x8000)
3554                     glink_vma += 4;
3555                 }
3556               else
3557                 glink_vma += 4;
3558             }
3559           count += plt_count;
3560         }
3561     }
3562
3563  done:
3564   free (syms);
3565   return count;
3566 }
3567 \f
3568 /* The following functions are specific to the ELF linker, while
3569    functions above are used generally.  Those named ppc64_elf_* are
3570    called by the main ELF linker code.  They appear in this file more
3571    or less in the order in which they are called.  eg.
3572    ppc64_elf_check_relocs is called early in the link process,
3573    ppc64_elf_finish_dynamic_sections is one of the last functions
3574    called.
3575
3576    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577    functions have both a function code symbol and a function descriptor
3578    symbol.  A call to foo in a relocatable object file looks like:
3579
3580    .            .text
3581    .    x:
3582    .            bl      .foo
3583    .            nop
3584
3585    The function definition in another object file might be:
3586
3587    .            .section .opd
3588    .    foo:    .quad   .foo
3589    .            .quad   .TOC.@tocbase
3590    .            .quad   0
3591    .
3592    .            .text
3593    .    .foo:   blr
3594
3595    When the linker resolves the call during a static link, the branch
3596    unsurprisingly just goes to .foo and the .opd information is unused.
3597    If the function definition is in a shared library, things are a little
3598    different:  The call goes via a plt call stub, the opd information gets
3599    copied to the plt, and the linker patches the nop.
3600
3601    .    x:
3602    .            bl      .foo_stub
3603    .            ld      2,40(1)
3604    .
3605    .
3606    .    .foo_stub:
3607    .            std     2,40(1)                 # in practice, the call stub
3608    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3609    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3610    .            ld      12,0(11)
3611    .            ld      2,8(11)
3612    .            mtctr   12
3613    .            ld      11,16(11)
3614    .            bctr
3615    .
3616    .            .section .plt
3617    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3618
3619    The "reloc ()" notation is supposed to indicate that the linker emits
3620    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3621    copying.
3622
3623    What are the difficulties here?  Well, firstly, the relocations
3624    examined by the linker in check_relocs are against the function code
3625    sym .foo, while the dynamic relocation in the plt is emitted against
3626    the function descriptor symbol, foo.  Somewhere along the line, we need
3627    to carefully copy dynamic link information from one symbol to the other.
3628    Secondly, the generic part of the elf linker will make .foo a dynamic
3629    symbol as is normal for most other backends.  We need foo dynamic
3630    instead, at least for an application final link.  However, when
3631    creating a shared library containing foo, we need to have both symbols
3632    dynamic so that references to .foo are satisfied during the early
3633    stages of linking.  Otherwise the linker might decide to pull in a
3634    definition from some other object, eg. a static library.
3635
3636    Update: As of August 2004, we support a new convention.  Function
3637    calls may use the function descriptor symbol, ie. "bl foo".  This
3638    behaves exactly as "bl .foo".  */
3639
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641    selects those that must be copied when linking a shared library,
3642    even when the symbol is local.  */
3643
3644 static int
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646                    enum elf_ppc64_reloc_type r_type)
3647 {
3648   switch (r_type)
3649     {
3650     default:
3651       return 1;
3652
3653     case R_PPC64_REL32:
3654     case R_PPC64_REL64:
3655     case R_PPC64_REL30:
3656       return 0;
3657
3658     case R_PPC64_TPREL16:
3659     case R_PPC64_TPREL16_LO:
3660     case R_PPC64_TPREL16_HI:
3661     case R_PPC64_TPREL16_HA:
3662     case R_PPC64_TPREL16_DS:
3663     case R_PPC64_TPREL16_LO_DS:
3664     case R_PPC64_TPREL16_HIGH:
3665     case R_PPC64_TPREL16_HIGHA:
3666     case R_PPC64_TPREL16_HIGHER:
3667     case R_PPC64_TPREL16_HIGHERA:
3668     case R_PPC64_TPREL16_HIGHEST:
3669     case R_PPC64_TPREL16_HIGHESTA:
3670     case R_PPC64_TPREL64:
3671       return !info->executable;
3672     }
3673 }
3674
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676    copying dynamic variables from a shared lib into an app's dynbss
3677    section, and instead use a dynamic relocation to point into the
3678    shared lib.  With code that gcc generates, it's vital that this be
3679    enabled;  In the PowerPC64 ABI, the address of a function is actually
3680    the address of a function descriptor, which resides in the .opd
3681    section.  gcc uses the descriptor directly rather than going via the
3682    GOT as some other ABI's do, which means that initialized function
3683    pointers must reference the descriptor.  Thus, a function pointer
3684    initialized to the address of a function in a shared library will
3685    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3686    redefines the function descriptor symbol to point to the copy.  This
3687    presents a problem as a plt entry for that function is also
3688    initialized from the function descriptor symbol and the copy reloc
3689    may not be initialized first.  */
3690 #define ELIMINATE_COPY_RELOCS 1
3691
3692 /* Section name for stubs is the associated section name plus this
3693    string.  */
3694 #define STUB_SUFFIX ".stub"
3695
3696 /* Linker stubs.
3697    ppc_stub_long_branch:
3698    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699    destination, but a 24 bit branch in a stub section will reach.
3700    .    b       dest
3701
3702    ppc_stub_plt_branch:
3703    Similar to the above, but a 24 bit branch in the stub section won't
3704    reach its destination.
3705    .    addis   %r11,%r2,xxx@toc@ha
3706    .    ld      %r12,xxx@toc@l(%r11)
3707    .    mtctr   %r12
3708    .    bctr
3709
3710    ppc_stub_plt_call:
3711    Used to call a function in a shared library.  If it so happens that
3712    the plt entry referenced crosses a 64k boundary, then an extra
3713    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3714    .    std     %r2,40(%r1)
3715    .    addis   %r11,%r2,xxx@toc@ha
3716    .    ld      %r12,xxx+0@toc@l(%r11)
3717    .    mtctr   %r12
3718    .    ld      %r2,xxx+8@toc@l(%r11)
3719    .    ld      %r11,xxx+16@toc@l(%r11)
3720    .    bctr
3721
3722    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723    code to adjust the value and save r2 to support multiple toc sections.
3724    A ppc_stub_long_branch with an r2 offset looks like:
3725    .    std     %r2,40(%r1)
3726    .    addis   %r2,%r2,off@ha
3727    .    addi    %r2,%r2,off@l
3728    .    b       dest
3729
3730    A ppc_stub_plt_branch with an r2 offset looks like:
3731    .    std     %r2,40(%r1)
3732    .    addis   %r11,%r2,xxx@toc@ha
3733    .    ld      %r12,xxx@toc@l(%r11)
3734    .    addis   %r2,%r2,off@ha
3735    .    addi    %r2,%r2,off@l
3736    .    mtctr   %r12
3737    .    bctr
3738
3739    In cases where the "addis" instruction would add zero, the "addis" is
3740    omitted and following instructions modified slightly in some cases.
3741 */
3742
3743 enum ppc_stub_type {
3744   ppc_stub_none,
3745   ppc_stub_long_branch,
3746   ppc_stub_long_branch_r2off,
3747   ppc_stub_plt_branch,
3748   ppc_stub_plt_branch_r2off,
3749   ppc_stub_plt_call,
3750   ppc_stub_plt_call_r2save
3751 };
3752
3753 struct ppc_stub_hash_entry {
3754
3755   /* Base hash table entry structure.  */
3756   struct bfd_hash_entry root;
3757
3758   enum ppc_stub_type stub_type;
3759
3760   /* The stub section.  */
3761   asection *stub_sec;
3762
3763   /* Offset within stub_sec of the beginning of this stub.  */
3764   bfd_vma stub_offset;
3765
3766   /* Given the symbol's value and its section we can determine its final
3767      value when building the stubs (so the stub knows where to jump.  */
3768   bfd_vma target_value;
3769   asection *target_section;
3770
3771   /* The symbol table entry, if any, that this was derived from.  */
3772   struct ppc_link_hash_entry *h;
3773   struct plt_entry *plt_ent;
3774
3775   /* Where this stub is being called from, or, in the case of combined
3776      stub sections, the first input section in the group.  */
3777   asection *id_sec;
3778
3779   /* Symbol st_other.  */
3780   unsigned char other;
3781 };
3782
3783 struct ppc_branch_hash_entry {
3784
3785   /* Base hash table entry structure.  */
3786   struct bfd_hash_entry root;
3787
3788   /* Offset within branch lookup table.  */
3789   unsigned int offset;
3790
3791   /* Generation marker.  */
3792   unsigned int iter;
3793 };
3794
3795 /* Used to track dynamic relocations for local symbols.  */
3796 struct ppc_dyn_relocs
3797 {
3798   struct ppc_dyn_relocs *next;
3799
3800   /* The input section of the reloc.  */
3801   asection *sec;
3802
3803   /* Total number of relocs copied for the input section.  */
3804   unsigned int count : 31;
3805
3806   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3807   unsigned int ifunc : 1;
3808 };
3809
3810 struct ppc_link_hash_entry
3811 {
3812   struct elf_link_hash_entry elf;
3813
3814   union {
3815     /* A pointer to the most recently used stub hash entry against this
3816        symbol.  */
3817     struct ppc_stub_hash_entry *stub_cache;
3818
3819     /* A pointer to the next symbol starting with a '.'  */
3820     struct ppc_link_hash_entry *next_dot_sym;
3821   } u;
3822
3823   /* Track dynamic relocs copied for this symbol.  */
3824   struct elf_dyn_relocs *dyn_relocs;
3825
3826   /* Link between function code and descriptor symbols.  */
3827   struct ppc_link_hash_entry *oh;
3828
3829   /* Flag function code and descriptor symbols.  */
3830   unsigned int is_func:1;
3831   unsigned int is_func_descriptor:1;
3832   unsigned int fake:1;
3833
3834   /* Whether global opd/toc sym has been adjusted or not.
3835      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836      should be set for all globals defined in any opd/toc section.  */
3837   unsigned int adjust_done:1;
3838
3839   /* Set if we twiddled this symbol to weak at some stage.  */
3840   unsigned int was_undefined:1;
3841
3842   /* Contexts in which symbol is used in the GOT (or TOC).
3843      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844      corresponding relocs are encountered during check_relocs.
3845      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846      indicate the corresponding GOT entry type is not needed.
3847      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848      a TPREL one.  We use a separate flag rather than setting TPREL
3849      just for convenience in distinguishing the two cases.  */
3850 #define TLS_GD           1      /* GD reloc. */
3851 #define TLS_LD           2      /* LD reloc. */
3852 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3853 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3854 #define TLS_TLS         16      /* Any TLS reloc.  */
3855 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3858   unsigned char tls_mask;
3859 };
3860
3861 /* ppc64 ELF linker hash table.  */
3862
3863 struct ppc_link_hash_table
3864 {
3865   struct elf_link_hash_table elf;
3866
3867   /* The stub hash table.  */
3868   struct bfd_hash_table stub_hash_table;
3869
3870   /* Another hash table for plt_branch stubs.  */
3871   struct bfd_hash_table branch_hash_table;
3872
3873   /* Hash table for function prologue tocsave.  */
3874   htab_t tocsave_htab;
3875
3876   /* Linker stub bfd.  */
3877   bfd *stub_bfd;
3878
3879   /* Linker call-backs.  */
3880   asection * (*add_stub_section) (const char *, asection *);
3881   void (*layout_sections_again) (void);
3882
3883   /* Array to keep track of which stub sections have been created, and
3884      information on stub grouping.  */
3885   struct map_stub {
3886     /* This is the section to which stubs in the group will be attached.  */
3887     asection *link_sec;
3888     /* The stub section.  */
3889     asection *stub_sec;
3890     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3891     bfd_vma toc_off;
3892   } *stub_group;
3893
3894   /* Temp used when calculating TOC pointers.  */
3895   bfd_vma toc_curr;
3896   bfd *toc_bfd;
3897   asection *toc_first_sec;
3898
3899   /* Highest input section id.  */
3900   int top_id;
3901
3902   /* Highest output section index.  */
3903   int top_index;
3904
3905   /* Used when adding symbols.  */
3906   struct ppc_link_hash_entry *dot_syms;
3907
3908   /* List of input sections for each output section.  */
3909   asection **input_list;
3910
3911   /* Shortcuts to get to dynamic linker sections.  */
3912   asection *dynbss;
3913   asection *relbss;
3914   asection *glink;
3915   asection *sfpr;
3916   asection *brlt;
3917   asection *relbrlt;
3918   asection *glink_eh_frame;
3919
3920   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3921   struct ppc_link_hash_entry *tls_get_addr;
3922   struct ppc_link_hash_entry *tls_get_addr_fd;
3923
3924   /* The size of reliplt used by got entry relocs.  */
3925   bfd_size_type got_reli_size;
3926
3927   /* Statistics.  */
3928   unsigned long stub_count[ppc_stub_plt_call_r2save];
3929
3930   /* Number of stubs against global syms.  */
3931   unsigned long stub_globals;
3932
3933   /* Alignment of PLT call stubs.  */
3934   unsigned int plt_stub_align:4;
3935
3936   /* Set if we're linking code with function descriptors.  */
3937   unsigned int opd_abi:1;
3938
3939   /* Set if PLT call stubs should load r11.  */
3940   unsigned int plt_static_chain:1;
3941
3942   /* Set if PLT call stubs need a read-read barrier.  */
3943   unsigned int plt_thread_safe:1;
3944
3945   /* Set if we should emit symbols for stubs.  */
3946   unsigned int emit_stub_syms:1;
3947
3948   /* Set if __tls_get_addr optimization should not be done.  */
3949   unsigned int no_tls_get_addr_opt:1;
3950
3951   /* Support for multiple toc sections.  */
3952   unsigned int do_multi_toc:1;
3953   unsigned int multi_toc_needed:1;
3954   unsigned int second_toc_pass:1;
3955   unsigned int do_toc_opt:1;
3956
3957   /* Set on error.  */
3958   unsigned int stub_error:1;
3959
3960   /* Temp used by ppc64_elf_process_dot_syms.  */
3961   unsigned int twiddled_syms:1;
3962
3963   /* Incremented every time we size stubs.  */
3964   unsigned int stub_iteration;
3965
3966   /* Small local sym cache.  */
3967   struct sym_cache sym_cache;
3968 };
3969
3970 /* Rename some of the generic section flags to better document how they
3971    are used here.  */
3972
3973 /* Nonzero if this section has TLS related relocations.  */
3974 #define has_tls_reloc sec_flg0
3975
3976 /* Nonzero if this section has a call to __tls_get_addr.  */
3977 #define has_tls_get_addr_call sec_flg1
3978
3979 /* Nonzero if this section has any toc or got relocs.  */
3980 #define has_toc_reloc sec_flg2
3981
3982 /* Nonzero if this section has a call to another section that uses
3983    the toc or got.  */
3984 #define makes_toc_func_call sec_flg3
3985
3986 /* Recursion protection when determining above flag.  */
3987 #define call_check_in_progress sec_flg4
3988 #define call_check_done sec_flg5
3989
3990 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3991
3992 #define ppc_hash_table(p) \
3993   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3994   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3995
3996 #define ppc_stub_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_stub_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 #define ppc_branch_hash_lookup(table, string, create, copy) \
4001   ((struct ppc_branch_hash_entry *) \
4002    bfd_hash_lookup ((table), (string), (create), (copy)))
4003
4004 /* Create an entry in the stub hash table.  */
4005
4006 static struct bfd_hash_entry *
4007 stub_hash_newfunc (struct bfd_hash_entry *entry,
4008                    struct bfd_hash_table *table,
4009                    const char *string)
4010 {
4011   /* Allocate the structure if it has not already been allocated by a
4012      subclass.  */
4013   if (entry == NULL)
4014     {
4015       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016       if (entry == NULL)
4017         return entry;
4018     }
4019
4020   /* Call the allocation method of the superclass.  */
4021   entry = bfd_hash_newfunc (entry, table, string);
4022   if (entry != NULL)
4023     {
4024       struct ppc_stub_hash_entry *eh;
4025
4026       /* Initialize the local fields.  */
4027       eh = (struct ppc_stub_hash_entry *) entry;
4028       eh->stub_type = ppc_stub_none;
4029       eh->stub_sec = NULL;
4030       eh->stub_offset = 0;
4031       eh->target_value = 0;
4032       eh->target_section = NULL;
4033       eh->h = NULL;
4034       eh->plt_ent = NULL;
4035       eh->id_sec = NULL;
4036       eh->other = 0;
4037     }
4038
4039   return entry;
4040 }
4041
4042 /* Create an entry in the branch hash table.  */
4043
4044 static struct bfd_hash_entry *
4045 branch_hash_newfunc (struct bfd_hash_entry *entry,
4046                      struct bfd_hash_table *table,
4047                      const char *string)
4048 {
4049   /* Allocate the structure if it has not already been allocated by a
4050      subclass.  */
4051   if (entry == NULL)
4052     {
4053       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054       if (entry == NULL)
4055         return entry;
4056     }
4057
4058   /* Call the allocation method of the superclass.  */
4059   entry = bfd_hash_newfunc (entry, table, string);
4060   if (entry != NULL)
4061     {
4062       struct ppc_branch_hash_entry *eh;
4063
4064       /* Initialize the local fields.  */
4065       eh = (struct ppc_branch_hash_entry *) entry;
4066       eh->offset = 0;
4067       eh->iter = 0;
4068     }
4069
4070   return entry;
4071 }
4072
4073 /* Create an entry in a ppc64 ELF linker hash table.  */
4074
4075 static struct bfd_hash_entry *
4076 link_hash_newfunc (struct bfd_hash_entry *entry,
4077                    struct bfd_hash_table *table,
4078                    const char *string)
4079 {
4080   /* Allocate the structure if it has not already been allocated by a
4081      subclass.  */
4082   if (entry == NULL)
4083     {
4084       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085       if (entry == NULL)
4086         return entry;
4087     }
4088
4089   /* Call the allocation method of the superclass.  */
4090   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4091   if (entry != NULL)
4092     {
4093       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4094
4095       memset (&eh->u.stub_cache, 0,
4096               (sizeof (struct ppc_link_hash_entry)
4097                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4098
4099       /* When making function calls, old ABI code references function entry
4100          points (dot symbols), while new ABI code references the function
4101          descriptor symbol.  We need to make any combination of reference and
4102          definition work together, without breaking archive linking.
4103
4104          For a defined function "foo" and an undefined call to "bar":
4105          An old object defines "foo" and ".foo", references ".bar" (possibly
4106          "bar" too).
4107          A new object defines "foo" and references "bar".
4108
4109          A new object thus has no problem with its undefined symbols being
4110          satisfied by definitions in an old object.  On the other hand, the
4111          old object won't have ".bar" satisfied by a new object.
4112
4113          Keep a list of newly added dot-symbols.  */
4114
4115       if (string[0] == '.')
4116         {
4117           struct ppc_link_hash_table *htab;
4118
4119           htab = (struct ppc_link_hash_table *) table;
4120           eh->u.next_dot_sym = htab->dot_syms;
4121           htab->dot_syms = eh;
4122         }
4123     }
4124
4125   return entry;
4126 }
4127
4128 struct tocsave_entry {
4129   asection *sec;
4130   bfd_vma offset;
4131 };
4132
4133 static hashval_t
4134 tocsave_htab_hash (const void *p)
4135 {
4136   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4137   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4138 }
4139
4140 static int
4141 tocsave_htab_eq (const void *p1, const void *p2)
4142 {
4143   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4144   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4145   return e1->sec == e2->sec && e1->offset == e2->offset;
4146 }
4147
4148 /* Create a ppc64 ELF linker hash table.  */
4149
4150 static struct bfd_link_hash_table *
4151 ppc64_elf_link_hash_table_create (bfd *abfd)
4152 {
4153   struct ppc_link_hash_table *htab;
4154   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4155
4156   htab = bfd_zmalloc (amt);
4157   if (htab == NULL)
4158     return NULL;
4159
4160   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4161                                       sizeof (struct ppc_link_hash_entry),
4162                                       PPC64_ELF_DATA))
4163     {
4164       free (htab);
4165       return NULL;
4166     }
4167
4168   /* Init the stub hash table too.  */
4169   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4170                             sizeof (struct ppc_stub_hash_entry)))
4171     {
4172       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4173       return NULL;
4174     }
4175
4176   /* And the branch hash table.  */
4177   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4178                             sizeof (struct ppc_branch_hash_entry)))
4179     {
4180       bfd_hash_table_free (&htab->stub_hash_table);
4181       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4182       return NULL;
4183     }
4184
4185   htab->tocsave_htab = htab_try_create (1024,
4186                                         tocsave_htab_hash,
4187                                         tocsave_htab_eq,
4188                                         NULL);
4189   if (htab->tocsave_htab == NULL)
4190     {
4191       bfd_hash_table_free (&htab->branch_hash_table);
4192       bfd_hash_table_free (&htab->stub_hash_table);
4193       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4194       return NULL;
4195     }
4196
4197   /* Initializing two fields of the union is just cosmetic.  We really
4198      only care about glist, but when compiled on a 32-bit host the
4199      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4200      debugger inspection of these fields look nicer.  */
4201   htab->elf.init_got_refcount.refcount = 0;
4202   htab->elf.init_got_refcount.glist = NULL;
4203   htab->elf.init_plt_refcount.refcount = 0;
4204   htab->elf.init_plt_refcount.glist = NULL;
4205   htab->elf.init_got_offset.offset = 0;
4206   htab->elf.init_got_offset.glist = NULL;
4207   htab->elf.init_plt_offset.offset = 0;
4208   htab->elf.init_plt_offset.glist = NULL;
4209
4210   return &htab->elf.root;
4211 }
4212
4213 /* Free the derived linker hash table.  */
4214
4215 static void
4216 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4217 {
4218   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4219
4220   bfd_hash_table_free (&htab->stub_hash_table);
4221   bfd_hash_table_free (&htab->branch_hash_table);
4222   if (htab->tocsave_htab)
4223     htab_delete (htab->tocsave_htab);
4224   _bfd_elf_link_hash_table_free (hash);
4225 }
4226
4227 /* Create sections for linker generated code.  */
4228
4229 static bfd_boolean
4230 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4231 {
4232   struct ppc_link_hash_table *htab;
4233   flagword flags;
4234
4235   htab = ppc_hash_table (info);
4236
4237   /* Create .sfpr for code to save and restore fp regs.  */
4238   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4239            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4240   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4241                                                    flags);
4242   if (htab->sfpr == NULL
4243       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4244     return FALSE;
4245
4246   /* Create .glink for lazy dynamic linking support.  */
4247   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4248                                                     flags);
4249   if (htab->glink == NULL
4250       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4251     return FALSE;
4252
4253   if (!info->no_ld_generated_unwind_info)
4254     {
4255       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4256                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4257       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4258                                                                  ".eh_frame",
4259                                                                  flags);
4260       if (htab->glink_eh_frame == NULL
4261           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4262         return FALSE;
4263     }
4264
4265   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4266   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4267   if (htab->elf.iplt == NULL
4268       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4269     return FALSE;
4270
4271   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4272            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4273   htab->elf.irelplt
4274     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4275   if (htab->elf.irelplt == NULL
4276       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4277     return FALSE;
4278
4279   /* Create branch lookup table for plt_branch stubs.  */
4280   flags = (SEC_ALLOC | SEC_LOAD
4281            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4282   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4283                                                    flags);
4284   if (htab->brlt == NULL
4285       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4286     return FALSE;
4287
4288   if (!info->shared)
4289     return TRUE;
4290
4291   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4292            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4293   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4294                                                       ".rela.branch_lt",
4295                                                       flags);
4296   if (htab->relbrlt == NULL
4297       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4298     return FALSE;
4299
4300   return TRUE;
4301 }
4302
4303 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4304
4305 bfd_boolean
4306 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4307 {
4308   struct ppc_link_hash_table *htab;
4309
4310   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4311
4312 /* Always hook our dynamic sections into the first bfd, which is the
4313    linker created stub bfd.  This ensures that the GOT header is at
4314    the start of the output TOC section.  */
4315   htab = ppc_hash_table (info);
4316   if (htab == NULL)
4317     return FALSE;
4318   htab->stub_bfd = abfd;
4319   htab->elf.dynobj = abfd;
4320
4321   if (info->relocatable)
4322     return TRUE;
4323
4324   return create_linkage_sections (htab->elf.dynobj, info);
4325 }
4326
4327 /* Build a name for an entry in the stub hash table.  */
4328
4329 static char *
4330 ppc_stub_name (const asection *input_section,
4331                const asection *sym_sec,
4332                const struct ppc_link_hash_entry *h,
4333                const Elf_Internal_Rela *rel)
4334 {
4335   char *stub_name;
4336   ssize_t len;
4337
4338   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4339      offsets from a sym as a branch target?  In fact, we could
4340      probably assume the addend is always zero.  */
4341   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4342
4343   if (h)
4344     {
4345       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4346       stub_name = bfd_malloc (len);
4347       if (stub_name == NULL)
4348         return stub_name;
4349
4350       len = sprintf (stub_name, "%08x.%s+%x",
4351                      input_section->id & 0xffffffff,
4352                      h->elf.root.root.string,
4353                      (int) rel->r_addend & 0xffffffff);
4354     }
4355   else
4356     {
4357       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4358       stub_name = bfd_malloc (len);
4359       if (stub_name == NULL)
4360         return stub_name;
4361
4362       len = sprintf (stub_name, "%08x.%x:%x+%x",
4363                      input_section->id & 0xffffffff,
4364                      sym_sec->id & 0xffffffff,
4365                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4366                      (int) rel->r_addend & 0xffffffff);
4367     }
4368   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4369     stub_name[len - 2] = 0;
4370   return stub_name;
4371 }
4372
4373 /* Look up an entry in the stub hash.  Stub entries are cached because
4374    creating the stub name takes a bit of time.  */
4375
4376 static struct ppc_stub_hash_entry *
4377 ppc_get_stub_entry (const asection *input_section,
4378                     const asection *sym_sec,
4379                     struct ppc_link_hash_entry *h,
4380                     const Elf_Internal_Rela *rel,
4381                     struct ppc_link_hash_table *htab)
4382 {
4383   struct ppc_stub_hash_entry *stub_entry;
4384   const asection *id_sec;
4385
4386   /* If this input section is part of a group of sections sharing one
4387      stub section, then use the id of the first section in the group.
4388      Stub names need to include a section id, as there may well be
4389      more than one stub used to reach say, printf, and we need to
4390      distinguish between them.  */
4391   id_sec = htab->stub_group[input_section->id].link_sec;
4392
4393   if (h != NULL && h->u.stub_cache != NULL
4394       && h->u.stub_cache->h == h
4395       && h->u.stub_cache->id_sec == id_sec)
4396     {
4397       stub_entry = h->u.stub_cache;
4398     }
4399   else
4400     {
4401       char *stub_name;
4402
4403       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4404       if (stub_name == NULL)
4405         return NULL;
4406
4407       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4408                                          stub_name, FALSE, FALSE);
4409       if (h != NULL)
4410         h->u.stub_cache = stub_entry;
4411
4412       free (stub_name);
4413     }
4414
4415   return stub_entry;
4416 }
4417
4418 /* Add a new stub entry to the stub hash.  Not all fields of the new
4419    stub entry are initialised.  */
4420
4421 static struct ppc_stub_hash_entry *
4422 ppc_add_stub (const char *stub_name,
4423               asection *section,
4424               struct bfd_link_info *info)
4425 {
4426   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4427   asection *link_sec;
4428   asection *stub_sec;
4429   struct ppc_stub_hash_entry *stub_entry;
4430
4431   link_sec = htab->stub_group[section->id].link_sec;
4432   stub_sec = htab->stub_group[section->id].stub_sec;
4433   if (stub_sec == NULL)
4434     {
4435       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4436       if (stub_sec == NULL)
4437         {
4438           size_t namelen;
4439           bfd_size_type len;
4440           char *s_name;
4441
4442           namelen = strlen (link_sec->name);
4443           len = namelen + sizeof (STUB_SUFFIX);
4444           s_name = bfd_alloc (htab->stub_bfd, len);
4445           if (s_name == NULL)
4446             return NULL;
4447
4448           memcpy (s_name, link_sec->name, namelen);
4449           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4450           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4451           if (stub_sec == NULL)
4452             return NULL;
4453           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4454         }
4455       htab->stub_group[section->id].stub_sec = stub_sec;
4456     }
4457
4458   /* Enter this entry into the linker stub hash table.  */
4459   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4460                                      TRUE, FALSE);
4461   if (stub_entry == NULL)
4462     {
4463       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4464                               section->owner, stub_name);
4465       return NULL;
4466     }
4467
4468   stub_entry->stub_sec = stub_sec;
4469   stub_entry->stub_offset = 0;
4470   stub_entry->id_sec = link_sec;
4471   return stub_entry;
4472 }
4473
4474 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4475    not already done.  */
4476
4477 static bfd_boolean
4478 create_got_section (bfd *abfd, struct bfd_link_info *info)
4479 {
4480   asection *got, *relgot;
4481   flagword flags;
4482   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4483
4484   if (!is_ppc64_elf (abfd))
4485     return FALSE;
4486   if (htab == NULL)
4487     return FALSE;
4488
4489   if (!htab->elf.sgot
4490       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4491     return FALSE;
4492
4493   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4494            | SEC_LINKER_CREATED);
4495
4496   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4497   if (!got
4498       || !bfd_set_section_alignment (abfd, got, 3))
4499     return FALSE;
4500
4501   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4502                                                flags | SEC_READONLY);
4503   if (!relgot
4504       || ! bfd_set_section_alignment (abfd, relgot, 3))
4505     return FALSE;
4506
4507   ppc64_elf_tdata (abfd)->got = got;
4508   ppc64_elf_tdata (abfd)->relgot = relgot;
4509   return TRUE;
4510 }
4511
4512 /* Create the dynamic sections, and set up shortcuts.  */
4513
4514 static bfd_boolean
4515 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4516 {
4517   struct ppc_link_hash_table *htab;
4518
4519   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4520     return FALSE;
4521
4522   htab = ppc_hash_table (info);
4523   if (htab == NULL)
4524     return FALSE;
4525
4526   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4527   if (!info->shared)
4528     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4529
4530   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4531       || (!info->shared && !htab->relbss))
4532     abort ();
4533
4534   return TRUE;
4535 }
4536
4537 /* Follow indirect and warning symbol links.  */
4538
4539 static inline struct bfd_link_hash_entry *
4540 follow_link (struct bfd_link_hash_entry *h)
4541 {
4542   while (h->type == bfd_link_hash_indirect
4543          || h->type == bfd_link_hash_warning)
4544     h = h->u.i.link;
4545   return h;
4546 }
4547
4548 static inline struct elf_link_hash_entry *
4549 elf_follow_link (struct elf_link_hash_entry *h)
4550 {
4551   return (struct elf_link_hash_entry *) follow_link (&h->root);
4552 }
4553
4554 static inline struct ppc_link_hash_entry *
4555 ppc_follow_link (struct ppc_link_hash_entry *h)
4556 {
4557   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4558 }
4559
4560 /* Merge PLT info on FROM with that on TO.  */
4561
4562 static void
4563 move_plt_plist (struct ppc_link_hash_entry *from,
4564                 struct ppc_link_hash_entry *to)
4565 {
4566   if (from->elf.plt.plist != NULL)
4567     {
4568       if (to->elf.plt.plist != NULL)
4569         {
4570           struct plt_entry **entp;
4571           struct plt_entry *ent;
4572
4573           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4574             {
4575               struct plt_entry *dent;
4576
4577               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4578                 if (dent->addend == ent->addend)
4579                   {
4580                     dent->plt.refcount += ent->plt.refcount;
4581                     *entp = ent->next;
4582                     break;
4583                   }
4584               if (dent == NULL)
4585                 entp = &ent->next;
4586             }
4587           *entp = to->elf.plt.plist;
4588         }
4589
4590       to->elf.plt.plist = from->elf.plt.plist;
4591       from->elf.plt.plist = NULL;
4592     }
4593 }
4594
4595 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4596
4597 static void
4598 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4599                                 struct elf_link_hash_entry *dir,
4600                                 struct elf_link_hash_entry *ind)
4601 {
4602   struct ppc_link_hash_entry *edir, *eind;
4603
4604   edir = (struct ppc_link_hash_entry *) dir;
4605   eind = (struct ppc_link_hash_entry *) ind;
4606
4607   edir->is_func |= eind->is_func;
4608   edir->is_func_descriptor |= eind->is_func_descriptor;
4609   edir->tls_mask |= eind->tls_mask;
4610   if (eind->oh != NULL)
4611     edir->oh = ppc_follow_link (eind->oh);
4612
4613   /* If called to transfer flags for a weakdef during processing
4614      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4615      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4616   if (!(ELIMINATE_COPY_RELOCS
4617         && eind->elf.root.type != bfd_link_hash_indirect
4618         && edir->elf.dynamic_adjusted))
4619     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4620
4621   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4622   edir->elf.ref_regular |= eind->elf.ref_regular;
4623   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4624   edir->elf.needs_plt |= eind->elf.needs_plt;
4625   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4626
4627   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4628   if (eind->dyn_relocs != NULL)
4629     {
4630       if (edir->dyn_relocs != NULL)
4631         {
4632           struct elf_dyn_relocs **pp;
4633           struct elf_dyn_relocs *p;
4634
4635           /* Add reloc counts against the indirect sym to the direct sym
4636              list.  Merge any entries against the same section.  */
4637           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4638             {
4639               struct elf_dyn_relocs *q;
4640
4641               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4642                 if (q->sec == p->sec)
4643                   {
4644                     q->pc_count += p->pc_count;
4645                     q->count += p->count;
4646                     *pp = p->next;
4647                     break;
4648                   }
4649               if (q == NULL)
4650                 pp = &p->next;
4651             }
4652           *pp = edir->dyn_relocs;
4653         }
4654
4655       edir->dyn_relocs = eind->dyn_relocs;
4656       eind->dyn_relocs = NULL;
4657     }
4658
4659   /* If we were called to copy over info for a weak sym, that's all.
4660      You might think dyn_relocs need not be copied over;  After all,
4661      both syms will be dynamic or both non-dynamic so we're just
4662      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4663      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4664      dyn_relocs in read-only sections, and it does so on what is the
4665      DIR sym here.  */
4666   if (eind->elf.root.type != bfd_link_hash_indirect)
4667     return;
4668
4669   /* Copy over got entries that we may have already seen to the
4670      symbol which just became indirect.  */
4671   if (eind->elf.got.glist != NULL)
4672     {
4673       if (edir->elf.got.glist != NULL)
4674         {
4675           struct got_entry **entp;
4676           struct got_entry *ent;
4677
4678           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4679             {
4680               struct got_entry *dent;
4681
4682               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4683                 if (dent->addend == ent->addend
4684                     && dent->owner == ent->owner
4685                     && dent->tls_type == ent->tls_type)
4686                   {
4687                     dent->got.refcount += ent->got.refcount;
4688                     *entp = ent->next;
4689                     break;
4690                   }
4691               if (dent == NULL)
4692                 entp = &ent->next;
4693             }
4694           *entp = edir->elf.got.glist;
4695         }
4696
4697       edir->elf.got.glist = eind->elf.got.glist;
4698       eind->elf.got.glist = NULL;
4699     }
4700
4701   /* And plt entries.  */
4702   move_plt_plist (eind, edir);
4703
4704   if (eind->elf.dynindx != -1)
4705     {
4706       if (edir->elf.dynindx != -1)
4707         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4708                                 edir->elf.dynstr_index);
4709       edir->elf.dynindx = eind->elf.dynindx;
4710       edir->elf.dynstr_index = eind->elf.dynstr_index;
4711       eind->elf.dynindx = -1;
4712       eind->elf.dynstr_index = 0;
4713     }
4714 }
4715
4716 /* Find the function descriptor hash entry from the given function code
4717    hash entry FH.  Link the entries via their OH fields.  */
4718
4719 static struct ppc_link_hash_entry *
4720 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4721 {
4722   struct ppc_link_hash_entry *fdh = fh->oh;
4723
4724   if (fdh == NULL)
4725     {
4726       const char *fd_name = fh->elf.root.root.string + 1;
4727
4728       fdh = (struct ppc_link_hash_entry *)
4729         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4730       if (fdh == NULL)
4731         return fdh;
4732
4733       fdh->is_func_descriptor = 1;
4734       fdh->oh = fh;
4735       fh->is_func = 1;
4736       fh->oh = fdh;
4737     }
4738
4739   return ppc_follow_link (fdh);
4740 }
4741
4742 /* Make a fake function descriptor sym for the code sym FH.  */
4743
4744 static struct ppc_link_hash_entry *
4745 make_fdh (struct bfd_link_info *info,
4746           struct ppc_link_hash_entry *fh)
4747 {
4748   bfd *abfd;
4749   asymbol *newsym;
4750   struct bfd_link_hash_entry *bh;
4751   struct ppc_link_hash_entry *fdh;
4752
4753   abfd = fh->elf.root.u.undef.abfd;
4754   newsym = bfd_make_empty_symbol (abfd);
4755   newsym->name = fh->elf.root.root.string + 1;
4756   newsym->section = bfd_und_section_ptr;
4757   newsym->value = 0;
4758   newsym->flags = BSF_WEAK;
4759
4760   bh = NULL;
4761   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4762                                          newsym->flags, newsym->section,
4763                                          newsym->value, NULL, FALSE, FALSE,
4764                                          &bh))
4765     return NULL;
4766
4767   fdh = (struct ppc_link_hash_entry *) bh;
4768   fdh->elf.non_elf = 0;
4769   fdh->fake = 1;
4770   fdh->is_func_descriptor = 1;
4771   fdh->oh = fh;
4772   fh->is_func = 1;
4773   fh->oh = fdh;
4774   return fdh;
4775 }
4776
4777 /* Fix function descriptor symbols defined in .opd sections to be
4778    function type.  */
4779
4780 static bfd_boolean
4781 ppc64_elf_add_symbol_hook (bfd *ibfd,
4782                            struct bfd_link_info *info,
4783                            Elf_Internal_Sym *isym,
4784                            const char **name,
4785                            flagword *flags ATTRIBUTE_UNUSED,
4786                            asection **sec,
4787                            bfd_vma *value ATTRIBUTE_UNUSED)
4788 {
4789   if ((ibfd->flags & DYNAMIC) == 0
4790       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4791     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4792
4793   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4794     {
4795       if ((ibfd->flags & DYNAMIC) == 0)
4796         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4797     }
4798   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4799     ;
4800   else if (*sec != NULL
4801            && strcmp ((*sec)->name, ".opd") == 0)
4802     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4803
4804   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4805     {
4806       if (abiversion (ibfd) == 0)
4807         set_abiversion (ibfd, 2);
4808       else if (abiversion (ibfd) == 1)
4809         {
4810           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4811                                     " for ABI version 1\n"), name);
4812           bfd_set_error (bfd_error_bad_value);
4813           return FALSE;
4814         }
4815     }
4816
4817   return TRUE;
4818 }
4819
4820 /* Merge non-visibility st_other attributes: local entry point.  */
4821
4822 static void
4823 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4824                                   const Elf_Internal_Sym *isym,
4825                                   bfd_boolean definition,
4826                                   bfd_boolean dynamic)
4827 {
4828   if (definition && !dynamic)
4829     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4830                 | ELF_ST_VISIBILITY (h->other));
4831 }
4832
4833 /* This function makes an old ABI object reference to ".bar" cause the
4834    inclusion of a new ABI object archive that defines "bar".
4835    NAME is a symbol defined in an archive.  Return a symbol in the hash
4836    table that might be satisfied by the archive symbols.  */
4837
4838 static struct elf_link_hash_entry *
4839 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4840                                  struct bfd_link_info *info,
4841                                  const char *name)
4842 {
4843   struct elf_link_hash_entry *h;
4844   char *dot_name;
4845   size_t len;
4846
4847   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4848   if (h != NULL
4849       /* Don't return this sym if it is a fake function descriptor
4850          created by add_symbol_adjust.  */
4851       && !(h->root.type == bfd_link_hash_undefweak
4852            && ((struct ppc_link_hash_entry *) h)->fake))
4853     return h;
4854
4855   if (name[0] == '.')
4856     return h;
4857
4858   len = strlen (name);
4859   dot_name = bfd_alloc (abfd, len + 2);
4860   if (dot_name == NULL)
4861     return (struct elf_link_hash_entry *) 0 - 1;
4862   dot_name[0] = '.';
4863   memcpy (dot_name + 1, name, len + 1);
4864   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4865   bfd_release (abfd, dot_name);
4866   return h;
4867 }
4868
4869 /* This function satisfies all old ABI object references to ".bar" if a
4870    new ABI object defines "bar".  Well, at least, undefined dot symbols
4871    are made weak.  This stops later archive searches from including an
4872    object if we already have a function descriptor definition.  It also
4873    prevents the linker complaining about undefined symbols.
4874    We also check and correct mismatched symbol visibility here.  The
4875    most restrictive visibility of the function descriptor and the
4876    function entry symbol is used.  */
4877
4878 static bfd_boolean
4879 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4880 {
4881   struct ppc_link_hash_table *htab;
4882   struct ppc_link_hash_entry *fdh;
4883
4884   if (eh->elf.root.type == bfd_link_hash_indirect)
4885     return TRUE;
4886
4887   if (eh->elf.root.type == bfd_link_hash_warning)
4888     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4889
4890   if (eh->elf.root.root.string[0] != '.')
4891     abort ();
4892
4893   htab = ppc_hash_table (info);
4894   if (htab == NULL)
4895     return FALSE;
4896
4897   fdh = lookup_fdh (eh, htab);
4898   if (fdh == NULL)
4899     {
4900       if (!info->relocatable
4901           && (eh->elf.root.type == bfd_link_hash_undefined
4902               || eh->elf.root.type == bfd_link_hash_undefweak)
4903           && eh->elf.ref_regular)
4904         {
4905           /* Make an undefweak function descriptor sym, which is enough to
4906              pull in an --as-needed shared lib, but won't cause link
4907              errors.  Archives are handled elsewhere.  */
4908           fdh = make_fdh (info, eh);
4909           if (fdh == NULL)
4910             return FALSE;
4911           fdh->elf.ref_regular = 1;
4912         }
4913     }
4914   else
4915     {
4916       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4917       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4918       if (entry_vis < descr_vis)
4919         fdh->elf.other += entry_vis - descr_vis;
4920       else if (entry_vis > descr_vis)
4921         eh->elf.other += descr_vis - entry_vis;
4922
4923       if ((fdh->elf.root.type == bfd_link_hash_defined
4924            || fdh->elf.root.type == bfd_link_hash_defweak)
4925           && eh->elf.root.type == bfd_link_hash_undefined)
4926         {
4927           eh->elf.root.type = bfd_link_hash_undefweak;
4928           eh->was_undefined = 1;
4929           htab->twiddled_syms = 1;
4930         }
4931     }
4932
4933   return TRUE;
4934 }
4935
4936 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4937
4938 static bfd_boolean
4939 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4940 {
4941   struct ppc_link_hash_table *htab;
4942   struct ppc_link_hash_entry **p, *eh;
4943
4944   if (!is_ppc64_elf (info->output_bfd))
4945     return TRUE;
4946   htab = ppc_hash_table (info);
4947   if (htab == NULL)
4948     return FALSE;
4949
4950   if (is_ppc64_elf (ibfd))
4951     {
4952       p = &htab->dot_syms;
4953       while ((eh = *p) != NULL)
4954         {
4955           *p = NULL;
4956           if (&eh->elf == htab->elf.hgot)
4957             ;
4958           else if (htab->elf.hgot == NULL
4959                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4960             htab->elf.hgot = &eh->elf;
4961           else if (!add_symbol_adjust (eh, info))
4962             return FALSE;
4963           p = &eh->u.next_dot_sym;
4964         }
4965     }
4966
4967   /* Clear the list for non-ppc64 input files.  */
4968   p = &htab->dot_syms;
4969   while ((eh = *p) != NULL)
4970     {
4971       *p = NULL;
4972       p = &eh->u.next_dot_sym;
4973     }
4974
4975   /* We need to fix the undefs list for any syms we have twiddled to
4976      undef_weak.  */
4977   if (htab->twiddled_syms)
4978     {
4979       bfd_link_repair_undef_list (&htab->elf.root);
4980       htab->twiddled_syms = 0;
4981     }
4982   return TRUE;
4983 }
4984
4985 /* Undo hash table changes when an --as-needed input file is determined
4986    not to be needed.  */
4987
4988 static bfd_boolean
4989 ppc64_elf_notice_as_needed (bfd *ibfd,
4990                             struct bfd_link_info *info,
4991                             enum notice_asneeded_action act)
4992 {
4993   if (act == notice_not_needed)
4994     {
4995       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4996
4997       if (htab == NULL)
4998         return FALSE;
4999
5000       htab->dot_syms = NULL;
5001     }
5002   return _bfd_elf_notice_as_needed (ibfd, info, act);
5003 }
5004
5005 /* If --just-symbols against a final linked binary, then assume we need
5006    toc adjusting stubs when calling functions defined there.  */
5007
5008 static void
5009 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5010 {
5011   if ((sec->flags & SEC_CODE) != 0
5012       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5013       && is_ppc64_elf (sec->owner))
5014     {
5015       if (abiversion (sec->owner) >= 2
5016           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5017         sec->has_toc_reloc = 1;
5018     }
5019   _bfd_elf_link_just_syms (sec, info);
5020 }
5021
5022 static struct plt_entry **
5023 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5024                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5025 {
5026   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5027   struct plt_entry **local_plt;
5028   unsigned char *local_got_tls_masks;
5029
5030   if (local_got_ents == NULL)
5031     {
5032       bfd_size_type size = symtab_hdr->sh_info;
5033
5034       size *= (sizeof (*local_got_ents)
5035                + sizeof (*local_plt)
5036                + sizeof (*local_got_tls_masks));
5037       local_got_ents = bfd_zalloc (abfd, size);
5038       if (local_got_ents == NULL)
5039         return NULL;
5040       elf_local_got_ents (abfd) = local_got_ents;
5041     }
5042
5043   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5044     {
5045       struct got_entry *ent;
5046
5047       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5048         if (ent->addend == r_addend
5049             && ent->owner == abfd
5050             && ent->tls_type == tls_type)
5051           break;
5052       if (ent == NULL)
5053         {
5054           bfd_size_type amt = sizeof (*ent);
5055           ent = bfd_alloc (abfd, amt);
5056           if (ent == NULL)
5057             return FALSE;
5058           ent->next = local_got_ents[r_symndx];
5059           ent->addend = r_addend;
5060           ent->owner = abfd;
5061           ent->tls_type = tls_type;
5062           ent->is_indirect = FALSE;
5063           ent->got.refcount = 0;
5064           local_got_ents[r_symndx] = ent;
5065         }
5066       ent->got.refcount += 1;
5067     }
5068
5069   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5070   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5071   local_got_tls_masks[r_symndx] |= tls_type;
5072
5073   return local_plt + r_symndx;
5074 }
5075
5076 static bfd_boolean
5077 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5078 {
5079   struct plt_entry *ent;
5080
5081   for (ent = *plist; ent != NULL; ent = ent->next)
5082     if (ent->addend == addend)
5083       break;
5084   if (ent == NULL)
5085     {
5086       bfd_size_type amt = sizeof (*ent);
5087       ent = bfd_alloc (abfd, amt);
5088       if (ent == NULL)
5089         return FALSE;
5090       ent->next = *plist;
5091       ent->addend = addend;
5092       ent->plt.refcount = 0;
5093       *plist = ent;
5094     }
5095   ent->plt.refcount += 1;
5096   return TRUE;
5097 }
5098
5099 static bfd_boolean
5100 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5101 {
5102   return (r_type == R_PPC64_REL24
5103           || r_type == R_PPC64_REL14
5104           || r_type == R_PPC64_REL14_BRTAKEN
5105           || r_type == R_PPC64_REL14_BRNTAKEN
5106           || r_type == R_PPC64_ADDR24
5107           || r_type == R_PPC64_ADDR14
5108           || r_type == R_PPC64_ADDR14_BRTAKEN
5109           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5110 }
5111
5112 /* Look through the relocs for a section during the first phase, and
5113    calculate needed space in the global offset table, procedure
5114    linkage table, and dynamic reloc sections.  */
5115
5116 static bfd_boolean
5117 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5118                         asection *sec, const Elf_Internal_Rela *relocs)
5119 {
5120   struct ppc_link_hash_table *htab;
5121   Elf_Internal_Shdr *symtab_hdr;
5122   struct elf_link_hash_entry **sym_hashes;
5123   const Elf_Internal_Rela *rel;
5124   const Elf_Internal_Rela *rel_end;
5125   asection *sreloc;
5126   asection **opd_sym_map;
5127   struct elf_link_hash_entry *tga, *dottga;
5128
5129   if (info->relocatable)
5130     return TRUE;
5131
5132   /* Don't do anything special with non-loaded, non-alloced sections.
5133      In particular, any relocs in such sections should not affect GOT
5134      and PLT reference counting (ie. we don't allow them to create GOT
5135      or PLT entries), there's no possibility or desire to optimize TLS
5136      relocs, and there's not much point in propagating relocs to shared
5137      libs that the dynamic linker won't relocate.  */
5138   if ((sec->flags & SEC_ALLOC) == 0)
5139     return TRUE;
5140
5141   BFD_ASSERT (is_ppc64_elf (abfd));
5142
5143   htab = ppc_hash_table (info);
5144   if (htab == NULL)
5145     return FALSE;
5146
5147   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5148                               FALSE, FALSE, TRUE);
5149   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5150                                  FALSE, FALSE, TRUE);
5151   symtab_hdr = &elf_symtab_hdr (abfd);
5152   sym_hashes = elf_sym_hashes (abfd);
5153   sreloc = NULL;
5154   opd_sym_map = NULL;
5155   if (strcmp (sec->name, ".opd") == 0)
5156     {
5157       /* Garbage collection needs some extra help with .opd sections.
5158          We don't want to necessarily keep everything referenced by
5159          relocs in .opd, as that would keep all functions.  Instead,
5160          if we reference an .opd symbol (a function descriptor), we
5161          want to keep the function code symbol's section.  This is
5162          easy for global symbols, but for local syms we need to keep
5163          information about the associated function section.  */
5164       bfd_size_type amt;
5165
5166       if (abiversion (abfd) == 0)
5167         set_abiversion (abfd, 1);
5168       else if (abiversion (abfd) == 2)
5169         {
5170           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5171                                   abiversion (abfd));
5172           bfd_set_error (bfd_error_bad_value);
5173           return FALSE;
5174         }
5175       amt = sec->size * sizeof (*opd_sym_map) / 8;
5176       opd_sym_map = bfd_zalloc (abfd, amt);
5177       if (opd_sym_map == NULL)
5178         return FALSE;
5179       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5180       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5181       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5182     }
5183
5184   rel_end = relocs + sec->reloc_count;
5185   for (rel = relocs; rel < rel_end; rel++)
5186     {
5187       unsigned long r_symndx;
5188       struct elf_link_hash_entry *h;
5189       enum elf_ppc64_reloc_type r_type;
5190       int tls_type;
5191       struct _ppc64_elf_section_data *ppc64_sec;
5192       struct plt_entry **ifunc;
5193
5194       r_symndx = ELF64_R_SYM (rel->r_info);
5195       if (r_symndx < symtab_hdr->sh_info)
5196         h = NULL;
5197       else
5198         {
5199           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5200           h = elf_follow_link (h);
5201
5202           /* PR15323, ref flags aren't set for references in the same
5203              object.  */
5204           h->root.non_ir_ref = 1;
5205
5206           if (h == htab->elf.hgot)
5207             sec->has_toc_reloc = 1;
5208         }
5209
5210       tls_type = 0;
5211       ifunc = NULL;
5212       if (h != NULL)
5213         {
5214           if (h->type == STT_GNU_IFUNC)
5215             {
5216               h->needs_plt = 1;
5217               ifunc = &h->plt.plist;
5218             }
5219         }
5220       else
5221         {
5222           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5223                                                           abfd, r_symndx);
5224           if (isym == NULL)
5225             return FALSE;
5226
5227           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5228             {
5229               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5230                                              rel->r_addend, PLT_IFUNC);
5231               if (ifunc == NULL)
5232                 return FALSE;
5233             }
5234         }
5235       r_type = ELF64_R_TYPE (rel->r_info);
5236       if (is_branch_reloc (r_type))
5237         {
5238           if (h != NULL && (h == tga || h == dottga))
5239             {
5240               if (rel != relocs
5241                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5242                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5243                 /* We have a new-style __tls_get_addr call with a marker
5244                    reloc.  */
5245                 ;
5246               else
5247                 /* Mark this section as having an old-style call.  */
5248                 sec->has_tls_get_addr_call = 1;
5249             }
5250
5251           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5252           if (ifunc != NULL
5253               && !update_plt_info (abfd, ifunc, rel->r_addend))
5254             return FALSE;
5255         }
5256
5257       switch (r_type)
5258         {
5259         case R_PPC64_TLSGD:
5260         case R_PPC64_TLSLD:
5261           /* These special tls relocs tie a call to __tls_get_addr with
5262              its parameter symbol.  */
5263           break;
5264
5265         case R_PPC64_GOT_TLSLD16:
5266         case R_PPC64_GOT_TLSLD16_LO:
5267         case R_PPC64_GOT_TLSLD16_HI:
5268         case R_PPC64_GOT_TLSLD16_HA:
5269           tls_type = TLS_TLS | TLS_LD;
5270           goto dogottls;
5271
5272         case R_PPC64_GOT_TLSGD16:
5273         case R_PPC64_GOT_TLSGD16_LO:
5274         case R_PPC64_GOT_TLSGD16_HI:
5275         case R_PPC64_GOT_TLSGD16_HA:
5276           tls_type = TLS_TLS | TLS_GD;
5277           goto dogottls;
5278
5279         case R_PPC64_GOT_TPREL16_DS:
5280         case R_PPC64_GOT_TPREL16_LO_DS:
5281         case R_PPC64_GOT_TPREL16_HI:
5282         case R_PPC64_GOT_TPREL16_HA:
5283           if (!info->executable)
5284             info->flags |= DF_STATIC_TLS;
5285           tls_type = TLS_TLS | TLS_TPREL;
5286           goto dogottls;
5287
5288         case R_PPC64_GOT_DTPREL16_DS:
5289         case R_PPC64_GOT_DTPREL16_LO_DS:
5290         case R_PPC64_GOT_DTPREL16_HI:
5291         case R_PPC64_GOT_DTPREL16_HA:
5292           tls_type = TLS_TLS | TLS_DTPREL;
5293         dogottls:
5294           sec->has_tls_reloc = 1;
5295           /* Fall thru */
5296
5297         case R_PPC64_GOT16:
5298         case R_PPC64_GOT16_DS:
5299         case R_PPC64_GOT16_HA:
5300         case R_PPC64_GOT16_HI:
5301         case R_PPC64_GOT16_LO:
5302         case R_PPC64_GOT16_LO_DS:
5303           /* This symbol requires a global offset table entry.  */
5304           sec->has_toc_reloc = 1;
5305           if (r_type == R_PPC64_GOT_TLSLD16
5306               || r_type == R_PPC64_GOT_TLSGD16
5307               || r_type == R_PPC64_GOT_TPREL16_DS
5308               || r_type == R_PPC64_GOT_DTPREL16_DS
5309               || r_type == R_PPC64_GOT16
5310               || r_type == R_PPC64_GOT16_DS)
5311             {
5312               htab->do_multi_toc = 1;
5313               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5314             }
5315
5316           if (ppc64_elf_tdata (abfd)->got == NULL
5317               && !create_got_section (abfd, info))
5318             return FALSE;
5319
5320           if (h != NULL)
5321             {
5322               struct ppc_link_hash_entry *eh;
5323               struct got_entry *ent;
5324
5325               eh = (struct ppc_link_hash_entry *) h;
5326               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5327                 if (ent->addend == rel->r_addend
5328                     && ent->owner == abfd
5329                     && ent->tls_type == tls_type)
5330                   break;
5331               if (ent == NULL)
5332                 {
5333                   bfd_size_type amt = sizeof (*ent);
5334                   ent = bfd_alloc (abfd, amt);
5335                   if (ent == NULL)
5336                     return FALSE;
5337                   ent->next = eh->elf.got.glist;
5338                   ent->addend = rel->r_addend;
5339                   ent->owner = abfd;
5340                   ent->tls_type = tls_type;
5341                   ent->is_indirect = FALSE;
5342                   ent->got.refcount = 0;
5343                   eh->elf.got.glist = ent;
5344                 }
5345               ent->got.refcount += 1;
5346               eh->tls_mask |= tls_type;
5347             }
5348           else
5349             /* This is a global offset table entry for a local symbol.  */
5350             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5351                                         rel->r_addend, tls_type))
5352               return FALSE;
5353
5354           /* We may also need a plt entry if the symbol turns out to be
5355              an ifunc.  */
5356           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5357             {
5358               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5359                 return FALSE;
5360             }
5361           break;
5362
5363         case R_PPC64_PLT16_HA:
5364         case R_PPC64_PLT16_HI:
5365         case R_PPC64_PLT16_LO:
5366         case R_PPC64_PLT32:
5367         case R_PPC64_PLT64:
5368           /* This symbol requires a procedure linkage table entry.  We
5369              actually build the entry in adjust_dynamic_symbol,
5370              because this might be a case of linking PIC code without
5371              linking in any dynamic objects, in which case we don't
5372              need to generate a procedure linkage table after all.  */
5373           if (h == NULL)
5374             {
5375               /* It does not make sense to have a procedure linkage
5376                  table entry for a local symbol.  */
5377               bfd_set_error (bfd_error_bad_value);
5378               return FALSE;
5379             }
5380           else
5381             {
5382               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5383                 return FALSE;
5384               h->needs_plt = 1;
5385               if (h->root.root.string[0] == '.'
5386                   && h->root.root.string[1] != '\0')
5387                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5388             }
5389           break;
5390
5391           /* The following relocations don't need to propagate the
5392              relocation if linking a shared object since they are
5393              section relative.  */
5394         case R_PPC64_SECTOFF:
5395         case R_PPC64_SECTOFF_LO:
5396         case R_PPC64_SECTOFF_HI:
5397         case R_PPC64_SECTOFF_HA:
5398         case R_PPC64_SECTOFF_DS:
5399         case R_PPC64_SECTOFF_LO_DS:
5400         case R_PPC64_DTPREL16:
5401         case R_PPC64_DTPREL16_LO:
5402         case R_PPC64_DTPREL16_HI:
5403         case R_PPC64_DTPREL16_HA:
5404         case R_PPC64_DTPREL16_DS:
5405         case R_PPC64_DTPREL16_LO_DS:
5406         case R_PPC64_DTPREL16_HIGH:
5407         case R_PPC64_DTPREL16_HIGHA:
5408         case R_PPC64_DTPREL16_HIGHER:
5409         case R_PPC64_DTPREL16_HIGHERA:
5410         case R_PPC64_DTPREL16_HIGHEST:
5411         case R_PPC64_DTPREL16_HIGHESTA:
5412           break;
5413
5414           /* Nor do these.  */
5415         case R_PPC64_REL16:
5416         case R_PPC64_REL16_LO:
5417         case R_PPC64_REL16_HI:
5418         case R_PPC64_REL16_HA:
5419           break;
5420
5421         case R_PPC64_TOC16:
5422         case R_PPC64_TOC16_DS:
5423           htab->do_multi_toc = 1;
5424           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5425         case R_PPC64_TOC16_LO:
5426         case R_PPC64_TOC16_HI:
5427         case R_PPC64_TOC16_HA:
5428         case R_PPC64_TOC16_LO_DS:
5429           sec->has_toc_reloc = 1;
5430           break;
5431
5432           /* This relocation describes the C++ object vtable hierarchy.
5433              Reconstruct it for later use during GC.  */
5434         case R_PPC64_GNU_VTINHERIT:
5435           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5436             return FALSE;
5437           break;
5438
5439           /* This relocation describes which C++ vtable entries are actually
5440              used.  Record for later use during GC.  */
5441         case R_PPC64_GNU_VTENTRY:
5442           BFD_ASSERT (h != NULL);
5443           if (h != NULL
5444               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5445             return FALSE;
5446           break;
5447
5448         case R_PPC64_REL14:
5449         case R_PPC64_REL14_BRTAKEN:
5450         case R_PPC64_REL14_BRNTAKEN:
5451           {
5452             asection *dest = NULL;
5453
5454             /* Heuristic: If jumping outside our section, chances are
5455                we are going to need a stub.  */
5456             if (h != NULL)
5457               {
5458                 /* If the sym is weak it may be overridden later, so
5459                    don't assume we know where a weak sym lives.  */
5460                 if (h->root.type == bfd_link_hash_defined)
5461                   dest = h->root.u.def.section;
5462               }
5463             else
5464               {
5465                 Elf_Internal_Sym *isym;
5466
5467                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5468                                               abfd, r_symndx);
5469                 if (isym == NULL)
5470                   return FALSE;
5471
5472                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5473               }
5474
5475             if (dest != sec)
5476               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5477           }
5478           /* Fall through.  */
5479
5480         case R_PPC64_REL24:
5481           if (h != NULL && ifunc == NULL)
5482             {
5483               /* We may need a .plt entry if the function this reloc
5484                  refers to is in a shared lib.  */
5485               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5486                 return FALSE;
5487               h->needs_plt = 1;
5488               if (h->root.root.string[0] == '.'
5489                   && h->root.root.string[1] != '\0')
5490                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5491               if (h == tga || h == dottga)
5492                 sec->has_tls_reloc = 1;
5493             }
5494           break;
5495
5496         case R_PPC64_TPREL64:
5497           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5498           if (!info->executable)
5499             info->flags |= DF_STATIC_TLS;
5500           goto dotlstoc;
5501
5502         case R_PPC64_DTPMOD64:
5503           if (rel + 1 < rel_end
5504               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5505               && rel[1].r_offset == rel->r_offset + 8)
5506             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5507           else
5508             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5509           goto dotlstoc;
5510
5511         case R_PPC64_DTPREL64:
5512           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5513           if (rel != relocs
5514               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5515               && rel[-1].r_offset == rel->r_offset - 8)
5516             /* This is the second reloc of a dtpmod, dtprel pair.
5517                Don't mark with TLS_DTPREL.  */
5518             goto dodyn;
5519
5520         dotlstoc:
5521           sec->has_tls_reloc = 1;
5522           if (h != NULL)
5523             {
5524               struct ppc_link_hash_entry *eh;
5525               eh = (struct ppc_link_hash_entry *) h;
5526               eh->tls_mask |= tls_type;
5527             }
5528           else
5529             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5530                                         rel->r_addend, tls_type))
5531               return FALSE;
5532
5533           ppc64_sec = ppc64_elf_section_data (sec);
5534           if (ppc64_sec->sec_type != sec_toc)
5535             {
5536               bfd_size_type amt;
5537
5538               /* One extra to simplify get_tls_mask.  */
5539               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5540               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5541               if (ppc64_sec->u.toc.symndx == NULL)
5542                 return FALSE;
5543               amt = sec->size * sizeof (bfd_vma) / 8;
5544               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5545               if (ppc64_sec->u.toc.add == NULL)
5546                 return FALSE;
5547               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5548               ppc64_sec->sec_type = sec_toc;
5549             }
5550           BFD_ASSERT (rel->r_offset % 8 == 0);
5551           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5552           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5553
5554           /* Mark the second slot of a GD or LD entry.
5555              -1 to indicate GD and -2 to indicate LD.  */
5556           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5557             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5558           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5559             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5560           goto dodyn;
5561
5562         case R_PPC64_TPREL16:
5563         case R_PPC64_TPREL16_LO:
5564         case R_PPC64_TPREL16_HI:
5565         case R_PPC64_TPREL16_HA:
5566         case R_PPC64_TPREL16_DS:
5567         case R_PPC64_TPREL16_LO_DS:
5568         case R_PPC64_TPREL16_HIGH:
5569         case R_PPC64_TPREL16_HIGHA:
5570         case R_PPC64_TPREL16_HIGHER:
5571         case R_PPC64_TPREL16_HIGHERA:
5572         case R_PPC64_TPREL16_HIGHEST:
5573         case R_PPC64_TPREL16_HIGHESTA:
5574           if (info->shared)
5575             {
5576               if (!info->executable)
5577                 info->flags |= DF_STATIC_TLS;
5578               goto dodyn;
5579             }
5580           break;
5581
5582         case R_PPC64_ADDR64:
5583           if (opd_sym_map != NULL
5584               && rel + 1 < rel_end
5585               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5586             {
5587               if (h != NULL)
5588                 {
5589                   if (h->root.root.string[0] == '.'
5590                       && h->root.root.string[1] != 0
5591                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5592                     ;
5593                   else
5594                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5595                 }
5596               else
5597                 {
5598                   asection *s;
5599                   Elf_Internal_Sym *isym;
5600
5601                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5602                                                 abfd, r_symndx);
5603                   if (isym == NULL)
5604                     return FALSE;
5605
5606                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5607                   if (s != NULL && s != sec)
5608                     opd_sym_map[rel->r_offset / 8] = s;
5609                 }
5610             }
5611           /* Fall through.  */
5612
5613         case R_PPC64_ADDR16:
5614         case R_PPC64_ADDR16_DS:
5615         case R_PPC64_ADDR16_HA:
5616         case R_PPC64_ADDR16_HI:
5617         case R_PPC64_ADDR16_HIGH:
5618         case R_PPC64_ADDR16_HIGHA:
5619         case R_PPC64_ADDR16_HIGHER:
5620         case R_PPC64_ADDR16_HIGHERA:
5621         case R_PPC64_ADDR16_HIGHEST:
5622         case R_PPC64_ADDR16_HIGHESTA:
5623         case R_PPC64_ADDR16_LO:
5624         case R_PPC64_ADDR16_LO_DS:
5625           if (h != NULL && !info->shared && abiversion (abfd) == 2
5626               && rel->r_addend == 0)
5627             {
5628               /* We may need a .plt entry if this reloc refers to a
5629                  function in a shared lib.  */
5630               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5631                 return FALSE;
5632               h->pointer_equality_needed = 1;
5633             }
5634           /* Fall through.  */
5635
5636         case R_PPC64_REL30:
5637         case R_PPC64_REL32:
5638         case R_PPC64_REL64:
5639         case R_PPC64_ADDR14:
5640         case R_PPC64_ADDR14_BRNTAKEN:
5641         case R_PPC64_ADDR14_BRTAKEN:
5642         case R_PPC64_ADDR24:
5643         case R_PPC64_ADDR32:
5644         case R_PPC64_UADDR16:
5645         case R_PPC64_UADDR32:
5646         case R_PPC64_UADDR64:
5647         case R_PPC64_TOC:
5648           if (h != NULL && !info->shared)
5649             /* We may need a copy reloc.  */
5650             h->non_got_ref = 1;
5651
5652           /* Don't propagate .opd relocs.  */
5653           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5654             break;
5655
5656           /* If we are creating a shared library, and this is a reloc
5657              against a global symbol, or a non PC relative reloc
5658              against a local symbol, then we need to copy the reloc
5659              into the shared library.  However, if we are linking with
5660              -Bsymbolic, we do not need to copy a reloc against a
5661              global symbol which is defined in an object we are
5662              including in the link (i.e., DEF_REGULAR is set).  At
5663              this point we have not seen all the input files, so it is
5664              possible that DEF_REGULAR is not set now but will be set
5665              later (it is never cleared).  In case of a weak definition,
5666              DEF_REGULAR may be cleared later by a strong definition in
5667              a shared library.  We account for that possibility below by
5668              storing information in the dyn_relocs field of the hash
5669              table entry.  A similar situation occurs when creating
5670              shared libraries and symbol visibility changes render the
5671              symbol local.
5672
5673              If on the other hand, we are creating an executable, we
5674              may need to keep relocations for symbols satisfied by a
5675              dynamic library if we manage to avoid copy relocs for the
5676              symbol.  */
5677         dodyn:
5678           if ((info->shared
5679                && (must_be_dyn_reloc (info, r_type)
5680                    || (h != NULL
5681                        && (!SYMBOLIC_BIND (info, h)
5682                            || h->root.type == bfd_link_hash_defweak
5683                            || !h->def_regular))))
5684               || (ELIMINATE_COPY_RELOCS
5685                   && !info->shared
5686                   && h != NULL
5687                   && (h->root.type == bfd_link_hash_defweak
5688                       || !h->def_regular))
5689               || (!info->shared
5690                   && ifunc != NULL))
5691             {
5692               /* We must copy these reloc types into the output file.
5693                  Create a reloc section in dynobj and make room for
5694                  this reloc.  */
5695               if (sreloc == NULL)
5696                 {
5697                   sreloc = _bfd_elf_make_dynamic_reloc_section
5698                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5699
5700                   if (sreloc == NULL)
5701                     return FALSE;
5702                 }
5703
5704               /* If this is a global symbol, we count the number of
5705                  relocations we need for this symbol.  */
5706               if (h != NULL)
5707                 {
5708                   struct elf_dyn_relocs *p;
5709                   struct elf_dyn_relocs **head;
5710
5711                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5712                   p = *head;
5713                   if (p == NULL || p->sec != sec)
5714                     {
5715                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5716                       if (p == NULL)
5717                         return FALSE;
5718                       p->next = *head;
5719                       *head = p;
5720                       p->sec = sec;
5721                       p->count = 0;
5722                       p->pc_count = 0;
5723                     }
5724                   p->count += 1;
5725                   if (!must_be_dyn_reloc (info, r_type))
5726                     p->pc_count += 1;
5727                 }
5728               else
5729                 {
5730                   /* Track dynamic relocs needed for local syms too.
5731                      We really need local syms available to do this
5732                      easily.  Oh well.  */
5733                   struct ppc_dyn_relocs *p;
5734                   struct ppc_dyn_relocs **head;
5735                   bfd_boolean is_ifunc;
5736                   asection *s;
5737                   void *vpp;
5738                   Elf_Internal_Sym *isym;
5739
5740                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5741                                                 abfd, r_symndx);
5742                   if (isym == NULL)
5743                     return FALSE;
5744
5745                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5746                   if (s == NULL)
5747                     s = sec;
5748
5749                   vpp = &elf_section_data (s)->local_dynrel;
5750                   head = (struct ppc_dyn_relocs **) vpp;
5751                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5752                   p = *head;
5753                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5754                     p = p->next;
5755                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5756                     {
5757                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5758                       if (p == NULL)
5759                         return FALSE;
5760                       p->next = *head;
5761                       *head = p;
5762                       p->sec = sec;
5763                       p->ifunc = is_ifunc;
5764                       p->count = 0;
5765                     }
5766                   p->count += 1;
5767                 }
5768             }
5769           break;
5770
5771         default:
5772           break;
5773         }
5774     }
5775
5776   return TRUE;
5777 }
5778
5779 /* Merge backend specific data from an object file to the output
5780    object file when linking.  */
5781
5782 static bfd_boolean
5783 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5784 {
5785   unsigned long iflags, oflags;
5786
5787   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5788     return TRUE;
5789
5790   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5791     return TRUE;
5792
5793   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5794     return FALSE;
5795
5796   iflags = elf_elfheader (ibfd)->e_flags;
5797   oflags = elf_elfheader (obfd)->e_flags;
5798
5799   if (!elf_flags_init (obfd) || oflags == 0)
5800     {
5801       elf_flags_init (obfd) = TRUE;
5802       elf_elfheader (obfd)->e_flags = iflags;
5803     }
5804   else if (iflags == oflags || iflags == 0)
5805     ;
5806   else if (iflags & ~EF_PPC64_ABI)
5807     {
5808       (*_bfd_error_handler)
5809         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5810       bfd_set_error (bfd_error_bad_value);
5811       return FALSE;
5812     }
5813   else
5814     {
5815       (*_bfd_error_handler)
5816         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5817          ibfd, iflags, oflags);
5818       bfd_set_error (bfd_error_bad_value);
5819       return FALSE;
5820     }
5821
5822   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5823   _bfd_elf_merge_object_attributes (ibfd, obfd);
5824
5825   return TRUE;
5826 }
5827
5828 static bfd_boolean
5829 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5830 {
5831   /* Print normal ELF private data.  */
5832   _bfd_elf_print_private_bfd_data (abfd, ptr);
5833
5834   if (elf_elfheader (abfd)->e_flags != 0)
5835     {
5836       FILE *file = ptr;
5837
5838       /* xgettext:c-format */
5839       fprintf (file, _("private flags = 0x%lx:"),
5840                elf_elfheader (abfd)->e_flags);
5841
5842       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5843         fprintf (file, _(" [abiv%ld]"),
5844                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5845       fputc ('\n', file);
5846     }
5847
5848   return TRUE;
5849 }
5850
5851 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5852    of the code entry point, and its section.  */
5853
5854 static bfd_vma
5855 opd_entry_value (asection *opd_sec,
5856                  bfd_vma offset,
5857                  asection **code_sec,
5858                  bfd_vma *code_off,
5859                  bfd_boolean in_code_sec)
5860 {
5861   bfd *opd_bfd = opd_sec->owner;
5862   Elf_Internal_Rela *relocs;
5863   Elf_Internal_Rela *lo, *hi, *look;
5864   bfd_vma val;
5865
5866   /* No relocs implies we are linking a --just-symbols object, or looking
5867      at a final linked executable with addr2line or somesuch.  */
5868   if (opd_sec->reloc_count == 0)
5869     {
5870       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5871
5872       if (contents == NULL)
5873         {
5874           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5875             return (bfd_vma) -1;
5876           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5877         }
5878
5879       val = bfd_get_64 (opd_bfd, contents + offset);
5880       if (code_sec != NULL)
5881         {
5882           asection *sec, *likely = NULL;
5883
5884           if (in_code_sec)
5885             {
5886               sec = *code_sec;
5887               if (sec->vma <= val
5888                   && val < sec->vma + sec->size)
5889                 likely = sec;
5890               else
5891                 val = -1;
5892             }
5893           else
5894             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5895               if (sec->vma <= val
5896                   && (sec->flags & SEC_LOAD) != 0
5897                   && (sec->flags & SEC_ALLOC) != 0)
5898                 likely = sec;
5899           if (likely != NULL)
5900             {
5901               *code_sec = likely;
5902               if (code_off != NULL)
5903                 *code_off = val - likely->vma;
5904             }
5905         }
5906       return val;
5907     }
5908
5909   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5910
5911   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5912   if (relocs == NULL)
5913     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5914
5915   /* Go find the opd reloc at the sym address.  */
5916   lo = relocs;
5917   BFD_ASSERT (lo != NULL);
5918   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5919   val = (bfd_vma) -1;
5920   while (lo < hi)
5921     {
5922       look = lo + (hi - lo) / 2;
5923       if (look->r_offset < offset)
5924         lo = look + 1;
5925       else if (look->r_offset > offset)
5926         hi = look;
5927       else
5928         {
5929           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5930
5931           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5932               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5933             {
5934               unsigned long symndx = ELF64_R_SYM (look->r_info);
5935               asection *sec;
5936
5937               if (symndx < symtab_hdr->sh_info
5938                   || elf_sym_hashes (opd_bfd) == NULL)
5939                 {
5940                   Elf_Internal_Sym *sym;
5941
5942                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5943                   if (sym == NULL)
5944                     {
5945                       size_t symcnt = symtab_hdr->sh_info;
5946                       if (elf_sym_hashes (opd_bfd) == NULL)
5947                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5948                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5949                                                   0, NULL, NULL, NULL);
5950                       if (sym == NULL)
5951                         break;
5952                       symtab_hdr->contents = (bfd_byte *) sym;
5953                     }
5954
5955                   sym += symndx;
5956                   val = sym->st_value;
5957                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5958                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5959                 }
5960               else
5961                 {
5962                   struct elf_link_hash_entry **sym_hashes;
5963                   struct elf_link_hash_entry *rh;
5964
5965                   sym_hashes = elf_sym_hashes (opd_bfd);
5966                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5967                   if (rh != NULL)
5968                     {
5969                       rh = elf_follow_link (rh);
5970                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5971                                   || rh->root.type == bfd_link_hash_defweak);
5972                       val = rh->root.u.def.value;
5973                       sec = rh->root.u.def.section;
5974                     }
5975                   else
5976                     {
5977                       /* Handle the odd case where we can be called
5978                          during bfd_elf_link_add_symbols before the
5979                          symbol hashes have been fully populated.  */
5980                       Elf_Internal_Sym *sym;
5981
5982                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5983                                                   symndx, NULL, NULL, NULL);
5984                       if (sym == NULL)
5985                         break;
5986
5987                       val = sym->st_value;
5988                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5989                       free (sym);
5990                     }
5991                 }
5992               val += look->r_addend;
5993               if (code_off != NULL)
5994                 *code_off = val;
5995               if (code_sec != NULL)
5996                 {
5997                   if (in_code_sec && *code_sec != sec)
5998                     return -1;
5999                   else
6000                     *code_sec = sec;
6001                 }
6002               if (sec != NULL && sec->output_section != NULL)
6003                 val += sec->output_section->vma + sec->output_offset;
6004             }
6005           break;
6006         }
6007     }
6008
6009   return val;
6010 }
6011
6012 /* If the ELF symbol SYM might be a function in SEC, return the
6013    function size and set *CODE_OFF to the function's entry point,
6014    otherwise return zero.  */
6015
6016 static bfd_size_type
6017 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6018                               bfd_vma *code_off)
6019 {
6020   bfd_size_type size;
6021
6022   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6023                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6024     return 0;
6025
6026   size = 0;
6027   if (!(sym->flags & BSF_SYNTHETIC))
6028     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6029
6030   if (strcmp (sym->section->name, ".opd") == 0)
6031     {
6032       if (opd_entry_value (sym->section, sym->value,
6033                            &sec, code_off, TRUE) == (bfd_vma) -1)
6034         return 0;
6035       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6036          symbol.  This size has nothing to do with the code size of the
6037          function, which is what we're supposed to return, but the
6038          code size isn't available without looking up the dot-sym.
6039          However, doing that would be a waste of time particularly
6040          since elf_find_function will look at the dot-sym anyway.
6041          Now, elf_find_function will keep the largest size of any
6042          function sym found at the code address of interest, so return
6043          1 here to avoid it incorrectly caching a larger function size
6044          for a small function.  This does mean we return the wrong
6045          size for a new-ABI function of size 24, but all that does is
6046          disable caching for such functions.  */
6047       if (size == 24)
6048         size = 1;
6049     }
6050   else
6051     {
6052       if (sym->section != sec)
6053         return 0;
6054       *code_off = sym->value;
6055     }
6056   if (size == 0)
6057     size = 1;
6058   return size;
6059 }
6060
6061 /* Return true if symbol is defined in a regular object file.  */
6062
6063 static bfd_boolean
6064 is_static_defined (struct elf_link_hash_entry *h)
6065 {
6066   return ((h->root.type == bfd_link_hash_defined
6067            || h->root.type == bfd_link_hash_defweak)
6068           && h->root.u.def.section != NULL
6069           && h->root.u.def.section->output_section != NULL);
6070 }
6071
6072 /* If FDH is a function descriptor symbol, return the associated code
6073    entry symbol if it is defined.  Return NULL otherwise.  */
6074
6075 static struct ppc_link_hash_entry *
6076 defined_code_entry (struct ppc_link_hash_entry *fdh)
6077 {
6078   if (fdh->is_func_descriptor)
6079     {
6080       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6081       if (fh->elf.root.type == bfd_link_hash_defined
6082           || fh->elf.root.type == bfd_link_hash_defweak)
6083         return fh;
6084     }
6085   return NULL;
6086 }
6087
6088 /* If FH is a function code entry symbol, return the associated
6089    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6090
6091 static struct ppc_link_hash_entry *
6092 defined_func_desc (struct ppc_link_hash_entry *fh)
6093 {
6094   if (fh->oh != NULL
6095       && fh->oh->is_func_descriptor)
6096     {
6097       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6098       if (fdh->elf.root.type == bfd_link_hash_defined
6099           || fdh->elf.root.type == bfd_link_hash_defweak)
6100         return fdh;
6101     }
6102   return NULL;
6103 }
6104
6105 /* Mark all our entry sym sections, both opd and code section.  */
6106
6107 static void
6108 ppc64_elf_gc_keep (struct bfd_link_info *info)
6109 {
6110   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6111   struct bfd_sym_chain *sym;
6112
6113   if (htab == NULL)
6114     return;
6115
6116   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6117     {
6118       struct ppc_link_hash_entry *eh, *fh;
6119       asection *sec;
6120
6121       eh = (struct ppc_link_hash_entry *)
6122         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6123       if (eh == NULL)
6124         continue;
6125       if (eh->elf.root.type != bfd_link_hash_defined
6126           && eh->elf.root.type != bfd_link_hash_defweak)
6127         continue;
6128
6129       fh = defined_code_entry (eh);
6130       if (fh != NULL)
6131         {
6132           sec = fh->elf.root.u.def.section;
6133           sec->flags |= SEC_KEEP;
6134         }
6135       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6136                && opd_entry_value (eh->elf.root.u.def.section,
6137                                    eh->elf.root.u.def.value,
6138                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6139         sec->flags |= SEC_KEEP;
6140
6141       sec = eh->elf.root.u.def.section;
6142       sec->flags |= SEC_KEEP;
6143     }
6144 }
6145
6146 /* Mark sections containing dynamically referenced symbols.  When
6147    building shared libraries, we must assume that any visible symbol is
6148    referenced.  */
6149
6150 static bfd_boolean
6151 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6152 {
6153   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6154   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6155   struct ppc_link_hash_entry *fdh;
6156
6157   /* Dynamic linking info is on the func descriptor sym.  */
6158   fdh = defined_func_desc (eh);
6159   if (fdh != NULL)
6160     eh = fdh;
6161
6162   if ((eh->elf.root.type == bfd_link_hash_defined
6163        || eh->elf.root.type == bfd_link_hash_defweak)
6164       && (eh->elf.ref_dynamic
6165           || (!info->executable
6166               && eh->elf.def_regular
6167               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6168               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6169               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6170                   || !bfd_hide_sym_by_version (info->version_info,
6171                                                eh->elf.root.root.string)))))
6172     {
6173       asection *code_sec;
6174       struct ppc_link_hash_entry *fh;
6175
6176       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6177
6178       /* Function descriptor syms cause the associated
6179          function code sym section to be marked.  */
6180       fh = defined_code_entry (eh);
6181       if (fh != NULL)
6182         {
6183           code_sec = fh->elf.root.u.def.section;
6184           code_sec->flags |= SEC_KEEP;
6185         }
6186       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6187                && opd_entry_value (eh->elf.root.u.def.section,
6188                                    eh->elf.root.u.def.value,
6189                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6190         code_sec->flags |= SEC_KEEP;
6191     }
6192
6193   return TRUE;
6194 }
6195
6196 /* Return the section that should be marked against GC for a given
6197    relocation.  */
6198
6199 static asection *
6200 ppc64_elf_gc_mark_hook (asection *sec,
6201                         struct bfd_link_info *info,
6202                         Elf_Internal_Rela *rel,
6203                         struct elf_link_hash_entry *h,
6204                         Elf_Internal_Sym *sym)
6205 {
6206   asection *rsec;
6207
6208   /* Syms return NULL if we're marking .opd, so we avoid marking all
6209      function sections, as all functions are referenced in .opd.  */
6210   rsec = NULL;
6211   if (get_opd_info (sec) != NULL)
6212     return rsec;
6213
6214   if (h != NULL)
6215     {
6216       enum elf_ppc64_reloc_type r_type;
6217       struct ppc_link_hash_entry *eh, *fh, *fdh;
6218
6219       r_type = ELF64_R_TYPE (rel->r_info);
6220       switch (r_type)
6221         {
6222         case R_PPC64_GNU_VTINHERIT:
6223         case R_PPC64_GNU_VTENTRY:
6224           break;
6225
6226         default:
6227           switch (h->root.type)
6228             {
6229             case bfd_link_hash_defined:
6230             case bfd_link_hash_defweak:
6231               eh = (struct ppc_link_hash_entry *) h;
6232               fdh = defined_func_desc (eh);
6233               if (fdh != NULL)
6234                 eh = fdh;
6235
6236               /* Function descriptor syms cause the associated
6237                  function code sym section to be marked.  */
6238               fh = defined_code_entry (eh);
6239               if (fh != NULL)
6240                 {
6241                   /* They also mark their opd section.  */
6242                   eh->elf.root.u.def.section->gc_mark = 1;
6243
6244                   rsec = fh->elf.root.u.def.section;
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                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6250                 eh->elf.root.u.def.section->gc_mark = 1;
6251               else
6252                 rsec = h->root.u.def.section;
6253               break;
6254
6255             case bfd_link_hash_common:
6256               rsec = h->root.u.c.p->section;
6257               break;
6258
6259             default:
6260               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6261             }
6262         }
6263     }
6264   else
6265     {
6266       struct _opd_sec_data *opd;
6267
6268       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6269       opd = get_opd_info (rsec);
6270       if (opd != NULL && opd->func_sec != NULL)
6271         {
6272           rsec->gc_mark = 1;
6273
6274           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6275         }
6276     }
6277
6278   return rsec;
6279 }
6280
6281 /* Update the .got, .plt. and dynamic reloc reference counts for the
6282    section being removed.  */
6283
6284 static bfd_boolean
6285 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6286                          asection *sec, const Elf_Internal_Rela *relocs)
6287 {
6288   struct ppc_link_hash_table *htab;
6289   Elf_Internal_Shdr *symtab_hdr;
6290   struct elf_link_hash_entry **sym_hashes;
6291   struct got_entry **local_got_ents;
6292   const Elf_Internal_Rela *rel, *relend;
6293
6294   if (info->relocatable)
6295     return TRUE;
6296
6297   if ((sec->flags & SEC_ALLOC) == 0)
6298     return TRUE;
6299
6300   elf_section_data (sec)->local_dynrel = NULL;
6301
6302   htab = ppc_hash_table (info);
6303   if (htab == NULL)
6304     return FALSE;
6305
6306   symtab_hdr = &elf_symtab_hdr (abfd);
6307   sym_hashes = elf_sym_hashes (abfd);
6308   local_got_ents = elf_local_got_ents (abfd);
6309
6310   relend = relocs + sec->reloc_count;
6311   for (rel = relocs; rel < relend; rel++)
6312     {
6313       unsigned long r_symndx;
6314       enum elf_ppc64_reloc_type r_type;
6315       struct elf_link_hash_entry *h = NULL;
6316       unsigned char tls_type = 0;
6317
6318       r_symndx = ELF64_R_SYM (rel->r_info);
6319       r_type = ELF64_R_TYPE (rel->r_info);
6320       if (r_symndx >= symtab_hdr->sh_info)
6321         {
6322           struct ppc_link_hash_entry *eh;
6323           struct elf_dyn_relocs **pp;
6324           struct elf_dyn_relocs *p;
6325
6326           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6327           h = elf_follow_link (h);
6328           eh = (struct ppc_link_hash_entry *) h;
6329
6330           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6331             if (p->sec == sec)
6332               {
6333                 /* Everything must go for SEC.  */
6334                 *pp = p->next;
6335                 break;
6336               }
6337         }
6338
6339       if (is_branch_reloc (r_type))
6340         {
6341           struct plt_entry **ifunc = NULL;
6342           if (h != NULL)
6343             {
6344               if (h->type == STT_GNU_IFUNC)
6345                 ifunc = &h->plt.plist;
6346             }
6347           else if (local_got_ents != NULL)
6348             {
6349               struct plt_entry **local_plt = (struct plt_entry **)
6350                 (local_got_ents + symtab_hdr->sh_info);
6351               unsigned char *local_got_tls_masks = (unsigned char *)
6352                 (local_plt + symtab_hdr->sh_info);
6353               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6354                 ifunc = local_plt + r_symndx;
6355             }
6356           if (ifunc != NULL)
6357             {
6358               struct plt_entry *ent;
6359
6360               for (ent = *ifunc; ent != NULL; ent = ent->next)
6361                 if (ent->addend == rel->r_addend)
6362                   break;
6363               if (ent == NULL)
6364                 abort ();
6365               if (ent->plt.refcount > 0)
6366                 ent->plt.refcount -= 1;
6367               continue;
6368             }
6369         }
6370
6371       switch (r_type)
6372         {
6373         case R_PPC64_GOT_TLSLD16:
6374         case R_PPC64_GOT_TLSLD16_LO:
6375         case R_PPC64_GOT_TLSLD16_HI:
6376         case R_PPC64_GOT_TLSLD16_HA:
6377           tls_type = TLS_TLS | TLS_LD;
6378           goto dogot;
6379
6380         case R_PPC64_GOT_TLSGD16:
6381         case R_PPC64_GOT_TLSGD16_LO:
6382         case R_PPC64_GOT_TLSGD16_HI:
6383         case R_PPC64_GOT_TLSGD16_HA:
6384           tls_type = TLS_TLS | TLS_GD;
6385           goto dogot;
6386
6387         case R_PPC64_GOT_TPREL16_DS:
6388         case R_PPC64_GOT_TPREL16_LO_DS:
6389         case R_PPC64_GOT_TPREL16_HI:
6390         case R_PPC64_GOT_TPREL16_HA:
6391           tls_type = TLS_TLS | TLS_TPREL;
6392           goto dogot;
6393
6394         case R_PPC64_GOT_DTPREL16_DS:
6395         case R_PPC64_GOT_DTPREL16_LO_DS:
6396         case R_PPC64_GOT_DTPREL16_HI:
6397         case R_PPC64_GOT_DTPREL16_HA:
6398           tls_type = TLS_TLS | TLS_DTPREL;
6399           goto dogot;
6400
6401         case R_PPC64_GOT16:
6402         case R_PPC64_GOT16_DS:
6403         case R_PPC64_GOT16_HA:
6404         case R_PPC64_GOT16_HI:
6405         case R_PPC64_GOT16_LO:
6406         case R_PPC64_GOT16_LO_DS:
6407         dogot:
6408           {
6409             struct got_entry *ent;
6410
6411             if (h != NULL)
6412               ent = h->got.glist;
6413             else
6414               ent = local_got_ents[r_symndx];
6415
6416             for (; ent != NULL; ent = ent->next)
6417               if (ent->addend == rel->r_addend
6418                   && ent->owner == abfd
6419                   && ent->tls_type == tls_type)
6420                 break;
6421             if (ent == NULL)
6422               abort ();
6423             if (ent->got.refcount > 0)
6424               ent->got.refcount -= 1;
6425           }
6426           break;
6427
6428         case R_PPC64_PLT16_HA:
6429         case R_PPC64_PLT16_HI:
6430         case R_PPC64_PLT16_LO:
6431         case R_PPC64_PLT32:
6432         case R_PPC64_PLT64:
6433         case R_PPC64_REL14:
6434         case R_PPC64_REL14_BRNTAKEN:
6435         case R_PPC64_REL14_BRTAKEN:
6436         case R_PPC64_REL24:
6437           if (h != NULL)
6438             {
6439               struct plt_entry *ent;
6440
6441               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6442                 if (ent->addend == rel->r_addend)
6443                   break;
6444               if (ent != NULL && ent->plt.refcount > 0)
6445                 ent->plt.refcount -= 1;
6446             }
6447           break;
6448
6449         default:
6450           break;
6451         }
6452     }
6453   return TRUE;
6454 }
6455
6456 /* The maximum size of .sfpr.  */
6457 #define SFPR_MAX (218*4)
6458
6459 struct sfpr_def_parms
6460 {
6461   const char name[12];
6462   unsigned char lo, hi;
6463   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6464   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6465 };
6466
6467 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6468
6469 static bfd_boolean
6470 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6471 {
6472   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6473   unsigned int i;
6474   size_t len = strlen (parm->name);
6475   bfd_boolean writing = FALSE;
6476   char sym[16];
6477
6478   if (htab == NULL)
6479     return FALSE;
6480
6481   memcpy (sym, parm->name, len);
6482   sym[len + 2] = 0;
6483
6484   for (i = parm->lo; i <= parm->hi; i++)
6485     {
6486       struct elf_link_hash_entry *h;
6487
6488       sym[len + 0] = i / 10 + '0';
6489       sym[len + 1] = i % 10 + '0';
6490       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6491       if (h != NULL
6492           && !h->def_regular)
6493         {
6494           h->root.type = bfd_link_hash_defined;
6495           h->root.u.def.section = htab->sfpr;
6496           h->root.u.def.value = htab->sfpr->size;
6497           h->type = STT_FUNC;
6498           h->def_regular = 1;
6499           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6500           writing = TRUE;
6501           if (htab->sfpr->contents == NULL)
6502             {
6503               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6504               if (htab->sfpr->contents == NULL)
6505                 return FALSE;
6506             }
6507         }
6508       if (writing)
6509         {
6510           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6511           if (i != parm->hi)
6512             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6513           else
6514             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6515           htab->sfpr->size = p - htab->sfpr->contents;
6516         }
6517     }
6518
6519   return TRUE;
6520 }
6521
6522 static bfd_byte *
6523 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6524 {
6525   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6526   return p + 4;
6527 }
6528
6529 static bfd_byte *
6530 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6531 {
6532   p = savegpr0 (abfd, p, r);
6533   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6534   p = p + 4;
6535   bfd_put_32 (abfd, BLR, p);
6536   return p + 4;
6537 }
6538
6539 static bfd_byte *
6540 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6541 {
6542   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6543   return p + 4;
6544 }
6545
6546 static bfd_byte *
6547 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6548 {
6549   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6550   p = p + 4;
6551   p = restgpr0 (abfd, p, r);
6552   bfd_put_32 (abfd, MTLR_R0, p);
6553   p = p + 4;
6554   if (r == 29)
6555     {
6556       p = restgpr0 (abfd, p, 30);
6557       p = restgpr0 (abfd, p, 31);
6558     }
6559   bfd_put_32 (abfd, BLR, p);
6560   return p + 4;
6561 }
6562
6563 static bfd_byte *
6564 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6565 {
6566   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6567   return p + 4;
6568 }
6569
6570 static bfd_byte *
6571 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6572 {
6573   p = savegpr1 (abfd, p, r);
6574   bfd_put_32 (abfd, BLR, p);
6575   return p + 4;
6576 }
6577
6578 static bfd_byte *
6579 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6580 {
6581   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6582   return p + 4;
6583 }
6584
6585 static bfd_byte *
6586 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6587 {
6588   p = restgpr1 (abfd, p, r);
6589   bfd_put_32 (abfd, BLR, p);
6590   return p + 4;
6591 }
6592
6593 static bfd_byte *
6594 savefpr (bfd *abfd, bfd_byte *p, int r)
6595 {
6596   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6597   return p + 4;
6598 }
6599
6600 static bfd_byte *
6601 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6602 {
6603   p = savefpr (abfd, p, r);
6604   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6605   p = p + 4;
6606   bfd_put_32 (abfd, BLR, p);
6607   return p + 4;
6608 }
6609
6610 static bfd_byte *
6611 restfpr (bfd *abfd, bfd_byte *p, int r)
6612 {
6613   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6614   return p + 4;
6615 }
6616
6617 static bfd_byte *
6618 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6619 {
6620   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6621   p = p + 4;
6622   p = restfpr (abfd, p, r);
6623   bfd_put_32 (abfd, MTLR_R0, p);
6624   p = p + 4;
6625   if (r == 29)
6626     {
6627       p = restfpr (abfd, p, 30);
6628       p = restfpr (abfd, p, 31);
6629     }
6630   bfd_put_32 (abfd, BLR, p);
6631   return p + 4;
6632 }
6633
6634 static bfd_byte *
6635 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6636 {
6637   p = savefpr (abfd, p, r);
6638   bfd_put_32 (abfd, BLR, p);
6639   return p + 4;
6640 }
6641
6642 static bfd_byte *
6643 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6644 {
6645   p = restfpr (abfd, p, r);
6646   bfd_put_32 (abfd, BLR, p);
6647   return p + 4;
6648 }
6649
6650 static bfd_byte *
6651 savevr (bfd *abfd, bfd_byte *p, int r)
6652 {
6653   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6654   p = p + 4;
6655   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6656   return p + 4;
6657 }
6658
6659 static bfd_byte *
6660 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6661 {
6662   p = savevr (abfd, p, r);
6663   bfd_put_32 (abfd, BLR, p);
6664   return p + 4;
6665 }
6666
6667 static bfd_byte *
6668 restvr (bfd *abfd, bfd_byte *p, int r)
6669 {
6670   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6671   p = p + 4;
6672   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6673   return p + 4;
6674 }
6675
6676 static bfd_byte *
6677 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6678 {
6679   p = restvr (abfd, p, r);
6680   bfd_put_32 (abfd, BLR, p);
6681   return p + 4;
6682 }
6683
6684 /* Called via elf_link_hash_traverse to transfer dynamic linking
6685    information on function code symbol entries to their corresponding
6686    function descriptor symbol entries.  */
6687
6688 static bfd_boolean
6689 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6690 {
6691   struct bfd_link_info *info;
6692   struct ppc_link_hash_table *htab;
6693   struct plt_entry *ent;
6694   struct ppc_link_hash_entry *fh;
6695   struct ppc_link_hash_entry *fdh;
6696   bfd_boolean force_local;
6697
6698   fh = (struct ppc_link_hash_entry *) h;
6699   if (fh->elf.root.type == bfd_link_hash_indirect)
6700     return TRUE;
6701
6702   info = inf;
6703   htab = ppc_hash_table (info);
6704   if (htab == NULL)
6705     return FALSE;
6706
6707   /* Resolve undefined references to dot-symbols as the value
6708      in the function descriptor, if we have one in a regular object.
6709      This is to satisfy cases like ".quad .foo".  Calls to functions
6710      in dynamic objects are handled elsewhere.  */
6711   if (fh->elf.root.type == bfd_link_hash_undefweak
6712       && fh->was_undefined
6713       && (fdh = defined_func_desc (fh)) != NULL
6714       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6715       && opd_entry_value (fdh->elf.root.u.def.section,
6716                           fdh->elf.root.u.def.value,
6717                           &fh->elf.root.u.def.section,
6718                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6719     {
6720       fh->elf.root.type = fdh->elf.root.type;
6721       fh->elf.forced_local = 1;
6722       fh->elf.def_regular = fdh->elf.def_regular;
6723       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6724     }
6725
6726   /* If this is a function code symbol, transfer dynamic linking
6727      information to the function descriptor symbol.  */
6728   if (!fh->is_func)
6729     return TRUE;
6730
6731   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6732     if (ent->plt.refcount > 0)
6733       break;
6734   if (ent == NULL
6735       || fh->elf.root.root.string[0] != '.'
6736       || fh->elf.root.root.string[1] == '\0')
6737     return TRUE;
6738
6739   /* Find the corresponding function descriptor symbol.  Create it
6740      as undefined if necessary.  */
6741
6742   fdh = lookup_fdh (fh, htab);
6743   if (fdh == NULL
6744       && !info->executable
6745       && (fh->elf.root.type == bfd_link_hash_undefined
6746           || fh->elf.root.type == bfd_link_hash_undefweak))
6747     {
6748       fdh = make_fdh (info, fh);
6749       if (fdh == NULL)
6750         return FALSE;
6751     }
6752
6753   /* Fake function descriptors are made undefweak.  If the function
6754      code symbol is strong undefined, make the fake sym the same.
6755      If the function code symbol is defined, then force the fake
6756      descriptor local;  We can't support overriding of symbols in a
6757      shared library on a fake descriptor.  */
6758
6759   if (fdh != NULL
6760       && fdh->fake
6761       && fdh->elf.root.type == bfd_link_hash_undefweak)
6762     {
6763       if (fh->elf.root.type == bfd_link_hash_undefined)
6764         {
6765           fdh->elf.root.type = bfd_link_hash_undefined;
6766           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6767         }
6768       else if (fh->elf.root.type == bfd_link_hash_defined
6769                || fh->elf.root.type == bfd_link_hash_defweak)
6770         {
6771           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6772         }
6773     }
6774
6775   if (fdh != NULL
6776       && !fdh->elf.forced_local
6777       && (!info->executable
6778           || fdh->elf.def_dynamic
6779           || fdh->elf.ref_dynamic
6780           || (fdh->elf.root.type == bfd_link_hash_undefweak
6781               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6782     {
6783       if (fdh->elf.dynindx == -1)
6784         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6785           return FALSE;
6786       fdh->elf.ref_regular |= fh->elf.ref_regular;
6787       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6788       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6789       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6790       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6791         {
6792           move_plt_plist (fh, fdh);
6793           fdh->elf.needs_plt = 1;
6794         }
6795       fdh->is_func_descriptor = 1;
6796       fdh->oh = fh;
6797       fh->oh = fdh;
6798     }
6799
6800   /* Now that the info is on the function descriptor, clear the
6801      function code sym info.  Any function code syms for which we
6802      don't have a definition in a regular file, we force local.
6803      This prevents a shared library from exporting syms that have
6804      been imported from another library.  Function code syms that
6805      are really in the library we must leave global to prevent the
6806      linker dragging in a definition from a static library.  */
6807   force_local = (!fh->elf.def_regular
6808                  || fdh == NULL
6809                  || !fdh->elf.def_regular
6810                  || fdh->elf.forced_local);
6811   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6812
6813   return TRUE;
6814 }
6815
6816 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6817    this hook to a) provide some gcc support functions, and b) transfer
6818    dynamic linking information gathered so far on function code symbol
6819    entries, to their corresponding function descriptor symbol entries.  */
6820
6821 static bfd_boolean
6822 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6823                             struct bfd_link_info *info)
6824 {
6825   struct ppc_link_hash_table *htab;
6826   unsigned int i;
6827   static const struct sfpr_def_parms funcs[] =
6828     {
6829       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6830       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6831       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6832       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6833       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6834       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6835       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6836       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6837       { "._savef", 14, 31, savefpr, savefpr1_tail },
6838       { "._restf", 14, 31, restfpr, restfpr1_tail },
6839       { "_savevr_", 20, 31, savevr, savevr_tail },
6840       { "_restvr_", 20, 31, restvr, restvr_tail }
6841     };
6842
6843   htab = ppc_hash_table (info);
6844   if (htab == NULL)
6845     return FALSE;
6846
6847   if (!info->relocatable
6848       && htab->elf.hgot != NULL)
6849     {
6850       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6851       /* Make .TOC. defined so as to prevent it being made dynamic.
6852          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6853       htab->elf.hgot->type = STT_OBJECT;
6854       htab->elf.hgot->root.type = bfd_link_hash_defined;
6855       htab->elf.hgot->root.u.def.value = 0;
6856       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6857       htab->elf.hgot->def_regular = 1;
6858       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6859                                | STV_HIDDEN);
6860     }
6861
6862   if (htab->sfpr == NULL)
6863     /* We don't have any relocs.  */
6864     return TRUE;
6865
6866   /* Provide any missing _save* and _rest* functions.  */
6867   htab->sfpr->size = 0;
6868   if (!info->relocatable)
6869     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6870       if (!sfpr_define (info, &funcs[i]))
6871         return FALSE;
6872
6873   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6874
6875   if (htab->sfpr->size == 0)
6876     htab->sfpr->flags |= SEC_EXCLUDE;
6877
6878   return TRUE;
6879 }
6880
6881 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6882
6883 static bfd_boolean
6884 readonly_dynrelocs (struct elf_link_hash_entry *h)
6885 {
6886   struct ppc_link_hash_entry *eh;
6887   struct elf_dyn_relocs *p;
6888
6889   eh = (struct ppc_link_hash_entry *) h;
6890   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6891     {
6892       asection *s = p->sec->output_section;
6893
6894       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6895         return TRUE;
6896     }
6897   return FALSE;
6898 }
6899
6900 /* Adjust a symbol defined by a dynamic object and referenced by a
6901    regular object.  The current definition is in some section of the
6902    dynamic object, but we're not including those sections.  We have to
6903    change the definition to something the rest of the link can
6904    understand.  */
6905
6906 static bfd_boolean
6907 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6908                                  struct elf_link_hash_entry *h)
6909 {
6910   struct ppc_link_hash_table *htab;
6911   asection *s;
6912
6913   htab = ppc_hash_table (info);
6914   if (htab == NULL)
6915     return FALSE;
6916
6917   /* Deal with function syms.  */
6918   if (h->type == STT_FUNC
6919       || h->type == STT_GNU_IFUNC
6920       || h->needs_plt)
6921     {
6922       /* Clear procedure linkage table information for any symbol that
6923          won't need a .plt entry.  */
6924       struct plt_entry *ent;
6925       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6926         if (ent->plt.refcount > 0)
6927           break;
6928       if (ent == NULL
6929           || (h->type != STT_GNU_IFUNC
6930               && (SYMBOL_CALLS_LOCAL (info, h)
6931                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6932                       && h->root.type == bfd_link_hash_undefweak))))
6933         {
6934           h->plt.plist = NULL;
6935           h->needs_plt = 0;
6936         }
6937       else if (abiversion (info->output_bfd) == 2)
6938         {
6939           /* After adjust_dynamic_symbol, non_got_ref set in the
6940              non-shared case means that we have allocated space in
6941              .dynbss for the symbol and thus dyn_relocs for this
6942              symbol should be discarded.
6943              If we get here we know we are making a PLT entry for this
6944              symbol, and in an executable we'd normally resolve
6945              relocations against this symbol to the PLT entry.  Allow
6946              dynamic relocs if the reference is weak, and the dynamic
6947              relocs will not cause text relocation.  */
6948           if (!h->ref_regular_nonweak
6949               && h->non_got_ref
6950               && h->type != STT_GNU_IFUNC
6951               && !readonly_dynrelocs (h))
6952             h->non_got_ref = 0;
6953
6954           /* If making a plt entry, then we don't need copy relocs.  */
6955           return TRUE;
6956         }
6957     }
6958   else
6959     h->plt.plist = NULL;
6960
6961   /* If this is a weak symbol, and there is a real definition, the
6962      processor independent code will have arranged for us to see the
6963      real definition first, and we can just use the same value.  */
6964   if (h->u.weakdef != NULL)
6965     {
6966       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6967                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6968       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6969       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6970       if (ELIMINATE_COPY_RELOCS)
6971         h->non_got_ref = h->u.weakdef->non_got_ref;
6972       return TRUE;
6973     }
6974
6975   /* If we are creating a shared library, we must presume that the
6976      only references to the symbol are via the global offset table.
6977      For such cases we need not do anything here; the relocations will
6978      be handled correctly by relocate_section.  */
6979   if (info->shared)
6980     return TRUE;
6981
6982   /* If there are no references to this symbol that do not use the
6983      GOT, we don't need to generate a copy reloc.  */
6984   if (!h->non_got_ref)
6985     return TRUE;
6986
6987   /* Don't generate a copy reloc for symbols defined in the executable.  */
6988   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6989     return TRUE;
6990
6991   /* If we didn't find any dynamic relocs in read-only sections, then
6992      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6993   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6994     {
6995       h->non_got_ref = 0;
6996       return TRUE;
6997     }
6998
6999   if (h->plt.plist != NULL)
7000     {
7001       /* We should never get here, but unfortunately there are versions
7002          of gcc out there that improperly (for this ABI) put initialized
7003          function pointers, vtable refs and suchlike in read-only
7004          sections.  Allow them to proceed, but warn that this might
7005          break at runtime.  */
7006       info->callbacks->einfo
7007         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7008            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7009          h->root.root.string);
7010     }
7011
7012   /* This is a reference to a symbol defined by a dynamic object which
7013      is not a function.  */
7014
7015   /* We must allocate the symbol in our .dynbss section, which will
7016      become part of the .bss section of the executable.  There will be
7017      an entry for this symbol in the .dynsym section.  The dynamic
7018      object will contain position independent code, so all references
7019      from the dynamic object to this symbol will go through the global
7020      offset table.  The dynamic linker will use the .dynsym entry to
7021      determine the address it must put in the global offset table, so
7022      both the dynamic object and the regular object will refer to the
7023      same memory location for the variable.  */
7024
7025   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7026      to copy the initial value out of the dynamic object and into the
7027      runtime process image.  We need to remember the offset into the
7028      .rela.bss section we are going to use.  */
7029   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7030     {
7031       htab->relbss->size += sizeof (Elf64_External_Rela);
7032       h->needs_copy = 1;
7033     }
7034
7035   s = htab->dynbss;
7036
7037   return _bfd_elf_adjust_dynamic_copy (h, s);
7038 }
7039
7040 /* If given a function descriptor symbol, hide both the function code
7041    sym and the descriptor.  */
7042 static void
7043 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7044                        struct elf_link_hash_entry *h,
7045                        bfd_boolean force_local)
7046 {
7047   struct ppc_link_hash_entry *eh;
7048   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7049
7050   eh = (struct ppc_link_hash_entry *) h;
7051   if (eh->is_func_descriptor)
7052     {
7053       struct ppc_link_hash_entry *fh = eh->oh;
7054
7055       if (fh == NULL)
7056         {
7057           const char *p, *q;
7058           struct ppc_link_hash_table *htab;
7059           char save;
7060
7061           /* We aren't supposed to use alloca in BFD because on
7062              systems which do not have alloca the version in libiberty
7063              calls xmalloc, which might cause the program to crash
7064              when it runs out of memory.  This function doesn't have a
7065              return status, so there's no way to gracefully return an
7066              error.  So cheat.  We know that string[-1] can be safely
7067              accessed;  It's either a string in an ELF string table,
7068              or allocated in an objalloc structure.  */
7069
7070           p = eh->elf.root.root.string - 1;
7071           save = *p;
7072           *(char *) p = '.';
7073           htab = ppc_hash_table (info);
7074           if (htab == NULL)
7075             return;
7076
7077           fh = (struct ppc_link_hash_entry *)
7078             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7079           *(char *) p = save;
7080
7081           /* Unfortunately, if it so happens that the string we were
7082              looking for was allocated immediately before this string,
7083              then we overwrote the string terminator.  That's the only
7084              reason the lookup should fail.  */
7085           if (fh == NULL)
7086             {
7087               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7088               while (q >= eh->elf.root.root.string && *q == *p)
7089                 --q, --p;
7090               if (q < eh->elf.root.root.string && *p == '.')
7091                 fh = (struct ppc_link_hash_entry *)
7092                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7093             }
7094           if (fh != NULL)
7095             {
7096               eh->oh = fh;
7097               fh->oh = eh;
7098             }
7099         }
7100       if (fh != NULL)
7101         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7102     }
7103 }
7104
7105 static bfd_boolean
7106 get_sym_h (struct elf_link_hash_entry **hp,
7107            Elf_Internal_Sym **symp,
7108            asection **symsecp,
7109            unsigned char **tls_maskp,
7110            Elf_Internal_Sym **locsymsp,
7111            unsigned long r_symndx,
7112            bfd *ibfd)
7113 {
7114   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7115
7116   if (r_symndx >= symtab_hdr->sh_info)
7117     {
7118       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7119       struct elf_link_hash_entry *h;
7120
7121       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7122       h = elf_follow_link (h);
7123
7124       if (hp != NULL)
7125         *hp = h;
7126
7127       if (symp != NULL)
7128         *symp = NULL;
7129
7130       if (symsecp != NULL)
7131         {
7132           asection *symsec = NULL;
7133           if (h->root.type == bfd_link_hash_defined
7134               || h->root.type == bfd_link_hash_defweak)
7135             symsec = h->root.u.def.section;
7136           *symsecp = symsec;
7137         }
7138
7139       if (tls_maskp != NULL)
7140         {
7141           struct ppc_link_hash_entry *eh;
7142
7143           eh = (struct ppc_link_hash_entry *) h;
7144           *tls_maskp = &eh->tls_mask;
7145         }
7146     }
7147   else
7148     {
7149       Elf_Internal_Sym *sym;
7150       Elf_Internal_Sym *locsyms = *locsymsp;
7151
7152       if (locsyms == NULL)
7153         {
7154           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7155           if (locsyms == NULL)
7156             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7157                                             symtab_hdr->sh_info,
7158                                             0, NULL, NULL, NULL);
7159           if (locsyms == NULL)
7160             return FALSE;
7161           *locsymsp = locsyms;
7162         }
7163       sym = locsyms + r_symndx;
7164
7165       if (hp != NULL)
7166         *hp = NULL;
7167
7168       if (symp != NULL)
7169         *symp = sym;
7170
7171       if (symsecp != NULL)
7172         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7173
7174       if (tls_maskp != NULL)
7175         {
7176           struct got_entry **lgot_ents;
7177           unsigned char *tls_mask;
7178
7179           tls_mask = NULL;
7180           lgot_ents = elf_local_got_ents (ibfd);
7181           if (lgot_ents != NULL)
7182             {
7183               struct plt_entry **local_plt = (struct plt_entry **)
7184                 (lgot_ents + symtab_hdr->sh_info);
7185               unsigned char *lgot_masks = (unsigned char *)
7186                 (local_plt + symtab_hdr->sh_info);
7187               tls_mask = &lgot_masks[r_symndx];
7188             }
7189           *tls_maskp = tls_mask;
7190         }
7191     }
7192   return TRUE;
7193 }
7194
7195 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7196    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7197    type suitable for optimization, and 1 otherwise.  */
7198
7199 static int
7200 get_tls_mask (unsigned char **tls_maskp,
7201               unsigned long *toc_symndx,
7202               bfd_vma *toc_addend,
7203               Elf_Internal_Sym **locsymsp,
7204               const Elf_Internal_Rela *rel,
7205               bfd *ibfd)
7206 {
7207   unsigned long r_symndx;
7208   int next_r;
7209   struct elf_link_hash_entry *h;
7210   Elf_Internal_Sym *sym;
7211   asection *sec;
7212   bfd_vma off;
7213
7214   r_symndx = ELF64_R_SYM (rel->r_info);
7215   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7216     return 0;
7217
7218   if ((*tls_maskp != NULL && **tls_maskp != 0)
7219       || sec == NULL
7220       || ppc64_elf_section_data (sec) == NULL
7221       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7222     return 1;
7223
7224   /* Look inside a TOC section too.  */
7225   if (h != NULL)
7226     {
7227       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7228       off = h->root.u.def.value;
7229     }
7230   else
7231     off = sym->st_value;
7232   off += rel->r_addend;
7233   BFD_ASSERT (off % 8 == 0);
7234   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7235   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7236   if (toc_symndx != NULL)
7237     *toc_symndx = r_symndx;
7238   if (toc_addend != NULL)
7239     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7240   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7241     return 0;
7242   if ((h == NULL || is_static_defined (h))
7243       && (next_r == -1 || next_r == -2))
7244     return 1 - next_r;
7245   return 1;
7246 }
7247
7248 /* Find (or create) an entry in the tocsave hash table.  */
7249
7250 static struct tocsave_entry *
7251 tocsave_find (struct ppc_link_hash_table *htab,
7252               enum insert_option insert,
7253               Elf_Internal_Sym **local_syms,
7254               const Elf_Internal_Rela *irela,
7255               bfd *ibfd)
7256 {
7257   unsigned long r_indx;
7258   struct elf_link_hash_entry *h;
7259   Elf_Internal_Sym *sym;
7260   struct tocsave_entry ent, *p;
7261   hashval_t hash;
7262   struct tocsave_entry **slot;
7263
7264   r_indx = ELF64_R_SYM (irela->r_info);
7265   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7266     return NULL;
7267   if (ent.sec == NULL || ent.sec->output_section == NULL)
7268     {
7269       (*_bfd_error_handler)
7270         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7271       return NULL;
7272     }
7273
7274   if (h != NULL)
7275     ent.offset = h->root.u.def.value;
7276   else
7277     ent.offset = sym->st_value;
7278   ent.offset += irela->r_addend;
7279
7280   hash = tocsave_htab_hash (&ent);
7281   slot = ((struct tocsave_entry **)
7282           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7283   if (slot == NULL)
7284     return NULL;
7285
7286   if (*slot == NULL)
7287     {
7288       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7289       if (p == NULL)
7290         return NULL;
7291       *p = ent;
7292       *slot = p;
7293     }
7294   return *slot;
7295 }
7296
7297 /* Adjust all global syms defined in opd sections.  In gcc generated
7298    code for the old ABI, these will already have been done.  */
7299
7300 static bfd_boolean
7301 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7302 {
7303   struct ppc_link_hash_entry *eh;
7304   asection *sym_sec;
7305   struct _opd_sec_data *opd;
7306
7307   if (h->root.type == bfd_link_hash_indirect)
7308     return TRUE;
7309
7310   if (h->root.type != bfd_link_hash_defined
7311       && h->root.type != bfd_link_hash_defweak)
7312     return TRUE;
7313
7314   eh = (struct ppc_link_hash_entry *) h;
7315   if (eh->adjust_done)
7316     return TRUE;
7317
7318   sym_sec = eh->elf.root.u.def.section;
7319   opd = get_opd_info (sym_sec);
7320   if (opd != NULL && opd->adjust != NULL)
7321     {
7322       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7323       if (adjust == -1)
7324         {
7325           /* This entry has been deleted.  */
7326           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7327           if (dsec == NULL)
7328             {
7329               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7330                 if (discarded_section (dsec))
7331                   {
7332                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7333                     break;
7334                   }
7335             }
7336           eh->elf.root.u.def.value = 0;
7337           eh->elf.root.u.def.section = dsec;
7338         }
7339       else
7340         eh->elf.root.u.def.value += adjust;
7341       eh->adjust_done = 1;
7342     }
7343   return TRUE;
7344 }
7345
7346 /* Handles decrementing dynamic reloc counts for the reloc specified by
7347    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7348    have already been determined.  */
7349
7350 static bfd_boolean
7351 dec_dynrel_count (bfd_vma r_info,
7352                   asection *sec,
7353                   struct bfd_link_info *info,
7354                   Elf_Internal_Sym **local_syms,
7355                   struct elf_link_hash_entry *h,
7356                   Elf_Internal_Sym *sym)
7357 {
7358   enum elf_ppc64_reloc_type r_type;
7359   asection *sym_sec = NULL;
7360
7361   /* Can this reloc be dynamic?  This switch, and later tests here
7362      should be kept in sync with the code in check_relocs.  */
7363   r_type = ELF64_R_TYPE (r_info);
7364   switch (r_type)
7365     {
7366     default:
7367       return TRUE;
7368
7369     case R_PPC64_TPREL16:
7370     case R_PPC64_TPREL16_LO:
7371     case R_PPC64_TPREL16_HI:
7372     case R_PPC64_TPREL16_HA:
7373     case R_PPC64_TPREL16_DS:
7374     case R_PPC64_TPREL16_LO_DS:
7375     case R_PPC64_TPREL16_HIGH:
7376     case R_PPC64_TPREL16_HIGHA:
7377     case R_PPC64_TPREL16_HIGHER:
7378     case R_PPC64_TPREL16_HIGHERA:
7379     case R_PPC64_TPREL16_HIGHEST:
7380     case R_PPC64_TPREL16_HIGHESTA:
7381       if (!info->shared)
7382         return TRUE;
7383
7384     case R_PPC64_TPREL64:
7385     case R_PPC64_DTPMOD64:
7386     case R_PPC64_DTPREL64:
7387     case R_PPC64_ADDR64:
7388     case R_PPC64_REL30:
7389     case R_PPC64_REL32:
7390     case R_PPC64_REL64:
7391     case R_PPC64_ADDR14:
7392     case R_PPC64_ADDR14_BRNTAKEN:
7393     case R_PPC64_ADDR14_BRTAKEN:
7394     case R_PPC64_ADDR16:
7395     case R_PPC64_ADDR16_DS:
7396     case R_PPC64_ADDR16_HA:
7397     case R_PPC64_ADDR16_HI:
7398     case R_PPC64_ADDR16_HIGH:
7399     case R_PPC64_ADDR16_HIGHA:
7400     case R_PPC64_ADDR16_HIGHER:
7401     case R_PPC64_ADDR16_HIGHERA:
7402     case R_PPC64_ADDR16_HIGHEST:
7403     case R_PPC64_ADDR16_HIGHESTA:
7404     case R_PPC64_ADDR16_LO:
7405     case R_PPC64_ADDR16_LO_DS:
7406     case R_PPC64_ADDR24:
7407     case R_PPC64_ADDR32:
7408     case R_PPC64_UADDR16:
7409     case R_PPC64_UADDR32:
7410     case R_PPC64_UADDR64:
7411     case R_PPC64_TOC:
7412       break;
7413     }
7414
7415   if (local_syms != NULL)
7416     {
7417       unsigned long r_symndx;
7418       bfd *ibfd = sec->owner;
7419
7420       r_symndx = ELF64_R_SYM (r_info);
7421       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7422         return FALSE;
7423     }
7424
7425   if ((info->shared
7426        && (must_be_dyn_reloc (info, r_type)
7427            || (h != NULL
7428                && (!SYMBOLIC_BIND (info, h)
7429                    || h->root.type == bfd_link_hash_defweak
7430                    || !h->def_regular))))
7431       || (ELIMINATE_COPY_RELOCS
7432           && !info->shared
7433           && h != NULL
7434           && (h->root.type == bfd_link_hash_defweak
7435               || !h->def_regular)))
7436     ;
7437   else
7438     return TRUE;
7439
7440   if (h != NULL)
7441     {
7442       struct elf_dyn_relocs *p;
7443       struct elf_dyn_relocs **pp;
7444       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7445
7446       /* elf_gc_sweep may have already removed all dyn relocs associated
7447          with local syms for a given section.  Also, symbol flags are
7448          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7449          report a dynreloc miscount.  */
7450       if (*pp == NULL && info->gc_sections)
7451         return TRUE;
7452
7453       while ((p = *pp) != NULL)
7454         {
7455           if (p->sec == sec)
7456             {
7457               if (!must_be_dyn_reloc (info, r_type))
7458                 p->pc_count -= 1;
7459               p->count -= 1;
7460               if (p->count == 0)
7461                 *pp = p->next;
7462               return TRUE;
7463             }
7464           pp = &p->next;
7465         }
7466     }
7467   else
7468     {
7469       struct ppc_dyn_relocs *p;
7470       struct ppc_dyn_relocs **pp;
7471       void *vpp;
7472       bfd_boolean is_ifunc;
7473
7474       if (local_syms == NULL)
7475         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7476       if (sym_sec == NULL)
7477         sym_sec = sec;
7478
7479       vpp = &elf_section_data (sym_sec)->local_dynrel;
7480       pp = (struct ppc_dyn_relocs **) vpp;
7481
7482       if (*pp == NULL && info->gc_sections)
7483         return TRUE;
7484
7485       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7486       while ((p = *pp) != NULL)
7487         {
7488           if (p->sec == sec && p->ifunc == is_ifunc)
7489             {
7490               p->count -= 1;
7491               if (p->count == 0)
7492                 *pp = p->next;
7493               return TRUE;
7494             }
7495           pp = &p->next;
7496         }
7497     }
7498
7499   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7500                           sec->owner, sec);
7501   bfd_set_error (bfd_error_bad_value);
7502   return FALSE;
7503 }
7504
7505 /* Remove unused Official Procedure Descriptor entries.  Currently we
7506    only remove those associated with functions in discarded link-once
7507    sections, or weakly defined functions that have been overridden.  It
7508    would be possible to remove many more entries for statically linked
7509    applications.  */
7510
7511 bfd_boolean
7512 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7513 {
7514   bfd *ibfd;
7515   bfd_boolean some_edited = FALSE;
7516   asection *need_pad = NULL;
7517
7518   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7519     {
7520       asection *sec;
7521       Elf_Internal_Rela *relstart, *rel, *relend;
7522       Elf_Internal_Shdr *symtab_hdr;
7523       Elf_Internal_Sym *local_syms;
7524       bfd_vma offset;
7525       struct _opd_sec_data *opd;
7526       bfd_boolean need_edit, add_aux_fields;
7527       bfd_size_type cnt_16b = 0;
7528
7529       if (!is_ppc64_elf (ibfd))
7530         continue;
7531
7532       sec = bfd_get_section_by_name (ibfd, ".opd");
7533       if (sec == NULL || sec->size == 0)
7534         continue;
7535
7536       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7537         continue;
7538
7539       if (sec->output_section == bfd_abs_section_ptr)
7540         continue;
7541
7542       /* Look through the section relocs.  */
7543       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7544         continue;
7545
7546       local_syms = NULL;
7547       symtab_hdr = &elf_symtab_hdr (ibfd);
7548
7549       /* Read the relocations.  */
7550       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7551                                             info->keep_memory);
7552       if (relstart == NULL)
7553         return FALSE;
7554
7555       /* First run through the relocs to check they are sane, and to
7556          determine whether we need to edit this opd section.  */
7557       need_edit = FALSE;
7558       need_pad = sec;
7559       offset = 0;
7560       relend = relstart + sec->reloc_count;
7561       for (rel = relstart; rel < relend; )
7562         {
7563           enum elf_ppc64_reloc_type r_type;
7564           unsigned long r_symndx;
7565           asection *sym_sec;
7566           struct elf_link_hash_entry *h;
7567           Elf_Internal_Sym *sym;
7568
7569           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7570              only interested in the reloc pointing to a function entry
7571              point.  */
7572           if (rel->r_offset != offset
7573               || rel + 1 >= relend
7574               || (rel + 1)->r_offset != offset + 8)
7575             {
7576               /* If someone messes with .opd alignment then after a
7577                  "ld -r" we might have padding in the middle of .opd.
7578                  Also, there's nothing to prevent someone putting
7579                  something silly in .opd with the assembler.  No .opd
7580                  optimization for them!  */
7581             broken_opd:
7582               (*_bfd_error_handler)
7583                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7584               need_edit = FALSE;
7585               break;
7586             }
7587
7588           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7589               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7590             {
7591               (*_bfd_error_handler)
7592                 (_("%B: unexpected reloc type %u in .opd section"),
7593                  ibfd, r_type);
7594               need_edit = FALSE;
7595               break;
7596             }
7597
7598           r_symndx = ELF64_R_SYM (rel->r_info);
7599           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7600                           r_symndx, ibfd))
7601             goto error_ret;
7602
7603           if (sym_sec == NULL || sym_sec->owner == NULL)
7604             {
7605               const char *sym_name;
7606               if (h != NULL)
7607                 sym_name = h->root.root.string;
7608               else
7609                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7610                                              sym_sec);
7611
7612               (*_bfd_error_handler)
7613                 (_("%B: undefined sym `%s' in .opd section"),
7614                  ibfd, sym_name);
7615               need_edit = FALSE;
7616               break;
7617             }
7618
7619           /* opd entries are always for functions defined in the
7620              current input bfd.  If the symbol isn't defined in the
7621              input bfd, then we won't be using the function in this
7622              bfd;  It must be defined in a linkonce section in another
7623              bfd, or is weak.  It's also possible that we are
7624              discarding the function due to a linker script /DISCARD/,
7625              which we test for via the output_section.  */
7626           if (sym_sec->owner != ibfd
7627               || sym_sec->output_section == bfd_abs_section_ptr)
7628             need_edit = TRUE;
7629
7630           rel += 2;
7631           if (rel == relend
7632               || (rel + 1 == relend && rel->r_offset == offset + 16))
7633             {
7634               if (sec->size == offset + 24)
7635                 {
7636                   need_pad = NULL;
7637                   break;
7638                 }
7639               if (rel == relend && sec->size == offset + 16)
7640                 {
7641                   cnt_16b++;
7642                   break;
7643                 }
7644               goto broken_opd;
7645             }
7646
7647           if (rel->r_offset == offset + 24)
7648             offset += 24;
7649           else if (rel->r_offset != offset + 16)
7650             goto broken_opd;
7651           else if (rel + 1 < relend
7652                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7653                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7654             {
7655               offset += 16;
7656               cnt_16b++;
7657             }
7658           else if (rel + 2 < relend
7659                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7660                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7661             {
7662               offset += 24;
7663               rel += 1;
7664             }
7665           else
7666             goto broken_opd;
7667         }
7668
7669       add_aux_fields = non_overlapping && cnt_16b > 0;
7670
7671       if (need_edit || add_aux_fields)
7672         {
7673           Elf_Internal_Rela *write_rel;
7674           Elf_Internal_Shdr *rel_hdr;
7675           bfd_byte *rptr, *wptr;
7676           bfd_byte *new_contents;
7677           bfd_boolean skip;
7678           long opd_ent_size;
7679           bfd_size_type amt;
7680
7681           new_contents = NULL;
7682           amt = sec->size * sizeof (long) / 8;
7683           opd = &ppc64_elf_section_data (sec)->u.opd;
7684           opd->adjust = bfd_zalloc (sec->owner, amt);
7685           if (opd->adjust == NULL)
7686             return FALSE;
7687           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7688
7689           /* This seems a waste of time as input .opd sections are all
7690              zeros as generated by gcc, but I suppose there's no reason
7691              this will always be so.  We might start putting something in
7692              the third word of .opd entries.  */
7693           if ((sec->flags & SEC_IN_MEMORY) == 0)
7694             {
7695               bfd_byte *loc;
7696               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7697                 {
7698                   if (loc != NULL)
7699                     free (loc);
7700                 error_ret:
7701                   if (local_syms != NULL
7702                       && symtab_hdr->contents != (unsigned char *) local_syms)
7703                     free (local_syms);
7704                   if (elf_section_data (sec)->relocs != relstart)
7705                     free (relstart);
7706                   return FALSE;
7707                 }
7708               sec->contents = loc;
7709               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7710             }
7711
7712           elf_section_data (sec)->relocs = relstart;
7713
7714           new_contents = sec->contents;
7715           if (add_aux_fields)
7716             {
7717               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7718               if (new_contents == NULL)
7719                 return FALSE;
7720               need_pad = FALSE;
7721             }
7722           wptr = new_contents;
7723           rptr = sec->contents;
7724
7725           write_rel = relstart;
7726           skip = FALSE;
7727           offset = 0;
7728           opd_ent_size = 0;
7729           for (rel = relstart; rel < relend; rel++)
7730             {
7731               unsigned long r_symndx;
7732               asection *sym_sec;
7733               struct elf_link_hash_entry *h;
7734               Elf_Internal_Sym *sym;
7735
7736               r_symndx = ELF64_R_SYM (rel->r_info);
7737               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7738                               r_symndx, ibfd))
7739                 goto error_ret;
7740
7741               if (rel->r_offset == offset)
7742                 {
7743                   struct ppc_link_hash_entry *fdh = NULL;
7744
7745                   /* See if the .opd entry is full 24 byte or
7746                      16 byte (with fd_aux entry overlapped with next
7747                      fd_func).  */
7748                   opd_ent_size = 24;
7749                   if ((rel + 2 == relend && sec->size == offset + 16)
7750                       || (rel + 3 < relend
7751                           && rel[2].r_offset == offset + 16
7752                           && rel[3].r_offset == offset + 24
7753                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7754                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7755                     opd_ent_size = 16;
7756
7757                   if (h != NULL
7758                       && h->root.root.string[0] == '.')
7759                     {
7760                       struct ppc_link_hash_table *htab;
7761
7762                       htab = ppc_hash_table (info);
7763                       if (htab != NULL)
7764                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7765                                           htab);
7766                       if (fdh != NULL
7767                           && fdh->elf.root.type != bfd_link_hash_defined
7768                           && fdh->elf.root.type != bfd_link_hash_defweak)
7769                         fdh = NULL;
7770                     }
7771
7772                   skip = (sym_sec->owner != ibfd
7773                           || sym_sec->output_section == bfd_abs_section_ptr);
7774                   if (skip)
7775                     {
7776                       if (fdh != NULL && sym_sec->owner == ibfd)
7777                         {
7778                           /* Arrange for the function descriptor sym
7779                              to be dropped.  */
7780                           fdh->elf.root.u.def.value = 0;
7781                           fdh->elf.root.u.def.section = sym_sec;
7782                         }
7783                       opd->adjust[rel->r_offset / 8] = -1;
7784                     }
7785                   else
7786                     {
7787                       /* We'll be keeping this opd entry.  */
7788
7789                       if (fdh != NULL)
7790                         {
7791                           /* Redefine the function descriptor symbol to
7792                              this location in the opd section.  It is
7793                              necessary to update the value here rather
7794                              than using an array of adjustments as we do
7795                              for local symbols, because various places
7796                              in the generic ELF code use the value
7797                              stored in u.def.value.  */
7798                           fdh->elf.root.u.def.value = wptr - new_contents;
7799                           fdh->adjust_done = 1;
7800                         }
7801
7802                       /* Local syms are a bit tricky.  We could
7803                          tweak them as they can be cached, but
7804                          we'd need to look through the local syms
7805                          for the function descriptor sym which we
7806                          don't have at the moment.  So keep an
7807                          array of adjustments.  */
7808                       opd->adjust[rel->r_offset / 8]
7809                         = (wptr - new_contents) - (rptr - sec->contents);
7810
7811                       if (wptr != rptr)
7812                         memcpy (wptr, rptr, opd_ent_size);
7813                       wptr += opd_ent_size;
7814                       if (add_aux_fields && opd_ent_size == 16)
7815                         {
7816                           memset (wptr, '\0', 8);
7817                           wptr += 8;
7818                         }
7819                     }
7820                   rptr += opd_ent_size;
7821                   offset += opd_ent_size;
7822                 }
7823
7824               if (skip)
7825                 {
7826                   if (!NO_OPD_RELOCS
7827                       && !info->relocatable
7828                       && !dec_dynrel_count (rel->r_info, sec, info,
7829                                             NULL, h, sym))
7830                     goto error_ret;
7831                 }
7832               else
7833                 {
7834                   /* We need to adjust any reloc offsets to point to the
7835                      new opd entries.  While we're at it, we may as well
7836                      remove redundant relocs.  */
7837                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7838                   if (write_rel != rel)
7839                     memcpy (write_rel, rel, sizeof (*rel));
7840                   ++write_rel;
7841                 }
7842             }
7843
7844           sec->size = wptr - new_contents;
7845           sec->reloc_count = write_rel - relstart;
7846           if (add_aux_fields)
7847             {
7848               free (sec->contents);
7849               sec->contents = new_contents;
7850             }
7851
7852           /* Fudge the header size too, as this is used later in
7853              elf_bfd_final_link if we are emitting relocs.  */
7854           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7855           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7856           some_edited = TRUE;
7857         }
7858       else if (elf_section_data (sec)->relocs != relstart)
7859         free (relstart);
7860
7861       if (local_syms != NULL
7862           && symtab_hdr->contents != (unsigned char *) local_syms)
7863         {
7864           if (!info->keep_memory)
7865             free (local_syms);
7866           else
7867             symtab_hdr->contents = (unsigned char *) local_syms;
7868         }
7869     }
7870
7871   if (some_edited)
7872     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7873
7874   /* If we are doing a final link and the last .opd entry is just 16 byte
7875      long, add a 8 byte padding after it.  */
7876   if (need_pad != NULL && !info->relocatable)
7877     {
7878       bfd_byte *p;
7879
7880       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7881         {
7882           BFD_ASSERT (need_pad->size > 0);
7883
7884           p = bfd_malloc (need_pad->size + 8);
7885           if (p == NULL)
7886             return FALSE;
7887
7888           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7889                                           p, 0, need_pad->size))
7890             return FALSE;
7891
7892           need_pad->contents = p;
7893           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7894         }
7895       else
7896         {
7897           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7898           if (p == NULL)
7899             return FALSE;
7900
7901           need_pad->contents = p;
7902         }
7903
7904       memset (need_pad->contents + need_pad->size, 0, 8);
7905       need_pad->size += 8;
7906     }
7907
7908   return TRUE;
7909 }
7910
7911 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7912
7913 asection *
7914 ppc64_elf_tls_setup (struct bfd_link_info *info,
7915                      int no_tls_get_addr_opt,
7916                      int *no_multi_toc)
7917 {
7918   struct ppc_link_hash_table *htab;
7919
7920   htab = ppc_hash_table (info);
7921   if (htab == NULL)
7922     return NULL;
7923
7924   if (abiversion (info->output_bfd) == 1)
7925     htab->opd_abi = 1;
7926
7927   if (*no_multi_toc)
7928     htab->do_multi_toc = 0;
7929   else if (!htab->do_multi_toc)
7930     *no_multi_toc = 1;
7931
7932   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7933                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7934                                               FALSE, FALSE, TRUE));
7935   /* Move dynamic linking info to the function descriptor sym.  */
7936   if (htab->tls_get_addr != NULL)
7937     func_desc_adjust (&htab->tls_get_addr->elf, info);
7938   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7939                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7940                                                  FALSE, FALSE, TRUE));
7941   if (!no_tls_get_addr_opt)
7942     {
7943       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7944
7945       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7946                                   FALSE, FALSE, TRUE);
7947       if (opt != NULL)
7948         func_desc_adjust (opt, info);
7949       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7950                                      FALSE, FALSE, TRUE);
7951       if (opt_fd != NULL
7952           && (opt_fd->root.type == bfd_link_hash_defined
7953               || opt_fd->root.type == bfd_link_hash_defweak))
7954         {
7955           /* If glibc supports an optimized __tls_get_addr call stub,
7956              signalled by the presence of __tls_get_addr_opt, and we'll
7957              be calling __tls_get_addr via a plt call stub, then
7958              make __tls_get_addr point to __tls_get_addr_opt.  */
7959           tga_fd = &htab->tls_get_addr_fd->elf;
7960           if (htab->elf.dynamic_sections_created
7961               && tga_fd != NULL
7962               && (tga_fd->type == STT_FUNC
7963                   || tga_fd->needs_plt)
7964               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7965                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7966                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7967             {
7968               struct plt_entry *ent;
7969
7970               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7971                 if (ent->plt.refcount > 0)
7972                   break;
7973               if (ent != NULL)
7974                 {
7975                   tga_fd->root.type = bfd_link_hash_indirect;
7976                   tga_fd->root.u.i.link = &opt_fd->root;
7977                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7978                   if (opt_fd->dynindx != -1)
7979                     {
7980                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7981                       opt_fd->dynindx = -1;
7982                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7983                                               opt_fd->dynstr_index);
7984                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7985                         return NULL;
7986                     }
7987                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7988                   tga = &htab->tls_get_addr->elf;
7989                   if (opt != NULL && tga != NULL)
7990                     {
7991                       tga->root.type = bfd_link_hash_indirect;
7992                       tga->root.u.i.link = &opt->root;
7993                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7994                       _bfd_elf_link_hash_hide_symbol (info, opt,
7995                                                       tga->forced_local);
7996                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7997                     }
7998                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7999                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8000                   if (htab->tls_get_addr != NULL)
8001                     {
8002                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8003                       htab->tls_get_addr->is_func = 1;
8004                     }
8005                 }
8006             }
8007         }
8008       else
8009         no_tls_get_addr_opt = TRUE;
8010     }
8011   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8012   return _bfd_elf_tls_setup (info->output_bfd, info);
8013 }
8014
8015 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8016    HASH1 or HASH2.  */
8017
8018 static bfd_boolean
8019 branch_reloc_hash_match (const bfd *ibfd,
8020                          const Elf_Internal_Rela *rel,
8021                          const struct ppc_link_hash_entry *hash1,
8022                          const struct ppc_link_hash_entry *hash2)
8023 {
8024   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8025   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8026   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8027
8028   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8029     {
8030       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8031       struct elf_link_hash_entry *h;
8032
8033       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8034       h = elf_follow_link (h);
8035       if (h == &hash1->elf || h == &hash2->elf)
8036         return TRUE;
8037     }
8038   return FALSE;
8039 }
8040
8041 /* Run through all the TLS relocs looking for optimization
8042    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8043    a preliminary section layout so that we know the TLS segment
8044    offsets.  We can't optimize earlier because some optimizations need
8045    to know the tp offset, and we need to optimize before allocating
8046    dynamic relocations.  */
8047
8048 bfd_boolean
8049 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8050 {
8051   bfd *ibfd;
8052   asection *sec;
8053   struct ppc_link_hash_table *htab;
8054   unsigned char *toc_ref;
8055   int pass;
8056
8057   if (info->relocatable || !info->executable)
8058     return TRUE;
8059
8060   htab = ppc_hash_table (info);
8061   if (htab == NULL)
8062     return FALSE;
8063
8064   /* Make two passes over the relocs.  On the first pass, mark toc
8065      entries involved with tls relocs, and check that tls relocs
8066      involved in setting up a tls_get_addr call are indeed followed by
8067      such a call.  If they are not, we can't do any tls optimization.
8068      On the second pass twiddle tls_mask flags to notify
8069      relocate_section that optimization can be done, and adjust got
8070      and plt refcounts.  */
8071   toc_ref = NULL;
8072   for (pass = 0; pass < 2; ++pass)
8073     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8074       {
8075         Elf_Internal_Sym *locsyms = NULL;
8076         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8077
8078         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8079           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8080             {
8081               Elf_Internal_Rela *relstart, *rel, *relend;
8082               bfd_boolean found_tls_get_addr_arg = 0;
8083
8084               /* Read the relocations.  */
8085               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8086                                                     info->keep_memory);
8087               if (relstart == NULL)
8088                 {
8089                   free (toc_ref);
8090                   return FALSE;
8091                 }
8092
8093               relend = relstart + sec->reloc_count;
8094               for (rel = relstart; rel < relend; rel++)
8095                 {
8096                   enum elf_ppc64_reloc_type r_type;
8097                   unsigned long r_symndx;
8098                   struct elf_link_hash_entry *h;
8099                   Elf_Internal_Sym *sym;
8100                   asection *sym_sec;
8101                   unsigned char *tls_mask;
8102                   unsigned char tls_set, tls_clear, tls_type = 0;
8103                   bfd_vma value;
8104                   bfd_boolean ok_tprel, is_local;
8105                   long toc_ref_index = 0;
8106                   int expecting_tls_get_addr = 0;
8107                   bfd_boolean ret = FALSE;
8108
8109                   r_symndx = ELF64_R_SYM (rel->r_info);
8110                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8111                                   r_symndx, ibfd))
8112                     {
8113                     err_free_rel:
8114                       if (elf_section_data (sec)->relocs != relstart)
8115                         free (relstart);
8116                       if (toc_ref != NULL)
8117                         free (toc_ref);
8118                       if (locsyms != NULL
8119                           && (elf_symtab_hdr (ibfd).contents
8120                               != (unsigned char *) locsyms))
8121                         free (locsyms);
8122                       return ret;
8123                     }
8124
8125                   if (h != NULL)
8126                     {
8127                       if (h->root.type == bfd_link_hash_defined
8128                           || h->root.type == bfd_link_hash_defweak)
8129                         value = h->root.u.def.value;
8130                       else if (h->root.type == bfd_link_hash_undefweak)
8131                         value = 0;
8132                       else
8133                         {
8134                           found_tls_get_addr_arg = 0;
8135                           continue;
8136                         }
8137                     }
8138                   else
8139                     /* Symbols referenced by TLS relocs must be of type
8140                        STT_TLS.  So no need for .opd local sym adjust.  */
8141                     value = sym->st_value;
8142
8143                   ok_tprel = FALSE;
8144                   is_local = FALSE;
8145                   if (h == NULL
8146                       || !h->def_dynamic)
8147                     {
8148                       is_local = TRUE;
8149                       if (h != NULL
8150                           && h->root.type == bfd_link_hash_undefweak)
8151                         ok_tprel = TRUE;
8152                       else
8153                         {
8154                           value += sym_sec->output_offset;
8155                           value += sym_sec->output_section->vma;
8156                           value -= htab->elf.tls_sec->vma;
8157                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8158                                       < (bfd_vma) 1 << 32);
8159                         }
8160                     }
8161
8162                   r_type = ELF64_R_TYPE (rel->r_info);
8163                   /* If this section has old-style __tls_get_addr calls
8164                      without marker relocs, then check that each
8165                      __tls_get_addr call reloc is preceded by a reloc
8166                      that conceivably belongs to the __tls_get_addr arg
8167                      setup insn.  If we don't find matching arg setup
8168                      relocs, don't do any tls optimization.  */
8169                   if (pass == 0
8170                       && sec->has_tls_get_addr_call
8171                       && h != NULL
8172                       && (h == &htab->tls_get_addr->elf
8173                           || h == &htab->tls_get_addr_fd->elf)
8174                       && !found_tls_get_addr_arg
8175                       && is_branch_reloc (r_type))
8176                     {
8177                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8178                                                 "TLS optimization disabled\n"),
8179                                               ibfd, sec, rel->r_offset);
8180                       ret = TRUE;
8181                       goto err_free_rel;
8182                     }
8183
8184                   found_tls_get_addr_arg = 0;
8185                   switch (r_type)
8186                     {
8187                     case R_PPC64_GOT_TLSLD16:
8188                     case R_PPC64_GOT_TLSLD16_LO:
8189                       expecting_tls_get_addr = 1;
8190                       found_tls_get_addr_arg = 1;
8191                       /* Fall thru */
8192
8193                     case R_PPC64_GOT_TLSLD16_HI:
8194                     case R_PPC64_GOT_TLSLD16_HA:
8195                       /* These relocs should never be against a symbol
8196                          defined in a shared lib.  Leave them alone if
8197                          that turns out to be the case.  */
8198                       if (!is_local)
8199                         continue;
8200
8201                       /* LD -> LE */
8202                       tls_set = 0;
8203                       tls_clear = TLS_LD;
8204                       tls_type = TLS_TLS | TLS_LD;
8205                       break;
8206
8207                     case R_PPC64_GOT_TLSGD16:
8208                     case R_PPC64_GOT_TLSGD16_LO:
8209                       expecting_tls_get_addr = 1;
8210                       found_tls_get_addr_arg = 1;
8211                       /* Fall thru */
8212
8213                     case R_PPC64_GOT_TLSGD16_HI:
8214                     case R_PPC64_GOT_TLSGD16_HA:
8215                       if (ok_tprel)
8216                         /* GD -> LE */
8217                         tls_set = 0;
8218                       else
8219                         /* GD -> IE */
8220                         tls_set = TLS_TLS | TLS_TPRELGD;
8221                       tls_clear = TLS_GD;
8222                       tls_type = TLS_TLS | TLS_GD;
8223                       break;
8224
8225                     case R_PPC64_GOT_TPREL16_DS:
8226                     case R_PPC64_GOT_TPREL16_LO_DS:
8227                     case R_PPC64_GOT_TPREL16_HI:
8228                     case R_PPC64_GOT_TPREL16_HA:
8229                       if (ok_tprel)
8230                         {
8231                           /* IE -> LE */
8232                           tls_set = 0;
8233                           tls_clear = TLS_TPREL;
8234                           tls_type = TLS_TLS | TLS_TPREL;
8235                           break;
8236                         }
8237                       continue;
8238
8239                     case R_PPC64_TLSGD:
8240                     case R_PPC64_TLSLD:
8241                       found_tls_get_addr_arg = 1;
8242                       /* Fall thru */
8243
8244                     case R_PPC64_TLS:
8245                     case R_PPC64_TOC16:
8246                     case R_PPC64_TOC16_LO:
8247                       if (sym_sec == NULL || sym_sec != toc)
8248                         continue;
8249
8250                       /* Mark this toc entry as referenced by a TLS
8251                          code sequence.  We can do that now in the
8252                          case of R_PPC64_TLS, and after checking for
8253                          tls_get_addr for the TOC16 relocs.  */
8254                       if (toc_ref == NULL)
8255                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8256                       if (toc_ref == NULL)
8257                         goto err_free_rel;
8258
8259                       if (h != NULL)
8260                         value = h->root.u.def.value;
8261                       else
8262                         value = sym->st_value;
8263                       value += rel->r_addend;
8264                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8265                       toc_ref_index = (value + toc->output_offset) / 8;
8266                       if (r_type == R_PPC64_TLS
8267                           || r_type == R_PPC64_TLSGD
8268                           || r_type == R_PPC64_TLSLD)
8269                         {
8270                           toc_ref[toc_ref_index] = 1;
8271                           continue;
8272                         }
8273
8274                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8275                         continue;
8276
8277                       tls_set = 0;
8278                       tls_clear = 0;
8279                       expecting_tls_get_addr = 2;
8280                       break;
8281
8282                     case R_PPC64_TPREL64:
8283                       if (pass == 0
8284                           || sec != toc
8285                           || toc_ref == NULL
8286                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8287                         continue;
8288                       if (ok_tprel)
8289                         {
8290                           /* IE -> LE */
8291                           tls_set = TLS_EXPLICIT;
8292                           tls_clear = TLS_TPREL;
8293                           break;
8294                         }
8295                       continue;
8296
8297                     case R_PPC64_DTPMOD64:
8298                       if (pass == 0
8299                           || sec != toc
8300                           || toc_ref == NULL
8301                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8302                         continue;
8303                       if (rel + 1 < relend
8304                           && (rel[1].r_info
8305                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8306                           && rel[1].r_offset == rel->r_offset + 8)
8307                         {
8308                           if (ok_tprel)
8309                             /* GD -> LE */
8310                             tls_set = TLS_EXPLICIT | TLS_GD;
8311                           else
8312                             /* GD -> IE */
8313                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8314                           tls_clear = TLS_GD;
8315                         }
8316                       else
8317                         {
8318                           if (!is_local)
8319                             continue;
8320
8321                           /* LD -> LE */
8322                           tls_set = TLS_EXPLICIT;
8323                           tls_clear = TLS_LD;
8324                         }
8325                       break;
8326
8327                     default:
8328                       continue;
8329                     }
8330
8331                   if (pass == 0)
8332                     {
8333                       if (!expecting_tls_get_addr
8334                           || !sec->has_tls_get_addr_call)
8335                         continue;
8336
8337                       if (rel + 1 < relend
8338                           && branch_reloc_hash_match (ibfd, rel + 1,
8339                                                       htab->tls_get_addr,
8340                                                       htab->tls_get_addr_fd))
8341                         {
8342                           if (expecting_tls_get_addr == 2)
8343                             {
8344                               /* Check for toc tls entries.  */
8345                               unsigned char *toc_tls;
8346                               int retval;
8347
8348                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8349                                                      &locsyms,
8350                                                      rel, ibfd);
8351                               if (retval == 0)
8352                                 goto err_free_rel;
8353                               if (toc_tls != NULL)
8354                                 {
8355                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8356                                     found_tls_get_addr_arg = 1;
8357                                   if (retval > 1)
8358                                     toc_ref[toc_ref_index] = 1;
8359                                 }
8360                             }
8361                           continue;
8362                         }
8363
8364                       if (expecting_tls_get_addr != 1)
8365                         continue;
8366
8367                       /* Uh oh, we didn't find the expected call.  We
8368                          could just mark this symbol to exclude it
8369                          from tls optimization but it's safer to skip
8370                          the entire optimization.  */
8371                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8372                                                 "TLS optimization disabled\n"),
8373                                               ibfd, sec, rel->r_offset);
8374                       ret = TRUE;
8375                       goto err_free_rel;
8376                     }
8377
8378                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8379                     {
8380                       struct plt_entry *ent;
8381                       for (ent = htab->tls_get_addr->elf.plt.plist;
8382                            ent != NULL;
8383                            ent = ent->next)
8384                         if (ent->addend == 0)
8385                           {
8386                             if (ent->plt.refcount > 0)
8387                               {
8388                                 ent->plt.refcount -= 1;
8389                                 expecting_tls_get_addr = 0;
8390                               }
8391                             break;
8392                           }
8393                     }
8394
8395                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8396                     {
8397                       struct plt_entry *ent;
8398                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8399                            ent != NULL;
8400                            ent = ent->next)
8401                         if (ent->addend == 0)
8402                           {
8403                             if (ent->plt.refcount > 0)
8404                               ent->plt.refcount -= 1;
8405                             break;
8406                           }
8407                     }
8408
8409                   if (tls_clear == 0)
8410                     continue;
8411
8412                   if ((tls_set & TLS_EXPLICIT) == 0)
8413                     {
8414                       struct got_entry *ent;
8415
8416                       /* Adjust got entry for this reloc.  */
8417                       if (h != NULL)
8418                         ent = h->got.glist;
8419                       else
8420                         ent = elf_local_got_ents (ibfd)[r_symndx];
8421
8422                       for (; ent != NULL; ent = ent->next)
8423                         if (ent->addend == rel->r_addend
8424                             && ent->owner == ibfd
8425                             && ent->tls_type == tls_type)
8426                           break;
8427                       if (ent == NULL)
8428                         abort ();
8429
8430                       if (tls_set == 0)
8431                         {
8432                           /* We managed to get rid of a got entry.  */
8433                           if (ent->got.refcount > 0)
8434                             ent->got.refcount -= 1;
8435                         }
8436                     }
8437                   else
8438                     {
8439                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8440                          we'll lose one or two dyn relocs.  */
8441                       if (!dec_dynrel_count (rel->r_info, sec, info,
8442                                              NULL, h, sym))
8443                         return FALSE;
8444
8445                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8446                         {
8447                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8448                                                  NULL, h, sym))
8449                             return FALSE;
8450                         }
8451                     }
8452
8453                   *tls_mask |= tls_set;
8454                   *tls_mask &= ~tls_clear;
8455                 }
8456
8457               if (elf_section_data (sec)->relocs != relstart)
8458                 free (relstart);
8459             }
8460
8461         if (locsyms != NULL
8462             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8463           {
8464             if (!info->keep_memory)
8465               free (locsyms);
8466             else
8467               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8468           }
8469       }
8470
8471   if (toc_ref != NULL)
8472     free (toc_ref);
8473   return TRUE;
8474 }
8475
8476 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8477    the values of any global symbols in a toc section that has been
8478    edited.  Globals in toc sections should be a rarity, so this function
8479    sets a flag if any are found in toc sections other than the one just
8480    edited, so that futher hash table traversals can be avoided.  */
8481
8482 struct adjust_toc_info
8483 {
8484   asection *toc;
8485   unsigned long *skip;
8486   bfd_boolean global_toc_syms;
8487 };
8488
8489 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8490
8491 static bfd_boolean
8492 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8493 {
8494   struct ppc_link_hash_entry *eh;
8495   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8496   unsigned long i;
8497
8498   if (h->root.type != bfd_link_hash_defined
8499       && h->root.type != bfd_link_hash_defweak)
8500     return TRUE;
8501
8502   eh = (struct ppc_link_hash_entry *) h;
8503   if (eh->adjust_done)
8504     return TRUE;
8505
8506   if (eh->elf.root.u.def.section == toc_inf->toc)
8507     {
8508       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8509         i = toc_inf->toc->rawsize >> 3;
8510       else
8511         i = eh->elf.root.u.def.value >> 3;
8512
8513       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8514         {
8515           (*_bfd_error_handler)
8516             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8517           do
8518             ++i;
8519           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8520           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8521         }
8522
8523       eh->elf.root.u.def.value -= toc_inf->skip[i];
8524       eh->adjust_done = 1;
8525     }
8526   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8527     toc_inf->global_toc_syms = TRUE;
8528
8529   return TRUE;
8530 }
8531
8532 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8533
8534 static bfd_boolean
8535 ok_lo_toc_insn (unsigned int insn)
8536 {
8537   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8538           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8539           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8540           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8541           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8542           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8543           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8544           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8545           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8546           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8547           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8548           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8549           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8550           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8551           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8552               && (insn & 3) != 1)
8553           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8554               && ((insn & 3) == 0 || (insn & 3) == 3))
8555           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8556 }
8557
8558 /* Examine all relocs referencing .toc sections in order to remove
8559    unused .toc entries.  */
8560
8561 bfd_boolean
8562 ppc64_elf_edit_toc (struct bfd_link_info *info)
8563 {
8564   bfd *ibfd;
8565   struct adjust_toc_info toc_inf;
8566   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8567
8568   htab->do_toc_opt = 1;
8569   toc_inf.global_toc_syms = TRUE;
8570   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8571     {
8572       asection *toc, *sec;
8573       Elf_Internal_Shdr *symtab_hdr;
8574       Elf_Internal_Sym *local_syms;
8575       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8576       unsigned long *skip, *drop;
8577       unsigned char *used;
8578       unsigned char *keep, last, some_unused;
8579
8580       if (!is_ppc64_elf (ibfd))
8581         continue;
8582
8583       toc = bfd_get_section_by_name (ibfd, ".toc");
8584       if (toc == NULL
8585           || toc->size == 0
8586           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8587           || discarded_section (toc))
8588         continue;
8589
8590       toc_relocs = NULL;
8591       local_syms = NULL;
8592       symtab_hdr = &elf_symtab_hdr (ibfd);
8593
8594       /* Look at sections dropped from the final link.  */
8595       skip = NULL;
8596       relstart = NULL;
8597       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8598         {
8599           if (sec->reloc_count == 0
8600               || !discarded_section (sec)
8601               || get_opd_info (sec)
8602               || (sec->flags & SEC_ALLOC) == 0
8603               || (sec->flags & SEC_DEBUGGING) != 0)
8604             continue;
8605
8606           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8607           if (relstart == NULL)
8608             goto error_ret;
8609
8610           /* Run through the relocs to see which toc entries might be
8611              unused.  */
8612           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8613             {
8614               enum elf_ppc64_reloc_type r_type;
8615               unsigned long r_symndx;
8616               asection *sym_sec;
8617               struct elf_link_hash_entry *h;
8618               Elf_Internal_Sym *sym;
8619               bfd_vma val;
8620
8621               r_type = ELF64_R_TYPE (rel->r_info);
8622               switch (r_type)
8623                 {
8624                 default:
8625                   continue;
8626
8627                 case R_PPC64_TOC16:
8628                 case R_PPC64_TOC16_LO:
8629                 case R_PPC64_TOC16_HI:
8630                 case R_PPC64_TOC16_HA:
8631                 case R_PPC64_TOC16_DS:
8632                 case R_PPC64_TOC16_LO_DS:
8633                   break;
8634                 }
8635
8636               r_symndx = ELF64_R_SYM (rel->r_info);
8637               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8638                               r_symndx, ibfd))
8639                 goto error_ret;
8640
8641               if (sym_sec != toc)
8642                 continue;
8643
8644               if (h != NULL)
8645                 val = h->root.u.def.value;
8646               else
8647                 val = sym->st_value;
8648               val += rel->r_addend;
8649
8650               if (val >= toc->size)
8651                 continue;
8652
8653               /* Anything in the toc ought to be aligned to 8 bytes.
8654                  If not, don't mark as unused.  */
8655               if (val & 7)
8656                 continue;
8657
8658               if (skip == NULL)
8659                 {
8660                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8661                   if (skip == NULL)
8662                     goto error_ret;
8663                 }
8664
8665               skip[val >> 3] = ref_from_discarded;
8666             }
8667
8668           if (elf_section_data (sec)->relocs != relstart)
8669             free (relstart);
8670         }
8671
8672       /* For largetoc loads of address constants, we can convert
8673          .  addis rx,2,addr@got@ha
8674          .  ld ry,addr@got@l(rx)
8675          to
8676          .  addis rx,2,addr@toc@ha
8677          .  addi ry,rx,addr@toc@l
8678          when addr is within 2G of the toc pointer.  This then means
8679          that the word storing "addr" in the toc is no longer needed.  */
8680
8681       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8682           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8683           && toc->reloc_count != 0)
8684         {
8685           /* Read toc relocs.  */
8686           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8687                                                   info->keep_memory);
8688           if (toc_relocs == NULL)
8689             goto error_ret;
8690
8691           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8692             {
8693               enum elf_ppc64_reloc_type r_type;
8694               unsigned long r_symndx;
8695               asection *sym_sec;
8696               struct elf_link_hash_entry *h;
8697               Elf_Internal_Sym *sym;
8698               bfd_vma val, addr;
8699
8700               r_type = ELF64_R_TYPE (rel->r_info);
8701               if (r_type != R_PPC64_ADDR64)
8702                 continue;
8703
8704               r_symndx = ELF64_R_SYM (rel->r_info);
8705               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8706                               r_symndx, ibfd))
8707                 goto error_ret;
8708
8709               if (sym_sec == NULL
8710                   || discarded_section (sym_sec))
8711                 continue;
8712
8713               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8714                 continue;
8715
8716               if (h != NULL)
8717                 {
8718                   if (h->type == STT_GNU_IFUNC)
8719                     continue;
8720                   val = h->root.u.def.value;
8721                 }
8722               else
8723                 {
8724                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8725                     continue;
8726                   val = sym->st_value;
8727                 }
8728               val += rel->r_addend;
8729               val += sym_sec->output_section->vma + sym_sec->output_offset;
8730
8731               /* We don't yet know the exact toc pointer value, but we
8732                  know it will be somewhere in the toc section.  Don't
8733                  optimize if the difference from any possible toc
8734                  pointer is outside [ff..f80008000, 7fff7fff].  */
8735               addr = toc->output_section->vma + TOC_BASE_OFF;
8736               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8737                 continue;
8738
8739               addr = toc->output_section->vma + toc->output_section->rawsize;
8740               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8741                 continue;
8742
8743               if (skip == NULL)
8744                 {
8745                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8746                   if (skip == NULL)
8747                     goto error_ret;
8748                 }
8749
8750               skip[rel->r_offset >> 3]
8751                 |= can_optimize | ((rel - toc_relocs) << 2);
8752             }
8753         }
8754
8755       if (skip == NULL)
8756         continue;
8757
8758       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8759       if (used == NULL)
8760         {
8761         error_ret:
8762           if (local_syms != NULL
8763               && symtab_hdr->contents != (unsigned char *) local_syms)
8764             free (local_syms);
8765           if (sec != NULL
8766               && relstart != NULL
8767               && elf_section_data (sec)->relocs != relstart)
8768             free (relstart);
8769           if (toc_relocs != NULL
8770               && elf_section_data (toc)->relocs != toc_relocs)
8771             free (toc_relocs);
8772           if (skip != NULL)
8773             free (skip);
8774           return FALSE;
8775         }
8776
8777       /* Now check all kept sections that might reference the toc.
8778          Check the toc itself last.  */
8779       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8780                   : ibfd->sections);
8781            sec != NULL;
8782            sec = (sec == toc ? NULL
8783                   : sec->next == NULL ? toc
8784                   : sec->next == toc && toc->next ? toc->next
8785                   : sec->next))
8786         {
8787           int repeat;
8788
8789           if (sec->reloc_count == 0
8790               || discarded_section (sec)
8791               || get_opd_info (sec)
8792               || (sec->flags & SEC_ALLOC) == 0
8793               || (sec->flags & SEC_DEBUGGING) != 0)
8794             continue;
8795
8796           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8797                                                 info->keep_memory);
8798           if (relstart == NULL)
8799             {
8800               free (used);
8801               goto error_ret;
8802             }
8803
8804           /* Mark toc entries referenced as used.  */
8805           do
8806             {
8807               repeat = 0;
8808               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8809                 {
8810                   enum elf_ppc64_reloc_type r_type;
8811                   unsigned long r_symndx;
8812                   asection *sym_sec;
8813                   struct elf_link_hash_entry *h;
8814                   Elf_Internal_Sym *sym;
8815                   bfd_vma val;
8816                   enum {no_check, check_lo, check_ha} insn_check;
8817
8818                   r_type = ELF64_R_TYPE (rel->r_info);
8819                   switch (r_type)
8820                     {
8821                     default:
8822                       insn_check = no_check;
8823                       break;
8824
8825                     case R_PPC64_GOT_TLSLD16_HA:
8826                     case R_PPC64_GOT_TLSGD16_HA:
8827                     case R_PPC64_GOT_TPREL16_HA:
8828                     case R_PPC64_GOT_DTPREL16_HA:
8829                     case R_PPC64_GOT16_HA:
8830                     case R_PPC64_TOC16_HA:
8831                       insn_check = check_ha;
8832                       break;
8833
8834                     case R_PPC64_GOT_TLSLD16_LO:
8835                     case R_PPC64_GOT_TLSGD16_LO:
8836                     case R_PPC64_GOT_TPREL16_LO_DS:
8837                     case R_PPC64_GOT_DTPREL16_LO_DS:
8838                     case R_PPC64_GOT16_LO:
8839                     case R_PPC64_GOT16_LO_DS:
8840                     case R_PPC64_TOC16_LO:
8841                     case R_PPC64_TOC16_LO_DS:
8842                       insn_check = check_lo;
8843                       break;
8844                     }
8845
8846                   if (insn_check != no_check)
8847                     {
8848                       bfd_vma off = rel->r_offset & ~3;
8849                       unsigned char buf[4];
8850                       unsigned int insn;
8851
8852                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8853                         {
8854                           free (used);
8855                           goto error_ret;
8856                         }
8857                       insn = bfd_get_32 (ibfd, buf);
8858                       if (insn_check == check_lo
8859                           ? !ok_lo_toc_insn (insn)
8860                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8861                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8862                         {
8863                           char str[12];
8864
8865                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8866                           sprintf (str, "%#08x", insn);
8867                           info->callbacks->einfo
8868                             (_("%P: %H: toc optimization is not supported for"
8869                                " %s instruction.\n"),
8870                              ibfd, sec, rel->r_offset & ~3, str);
8871                         }
8872                     }
8873
8874                   switch (r_type)
8875                     {
8876                     case R_PPC64_TOC16:
8877                     case R_PPC64_TOC16_LO:
8878                     case R_PPC64_TOC16_HI:
8879                     case R_PPC64_TOC16_HA:
8880                     case R_PPC64_TOC16_DS:
8881                     case R_PPC64_TOC16_LO_DS:
8882                       /* In case we're taking addresses of toc entries.  */
8883                     case R_PPC64_ADDR64:
8884                       break;
8885
8886                     default:
8887                       continue;
8888                     }
8889
8890                   r_symndx = ELF64_R_SYM (rel->r_info);
8891                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8892                                   r_symndx, ibfd))
8893                     {
8894                       free (used);
8895                       goto error_ret;
8896                     }
8897
8898                   if (sym_sec != toc)
8899                     continue;
8900
8901                   if (h != NULL)
8902                     val = h->root.u.def.value;
8903                   else
8904                     val = sym->st_value;
8905                   val += rel->r_addend;
8906
8907                   if (val >= toc->size)
8908                     continue;
8909
8910                   if ((skip[val >> 3] & can_optimize) != 0)
8911                     {
8912                       bfd_vma off;
8913                       unsigned char opc;
8914
8915                       switch (r_type)
8916                         {
8917                         case R_PPC64_TOC16_HA:
8918                           break;
8919
8920                         case R_PPC64_TOC16_LO_DS:
8921                           off = rel->r_offset;
8922                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8923                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8924                                                          off, 1))
8925                             {
8926                               free (used);
8927                               goto error_ret;
8928                             }
8929                           if ((opc & (0x3f << 2)) == (58u << 2))
8930                             break;
8931                           /* Fall thru */
8932
8933                         default:
8934                           /* Wrong sort of reloc, or not a ld.  We may
8935                              as well clear ref_from_discarded too.  */
8936                           skip[val >> 3] = 0;
8937                         }
8938                     }
8939
8940                   if (sec != toc)
8941                     used[val >> 3] = 1;
8942                   /* For the toc section, we only mark as used if this
8943                      entry itself isn't unused.  */
8944                   else if ((used[rel->r_offset >> 3]
8945                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8946                            && !used[val >> 3])
8947                     {
8948                       /* Do all the relocs again, to catch reference
8949                          chains.  */
8950                       repeat = 1;
8951                       used[val >> 3] = 1;
8952                     }
8953                 }
8954             }
8955           while (repeat);
8956
8957           if (elf_section_data (sec)->relocs != relstart)
8958             free (relstart);
8959         }
8960
8961       /* Merge the used and skip arrays.  Assume that TOC
8962          doublewords not appearing as either used or unused belong
8963          to to an entry more than one doubleword in size.  */
8964       for (drop = skip, keep = used, last = 0, some_unused = 0;
8965            drop < skip + (toc->size + 7) / 8;
8966            ++drop, ++keep)
8967         {
8968           if (*keep)
8969             {
8970               *drop &= ~ref_from_discarded;
8971               if ((*drop & can_optimize) != 0)
8972                 some_unused = 1;
8973               last = 0;
8974             }
8975           else if ((*drop & ref_from_discarded) != 0)
8976             {
8977               some_unused = 1;
8978               last = ref_from_discarded;
8979             }
8980           else
8981             *drop = last;
8982         }
8983
8984       free (used);
8985
8986       if (some_unused)
8987         {
8988           bfd_byte *contents, *src;
8989           unsigned long off;
8990           Elf_Internal_Sym *sym;
8991           bfd_boolean local_toc_syms = FALSE;
8992
8993           /* Shuffle the toc contents, and at the same time convert the
8994              skip array from booleans into offsets.  */
8995           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8996             goto error_ret;
8997
8998           elf_section_data (toc)->this_hdr.contents = contents;
8999
9000           for (src = contents, off = 0, drop = skip;
9001                src < contents + toc->size;
9002                src += 8, ++drop)
9003             {
9004               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9005                 off += 8;
9006               else if (off != 0)
9007                 {
9008                   *drop = off;
9009                   memcpy (src - off, src, 8);
9010                 }
9011             }
9012           *drop = off;
9013           toc->rawsize = toc->size;
9014           toc->size = src - contents - off;
9015
9016           /* Adjust addends for relocs against the toc section sym,
9017              and optimize any accesses we can.  */
9018           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9019             {
9020               if (sec->reloc_count == 0
9021                   || discarded_section (sec))
9022                 continue;
9023
9024               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9025                                                     info->keep_memory);
9026               if (relstart == NULL)
9027                 goto error_ret;
9028
9029               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9030                 {
9031                   enum elf_ppc64_reloc_type r_type;
9032                   unsigned long r_symndx;
9033                   asection *sym_sec;
9034                   struct elf_link_hash_entry *h;
9035                   bfd_vma val;
9036
9037                   r_type = ELF64_R_TYPE (rel->r_info);
9038                   switch (r_type)
9039                     {
9040                     default:
9041                       continue;
9042
9043                     case R_PPC64_TOC16:
9044                     case R_PPC64_TOC16_LO:
9045                     case R_PPC64_TOC16_HI:
9046                     case R_PPC64_TOC16_HA:
9047                     case R_PPC64_TOC16_DS:
9048                     case R_PPC64_TOC16_LO_DS:
9049                     case R_PPC64_ADDR64:
9050                       break;
9051                     }
9052
9053                   r_symndx = ELF64_R_SYM (rel->r_info);
9054                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9055                                   r_symndx, ibfd))
9056                     goto error_ret;
9057
9058                   if (sym_sec != toc)
9059                     continue;
9060
9061                   if (h != NULL)
9062                     val = h->root.u.def.value;
9063                   else
9064                     {
9065                       val = sym->st_value;
9066                       if (val != 0)
9067                         local_toc_syms = TRUE;
9068                     }
9069
9070                   val += rel->r_addend;
9071
9072                   if (val > toc->rawsize)
9073                     val = toc->rawsize;
9074                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9075                     continue;
9076                   else if ((skip[val >> 3] & can_optimize) != 0)
9077                     {
9078                       Elf_Internal_Rela *tocrel
9079                         = toc_relocs + (skip[val >> 3] >> 2);
9080                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9081
9082                       switch (r_type)
9083                         {
9084                         case R_PPC64_TOC16_HA:
9085                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9086                           break;
9087
9088                         case R_PPC64_TOC16_LO_DS:
9089                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9090                           break;
9091
9092                         default:
9093                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9094                             ppc_howto_init ();
9095                           info->callbacks->einfo
9096                             (_("%P: %H: %s references "
9097                                "optimized away TOC entry\n"),
9098                              ibfd, sec, rel->r_offset,
9099                              ppc64_elf_howto_table[r_type]->name);
9100                           bfd_set_error (bfd_error_bad_value);
9101                           goto error_ret;
9102                         }
9103                       rel->r_addend = tocrel->r_addend;
9104                       elf_section_data (sec)->relocs = relstart;
9105                       continue;
9106                     }
9107
9108                   if (h != NULL || sym->st_value != 0)
9109                     continue;
9110
9111                   rel->r_addend -= skip[val >> 3];
9112                   elf_section_data (sec)->relocs = relstart;
9113                 }
9114
9115               if (elf_section_data (sec)->relocs != relstart)
9116                 free (relstart);
9117             }
9118
9119           /* We shouldn't have local or global symbols defined in the TOC,
9120              but handle them anyway.  */
9121           if (local_syms != NULL)
9122             for (sym = local_syms;
9123                  sym < local_syms + symtab_hdr->sh_info;
9124                  ++sym)
9125               if (sym->st_value != 0
9126                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9127                 {
9128                   unsigned long i;
9129
9130                   if (sym->st_value > toc->rawsize)
9131                     i = toc->rawsize >> 3;
9132                   else
9133                     i = sym->st_value >> 3;
9134
9135                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9136                     {
9137                       if (local_toc_syms)
9138                         (*_bfd_error_handler)
9139                           (_("%s defined on removed toc entry"),
9140                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9141                       do
9142                         ++i;
9143                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9144                       sym->st_value = (bfd_vma) i << 3;
9145                     }
9146
9147                   sym->st_value -= skip[i];
9148                   symtab_hdr->contents = (unsigned char *) local_syms;
9149                 }
9150
9151           /* Adjust any global syms defined in this toc input section.  */
9152           if (toc_inf.global_toc_syms)
9153             {
9154               toc_inf.toc = toc;
9155               toc_inf.skip = skip;
9156               toc_inf.global_toc_syms = FALSE;
9157               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9158                                       &toc_inf);
9159             }
9160
9161           if (toc->reloc_count != 0)
9162             {
9163               Elf_Internal_Shdr *rel_hdr;
9164               Elf_Internal_Rela *wrel;
9165               bfd_size_type sz;
9166
9167               /* Remove unused toc relocs, and adjust those we keep.  */
9168               if (toc_relocs == NULL)
9169                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9170                                                         info->keep_memory);
9171               if (toc_relocs == NULL)
9172                 goto error_ret;
9173
9174               wrel = toc_relocs;
9175               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9176                 if ((skip[rel->r_offset >> 3]
9177                      & (ref_from_discarded | can_optimize)) == 0)
9178                   {
9179                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9180                     wrel->r_info = rel->r_info;
9181                     wrel->r_addend = rel->r_addend;
9182                     ++wrel;
9183                   }
9184                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9185                                             &local_syms, NULL, NULL))
9186                   goto error_ret;
9187
9188               elf_section_data (toc)->relocs = toc_relocs;
9189               toc->reloc_count = wrel - toc_relocs;
9190               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9191               sz = rel_hdr->sh_entsize;
9192               rel_hdr->sh_size = toc->reloc_count * sz;
9193             }
9194         }
9195       else if (toc_relocs != NULL
9196                && elf_section_data (toc)->relocs != toc_relocs)
9197         free (toc_relocs);
9198
9199       if (local_syms != NULL
9200           && symtab_hdr->contents != (unsigned char *) local_syms)
9201         {
9202           if (!info->keep_memory)
9203             free (local_syms);
9204           else
9205             symtab_hdr->contents = (unsigned char *) local_syms;
9206         }
9207       free (skip);
9208     }
9209
9210   return TRUE;
9211 }
9212
9213 /* Return true iff input section I references the TOC using
9214    instructions limited to +/-32k offsets.  */
9215
9216 bfd_boolean
9217 ppc64_elf_has_small_toc_reloc (asection *i)
9218 {
9219   return (is_ppc64_elf (i->owner)
9220           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9221 }
9222
9223 /* Allocate space for one GOT entry.  */
9224
9225 static void
9226 allocate_got (struct elf_link_hash_entry *h,
9227               struct bfd_link_info *info,
9228               struct got_entry *gent)
9229 {
9230   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9231   bfd_boolean dyn;
9232   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9233   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9234                  ? 16 : 8);
9235   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9236                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9237   asection *got = ppc64_elf_tdata (gent->owner)->got;
9238
9239   gent->got.offset = got->size;
9240   got->size += entsize;
9241
9242   dyn = htab->elf.dynamic_sections_created;
9243   if (h->type == STT_GNU_IFUNC)
9244     {
9245       htab->elf.irelplt->size += rentsize;
9246       htab->got_reli_size += rentsize;
9247     }
9248   else if ((info->shared
9249             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9250            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9251                || h->root.type != bfd_link_hash_undefweak))
9252     {
9253       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9254       relgot->size += rentsize;
9255     }
9256 }
9257
9258 /* This function merges got entries in the same toc group.  */
9259
9260 static void
9261 merge_got_entries (struct got_entry **pent)
9262 {
9263   struct got_entry *ent, *ent2;
9264
9265   for (ent = *pent; ent != NULL; ent = ent->next)
9266     if (!ent->is_indirect)
9267       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9268         if (!ent2->is_indirect
9269             && ent2->addend == ent->addend
9270             && ent2->tls_type == ent->tls_type
9271             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9272           {
9273             ent2->is_indirect = TRUE;
9274             ent2->got.ent = ent;
9275           }
9276 }
9277
9278 /* Allocate space in .plt, .got and associated reloc sections for
9279    dynamic relocs.  */
9280
9281 static bfd_boolean
9282 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9283 {
9284   struct bfd_link_info *info;
9285   struct ppc_link_hash_table *htab;
9286   asection *s;
9287   struct ppc_link_hash_entry *eh;
9288   struct elf_dyn_relocs *p;
9289   struct got_entry **pgent, *gent;
9290
9291   if (h->root.type == bfd_link_hash_indirect)
9292     return TRUE;
9293
9294   info = (struct bfd_link_info *) inf;
9295   htab = ppc_hash_table (info);
9296   if (htab == NULL)
9297     return FALSE;
9298
9299   if ((htab->elf.dynamic_sections_created
9300        && h->dynindx != -1
9301        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9302       || h->type == STT_GNU_IFUNC)
9303     {
9304       struct plt_entry *pent;
9305       bfd_boolean doneone = FALSE;
9306       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9307         if (pent->plt.refcount > 0)
9308           {
9309             if (!htab->elf.dynamic_sections_created
9310                 || h->dynindx == -1)
9311               {
9312                 s = htab->elf.iplt;
9313                 pent->plt.offset = s->size;
9314                 s->size += PLT_ENTRY_SIZE (htab);
9315                 s = htab->elf.irelplt;
9316               }
9317             else
9318               {
9319                 /* If this is the first .plt entry, make room for the special
9320                    first entry.  */
9321                 s = htab->elf.splt;
9322                 if (s->size == 0)
9323                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9324
9325                 pent->plt.offset = s->size;
9326
9327                 /* Make room for this entry.  */
9328                 s->size += PLT_ENTRY_SIZE (htab);
9329
9330                 /* Make room for the .glink code.  */
9331                 s = htab->glink;
9332                 if (s->size == 0)
9333                   s->size += GLINK_CALL_STUB_SIZE;
9334                 if (htab->opd_abi)
9335                   {
9336                     /* We need bigger stubs past index 32767.  */
9337                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9338                       s->size += 4;
9339                     s->size += 2*4;
9340                   }
9341                 else
9342                   s->size += 4;
9343
9344                 /* We also need to make an entry in the .rela.plt section.  */
9345                 s = htab->elf.srelplt;
9346               }
9347             s->size += sizeof (Elf64_External_Rela);
9348             doneone = TRUE;
9349           }
9350         else
9351           pent->plt.offset = (bfd_vma) -1;
9352       if (!doneone)
9353         {
9354           h->plt.plist = NULL;
9355           h->needs_plt = 0;
9356         }
9357     }
9358   else
9359     {
9360       h->plt.plist = NULL;
9361       h->needs_plt = 0;
9362     }
9363
9364   eh = (struct ppc_link_hash_entry *) h;
9365   /* Run through the TLS GD got entries first if we're changing them
9366      to TPREL.  */
9367   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9368     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9369       if (gent->got.refcount > 0
9370           && (gent->tls_type & TLS_GD) != 0)
9371         {
9372           /* This was a GD entry that has been converted to TPREL.  If
9373              there happens to be a TPREL entry we can use that one.  */
9374           struct got_entry *ent;
9375           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9376             if (ent->got.refcount > 0
9377                 && (ent->tls_type & TLS_TPREL) != 0
9378                 && ent->addend == gent->addend
9379                 && ent->owner == gent->owner)
9380               {
9381                 gent->got.refcount = 0;
9382                 break;
9383               }
9384
9385           /* If not, then we'll be using our own TPREL entry.  */
9386           if (gent->got.refcount != 0)
9387             gent->tls_type = TLS_TLS | TLS_TPREL;
9388         }
9389
9390   /* Remove any list entry that won't generate a word in the GOT before
9391      we call merge_got_entries.  Otherwise we risk merging to empty
9392      entries.  */
9393   pgent = &h->got.glist;
9394   while ((gent = *pgent) != NULL)
9395     if (gent->got.refcount > 0)
9396       {
9397         if ((gent->tls_type & TLS_LD) != 0
9398             && !h->def_dynamic)
9399           {
9400             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9401             *pgent = gent->next;
9402           }
9403         else
9404           pgent = &gent->next;
9405       }
9406     else
9407       *pgent = gent->next;
9408
9409   if (!htab->do_multi_toc)
9410     merge_got_entries (&h->got.glist);
9411
9412   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9413     if (!gent->is_indirect)
9414       {
9415         /* Make sure this symbol is output as a dynamic symbol.
9416            Undefined weak syms won't yet be marked as dynamic,
9417            nor will all TLS symbols.  */
9418         if (h->dynindx == -1
9419             && !h->forced_local
9420             && h->type != STT_GNU_IFUNC
9421             && htab->elf.dynamic_sections_created)
9422           {
9423             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9424               return FALSE;
9425           }
9426
9427         if (!is_ppc64_elf (gent->owner))
9428           abort ();
9429
9430         allocate_got (h, info, gent);
9431       }
9432
9433   if (eh->dyn_relocs == NULL
9434       || (!htab->elf.dynamic_sections_created
9435           && h->type != STT_GNU_IFUNC))
9436     return TRUE;
9437
9438   /* In the shared -Bsymbolic case, discard space allocated for
9439      dynamic pc-relative relocs against symbols which turn out to be
9440      defined in regular objects.  For the normal shared case, discard
9441      space for relocs that have become local due to symbol visibility
9442      changes.  */
9443
9444   if (info->shared)
9445     {
9446       /* Relocs that use pc_count are those that appear on a call insn,
9447          or certain REL relocs (see must_be_dyn_reloc) that can be
9448          generated via assembly.  We want calls to protected symbols to
9449          resolve directly to the function rather than going via the plt.
9450          If people want function pointer comparisons to work as expected
9451          then they should avoid writing weird assembly.  */
9452       if (SYMBOL_CALLS_LOCAL (info, h))
9453         {
9454           struct elf_dyn_relocs **pp;
9455
9456           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9457             {
9458               p->count -= p->pc_count;
9459               p->pc_count = 0;
9460               if (p->count == 0)
9461                 *pp = p->next;
9462               else
9463                 pp = &p->next;
9464             }
9465         }
9466
9467       /* Also discard relocs on undefined weak syms with non-default
9468          visibility.  */
9469       if (eh->dyn_relocs != NULL
9470           && h->root.type == bfd_link_hash_undefweak)
9471         {
9472           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9473             eh->dyn_relocs = NULL;
9474
9475           /* Make sure this symbol is output as a dynamic symbol.
9476              Undefined weak syms won't yet be marked as dynamic.  */
9477           else if (h->dynindx == -1
9478                    && !h->forced_local)
9479             {
9480               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9481                 return FALSE;
9482             }
9483         }
9484     }
9485   else if (h->type == STT_GNU_IFUNC)
9486     {
9487       if (!h->non_got_ref)
9488         eh->dyn_relocs = NULL;
9489     }
9490   else if (ELIMINATE_COPY_RELOCS)
9491     {
9492       /* For the non-shared case, discard space for relocs against
9493          symbols which turn out to need copy relocs or are not
9494          dynamic.  */
9495
9496       if (!h->non_got_ref
9497           && !h->def_regular)
9498         {
9499           /* Make sure this symbol is output as a dynamic symbol.
9500              Undefined weak syms won't yet be marked as dynamic.  */
9501           if (h->dynindx == -1
9502               && !h->forced_local)
9503             {
9504               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9505                 return FALSE;
9506             }
9507
9508           /* If that succeeded, we know we'll be keeping all the
9509              relocs.  */
9510           if (h->dynindx != -1)
9511             goto keep;
9512         }
9513
9514       eh->dyn_relocs = NULL;
9515
9516     keep: ;
9517     }
9518
9519   /* Finally, allocate space.  */
9520   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9521     {
9522       asection *sreloc = elf_section_data (p->sec)->sreloc;
9523       if (eh->elf.type == STT_GNU_IFUNC)
9524         sreloc = htab->elf.irelplt;
9525       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9526     }
9527
9528   return TRUE;
9529 }
9530
9531 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9532    to set up space for global entry stubs.  These are put in glink,
9533    after the branch table.  */
9534
9535 static bfd_boolean
9536 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9537 {
9538   struct bfd_link_info *info;
9539   struct ppc_link_hash_table *htab;
9540   struct plt_entry *pent;
9541   asection *s;
9542
9543   if (h->root.type == bfd_link_hash_indirect)
9544     return TRUE;
9545
9546   if (!h->pointer_equality_needed)
9547     return TRUE;
9548
9549   if (h->def_regular)
9550     return TRUE;
9551
9552   info = inf;
9553   htab = ppc_hash_table (info);
9554   if (htab == NULL)
9555     return FALSE;
9556
9557   s = htab->glink;
9558   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9559     if (pent->plt.offset != (bfd_vma) -1
9560         && pent->addend == 0)
9561       {
9562         /* For ELFv2, if this symbol is not defined in a regular file
9563            and we are not generating a shared library or pie, then we
9564            need to define the symbol in the executable on a call stub.
9565            This is to avoid text relocations.  */
9566         s->size = (s->size + 15) & -16;
9567         h->root.u.def.section = s;
9568         h->root.u.def.value = s->size;
9569         s->size += 16;
9570         break;
9571       }
9572   return TRUE;
9573 }
9574
9575 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9576    read-only sections.  */
9577
9578 static bfd_boolean
9579 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9580 {
9581   if (h->root.type == bfd_link_hash_indirect)
9582     return TRUE;
9583
9584   if (readonly_dynrelocs (h))
9585     {
9586       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9587
9588       /* Not an error, just cut short the traversal.  */
9589       return FALSE;
9590     }
9591   return TRUE;
9592 }
9593
9594 /* Set the sizes of the dynamic sections.  */
9595
9596 static bfd_boolean
9597 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9598                                  struct bfd_link_info *info)
9599 {
9600   struct ppc_link_hash_table *htab;
9601   bfd *dynobj;
9602   asection *s;
9603   bfd_boolean relocs;
9604   bfd *ibfd;
9605   struct got_entry *first_tlsld;
9606
9607   htab = ppc_hash_table (info);
9608   if (htab == NULL)
9609     return FALSE;
9610
9611   dynobj = htab->elf.dynobj;
9612   if (dynobj == NULL)
9613     abort ();
9614
9615   if (htab->elf.dynamic_sections_created)
9616     {
9617       /* Set the contents of the .interp section to the interpreter.  */
9618       if (info->executable)
9619         {
9620           s = bfd_get_linker_section (dynobj, ".interp");
9621           if (s == NULL)
9622             abort ();
9623           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9624           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9625         }
9626     }
9627
9628   /* Set up .got offsets for local syms, and space for local dynamic
9629      relocs.  */
9630   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9631     {
9632       struct got_entry **lgot_ents;
9633       struct got_entry **end_lgot_ents;
9634       struct plt_entry **local_plt;
9635       struct plt_entry **end_local_plt;
9636       unsigned char *lgot_masks;
9637       bfd_size_type locsymcount;
9638       Elf_Internal_Shdr *symtab_hdr;
9639
9640       if (!is_ppc64_elf (ibfd))
9641         continue;
9642
9643       for (s = ibfd->sections; s != NULL; s = s->next)
9644         {
9645           struct ppc_dyn_relocs *p;
9646
9647           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9648             {
9649               if (!bfd_is_abs_section (p->sec)
9650                   && bfd_is_abs_section (p->sec->output_section))
9651                 {
9652                   /* Input section has been discarded, either because
9653                      it is a copy of a linkonce section or due to
9654                      linker script /DISCARD/, so we'll be discarding
9655                      the relocs too.  */
9656                 }
9657               else if (p->count != 0)
9658                 {
9659                   asection *srel = elf_section_data (p->sec)->sreloc;
9660                   if (p->ifunc)
9661                     srel = htab->elf.irelplt;
9662                   srel->size += p->count * sizeof (Elf64_External_Rela);
9663                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9664                     info->flags |= DF_TEXTREL;
9665                 }
9666             }
9667         }
9668
9669       lgot_ents = elf_local_got_ents (ibfd);
9670       if (!lgot_ents)
9671         continue;
9672
9673       symtab_hdr = &elf_symtab_hdr (ibfd);
9674       locsymcount = symtab_hdr->sh_info;
9675       end_lgot_ents = lgot_ents + locsymcount;
9676       local_plt = (struct plt_entry **) end_lgot_ents;
9677       end_local_plt = local_plt + locsymcount;
9678       lgot_masks = (unsigned char *) end_local_plt;
9679       s = ppc64_elf_tdata (ibfd)->got;
9680       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9681         {
9682           struct got_entry **pent, *ent;
9683
9684           pent = lgot_ents;
9685           while ((ent = *pent) != NULL)
9686             if (ent->got.refcount > 0)
9687               {
9688                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9689                   {
9690                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9691                     *pent = ent->next;
9692                   }
9693                 else
9694                   {
9695                     unsigned int ent_size = 8;
9696                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9697
9698                     ent->got.offset = s->size;
9699                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9700                       {
9701                         ent_size *= 2;
9702                         rel_size *= 2;
9703                       }
9704                     s->size += ent_size;
9705                     if ((*lgot_masks & PLT_IFUNC) != 0)
9706                       {
9707                         htab->elf.irelplt->size += rel_size;
9708                         htab->got_reli_size += rel_size;
9709                       }
9710                     else if (info->shared)
9711                       {
9712                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9713                         srel->size += rel_size;
9714                       }
9715                     pent = &ent->next;
9716                   }
9717               }
9718             else
9719               *pent = ent->next;
9720         }
9721
9722       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9723       for (; local_plt < end_local_plt; ++local_plt)
9724         {
9725           struct plt_entry *ent;
9726
9727           for (ent = *local_plt; ent != NULL; ent = ent->next)
9728             if (ent->plt.refcount > 0)
9729               {
9730                 s = htab->elf.iplt;
9731                 ent->plt.offset = s->size;
9732                 s->size += PLT_ENTRY_SIZE (htab);
9733
9734                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9735               }
9736             else
9737               ent->plt.offset = (bfd_vma) -1;
9738         }
9739     }
9740
9741   /* Allocate global sym .plt and .got entries, and space for global
9742      sym dynamic relocs.  */
9743   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9744   /* Stash the end of glink branch table.  */
9745   if (htab->glink != NULL)
9746     htab->glink->rawsize = htab->glink->size;
9747
9748   if (!htab->opd_abi && !info->shared)
9749     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9750
9751   first_tlsld = NULL;
9752   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9753     {
9754       struct got_entry *ent;
9755
9756       if (!is_ppc64_elf (ibfd))
9757         continue;
9758
9759       ent = ppc64_tlsld_got (ibfd);
9760       if (ent->got.refcount > 0)
9761         {
9762           if (!htab->do_multi_toc && first_tlsld != NULL)
9763             {
9764               ent->is_indirect = TRUE;
9765               ent->got.ent = first_tlsld;
9766             }
9767           else
9768             {
9769               if (first_tlsld == NULL)
9770                 first_tlsld = ent;
9771               s = ppc64_elf_tdata (ibfd)->got;
9772               ent->got.offset = s->size;
9773               ent->owner = ibfd;
9774               s->size += 16;
9775               if (info->shared)
9776                 {
9777                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9778                   srel->size += sizeof (Elf64_External_Rela);
9779                 }
9780             }
9781         }
9782       else
9783         ent->got.offset = (bfd_vma) -1;
9784     }
9785
9786   /* We now have determined the sizes of the various dynamic sections.
9787      Allocate memory for them.  */
9788   relocs = FALSE;
9789   for (s = dynobj->sections; s != NULL; s = s->next)
9790     {
9791       if ((s->flags & SEC_LINKER_CREATED) == 0)
9792         continue;
9793
9794       if (s == htab->brlt || s == htab->relbrlt)
9795         /* These haven't been allocated yet;  don't strip.  */
9796         continue;
9797       else if (s == htab->elf.sgot
9798                || s == htab->elf.splt
9799                || s == htab->elf.iplt
9800                || s == htab->glink
9801                || s == htab->dynbss)
9802         {
9803           /* Strip this section if we don't need it; see the
9804              comment below.  */
9805         }
9806       else if (s == htab->glink_eh_frame)
9807         {
9808           if (!bfd_is_abs_section (s->output_section))
9809             /* Not sized yet.  */
9810             continue;
9811         }
9812       else if (CONST_STRNEQ (s->name, ".rela"))
9813         {
9814           if (s->size != 0)
9815             {
9816               if (s != htab->elf.srelplt)
9817                 relocs = TRUE;
9818
9819               /* We use the reloc_count field as a counter if we need
9820                  to copy relocs into the output file.  */
9821               s->reloc_count = 0;
9822             }
9823         }
9824       else
9825         {
9826           /* It's not one of our sections, so don't allocate space.  */
9827           continue;
9828         }
9829
9830       if (s->size == 0)
9831         {
9832           /* If we don't need this section, strip it from the
9833              output file.  This is mostly to handle .rela.bss and
9834              .rela.plt.  We must create both sections in
9835              create_dynamic_sections, because they must be created
9836              before the linker maps input sections to output
9837              sections.  The linker does that before
9838              adjust_dynamic_symbol is called, and it is that
9839              function which decides whether anything needs to go
9840              into these sections.  */
9841           s->flags |= SEC_EXCLUDE;
9842           continue;
9843         }
9844
9845       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9846         continue;
9847
9848       /* Allocate memory for the section contents.  We use bfd_zalloc
9849          here in case unused entries are not reclaimed before the
9850          section's contents are written out.  This should not happen,
9851          but this way if it does we get a R_PPC64_NONE reloc in .rela
9852          sections instead of garbage.
9853          We also rely on the section contents being zero when writing
9854          the GOT.  */
9855       s->contents = bfd_zalloc (dynobj, s->size);
9856       if (s->contents == NULL)
9857         return FALSE;
9858     }
9859
9860   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9861     {
9862       if (!is_ppc64_elf (ibfd))
9863         continue;
9864
9865       s = ppc64_elf_tdata (ibfd)->got;
9866       if (s != NULL && s != htab->elf.sgot)
9867         {
9868           if (s->size == 0)
9869             s->flags |= SEC_EXCLUDE;
9870           else
9871             {
9872               s->contents = bfd_zalloc (ibfd, s->size);
9873               if (s->contents == NULL)
9874                 return FALSE;
9875             }
9876         }
9877       s = ppc64_elf_tdata (ibfd)->relgot;
9878       if (s != NULL)
9879         {
9880           if (s->size == 0)
9881             s->flags |= SEC_EXCLUDE;
9882           else
9883             {
9884               s->contents = bfd_zalloc (ibfd, s->size);
9885               if (s->contents == NULL)
9886                 return FALSE;
9887               relocs = TRUE;
9888               s->reloc_count = 0;
9889             }
9890         }
9891     }
9892
9893   if (htab->elf.dynamic_sections_created)
9894     {
9895       bfd_boolean tls_opt;
9896
9897       /* Add some entries to the .dynamic section.  We fill in the
9898          values later, in ppc64_elf_finish_dynamic_sections, but we
9899          must add the entries now so that we get the correct size for
9900          the .dynamic section.  The DT_DEBUG entry is filled in by the
9901          dynamic linker and used by the debugger.  */
9902 #define add_dynamic_entry(TAG, VAL) \
9903   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9904
9905       if (info->executable)
9906         {
9907           if (!add_dynamic_entry (DT_DEBUG, 0))
9908             return FALSE;
9909         }
9910
9911       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9912         {
9913           if (!add_dynamic_entry (DT_PLTGOT, 0)
9914               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9915               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9916               || !add_dynamic_entry (DT_JMPREL, 0)
9917               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9918             return FALSE;
9919         }
9920
9921       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9922         {
9923           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9924               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9925             return FALSE;
9926         }
9927
9928       tls_opt = (!htab->no_tls_get_addr_opt
9929                  && htab->tls_get_addr_fd != NULL
9930                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9931       if (tls_opt || !htab->opd_abi)
9932         {
9933           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9934             return FALSE;
9935         }
9936
9937       if (relocs)
9938         {
9939           if (!add_dynamic_entry (DT_RELA, 0)
9940               || !add_dynamic_entry (DT_RELASZ, 0)
9941               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9942             return FALSE;
9943
9944           /* If any dynamic relocs apply to a read-only section,
9945              then we need a DT_TEXTREL entry.  */
9946           if ((info->flags & DF_TEXTREL) == 0)
9947             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9948
9949           if ((info->flags & DF_TEXTREL) != 0)
9950             {
9951               if (!add_dynamic_entry (DT_TEXTREL, 0))
9952                 return FALSE;
9953             }
9954         }
9955     }
9956 #undef add_dynamic_entry
9957
9958   return TRUE;
9959 }
9960
9961 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9962
9963 static bfd_boolean
9964 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9965 {
9966   if (h->plt.plist != NULL
9967       && !h->def_regular
9968       && !h->pointer_equality_needed)
9969     return FALSE;
9970
9971   return _bfd_elf_hash_symbol (h);
9972 }
9973
9974 /* Determine the type of stub needed, if any, for a call.  */
9975
9976 static inline enum ppc_stub_type
9977 ppc_type_of_stub (asection *input_sec,
9978                   const Elf_Internal_Rela *rel,
9979                   struct ppc_link_hash_entry **hash,
9980                   struct plt_entry **plt_ent,
9981                   bfd_vma destination,
9982                   unsigned long local_off)
9983 {
9984   struct ppc_link_hash_entry *h = *hash;
9985   bfd_vma location;
9986   bfd_vma branch_offset;
9987   bfd_vma max_branch_offset;
9988   enum elf_ppc64_reloc_type r_type;
9989
9990   if (h != NULL)
9991     {
9992       struct plt_entry *ent;
9993       struct ppc_link_hash_entry *fdh = h;
9994       if (h->oh != NULL
9995           && h->oh->is_func_descriptor)
9996         {
9997           fdh = ppc_follow_link (h->oh);
9998           *hash = fdh;
9999         }
10000
10001       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10002         if (ent->addend == rel->r_addend
10003             && ent->plt.offset != (bfd_vma) -1)
10004           {
10005             *plt_ent = ent;
10006             return ppc_stub_plt_call;
10007           }
10008
10009       /* Here, we know we don't have a plt entry.  If we don't have a
10010          either a defined function descriptor or a defined entry symbol
10011          in a regular object file, then it is pointless trying to make
10012          any other type of stub.  */
10013       if (!is_static_defined (&fdh->elf)
10014           && !is_static_defined (&h->elf))
10015         return ppc_stub_none;
10016     }
10017   else if (elf_local_got_ents (input_sec->owner) != NULL)
10018     {
10019       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10020       struct plt_entry **local_plt = (struct plt_entry **)
10021         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10022       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10023
10024       if (local_plt[r_symndx] != NULL)
10025         {
10026           struct plt_entry *ent;
10027
10028           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10029             if (ent->addend == rel->r_addend
10030                 && ent->plt.offset != (bfd_vma) -1)
10031               {
10032                 *plt_ent = ent;
10033                 return ppc_stub_plt_call;
10034               }
10035         }
10036     }
10037
10038   /* Determine where the call point is.  */
10039   location = (input_sec->output_offset
10040               + input_sec->output_section->vma
10041               + rel->r_offset);
10042
10043   branch_offset = destination - location;
10044   r_type = ELF64_R_TYPE (rel->r_info);
10045
10046   /* Determine if a long branch stub is needed.  */
10047   max_branch_offset = 1 << 25;
10048   if (r_type != R_PPC64_REL24)
10049     max_branch_offset = 1 << 15;
10050
10051   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10052     /* We need a stub.  Figure out whether a long_branch or plt_branch
10053        is needed later.  */
10054     return ppc_stub_long_branch;
10055
10056   return ppc_stub_none;
10057 }
10058
10059 /* With power7 weakly ordered memory model, it is possible for ld.so
10060    to update a plt entry in one thread and have another thread see a
10061    stale zero toc entry.  To avoid this we need some sort of acquire
10062    barrier in the call stub.  One solution is to make the load of the
10063    toc word seem to appear to depend on the load of the function entry
10064    word.  Another solution is to test for r2 being zero, and branch to
10065    the appropriate glink entry if so.
10066
10067    .    fake dep barrier        compare
10068    .    ld 12,xxx(2)            ld 12,xxx(2)
10069    .    mtctr 12                mtctr 12
10070    .    xor 11,12,12            ld 2,xxx+8(2)
10071    .    add 2,2,11              cmpldi 2,0
10072    .    ld 2,xxx+8(2)           bnectr+
10073    .    bctr                    b <glink_entry>
10074
10075    The solution involving the compare turns out to be faster, so
10076    that's what we use unless the branch won't reach.  */
10077
10078 #define ALWAYS_USE_FAKE_DEP 0
10079 #define ALWAYS_EMIT_R2SAVE 0
10080
10081 #define PPC_LO(v) ((v) & 0xffff)
10082 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10083 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10084
10085 static inline unsigned int
10086 plt_stub_size (struct ppc_link_hash_table *htab,
10087                struct ppc_stub_hash_entry *stub_entry,
10088                bfd_vma off)
10089 {
10090   unsigned size = 12;
10091
10092   if (ALWAYS_EMIT_R2SAVE
10093       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10094     size += 4;
10095   if (PPC_HA (off) != 0)
10096     size += 4;
10097   if (htab->opd_abi)
10098     {
10099       size += 4;
10100       if (htab->plt_static_chain)
10101         size += 4;
10102       if (htab->plt_thread_safe)
10103         size += 8;
10104       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10105         size += 4;
10106     }
10107   if (stub_entry->h != NULL
10108       && (stub_entry->h == htab->tls_get_addr_fd
10109           || stub_entry->h == htab->tls_get_addr)
10110       && !htab->no_tls_get_addr_opt)
10111     size += 13 * 4;
10112   return size;
10113 }
10114
10115 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10116    then return the padding needed to do so.  */
10117 static inline unsigned int
10118 plt_stub_pad (struct ppc_link_hash_table *htab,
10119               struct ppc_stub_hash_entry *stub_entry,
10120               bfd_vma plt_off)
10121 {
10122   int stub_align = 1 << htab->plt_stub_align;
10123   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10124   bfd_vma stub_off = stub_entry->stub_sec->size;
10125
10126   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10127       > (stub_size & -stub_align))
10128     return stub_align - (stub_off & (stub_align - 1));
10129   return 0;
10130 }
10131
10132 /* Build a .plt call stub.  */
10133
10134 static inline bfd_byte *
10135 build_plt_stub (struct ppc_link_hash_table *htab,
10136                 struct ppc_stub_hash_entry *stub_entry,
10137                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10138 {
10139   bfd *obfd = htab->stub_bfd;
10140   bfd_boolean plt_load_toc = htab->opd_abi;
10141   bfd_boolean plt_static_chain = htab->plt_static_chain;
10142   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10143   bfd_boolean use_fake_dep = plt_thread_safe;
10144   bfd_vma cmp_branch_off = 0;
10145
10146   if (!ALWAYS_USE_FAKE_DEP
10147       && plt_load_toc
10148       && plt_thread_safe
10149       && !(stub_entry->h != NULL
10150            && (stub_entry->h == htab->tls_get_addr_fd
10151                || stub_entry->h == htab->tls_get_addr)
10152            && !htab->no_tls_get_addr_opt))
10153     {
10154       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10155       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10156                           / PLT_ENTRY_SIZE (htab));
10157       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10158       bfd_vma to, from;
10159
10160       if (pltindex > 32768)
10161         glinkoff += (pltindex - 32768) * 4;
10162       to = (glinkoff
10163             + htab->glink->output_offset
10164             + htab->glink->output_section->vma);
10165       from = (p - stub_entry->stub_sec->contents
10166               + 4 * (ALWAYS_EMIT_R2SAVE
10167                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10168               + 4 * (PPC_HA (offset) != 0)
10169               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10170                      != PPC_HA (offset))
10171               + 4 * (plt_static_chain != 0)
10172               + 20
10173               + stub_entry->stub_sec->output_offset
10174               + stub_entry->stub_sec->output_section->vma);
10175       cmp_branch_off = to - from;
10176       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10177     }
10178
10179   if (PPC_HA (offset) != 0)
10180     {
10181       if (r != NULL)
10182         {
10183           if (ALWAYS_EMIT_R2SAVE
10184               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10185             r[0].r_offset += 4;
10186           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10187           r[1].r_offset = r[0].r_offset + 4;
10188           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10189           r[1].r_addend = r[0].r_addend;
10190           if (plt_load_toc)
10191             {
10192               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10193                 {
10194                   r[2].r_offset = r[1].r_offset + 4;
10195                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10196                   r[2].r_addend = r[0].r_addend;
10197                 }
10198               else
10199                 {
10200                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10201                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10202                   r[2].r_addend = r[0].r_addend + 8;
10203                   if (plt_static_chain)
10204                     {
10205                       r[3].r_offset = r[2].r_offset + 4;
10206                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10207                       r[3].r_addend = r[0].r_addend + 16;
10208                     }
10209                 }
10210             }
10211         }
10212       if (ALWAYS_EMIT_R2SAVE
10213           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10214         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10215       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10216       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10217       if (plt_load_toc
10218           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10219         {
10220           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10221           offset = 0;
10222         }
10223       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10224       if (plt_load_toc)
10225         {
10226           if (use_fake_dep)
10227             {
10228               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10229               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10230             }
10231           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10232           if (plt_static_chain)
10233             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10234         }
10235     }
10236   else
10237     {
10238       if (r != NULL)
10239         {
10240           if (ALWAYS_EMIT_R2SAVE
10241               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10242             r[0].r_offset += 4;
10243           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10244           if (plt_load_toc)
10245             {
10246               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10247                 {
10248                   r[1].r_offset = r[0].r_offset + 4;
10249                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10250                   r[1].r_addend = r[0].r_addend;
10251                 }
10252               else
10253                 {
10254                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10255                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10256                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10257                   if (plt_static_chain)
10258                     {
10259                       r[2].r_offset = r[1].r_offset + 4;
10260                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10261                       r[2].r_addend = r[0].r_addend + 8;
10262                     }
10263                 }
10264             }
10265         }
10266       if (ALWAYS_EMIT_R2SAVE
10267           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10268         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10269       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10270       if (plt_load_toc
10271           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10272         {
10273           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10274           offset = 0;
10275         }
10276       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10277       if (plt_load_toc)
10278         {
10279           if (use_fake_dep)
10280             {
10281               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10282               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10283             }
10284           if (plt_static_chain)
10285             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10286           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10287         }
10288     }
10289   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10290     {
10291       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10292       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10293       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10294     }
10295   else
10296     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10297   return p;
10298 }
10299
10300 /* Build a special .plt call stub for __tls_get_addr.  */
10301
10302 #define LD_R11_0R3      0xe9630000
10303 #define LD_R12_0R3      0xe9830000
10304 #define MR_R0_R3        0x7c601b78
10305 #define CMPDI_R11_0     0x2c2b0000
10306 #define ADD_R3_R12_R13  0x7c6c6a14
10307 #define BEQLR           0x4d820020
10308 #define MR_R3_R0        0x7c030378
10309 #define STD_R11_0R1     0xf9610000
10310 #define BCTRL           0x4e800421
10311 #define LD_R11_0R1      0xe9610000
10312 #define MTLR_R11        0x7d6803a6
10313
10314 static inline bfd_byte *
10315 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10316                          struct ppc_stub_hash_entry *stub_entry,
10317                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10318 {
10319   bfd *obfd = htab->stub_bfd;
10320
10321   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10322   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10323   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10324   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10325   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10326   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10327   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10328   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10329   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10330
10331   if (r != NULL)
10332     r[0].r_offset += 9 * 4;
10333   p = build_plt_stub (htab, stub_entry, p, offset, r);
10334   bfd_put_32 (obfd, BCTRL, p - 4);
10335
10336   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10337   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10338   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10339   bfd_put_32 (obfd, BLR, p),                    p += 4;
10340
10341   return p;
10342 }
10343
10344 static Elf_Internal_Rela *
10345 get_relocs (asection *sec, int count)
10346 {
10347   Elf_Internal_Rela *relocs;
10348   struct bfd_elf_section_data *elfsec_data;
10349
10350   elfsec_data = elf_section_data (sec);
10351   relocs = elfsec_data->relocs;
10352   if (relocs == NULL)
10353     {
10354       bfd_size_type relsize;
10355       relsize = sec->reloc_count * sizeof (*relocs);
10356       relocs = bfd_alloc (sec->owner, relsize);
10357       if (relocs == NULL)
10358         return NULL;
10359       elfsec_data->relocs = relocs;
10360       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10361                                           sizeof (Elf_Internal_Shdr));
10362       if (elfsec_data->rela.hdr == NULL)
10363         return NULL;
10364       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10365                                         * sizeof (Elf64_External_Rela));
10366       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10367       sec->reloc_count = 0;
10368     }
10369   relocs += sec->reloc_count;
10370   sec->reloc_count += count;
10371   return relocs;
10372 }
10373
10374 static bfd_vma
10375 get_r2off (struct bfd_link_info *info,
10376            struct ppc_stub_hash_entry *stub_entry)
10377 {
10378   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10379   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10380
10381   if (r2off == 0)
10382     {
10383       /* Support linking -R objects.  Get the toc pointer from the
10384          opd entry.  */
10385       char buf[8];
10386       if (!htab->opd_abi)
10387         return r2off;
10388       asection *opd = stub_entry->h->elf.root.u.def.section;
10389       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10390
10391       if (strcmp (opd->name, ".opd") != 0
10392           || opd->reloc_count != 0)
10393         {
10394           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10395                                   stub_entry->h->elf.root.root.string);
10396           bfd_set_error (bfd_error_bad_value);
10397           return 0;
10398         }
10399       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10400         return 0;
10401       r2off = bfd_get_64 (opd->owner, buf);
10402       r2off -= elf_gp (info->output_bfd);
10403     }
10404   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10405   return r2off;
10406 }
10407
10408 static bfd_boolean
10409 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10410 {
10411   struct ppc_stub_hash_entry *stub_entry;
10412   struct ppc_branch_hash_entry *br_entry;
10413   struct bfd_link_info *info;
10414   struct ppc_link_hash_table *htab;
10415   bfd_byte *loc;
10416   bfd_byte *p;
10417   bfd_vma dest, off;
10418   int size;
10419   Elf_Internal_Rela *r;
10420   asection *plt;
10421
10422   /* Massage our args to the form they really have.  */
10423   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10424   info = in_arg;
10425
10426   htab = ppc_hash_table (info);
10427   if (htab == NULL)
10428     return FALSE;
10429
10430   /* Make a note of the offset within the stubs for this entry.  */
10431   stub_entry->stub_offset = stub_entry->stub_sec->size;
10432   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10433
10434   htab->stub_count[stub_entry->stub_type - 1] += 1;
10435   switch (stub_entry->stub_type)
10436     {
10437     case ppc_stub_long_branch:
10438     case ppc_stub_long_branch_r2off:
10439       /* Branches are relative.  This is where we are going to.  */
10440       dest = (stub_entry->target_value
10441               + stub_entry->target_section->output_offset
10442               + stub_entry->target_section->output_section->vma);
10443       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10444       off = dest;
10445
10446       /* And this is where we are coming from.  */
10447       off -= (stub_entry->stub_offset
10448               + stub_entry->stub_sec->output_offset
10449               + stub_entry->stub_sec->output_section->vma);
10450
10451       size = 4;
10452       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10453         {
10454           bfd_vma r2off = get_r2off (info, stub_entry);
10455
10456           if (r2off == 0)
10457             {
10458               htab->stub_error = TRUE;
10459               return FALSE;
10460             }
10461           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10462           loc += 4;
10463           size = 12;
10464           if (PPC_HA (r2off) != 0)
10465             {
10466               size = 16;
10467               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10468               loc += 4;
10469             }
10470           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10471           loc += 4;
10472           off -= size - 4;
10473         }
10474       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10475
10476       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10477         {
10478           info->callbacks->einfo
10479             (_("%P: long branch stub `%s' offset overflow\n"),
10480              stub_entry->root.string);
10481           htab->stub_error = TRUE;
10482           return FALSE;
10483         }
10484
10485       if (info->emitrelocations)
10486         {
10487           r = get_relocs (stub_entry->stub_sec, 1);
10488           if (r == NULL)
10489             return FALSE;
10490           r->r_offset = loc - stub_entry->stub_sec->contents;
10491           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10492           r->r_addend = dest;
10493           if (stub_entry->h != NULL)
10494             {
10495               struct elf_link_hash_entry **hashes;
10496               unsigned long symndx;
10497               struct ppc_link_hash_entry *h;
10498
10499               hashes = elf_sym_hashes (htab->stub_bfd);
10500               if (hashes == NULL)
10501                 {
10502                   bfd_size_type hsize;
10503
10504                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10505                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10506                   if (hashes == NULL)
10507                     return FALSE;
10508                   elf_sym_hashes (htab->stub_bfd) = hashes;
10509                   htab->stub_globals = 1;
10510                 }
10511               symndx = htab->stub_globals++;
10512               h = stub_entry->h;
10513               hashes[symndx] = &h->elf;
10514               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10515               if (h->oh != NULL && h->oh->is_func)
10516                 h = ppc_follow_link (h->oh);
10517               if (h->elf.root.u.def.section != stub_entry->target_section)
10518                 /* H is an opd symbol.  The addend must be zero.  */
10519                 r->r_addend = 0;
10520               else
10521                 {
10522                   off = (h->elf.root.u.def.value
10523                          + h->elf.root.u.def.section->output_offset
10524                          + h->elf.root.u.def.section->output_section->vma);
10525                   r->r_addend -= off;
10526                 }
10527             }
10528         }
10529       break;
10530
10531     case ppc_stub_plt_branch:
10532     case ppc_stub_plt_branch_r2off:
10533       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10534                                          stub_entry->root.string + 9,
10535                                          FALSE, FALSE);
10536       if (br_entry == NULL)
10537         {
10538           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10539                                   stub_entry->root.string);
10540           htab->stub_error = TRUE;
10541           return FALSE;
10542         }
10543
10544       dest = (stub_entry->target_value
10545               + stub_entry->target_section->output_offset
10546               + stub_entry->target_section->output_section->vma);
10547       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10548         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10549
10550       bfd_put_64 (htab->brlt->owner, dest,
10551                   htab->brlt->contents + br_entry->offset);
10552
10553       if (br_entry->iter == htab->stub_iteration)
10554         {
10555           br_entry->iter = 0;
10556
10557           if (htab->relbrlt != NULL)
10558             {
10559               /* Create a reloc for the branch lookup table entry.  */
10560               Elf_Internal_Rela rela;
10561               bfd_byte *rl;
10562
10563               rela.r_offset = (br_entry->offset
10564                                + htab->brlt->output_offset
10565                                + htab->brlt->output_section->vma);
10566               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10567               rela.r_addend = dest;
10568
10569               rl = htab->relbrlt->contents;
10570               rl += (htab->relbrlt->reloc_count++
10571                      * sizeof (Elf64_External_Rela));
10572               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10573             }
10574           else if (info->emitrelocations)
10575             {
10576               r = get_relocs (htab->brlt, 1);
10577               if (r == NULL)
10578                 return FALSE;
10579               /* brlt, being SEC_LINKER_CREATED does not go through the
10580                  normal reloc processing.  Symbols and offsets are not
10581                  translated from input file to output file form, so
10582                  set up the offset per the output file.  */
10583               r->r_offset = (br_entry->offset
10584                              + htab->brlt->output_offset
10585                              + htab->brlt->output_section->vma);
10586               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10587               r->r_addend = dest;
10588             }
10589         }
10590
10591       dest = (br_entry->offset
10592               + htab->brlt->output_offset
10593               + htab->brlt->output_section->vma);
10594
10595       off = (dest
10596              - elf_gp (htab->brlt->output_section->owner)
10597              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10598
10599       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10600         {
10601           info->callbacks->einfo
10602             (_("%P: linkage table error against `%T'\n"),
10603              stub_entry->root.string);
10604           bfd_set_error (bfd_error_bad_value);
10605           htab->stub_error = TRUE;
10606           return FALSE;
10607         }
10608
10609       if (info->emitrelocations)
10610         {
10611           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10612           if (r == NULL)
10613             return FALSE;
10614           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10615           if (bfd_big_endian (info->output_bfd))
10616             r[0].r_offset += 2;
10617           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10618             r[0].r_offset += 4;
10619           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10620           r[0].r_addend = dest;
10621           if (PPC_HA (off) != 0)
10622             {
10623               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10624               r[1].r_offset = r[0].r_offset + 4;
10625               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10626               r[1].r_addend = r[0].r_addend;
10627             }
10628         }
10629
10630       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10631         {
10632           if (PPC_HA (off) != 0)
10633             {
10634               size = 16;
10635               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10636               loc += 4;
10637               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10638             }
10639           else
10640             {
10641               size = 12;
10642               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10643             }
10644         }
10645       else
10646         {
10647           bfd_vma r2off = get_r2off (info, stub_entry);
10648
10649           if (r2off == 0 && htab->opd_abi)
10650             {
10651               htab->stub_error = TRUE;
10652               return FALSE;
10653             }
10654
10655           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10656           loc += 4;
10657           size = 16;
10658           if (PPC_HA (off) != 0)
10659             {
10660               size += 4;
10661               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10662               loc += 4;
10663               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10664             }
10665           else
10666             bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10667
10668           if (PPC_HA (r2off) != 0)
10669             {
10670               size += 4;
10671               loc += 4;
10672               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10673             }
10674           if (PPC_LO (r2off) != 0)
10675             {
10676               size += 4;
10677               loc += 4;
10678               bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10679             }
10680         }
10681       loc += 4;
10682       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10683       loc += 4;
10684       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10685       break;
10686
10687     case ppc_stub_plt_call:
10688     case ppc_stub_plt_call_r2save:
10689       if (stub_entry->h != NULL
10690           && stub_entry->h->is_func_descriptor
10691           && stub_entry->h->oh != NULL)
10692         {
10693           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10694
10695           /* If the old-ABI "dot-symbol" is undefined make it weak so
10696              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10697              FIXME: We used to define the symbol on one of the call
10698              stubs instead, which is why we test symbol section id
10699              against htab->top_id in various places.  Likely all
10700              these checks could now disappear.  */
10701           if (fh->elf.root.type == bfd_link_hash_undefined)
10702             fh->elf.root.type = bfd_link_hash_undefweak;
10703           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10704           fh->was_undefined = 0;
10705         }
10706
10707       /* Now build the stub.  */
10708       dest = stub_entry->plt_ent->plt.offset & ~1;
10709       if (dest >= (bfd_vma) -2)
10710         abort ();
10711
10712       plt = htab->elf.splt;
10713       if (!htab->elf.dynamic_sections_created
10714           || stub_entry->h == NULL
10715           || stub_entry->h->elf.dynindx == -1)
10716         plt = htab->elf.iplt;
10717
10718       dest += plt->output_offset + plt->output_section->vma;
10719
10720       if (stub_entry->h == NULL
10721           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10722         {
10723           Elf_Internal_Rela rela;
10724           bfd_byte *rl;
10725
10726           rela.r_offset = dest;
10727           if (htab->opd_abi)
10728             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10729           else
10730             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10731           rela.r_addend = (stub_entry->target_value
10732                            + stub_entry->target_section->output_offset
10733                            + stub_entry->target_section->output_section->vma);
10734
10735           rl = (htab->elf.irelplt->contents
10736                 + (htab->elf.irelplt->reloc_count++
10737                    * sizeof (Elf64_External_Rela)));
10738           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10739           stub_entry->plt_ent->plt.offset |= 1;
10740         }
10741
10742       off = (dest
10743              - elf_gp (plt->output_section->owner)
10744              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10745
10746       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10747         {
10748           info->callbacks->einfo
10749             (_("%P: linkage table error against `%T'\n"),
10750              stub_entry->h != NULL
10751              ? stub_entry->h->elf.root.root.string
10752              : "<local sym>");
10753           bfd_set_error (bfd_error_bad_value);
10754           htab->stub_error = TRUE;
10755           return FALSE;
10756         }
10757
10758       if (htab->plt_stub_align != 0)
10759         {
10760           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10761
10762           stub_entry->stub_sec->size += pad;
10763           stub_entry->stub_offset = stub_entry->stub_sec->size;
10764           loc += pad;
10765         }
10766
10767       r = NULL;
10768       if (info->emitrelocations)
10769         {
10770           r = get_relocs (stub_entry->stub_sec,
10771                           ((PPC_HA (off) != 0)
10772                            + (htab->opd_abi
10773                               ? 2 + (htab->plt_static_chain
10774                                      && PPC_HA (off + 16) == PPC_HA (off))
10775                               : 1)));
10776           if (r == NULL)
10777             return FALSE;
10778           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10779           if (bfd_big_endian (info->output_bfd))
10780             r[0].r_offset += 2;
10781           r[0].r_addend = dest;
10782         }
10783       if (stub_entry->h != NULL
10784           && (stub_entry->h == htab->tls_get_addr_fd
10785               || stub_entry->h == htab->tls_get_addr)
10786           && !htab->no_tls_get_addr_opt)
10787         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10788       else
10789         p = build_plt_stub (htab, stub_entry, loc, off, r);
10790       size = p - loc;
10791       break;
10792
10793     default:
10794       BFD_FAIL ();
10795       return FALSE;
10796     }
10797
10798   stub_entry->stub_sec->size += size;
10799
10800   if (htab->emit_stub_syms)
10801     {
10802       struct elf_link_hash_entry *h;
10803       size_t len1, len2;
10804       char *name;
10805       const char *const stub_str[] = { "long_branch",
10806                                        "long_branch_r2off",
10807                                        "plt_branch",
10808                                        "plt_branch_r2off",
10809                                        "plt_call",
10810                                        "plt_call" };
10811
10812       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10813       len2 = strlen (stub_entry->root.string);
10814       name = bfd_malloc (len1 + len2 + 2);
10815       if (name == NULL)
10816         return FALSE;
10817       memcpy (name, stub_entry->root.string, 9);
10818       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10819       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10820       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10821       if (h == NULL)
10822         return FALSE;
10823       if (h->root.type == bfd_link_hash_new)
10824         {
10825           h->root.type = bfd_link_hash_defined;
10826           h->root.u.def.section = stub_entry->stub_sec;
10827           h->root.u.def.value = stub_entry->stub_offset;
10828           h->ref_regular = 1;
10829           h->def_regular = 1;
10830           h->ref_regular_nonweak = 1;
10831           h->forced_local = 1;
10832           h->non_elf = 0;
10833         }
10834     }
10835
10836   return TRUE;
10837 }
10838
10839 /* As above, but don't actually build the stub.  Just bump offset so
10840    we know stub section sizes, and select plt_branch stubs where
10841    long_branch stubs won't do.  */
10842
10843 static bfd_boolean
10844 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10845 {
10846   struct ppc_stub_hash_entry *stub_entry;
10847   struct bfd_link_info *info;
10848   struct ppc_link_hash_table *htab;
10849   bfd_vma off;
10850   int size;
10851
10852   /* Massage our args to the form they really have.  */
10853   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10854   info = in_arg;
10855
10856   htab = ppc_hash_table (info);
10857   if (htab == NULL)
10858     return FALSE;
10859
10860   if (stub_entry->stub_type == ppc_stub_plt_call
10861       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10862     {
10863       asection *plt;
10864       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10865       if (off >= (bfd_vma) -2)
10866         abort ();
10867       plt = htab->elf.splt;
10868       if (!htab->elf.dynamic_sections_created
10869           || stub_entry->h == NULL
10870           || stub_entry->h->elf.dynindx == -1)
10871         plt = htab->elf.iplt;
10872       off += (plt->output_offset
10873               + plt->output_section->vma
10874               - elf_gp (plt->output_section->owner)
10875               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10876
10877       size = plt_stub_size (htab, stub_entry, off);
10878       if (htab->plt_stub_align)
10879         size += plt_stub_pad (htab, stub_entry, off);
10880       if (info->emitrelocations)
10881         {
10882           stub_entry->stub_sec->reloc_count
10883             += ((PPC_HA (off) != 0)
10884                 + (htab->opd_abi
10885                    ? 2 + (htab->plt_static_chain
10886                           && PPC_HA (off + 16) == PPC_HA (off))
10887                    : 1));
10888           stub_entry->stub_sec->flags |= SEC_RELOC;
10889         }
10890     }
10891   else
10892     {
10893       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10894          variants.  */
10895       bfd_vma r2off = 0;
10896       bfd_vma local_off = 0;
10897
10898       off = (stub_entry->target_value
10899              + stub_entry->target_section->output_offset
10900              + stub_entry->target_section->output_section->vma);
10901       off -= (stub_entry->stub_sec->size
10902               + stub_entry->stub_sec->output_offset
10903               + stub_entry->stub_sec->output_section->vma);
10904
10905       /* Reset the stub type from the plt variant in case we now
10906          can reach with a shorter stub.  */
10907       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10908         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10909
10910       size = 4;
10911       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10912         {
10913           r2off = get_r2off (info, stub_entry);
10914           if (r2off == 0 && htab->opd_abi)
10915             {
10916               htab->stub_error = TRUE;
10917               return FALSE;
10918             }
10919           size = 12;
10920           if (PPC_HA (r2off) != 0)
10921             size = 16;
10922           off -= size - 4;
10923         }
10924
10925       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10926
10927       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10928          Do the same for -R objects without function descriptors.  */
10929       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10930           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10931               && r2off == 0))
10932         {
10933           struct ppc_branch_hash_entry *br_entry;
10934
10935           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10936                                              stub_entry->root.string + 9,
10937                                              TRUE, FALSE);
10938           if (br_entry == NULL)
10939             {
10940               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10941                                       stub_entry->root.string);
10942               htab->stub_error = TRUE;
10943               return FALSE;
10944             }
10945
10946           if (br_entry->iter != htab->stub_iteration)
10947             {
10948               br_entry->iter = htab->stub_iteration;
10949               br_entry->offset = htab->brlt->size;
10950               htab->brlt->size += 8;
10951
10952               if (htab->relbrlt != NULL)
10953                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10954               else if (info->emitrelocations)
10955                 {
10956                   htab->brlt->reloc_count += 1;
10957                   htab->brlt->flags |= SEC_RELOC;
10958                 }
10959             }
10960
10961           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10962           off = (br_entry->offset
10963                  + htab->brlt->output_offset
10964                  + htab->brlt->output_section->vma
10965                  - elf_gp (htab->brlt->output_section->owner)
10966                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10967
10968           if (info->emitrelocations)
10969             {
10970               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10971               stub_entry->stub_sec->flags |= SEC_RELOC;
10972             }
10973
10974           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10975             {
10976               size = 12;
10977               if (PPC_HA (off) != 0)
10978                 size = 16;
10979             }
10980           else
10981             {
10982               size = 16;
10983               if (PPC_HA (off) != 0)
10984                 size += 4;
10985
10986               if (PPC_HA (r2off) != 0)
10987                 size += 4;
10988               if (PPC_LO (r2off) != 0)
10989                 size += 4;
10990             }
10991         }
10992       else if (info->emitrelocations)
10993         {
10994           stub_entry->stub_sec->reloc_count += 1;
10995           stub_entry->stub_sec->flags |= SEC_RELOC;
10996         }
10997     }
10998
10999   stub_entry->stub_sec->size += size;
11000   return TRUE;
11001 }
11002
11003 /* Set up various things so that we can make a list of input sections
11004    for each output section included in the link.  Returns -1 on error,
11005    0 when no stubs will be needed, and 1 on success.  */
11006
11007 int
11008 ppc64_elf_setup_section_lists
11009   (struct bfd_link_info *info,
11010    asection *(*add_stub_section) (const char *, asection *),
11011    void (*layout_sections_again) (void))
11012 {
11013   bfd *input_bfd;
11014   int top_id, top_index, id;
11015   asection *section;
11016   asection **input_list;
11017   bfd_size_type amt;
11018   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11019
11020   if (htab == NULL)
11021     return -1;
11022   /* Stash our params away.  */
11023   htab->add_stub_section = add_stub_section;
11024   htab->layout_sections_again = layout_sections_again;
11025
11026   /* Find the top input section id.  */
11027   for (input_bfd = info->input_bfds, top_id = 3;
11028        input_bfd != NULL;
11029        input_bfd = input_bfd->link_next)
11030     {
11031       for (section = input_bfd->sections;
11032            section != NULL;
11033            section = section->next)
11034         {
11035           if (top_id < section->id)
11036             top_id = section->id;
11037         }
11038     }
11039
11040   htab->top_id = top_id;
11041   amt = sizeof (struct map_stub) * (top_id + 1);
11042   htab->stub_group = bfd_zmalloc (amt);
11043   if (htab->stub_group == NULL)
11044     return -1;
11045
11046   /* Set toc_off for com, und, abs and ind sections.  */
11047   for (id = 0; id < 3; id++)
11048     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11049
11050   /* We can't use output_bfd->section_count here to find the top output
11051      section index as some sections may have been removed, and
11052      strip_excluded_output_sections doesn't renumber the indices.  */
11053   for (section = info->output_bfd->sections, top_index = 0;
11054        section != NULL;
11055        section = section->next)
11056     {
11057       if (top_index < section->index)
11058         top_index = section->index;
11059     }
11060
11061   htab->top_index = top_index;
11062   amt = sizeof (asection *) * (top_index + 1);
11063   input_list = bfd_zmalloc (amt);
11064   htab->input_list = input_list;
11065   if (input_list == NULL)
11066     return -1;
11067
11068   return 1;
11069 }
11070
11071 /* Set up for first pass at multitoc partitioning.  */
11072
11073 void
11074 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11075 {
11076   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11077
11078   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11079   htab->toc_bfd = NULL;
11080   htab->toc_first_sec = NULL;
11081 }
11082
11083 /* The linker repeatedly calls this function for each TOC input section
11084    and linker generated GOT section.  Group input bfds such that the toc
11085    within a group is less than 64k in size.  */
11086
11087 bfd_boolean
11088 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11089 {
11090   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11091   bfd_vma addr, off, limit;
11092
11093   if (htab == NULL)
11094     return FALSE;
11095
11096   if (!htab->second_toc_pass)
11097     {
11098       /* Keep track of the first .toc or .got section for this input bfd.  */
11099       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11100
11101       if (new_bfd)
11102         {
11103           htab->toc_bfd = isec->owner;
11104           htab->toc_first_sec = isec;
11105         }
11106
11107       addr = isec->output_offset + isec->output_section->vma;
11108       off = addr - htab->toc_curr;
11109       limit = 0x80008000;
11110       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11111         limit = 0x10000;
11112       if (off + isec->size > limit)
11113         {
11114           addr = (htab->toc_first_sec->output_offset
11115                   + htab->toc_first_sec->output_section->vma);
11116           htab->toc_curr = addr;
11117         }
11118
11119       /* toc_curr is the base address of this toc group.  Set elf_gp
11120          for the input section to be the offset relative to the
11121          output toc base plus 0x8000.  Making the input elf_gp an
11122          offset allows us to move the toc as a whole without
11123          recalculating input elf_gp.  */
11124       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11125       off += TOC_BASE_OFF;
11126
11127       /* Die if someone uses a linker script that doesn't keep input
11128          file .toc and .got together.  */
11129       if (new_bfd
11130           && elf_gp (isec->owner) != 0
11131           && elf_gp (isec->owner) != off)
11132         return FALSE;
11133
11134       elf_gp (isec->owner) = off;
11135       return TRUE;
11136     }
11137
11138   /* During the second pass toc_first_sec points to the start of
11139      a toc group, and toc_curr is used to track the old elf_gp.
11140      We use toc_bfd to ensure we only look at each bfd once.  */
11141   if (htab->toc_bfd == isec->owner)
11142     return TRUE;
11143   htab->toc_bfd = isec->owner;
11144
11145   if (htab->toc_first_sec == NULL
11146       || htab->toc_curr != elf_gp (isec->owner))
11147     {
11148       htab->toc_curr = elf_gp (isec->owner);
11149       htab->toc_first_sec = isec;
11150     }
11151   addr = (htab->toc_first_sec->output_offset
11152           + htab->toc_first_sec->output_section->vma);
11153   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11154   elf_gp (isec->owner) = off;
11155
11156   return TRUE;
11157 }
11158
11159 /* Called via elf_link_hash_traverse to merge GOT entries for global
11160    symbol H.  */
11161
11162 static bfd_boolean
11163 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11164 {
11165   if (h->root.type == bfd_link_hash_indirect)
11166     return TRUE;
11167
11168   merge_got_entries (&h->got.glist);
11169
11170   return TRUE;
11171 }
11172
11173 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11174    symbol H.  */
11175
11176 static bfd_boolean
11177 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11178 {
11179   struct got_entry *gent;
11180
11181   if (h->root.type == bfd_link_hash_indirect)
11182     return TRUE;
11183
11184   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11185     if (!gent->is_indirect)
11186       allocate_got (h, (struct bfd_link_info *) inf, gent);
11187   return TRUE;
11188 }
11189
11190 /* Called on the first multitoc pass after the last call to
11191    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11192    entries.  */
11193
11194 bfd_boolean
11195 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11196 {
11197   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11198   struct bfd *ibfd, *ibfd2;
11199   bfd_boolean done_something;
11200
11201   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11202
11203   if (!htab->do_multi_toc)
11204     return FALSE;
11205
11206   /* Merge global sym got entries within a toc group.  */
11207   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11208
11209   /* And tlsld_got.  */
11210   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11211     {
11212       struct got_entry *ent, *ent2;
11213
11214       if (!is_ppc64_elf (ibfd))
11215         continue;
11216
11217       ent = ppc64_tlsld_got (ibfd);
11218       if (!ent->is_indirect
11219           && ent->got.offset != (bfd_vma) -1)
11220         {
11221           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11222             {
11223               if (!is_ppc64_elf (ibfd2))
11224                 continue;
11225
11226               ent2 = ppc64_tlsld_got (ibfd2);
11227               if (!ent2->is_indirect
11228                   && ent2->got.offset != (bfd_vma) -1
11229                   && elf_gp (ibfd2) == elf_gp (ibfd))
11230                 {
11231                   ent2->is_indirect = TRUE;
11232                   ent2->got.ent = ent;
11233                 }
11234             }
11235         }
11236     }
11237
11238   /* Zap sizes of got sections.  */
11239   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11240   htab->elf.irelplt->size -= htab->got_reli_size;
11241   htab->got_reli_size = 0;
11242
11243   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11244     {
11245       asection *got, *relgot;
11246
11247       if (!is_ppc64_elf (ibfd))
11248         continue;
11249
11250       got = ppc64_elf_tdata (ibfd)->got;
11251       if (got != NULL)
11252         {
11253           got->rawsize = got->size;
11254           got->size = 0;
11255           relgot = ppc64_elf_tdata (ibfd)->relgot;
11256           relgot->rawsize = relgot->size;
11257           relgot->size = 0;
11258         }
11259     }
11260
11261   /* Now reallocate the got, local syms first.  We don't need to
11262      allocate section contents again since we never increase size.  */
11263   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11264     {
11265       struct got_entry **lgot_ents;
11266       struct got_entry **end_lgot_ents;
11267       struct plt_entry **local_plt;
11268       struct plt_entry **end_local_plt;
11269       unsigned char *lgot_masks;
11270       bfd_size_type locsymcount;
11271       Elf_Internal_Shdr *symtab_hdr;
11272       asection *s;
11273
11274       if (!is_ppc64_elf (ibfd))
11275         continue;
11276
11277       lgot_ents = elf_local_got_ents (ibfd);
11278       if (!lgot_ents)
11279         continue;
11280
11281       symtab_hdr = &elf_symtab_hdr (ibfd);
11282       locsymcount = symtab_hdr->sh_info;
11283       end_lgot_ents = lgot_ents + locsymcount;
11284       local_plt = (struct plt_entry **) end_lgot_ents;
11285       end_local_plt = local_plt + locsymcount;
11286       lgot_masks = (unsigned char *) end_local_plt;
11287       s = ppc64_elf_tdata (ibfd)->got;
11288       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11289         {
11290           struct got_entry *ent;
11291
11292           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11293             {
11294               unsigned int ent_size = 8;
11295               unsigned int rel_size = sizeof (Elf64_External_Rela);
11296
11297               ent->got.offset = s->size;
11298               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11299                 {
11300                   ent_size *= 2;
11301                   rel_size *= 2;
11302                 }
11303               s->size += ent_size;
11304               if ((*lgot_masks & PLT_IFUNC) != 0)
11305                 {
11306                   htab->elf.irelplt->size += rel_size;
11307                   htab->got_reli_size += rel_size;
11308                 }
11309               else if (info->shared)
11310                 {
11311                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11312                   srel->size += rel_size;
11313                 }
11314             }
11315         }
11316     }
11317
11318   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11319
11320   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11321     {
11322       struct got_entry *ent;
11323
11324       if (!is_ppc64_elf (ibfd))
11325         continue;
11326
11327       ent = ppc64_tlsld_got (ibfd);
11328       if (!ent->is_indirect
11329           && ent->got.offset != (bfd_vma) -1)
11330         {
11331           asection *s = ppc64_elf_tdata (ibfd)->got;
11332           ent->got.offset = s->size;
11333           s->size += 16;
11334           if (info->shared)
11335             {
11336               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11337               srel->size += sizeof (Elf64_External_Rela);
11338             }
11339         }
11340     }
11341
11342   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11343   if (!done_something)
11344     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11345       {
11346         asection *got;
11347
11348         if (!is_ppc64_elf (ibfd))
11349           continue;
11350
11351         got = ppc64_elf_tdata (ibfd)->got;
11352         if (got != NULL)
11353           {
11354             done_something = got->rawsize != got->size;
11355             if (done_something)
11356               break;
11357           }
11358       }
11359
11360   if (done_something)
11361     (*htab->layout_sections_again) ();
11362
11363   /* Set up for second pass over toc sections to recalculate elf_gp
11364      on input sections.  */
11365   htab->toc_bfd = NULL;
11366   htab->toc_first_sec = NULL;
11367   htab->second_toc_pass = TRUE;
11368   return done_something;
11369 }
11370
11371 /* Called after second pass of multitoc partitioning.  */
11372
11373 void
11374 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11375 {
11376   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11377
11378   /* After the second pass, toc_curr tracks the TOC offset used
11379      for code sections below in ppc64_elf_next_input_section.  */
11380   htab->toc_curr = TOC_BASE_OFF;
11381 }
11382
11383 /* No toc references were found in ISEC.  If the code in ISEC makes no
11384    calls, then there's no need to use toc adjusting stubs when branching
11385    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11386    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11387    needed, and 2 if a cyclical call-graph was found but no other reason
11388    for a stub was detected.  If called from the top level, a return of
11389    2 means the same as a return of 0.  */
11390
11391 static int
11392 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11393 {
11394   int ret;
11395
11396   /* Mark this section as checked.  */
11397   isec->call_check_done = 1;
11398
11399   /* We know none of our code bearing sections will need toc stubs.  */
11400   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11401     return 0;
11402
11403   if (isec->size == 0)
11404     return 0;
11405
11406   if (isec->output_section == NULL)
11407     return 0;
11408
11409   ret = 0;
11410   if (isec->reloc_count != 0)
11411     {
11412       Elf_Internal_Rela *relstart, *rel;
11413       Elf_Internal_Sym *local_syms;
11414       struct ppc_link_hash_table *htab;
11415
11416       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11417                                             info->keep_memory);
11418       if (relstart == NULL)
11419         return -1;
11420
11421       /* Look for branches to outside of this section.  */
11422       local_syms = NULL;
11423       htab = ppc_hash_table (info);
11424       if (htab == NULL)
11425         return -1;
11426
11427       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11428         {
11429           enum elf_ppc64_reloc_type r_type;
11430           unsigned long r_symndx;
11431           struct elf_link_hash_entry *h;
11432           struct ppc_link_hash_entry *eh;
11433           Elf_Internal_Sym *sym;
11434           asection *sym_sec;
11435           struct _opd_sec_data *opd;
11436           bfd_vma sym_value;
11437           bfd_vma dest;
11438
11439           r_type = ELF64_R_TYPE (rel->r_info);
11440           if (r_type != R_PPC64_REL24
11441               && r_type != R_PPC64_REL14
11442               && r_type != R_PPC64_REL14_BRTAKEN
11443               && r_type != R_PPC64_REL14_BRNTAKEN)
11444             continue;
11445
11446           r_symndx = ELF64_R_SYM (rel->r_info);
11447           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11448                           isec->owner))
11449             {
11450               ret = -1;
11451               break;
11452             }
11453
11454           /* Calls to dynamic lib functions go through a plt call stub
11455              that uses r2.  */
11456           eh = (struct ppc_link_hash_entry *) h;
11457           if (eh != NULL
11458               && (eh->elf.plt.plist != NULL
11459                   || (eh->oh != NULL
11460                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11461             {
11462               ret = 1;
11463               break;
11464             }
11465
11466           if (sym_sec == NULL)
11467             /* Ignore other undefined symbols.  */
11468             continue;
11469
11470           /* Assume branches to other sections not included in the
11471              link need stubs too, to cover -R and absolute syms.  */
11472           if (sym_sec->output_section == NULL)
11473             {
11474               ret = 1;
11475               break;
11476             }
11477
11478           if (h == NULL)
11479             sym_value = sym->st_value;
11480           else
11481             {
11482               if (h->root.type != bfd_link_hash_defined
11483                   && h->root.type != bfd_link_hash_defweak)
11484                 abort ();
11485               sym_value = h->root.u.def.value;
11486             }
11487           sym_value += rel->r_addend;
11488
11489           /* If this branch reloc uses an opd sym, find the code section.  */
11490           opd = get_opd_info (sym_sec);
11491           if (opd != NULL)
11492             {
11493               if (h == NULL && opd->adjust != NULL)
11494                 {
11495                   long adjust;
11496
11497                   adjust = opd->adjust[sym->st_value / 8];
11498                   if (adjust == -1)
11499                     /* Assume deleted functions won't ever be called.  */
11500                     continue;
11501                   sym_value += adjust;
11502                 }
11503
11504               dest = opd_entry_value (sym_sec, sym_value,
11505                                       &sym_sec, NULL, FALSE);
11506               if (dest == (bfd_vma) -1)
11507                 continue;
11508             }
11509           else
11510             dest = (sym_value
11511                     + sym_sec->output_offset
11512                     + sym_sec->output_section->vma);
11513
11514           /* Ignore branch to self.  */
11515           if (sym_sec == isec)
11516             continue;
11517
11518           /* If the called function uses the toc, we need a stub.  */
11519           if (sym_sec->has_toc_reloc
11520               || sym_sec->makes_toc_func_call)
11521             {
11522               ret = 1;
11523               break;
11524             }
11525
11526           /* Assume any branch that needs a long branch stub might in fact
11527              need a plt_branch stub.  A plt_branch stub uses r2.  */
11528           else if (dest - (isec->output_offset
11529                            + isec->output_section->vma
11530                            + rel->r_offset) + (1 << 25)
11531                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11532                                                              ? h->other
11533                                                              : sym->st_other))
11534             {
11535               ret = 1;
11536               break;
11537             }
11538
11539           /* If calling back to a section in the process of being
11540              tested, we can't say for sure that no toc adjusting stubs
11541              are needed, so don't return zero.  */
11542           else if (sym_sec->call_check_in_progress)
11543             ret = 2;
11544
11545           /* Branches to another section that itself doesn't have any TOC
11546              references are OK.  Recursively call ourselves to check.  */
11547           else if (!sym_sec->call_check_done)
11548             {
11549               int recur;
11550
11551               /* Mark current section as indeterminate, so that other
11552                  sections that call back to current won't be marked as
11553                  known.  */
11554               isec->call_check_in_progress = 1;
11555               recur = toc_adjusting_stub_needed (info, sym_sec);
11556               isec->call_check_in_progress = 0;
11557
11558               if (recur != 0)
11559                 {
11560                   ret = recur;
11561                   if (recur != 2)
11562                     break;
11563                 }
11564             }
11565         }
11566
11567       if (local_syms != NULL
11568           && (elf_symtab_hdr (isec->owner).contents
11569               != (unsigned char *) local_syms))
11570         free (local_syms);
11571       if (elf_section_data (isec)->relocs != relstart)
11572         free (relstart);
11573     }
11574
11575   if ((ret & 1) == 0
11576       && isec->map_head.s != NULL
11577       && (strcmp (isec->output_section->name, ".init") == 0
11578           || strcmp (isec->output_section->name, ".fini") == 0))
11579     {
11580       if (isec->map_head.s->has_toc_reloc
11581           || isec->map_head.s->makes_toc_func_call)
11582         ret = 1;
11583       else if (!isec->map_head.s->call_check_done)
11584         {
11585           int recur;
11586           isec->call_check_in_progress = 1;
11587           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11588           isec->call_check_in_progress = 0;
11589           if (recur != 0)
11590             ret = recur;
11591         }
11592     }
11593
11594   if (ret == 1)
11595     isec->makes_toc_func_call = 1;
11596
11597   return ret;
11598 }
11599
11600 /* The linker repeatedly calls this function for each input section,
11601    in the order that input sections are linked into output sections.
11602    Build lists of input sections to determine groupings between which
11603    we may insert linker stubs.  */
11604
11605 bfd_boolean
11606 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11607 {
11608   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11609
11610   if (htab == NULL)
11611     return FALSE;
11612
11613   if ((isec->output_section->flags & SEC_CODE) != 0
11614       && isec->output_section->index <= htab->top_index)
11615     {
11616       asection **list = htab->input_list + isec->output_section->index;
11617       /* Steal the link_sec pointer for our list.  */
11618 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11619       /* This happens to make the list in reverse order,
11620          which is what we want.  */
11621       PREV_SEC (isec) = *list;
11622       *list = isec;
11623     }
11624
11625   if (htab->multi_toc_needed)
11626     {
11627       /* Analyse sections that aren't already flagged as needing a
11628          valid toc pointer.  Exclude .fixup for the linux kernel.
11629          .fixup contains branches, but only back to the function that
11630          hit an exception.  */
11631       if (!(isec->has_toc_reloc
11632             || (isec->flags & SEC_CODE) == 0
11633             || strcmp (isec->name, ".fixup") == 0
11634             || isec->call_check_done))
11635         {
11636           if (toc_adjusting_stub_needed (info, isec) < 0)
11637             return FALSE;
11638         }
11639       /* Make all sections use the TOC assigned for this object file.
11640          This will be wrong for pasted sections;  We fix that in
11641          check_pasted_section().  */
11642       if (elf_gp (isec->owner) != 0)
11643         htab->toc_curr = elf_gp (isec->owner);
11644     }
11645
11646   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11647   return TRUE;
11648 }
11649
11650 /* Check that all .init and .fini sections use the same toc, if they
11651    have toc relocs.  */
11652
11653 static bfd_boolean
11654 check_pasted_section (struct bfd_link_info *info, const char *name)
11655 {
11656   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11657
11658   if (o != NULL)
11659     {
11660       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11661       bfd_vma toc_off = 0;
11662       asection *i;
11663
11664       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11665         if (i->has_toc_reloc)
11666           {
11667             if (toc_off == 0)
11668               toc_off = htab->stub_group[i->id].toc_off;
11669             else if (toc_off != htab->stub_group[i->id].toc_off)
11670               return FALSE;
11671           }
11672
11673       if (toc_off == 0)
11674         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11675           if (i->makes_toc_func_call)
11676             {
11677               toc_off = htab->stub_group[i->id].toc_off;
11678               break;
11679             }
11680
11681       /* Make sure the whole pasted function uses the same toc offset.  */
11682       if (toc_off != 0)
11683         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11684           htab->stub_group[i->id].toc_off = toc_off;
11685     }
11686   return TRUE;
11687 }
11688
11689 bfd_boolean
11690 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11691 {
11692   return (check_pasted_section (info, ".init")
11693           & check_pasted_section (info, ".fini"));
11694 }
11695
11696 /* See whether we can group stub sections together.  Grouping stub
11697    sections may result in fewer stubs.  More importantly, we need to
11698    put all .init* and .fini* stubs at the beginning of the .init or
11699    .fini output sections respectively, because glibc splits the
11700    _init and _fini functions into multiple parts.  Putting a stub in
11701    the middle of a function is not a good idea.  */
11702
11703 static void
11704 group_sections (struct ppc_link_hash_table *htab,
11705                 bfd_size_type stub_group_size,
11706                 bfd_boolean stubs_always_before_branch)
11707 {
11708   asection **list;
11709   bfd_size_type stub14_group_size;
11710   bfd_boolean suppress_size_errors;
11711
11712   suppress_size_errors = FALSE;
11713   stub14_group_size = stub_group_size;
11714   if (stub_group_size == 1)
11715     {
11716       /* Default values.  */
11717       if (stubs_always_before_branch)
11718         {
11719           stub_group_size = 0x1e00000;
11720           stub14_group_size = 0x7800;
11721         }
11722       else
11723         {
11724           stub_group_size = 0x1c00000;
11725           stub14_group_size = 0x7000;
11726         }
11727       suppress_size_errors = TRUE;
11728     }
11729
11730   list = htab->input_list + htab->top_index;
11731   do
11732     {
11733       asection *tail = *list;
11734       while (tail != NULL)
11735         {
11736           asection *curr;
11737           asection *prev;
11738           bfd_size_type total;
11739           bfd_boolean big_sec;
11740           bfd_vma curr_toc;
11741
11742           curr = tail;
11743           total = tail->size;
11744           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11745                              && ppc64_elf_section_data (tail)->has_14bit_branch
11746                              ? stub14_group_size : stub_group_size);
11747           if (big_sec && !suppress_size_errors)
11748             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11749                                      tail->owner, tail);
11750           curr_toc = htab->stub_group[tail->id].toc_off;
11751
11752           while ((prev = PREV_SEC (curr)) != NULL
11753                  && ((total += curr->output_offset - prev->output_offset)
11754                      < (ppc64_elf_section_data (prev) != NULL
11755                         && ppc64_elf_section_data (prev)->has_14bit_branch
11756                         ? stub14_group_size : stub_group_size))
11757                  && htab->stub_group[prev->id].toc_off == curr_toc)
11758             curr = prev;
11759
11760           /* OK, the size from the start of CURR to the end is less
11761              than stub_group_size and thus can be handled by one stub
11762              section.  (or the tail section is itself larger than
11763              stub_group_size, in which case we may be toast.)  We
11764              should really be keeping track of the total size of stubs
11765              added here, as stubs contribute to the final output
11766              section size.  That's a little tricky, and this way will
11767              only break if stubs added make the total size more than
11768              2^25, ie. for the default stub_group_size, if stubs total
11769              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11770           do
11771             {
11772               prev = PREV_SEC (tail);
11773               /* Set up this stub group.  */
11774               htab->stub_group[tail->id].link_sec = curr;
11775             }
11776           while (tail != curr && (tail = prev) != NULL);
11777
11778           /* But wait, there's more!  Input sections up to stub_group_size
11779              bytes before the stub section can be handled by it too.
11780              Don't do this if we have a really large section after the
11781              stubs, as adding more stubs increases the chance that
11782              branches may not reach into the stub section.  */
11783           if (!stubs_always_before_branch && !big_sec)
11784             {
11785               total = 0;
11786               while (prev != NULL
11787                      && ((total += tail->output_offset - prev->output_offset)
11788                          < (ppc64_elf_section_data (prev) != NULL
11789                             && ppc64_elf_section_data (prev)->has_14bit_branch
11790                             ? stub14_group_size : stub_group_size))
11791                      && htab->stub_group[prev->id].toc_off == curr_toc)
11792                 {
11793                   tail = prev;
11794                   prev = PREV_SEC (tail);
11795                   htab->stub_group[tail->id].link_sec = curr;
11796                 }
11797             }
11798           tail = prev;
11799         }
11800     }
11801   while (list-- != htab->input_list);
11802   free (htab->input_list);
11803 #undef PREV_SEC
11804 }
11805
11806 static const unsigned char glink_eh_frame_cie[] =
11807 {
11808   0, 0, 0, 16,                          /* length.  */
11809   0, 0, 0, 0,                           /* id.  */
11810   1,                                    /* CIE version.  */
11811   'z', 'R', 0,                          /* Augmentation string.  */
11812   4,                                    /* Code alignment.  */
11813   0x78,                                 /* Data alignment.  */
11814   65,                                   /* RA reg.  */
11815   1,                                    /* Augmentation size.  */
11816   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11817   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11818 };
11819
11820 /* Stripping output sections is normally done before dynamic section
11821    symbols have been allocated.  This function is called later, and
11822    handles cases like htab->brlt which is mapped to its own output
11823    section.  */
11824
11825 static void
11826 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11827 {
11828   if (isec->size == 0
11829       && isec->output_section->size == 0
11830       && !(isec->output_section->flags & SEC_KEEP)
11831       && !bfd_section_removed_from_list (info->output_bfd,
11832                                          isec->output_section)
11833       && elf_section_data (isec->output_section)->dynindx == 0)
11834     {
11835       isec->output_section->flags |= SEC_EXCLUDE;
11836       bfd_section_list_remove (info->output_bfd, isec->output_section);
11837       info->output_bfd->section_count--;
11838     }
11839 }
11840
11841 /* Determine and set the size of the stub section for a final link.
11842
11843    The basic idea here is to examine all the relocations looking for
11844    PC-relative calls to a target that is unreachable with a "bl"
11845    instruction.  */
11846
11847 bfd_boolean
11848 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11849                       bfd_boolean plt_static_chain, int plt_thread_safe,
11850                       int plt_stub_align)
11851 {
11852   bfd_size_type stub_group_size;
11853   bfd_boolean stubs_always_before_branch;
11854   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11855
11856   if (htab == NULL)
11857     return FALSE;
11858
11859   htab->plt_static_chain = plt_static_chain;
11860   htab->plt_stub_align = plt_stub_align;
11861   if (plt_thread_safe == -1 && !info->executable)
11862     plt_thread_safe = 1;
11863   if (!htab->opd_abi)
11864     plt_thread_safe = 0;
11865   else if (plt_thread_safe == -1)
11866     {
11867       static const char *const thread_starter[] =
11868         {
11869           "pthread_create",
11870           /* libstdc++ */
11871           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11872           /* librt */
11873           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11874           "mq_notify", "create_timer",
11875           /* libanl */
11876           "getaddrinfo_a",
11877           /* libgomp */
11878           "GOMP_parallel_start",
11879           "GOMP_parallel_loop_static_start",
11880           "GOMP_parallel_loop_dynamic_start",
11881           "GOMP_parallel_loop_guided_start",
11882           "GOMP_parallel_loop_runtime_start",
11883           "GOMP_parallel_sections_start",
11884         };
11885       unsigned i;
11886
11887       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11888         {
11889           struct elf_link_hash_entry *h;
11890           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11891                                     FALSE, FALSE, TRUE);
11892           plt_thread_safe = h != NULL && h->ref_regular;
11893           if (plt_thread_safe)
11894             break;
11895         }
11896     }
11897   htab->plt_thread_safe = plt_thread_safe;
11898   stubs_always_before_branch = group_size < 0;
11899   if (group_size < 0)
11900     stub_group_size = -group_size;
11901   else
11902     stub_group_size = group_size;
11903
11904   group_sections (htab, stub_group_size, stubs_always_before_branch);
11905
11906   while (1)
11907     {
11908       bfd *input_bfd;
11909       unsigned int bfd_indx;
11910       asection *stub_sec;
11911
11912       htab->stub_iteration += 1;
11913
11914       for (input_bfd = info->input_bfds, bfd_indx = 0;
11915            input_bfd != NULL;
11916            input_bfd = input_bfd->link_next, bfd_indx++)
11917         {
11918           Elf_Internal_Shdr *symtab_hdr;
11919           asection *section;
11920           Elf_Internal_Sym *local_syms = NULL;
11921
11922           if (!is_ppc64_elf (input_bfd))
11923             continue;
11924
11925           /* We'll need the symbol table in a second.  */
11926           symtab_hdr = &elf_symtab_hdr (input_bfd);
11927           if (symtab_hdr->sh_info == 0)
11928             continue;
11929
11930           /* Walk over each section attached to the input bfd.  */
11931           for (section = input_bfd->sections;
11932                section != NULL;
11933                section = section->next)
11934             {
11935               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11936
11937               /* If there aren't any relocs, then there's nothing more
11938                  to do.  */
11939               if ((section->flags & SEC_RELOC) == 0
11940                   || (section->flags & SEC_ALLOC) == 0
11941                   || (section->flags & SEC_LOAD) == 0
11942                   || (section->flags & SEC_CODE) == 0
11943                   || section->reloc_count == 0)
11944                 continue;
11945
11946               /* If this section is a link-once section that will be
11947                  discarded, then don't create any stubs.  */
11948               if (section->output_section == NULL
11949                   || section->output_section->owner != info->output_bfd)
11950                 continue;
11951
11952               /* Get the relocs.  */
11953               internal_relocs
11954                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11955                                              info->keep_memory);
11956               if (internal_relocs == NULL)
11957                 goto error_ret_free_local;
11958
11959               /* Now examine each relocation.  */
11960               irela = internal_relocs;
11961               irelaend = irela + section->reloc_count;
11962               for (; irela < irelaend; irela++)
11963                 {
11964                   enum elf_ppc64_reloc_type r_type;
11965                   unsigned int r_indx;
11966                   enum ppc_stub_type stub_type;
11967                   struct ppc_stub_hash_entry *stub_entry;
11968                   asection *sym_sec, *code_sec;
11969                   bfd_vma sym_value, code_value;
11970                   bfd_vma destination;
11971                   unsigned long local_off;
11972                   bfd_boolean ok_dest;
11973                   struct ppc_link_hash_entry *hash;
11974                   struct ppc_link_hash_entry *fdh;
11975                   struct elf_link_hash_entry *h;
11976                   Elf_Internal_Sym *sym;
11977                   char *stub_name;
11978                   const asection *id_sec;
11979                   struct _opd_sec_data *opd;
11980                   struct plt_entry *plt_ent;
11981
11982                   r_type = ELF64_R_TYPE (irela->r_info);
11983                   r_indx = ELF64_R_SYM (irela->r_info);
11984
11985                   if (r_type >= R_PPC64_max)
11986                     {
11987                       bfd_set_error (bfd_error_bad_value);
11988                       goto error_ret_free_internal;
11989                     }
11990
11991                   /* Only look for stubs on branch instructions.  */
11992                   if (r_type != R_PPC64_REL24
11993                       && r_type != R_PPC64_REL14
11994                       && r_type != R_PPC64_REL14_BRTAKEN
11995                       && r_type != R_PPC64_REL14_BRNTAKEN)
11996                     continue;
11997
11998                   /* Now determine the call target, its name, value,
11999                      section.  */
12000                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12001                                   r_indx, input_bfd))
12002                     goto error_ret_free_internal;
12003                   hash = (struct ppc_link_hash_entry *) h;
12004
12005                   ok_dest = FALSE;
12006                   fdh = NULL;
12007                   sym_value = 0;
12008                   if (hash == NULL)
12009                     {
12010                       sym_value = sym->st_value;
12011                       ok_dest = TRUE;
12012                     }
12013                   else if (hash->elf.root.type == bfd_link_hash_defined
12014                            || hash->elf.root.type == bfd_link_hash_defweak)
12015                     {
12016                       sym_value = hash->elf.root.u.def.value;
12017                       if (sym_sec->output_section != NULL)
12018                         ok_dest = TRUE;
12019                     }
12020                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12021                            || hash->elf.root.type == bfd_link_hash_undefined)
12022                     {
12023                       /* Recognise an old ABI func code entry sym, and
12024                          use the func descriptor sym instead if it is
12025                          defined.  */
12026                       if (hash->elf.root.root.string[0] == '.'
12027                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12028                         {
12029                           if (fdh->elf.root.type == bfd_link_hash_defined
12030                               || fdh->elf.root.type == bfd_link_hash_defweak)
12031                             {
12032                               sym_sec = fdh->elf.root.u.def.section;
12033                               sym_value = fdh->elf.root.u.def.value;
12034                               if (sym_sec->output_section != NULL)
12035                                 ok_dest = TRUE;
12036                             }
12037                           else
12038                             fdh = NULL;
12039                         }
12040                     }
12041                   else
12042                     {
12043                       bfd_set_error (bfd_error_bad_value);
12044                       goto error_ret_free_internal;
12045                     }
12046
12047                   destination = 0;
12048                   local_off = 0;
12049                   if (ok_dest)
12050                     {
12051                       sym_value += irela->r_addend;
12052                       destination = (sym_value
12053                                      + sym_sec->output_offset
12054                                      + sym_sec->output_section->vma);
12055                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12056                                                             ? hash->elf.other
12057                                                             : sym->st_other);
12058                     }
12059
12060                   code_sec = sym_sec;
12061                   code_value = sym_value;
12062                   opd = get_opd_info (sym_sec);
12063                   if (opd != NULL)
12064                     {
12065                       bfd_vma dest;
12066
12067                       if (hash == NULL && opd->adjust != NULL)
12068                         {
12069                           long adjust = opd->adjust[sym_value / 8];
12070                           if (adjust == -1)
12071                             continue;
12072                           code_value += adjust;
12073                           sym_value += adjust;
12074                         }
12075                       dest = opd_entry_value (sym_sec, sym_value,
12076                                               &code_sec, &code_value, FALSE);
12077                       if (dest != (bfd_vma) -1)
12078                         {
12079                           destination = dest;
12080                           if (fdh != NULL)
12081                             {
12082                               /* Fixup old ABI sym to point at code
12083                                  entry.  */
12084                               hash->elf.root.type = bfd_link_hash_defweak;
12085                               hash->elf.root.u.def.section = code_sec;
12086                               hash->elf.root.u.def.value = code_value;
12087                             }
12088                         }
12089                     }
12090
12091                   /* Determine what (if any) linker stub is needed.  */
12092                   plt_ent = NULL;
12093                   stub_type = ppc_type_of_stub (section, irela, &hash,
12094                                                 &plt_ent, destination,
12095                                                 local_off);
12096
12097                   if (stub_type != ppc_stub_plt_call)
12098                     {
12099                       /* Check whether we need a TOC adjusting stub.
12100                          Since the linker pastes together pieces from
12101                          different object files when creating the
12102                          _init and _fini functions, it may be that a
12103                          call to what looks like a local sym is in
12104                          fact a call needing a TOC adjustment.  */
12105                       if (code_sec != NULL
12106                           && code_sec->output_section != NULL
12107                           && (htab->stub_group[code_sec->id].toc_off
12108                               != htab->stub_group[section->id].toc_off)
12109                           && (code_sec->has_toc_reloc
12110                               || code_sec->makes_toc_func_call))
12111                         stub_type = ppc_stub_long_branch_r2off;
12112                     }
12113
12114                   if (stub_type == ppc_stub_none)
12115                     continue;
12116
12117                   /* __tls_get_addr calls might be eliminated.  */
12118                   if (stub_type != ppc_stub_plt_call
12119                       && hash != NULL
12120                       && (hash == htab->tls_get_addr
12121                           || hash == htab->tls_get_addr_fd)
12122                       && section->has_tls_reloc
12123                       && irela != internal_relocs)
12124                     {
12125                       /* Get tls info.  */
12126                       unsigned char *tls_mask;
12127
12128                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12129                                          irela - 1, input_bfd))
12130                         goto error_ret_free_internal;
12131                       if (*tls_mask != 0)
12132                         continue;
12133                     }
12134
12135                   if (stub_type == ppc_stub_plt_call
12136                       && irela + 1 < irelaend
12137                       && irela[1].r_offset == irela->r_offset + 4
12138                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12139                     {
12140                       if (!tocsave_find (htab, INSERT,
12141                                          &local_syms, irela + 1, input_bfd))
12142                         goto error_ret_free_internal;
12143                     }
12144                   else if (stub_type == ppc_stub_plt_call)
12145                     stub_type = ppc_stub_plt_call_r2save;
12146
12147                   /* Support for grouping stub sections.  */
12148                   id_sec = htab->stub_group[section->id].link_sec;
12149
12150                   /* Get the name of this stub.  */
12151                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12152                   if (!stub_name)
12153                     goto error_ret_free_internal;
12154
12155                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12156                                                      stub_name, FALSE, FALSE);
12157                   if (stub_entry != NULL)
12158                     {
12159                       /* The proper stub has already been created.  */
12160                       free (stub_name);
12161                       if (stub_type == ppc_stub_plt_call_r2save)
12162                         stub_entry->stub_type = stub_type;
12163                       continue;
12164                     }
12165
12166                   stub_entry = ppc_add_stub (stub_name, section, info);
12167                   if (stub_entry == NULL)
12168                     {
12169                       free (stub_name);
12170                     error_ret_free_internal:
12171                       if (elf_section_data (section)->relocs == NULL)
12172                         free (internal_relocs);
12173                     error_ret_free_local:
12174                       if (local_syms != NULL
12175                           && (symtab_hdr->contents
12176                               != (unsigned char *) local_syms))
12177                         free (local_syms);
12178                       return FALSE;
12179                     }
12180
12181                   stub_entry->stub_type = stub_type;
12182                   if (stub_type != ppc_stub_plt_call
12183                       && stub_type != ppc_stub_plt_call_r2save)
12184                     {
12185                       stub_entry->target_value = code_value;
12186                       stub_entry->target_section = code_sec;
12187                     }
12188                   else
12189                     {
12190                       stub_entry->target_value = sym_value;
12191                       stub_entry->target_section = sym_sec;
12192                     }
12193                   stub_entry->h = hash;
12194                   stub_entry->plt_ent = plt_ent;
12195                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12196
12197                   if (stub_entry->h != NULL)
12198                     htab->stub_globals += 1;
12199                 }
12200
12201               /* We're done with the internal relocs, free them.  */
12202               if (elf_section_data (section)->relocs != internal_relocs)
12203                 free (internal_relocs);
12204             }
12205
12206           if (local_syms != NULL
12207               && symtab_hdr->contents != (unsigned char *) local_syms)
12208             {
12209               if (!info->keep_memory)
12210                 free (local_syms);
12211               else
12212                 symtab_hdr->contents = (unsigned char *) local_syms;
12213             }
12214         }
12215
12216       /* We may have added some stubs.  Find out the new size of the
12217          stub sections.  */
12218       for (stub_sec = htab->stub_bfd->sections;
12219            stub_sec != NULL;
12220            stub_sec = stub_sec->next)
12221         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12222           {
12223             stub_sec->rawsize = stub_sec->size;
12224             stub_sec->size = 0;
12225             stub_sec->reloc_count = 0;
12226             stub_sec->flags &= ~SEC_RELOC;
12227           }
12228
12229       htab->brlt->size = 0;
12230       htab->brlt->reloc_count = 0;
12231       htab->brlt->flags &= ~SEC_RELOC;
12232       if (htab->relbrlt != NULL)
12233         htab->relbrlt->size = 0;
12234
12235       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12236
12237       if (info->emitrelocations
12238           && htab->glink != NULL && htab->glink->size != 0)
12239         {
12240           htab->glink->reloc_count = 1;
12241           htab->glink->flags |= SEC_RELOC;
12242         }
12243
12244       if (htab->glink_eh_frame != NULL
12245           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12246           && htab->glink_eh_frame->output_section->size != 0)
12247         {
12248           size_t size = 0, align;
12249
12250           for (stub_sec = htab->stub_bfd->sections;
12251                stub_sec != NULL;
12252                stub_sec = stub_sec->next)
12253             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12254               size += 20;
12255           if (htab->glink != NULL && htab->glink->size != 0)
12256             size += 24;
12257           if (size != 0)
12258             size += sizeof (glink_eh_frame_cie);
12259           align = 1;
12260           align <<= htab->glink_eh_frame->output_section->alignment_power;
12261           align -= 1;
12262           size = (size + align) & ~align;
12263           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12264           htab->glink_eh_frame->size = size;
12265         }
12266
12267       if (htab->plt_stub_align != 0)
12268         for (stub_sec = htab->stub_bfd->sections;
12269              stub_sec != NULL;
12270              stub_sec = stub_sec->next)
12271           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12272             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12273                               & (-1 << htab->plt_stub_align));
12274
12275       for (stub_sec = htab->stub_bfd->sections;
12276            stub_sec != NULL;
12277            stub_sec = stub_sec->next)
12278         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12279             && stub_sec->rawsize != stub_sec->size)
12280           break;
12281
12282       /* Exit from this loop when no stubs have been added, and no stubs
12283          have changed size.  */
12284       if (stub_sec == NULL
12285           && (htab->glink_eh_frame == NULL
12286               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12287         break;
12288
12289       /* Ask the linker to do its stuff.  */
12290       (*htab->layout_sections_again) ();
12291     }
12292
12293   maybe_strip_output (info, htab->brlt);
12294   if (htab->glink_eh_frame != NULL)
12295     maybe_strip_output (info, htab->glink_eh_frame);
12296
12297   return TRUE;
12298 }
12299
12300 /* Called after we have determined section placement.  If sections
12301    move, we'll be called again.  Provide a value for TOCstart.  */
12302
12303 bfd_vma
12304 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12305 {
12306   asection *s;
12307   bfd_vma TOCstart;
12308
12309   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12310      order.  The TOC starts where the first of these sections starts.  */
12311   s = bfd_get_section_by_name (obfd, ".got");
12312   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12313     s = bfd_get_section_by_name (obfd, ".toc");
12314   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12315     s = bfd_get_section_by_name (obfd, ".tocbss");
12316   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12317     s = bfd_get_section_by_name (obfd, ".plt");
12318   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12319     {
12320       /* This may happen for
12321          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12322          .toc directive
12323          o  bad linker script
12324          o --gc-sections and empty TOC sections
12325
12326          FIXME: Warn user?  */
12327
12328       /* Look for a likely section.  We probably won't even be
12329          using TOCstart.  */
12330       for (s = obfd->sections; s != NULL; s = s->next)
12331         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12332                          | SEC_EXCLUDE))
12333             == (SEC_ALLOC | SEC_SMALL_DATA))
12334           break;
12335       if (s == NULL)
12336         for (s = obfd->sections; s != NULL; s = s->next)
12337           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12338               == (SEC_ALLOC | SEC_SMALL_DATA))
12339             break;
12340       if (s == NULL)
12341         for (s = obfd->sections; s != NULL; s = s->next)
12342           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12343               == SEC_ALLOC)
12344             break;
12345       if (s == NULL)
12346         for (s = obfd->sections; s != NULL; s = s->next)
12347           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12348             break;
12349     }
12350
12351   TOCstart = 0;
12352   if (s != NULL)
12353     TOCstart = s->output_section->vma + s->output_offset;
12354
12355   _bfd_set_gp_value (obfd, TOCstart);
12356
12357   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12358     {
12359       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12360
12361       if (htab != NULL
12362           && htab->elf.hgot != NULL)
12363         {
12364           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12365           htab->elf.hgot->root.u.def.section = s;
12366         }
12367     }
12368   return TOCstart;
12369 }
12370
12371 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12372    write out any global entry stubs.  */
12373
12374 static bfd_boolean
12375 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12376 {
12377   struct bfd_link_info *info;
12378   struct ppc_link_hash_table *htab;
12379   struct plt_entry *pent;
12380   asection *s;
12381
12382   if (h->root.type == bfd_link_hash_indirect)
12383     return TRUE;
12384
12385   if (!h->pointer_equality_needed)
12386     return TRUE;
12387
12388   if (h->def_regular)
12389     return TRUE;
12390
12391   info = inf;
12392   htab = ppc_hash_table (info);
12393   if (htab == NULL)
12394     return FALSE;
12395
12396   s = htab->glink;
12397   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12398     if (pent->plt.offset != (bfd_vma) -1
12399         && pent->addend == 0)
12400       {
12401         bfd_byte *p;
12402         asection *plt;
12403         bfd_vma off;
12404
12405         p = s->contents + h->root.u.def.value;
12406         plt = htab->elf.splt;
12407         if (!htab->elf.dynamic_sections_created
12408             || h->dynindx == -1)
12409           plt = htab->elf.iplt;
12410         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12411         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12412
12413         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12414           {
12415             info->callbacks->einfo
12416               (_("%P: linkage table error against `%T'\n"),
12417                h->root.root.string);
12418             bfd_set_error (bfd_error_bad_value);
12419             htab->stub_error = TRUE;
12420           }
12421
12422         if (PPC_HA (off) != 0)
12423           {
12424             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12425             p += 4;
12426           }
12427         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12428         p += 4;
12429         bfd_put_32 (s->owner, MTCTR_R12, p);
12430         p += 4;
12431         bfd_put_32 (s->owner, BCTR, p);
12432         break;
12433       }
12434   return TRUE;
12435 }
12436
12437 /* Build all the stubs associated with the current output file.
12438    The stubs are kept in a hash table attached to the main linker
12439    hash table.  This function is called via gldelf64ppc_finish.  */
12440
12441 bfd_boolean
12442 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12443                        struct bfd_link_info *info,
12444                        char **stats)
12445 {
12446   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12447   asection *stub_sec;
12448   bfd_byte *p;
12449   int stub_sec_count = 0;
12450
12451   if (htab == NULL)
12452     return FALSE;
12453
12454   htab->emit_stub_syms = emit_stub_syms;
12455
12456   /* Allocate memory to hold the linker stubs.  */
12457   for (stub_sec = htab->stub_bfd->sections;
12458        stub_sec != NULL;
12459        stub_sec = stub_sec->next)
12460     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12461         && stub_sec->size != 0)
12462       {
12463         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12464         if (stub_sec->contents == NULL)
12465           return FALSE;
12466         /* We want to check that built size is the same as calculated
12467            size.  rawsize is a convenient location to use.  */
12468         stub_sec->rawsize = stub_sec->size;
12469         stub_sec->size = 0;
12470       }
12471
12472   if (htab->glink != NULL && htab->glink->size != 0)
12473     {
12474       unsigned int indx;
12475       bfd_vma plt0;
12476
12477       /* Build the .glink plt call stub.  */
12478       if (htab->emit_stub_syms)
12479         {
12480           struct elf_link_hash_entry *h;
12481           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12482                                     TRUE, FALSE, FALSE);
12483           if (h == NULL)
12484             return FALSE;
12485           if (h->root.type == bfd_link_hash_new)
12486             {
12487               h->root.type = bfd_link_hash_defined;
12488               h->root.u.def.section = htab->glink;
12489               h->root.u.def.value = 8;
12490               h->ref_regular = 1;
12491               h->def_regular = 1;
12492               h->ref_regular_nonweak = 1;
12493               h->forced_local = 1;
12494               h->non_elf = 0;
12495             }
12496         }
12497       plt0 = (htab->elf.splt->output_section->vma
12498               + htab->elf.splt->output_offset
12499               - 16);
12500       if (info->emitrelocations)
12501         {
12502           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12503           if (r == NULL)
12504             return FALSE;
12505           r->r_offset = (htab->glink->output_offset
12506                          + htab->glink->output_section->vma);
12507           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12508           r->r_addend = plt0;
12509         }
12510       p = htab->glink->contents;
12511       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12512       bfd_put_64 (htab->glink->owner, plt0, p);
12513       p += 8;
12514       if (htab->opd_abi)
12515         {
12516           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12517           p += 4;
12518           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12519           p += 4;
12520           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12521           p += 4;
12522           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12523           p += 4;
12524           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12525           p += 4;
12526           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12527           p += 4;
12528           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12529           p += 4;
12530           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12531           p += 4;
12532           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12533           p += 4;
12534           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12535           p += 4;
12536         }
12537       else
12538         {
12539           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12540           p += 4;
12541           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12542           p += 4;
12543           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12544           p += 4;
12545           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12546           p += 4;
12547           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12548           p += 4;
12549           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12550           p += 4;
12551           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12552           p += 4;
12553           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12554           p += 4;
12555           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12556           p += 4;
12557           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12558           p += 4;
12559           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12560           p += 4;
12561           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12562           p += 4;
12563         }
12564       bfd_put_32 (htab->glink->owner, BCTR, p);
12565       p += 4;
12566       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12567         {
12568           bfd_put_32 (htab->glink->owner, NOP, p);
12569           p += 4;
12570         }
12571
12572       /* Build the .glink lazy link call stubs.  */
12573       indx = 0;
12574       while (p < htab->glink->contents + htab->glink->rawsize)
12575         {
12576           if (htab->opd_abi)
12577             {
12578               if (indx < 0x8000)
12579                 {
12580                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12581                   p += 4;
12582                 }
12583               else
12584                 {
12585                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12586                   p += 4;
12587                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12588                               p);
12589                   p += 4;
12590                 }
12591             }
12592           bfd_put_32 (htab->glink->owner,
12593                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12594           indx++;
12595           p += 4;
12596         }
12597
12598       /* Build .glink global entry stubs.  */
12599       if (htab->glink->size > htab->glink->rawsize)
12600         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12601     }
12602
12603   if (htab->brlt->size != 0)
12604     {
12605       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12606                                          htab->brlt->size);
12607       if (htab->brlt->contents == NULL)
12608         return FALSE;
12609     }
12610   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12611     {
12612       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12613                                             htab->relbrlt->size);
12614       if (htab->relbrlt->contents == NULL)
12615         return FALSE;
12616     }
12617
12618   if (htab->glink_eh_frame != NULL
12619       && htab->glink_eh_frame->size != 0)
12620     {
12621       bfd_vma val;
12622       bfd_byte *last_fde;
12623       size_t last_fde_len, size, align, pad;
12624
12625       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12626       if (p == NULL)
12627         return FALSE;
12628       htab->glink_eh_frame->contents = p;
12629       last_fde = p;
12630
12631       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12632
12633       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12634       /* CIE length (rewrite in case little-endian).  */
12635       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12636       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12637       p += sizeof (glink_eh_frame_cie);
12638
12639       for (stub_sec = htab->stub_bfd->sections;
12640            stub_sec != NULL;
12641            stub_sec = stub_sec->next)
12642         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12643           {
12644             last_fde = p;
12645             last_fde_len = 16;
12646             /* FDE length.  */
12647             bfd_put_32 (htab->elf.dynobj, 16, p);
12648             p += 4;
12649             /* CIE pointer.  */
12650             val = p - htab->glink_eh_frame->contents;
12651             bfd_put_32 (htab->elf.dynobj, val, p);
12652             p += 4;
12653             /* Offset to stub section.  */
12654             val = (stub_sec->output_section->vma
12655                    + stub_sec->output_offset);
12656             val -= (htab->glink_eh_frame->output_section->vma
12657                     + htab->glink_eh_frame->output_offset);
12658             val -= p - htab->glink_eh_frame->contents;
12659             if (val + 0x80000000 > 0xffffffff)
12660               {
12661                 info->callbacks->einfo
12662                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12663                    stub_sec->name);
12664                 return FALSE;
12665               }
12666             bfd_put_32 (htab->elf.dynobj, val, p);
12667             p += 4;
12668             /* stub section size.  */
12669             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12670             p += 4;
12671             /* Augmentation.  */
12672             p += 1;
12673             /* Pad.  */
12674             p += 3;
12675           }
12676       if (htab->glink != NULL && htab->glink->size != 0)
12677         {
12678           last_fde = p;
12679           last_fde_len = 20;
12680           /* FDE length.  */
12681           bfd_put_32 (htab->elf.dynobj, 20, p);
12682           p += 4;
12683           /* CIE pointer.  */
12684           val = p - htab->glink_eh_frame->contents;
12685           bfd_put_32 (htab->elf.dynobj, val, p);
12686           p += 4;
12687           /* Offset to .glink.  */
12688           val = (htab->glink->output_section->vma
12689                  + htab->glink->output_offset
12690                  + 8);
12691           val -= (htab->glink_eh_frame->output_section->vma
12692                   + htab->glink_eh_frame->output_offset);
12693           val -= p - htab->glink_eh_frame->contents;
12694           if (val + 0x80000000 > 0xffffffff)
12695             {
12696               info->callbacks->einfo
12697                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12698                  htab->glink->name);
12699               return FALSE;
12700             }
12701           bfd_put_32 (htab->elf.dynobj, val, p);
12702           p += 4;
12703           /* .glink size.  */
12704           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12705           p += 4;
12706           /* Augmentation.  */
12707           p += 1;
12708
12709           *p++ = DW_CFA_advance_loc + 1;
12710           *p++ = DW_CFA_register;
12711           *p++ = 65;
12712           *p++ = 12;
12713           *p++ = DW_CFA_advance_loc + 4;
12714           *p++ = DW_CFA_restore_extended;
12715           *p++ = 65;
12716         }
12717       /* Subsume any padding into the last FDE if user .eh_frame
12718          sections are aligned more than glink_eh_frame.  Otherwise any
12719          zero padding will be seen as a terminator.  */
12720       size = p - htab->glink_eh_frame->contents;
12721       align = 1;
12722       align <<= htab->glink_eh_frame->output_section->alignment_power;
12723       align -= 1;
12724       pad = ((size + align) & ~align) - size;
12725       htab->glink_eh_frame->size = size + pad;
12726       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12727     }
12728
12729   /* Build the stubs as directed by the stub hash table.  */
12730   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12731
12732   if (htab->relbrlt != NULL)
12733     htab->relbrlt->reloc_count = 0;
12734
12735   if (htab->plt_stub_align != 0)
12736     for (stub_sec = htab->stub_bfd->sections;
12737          stub_sec != NULL;
12738          stub_sec = stub_sec->next)
12739       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12740         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12741                           & (-1 << htab->plt_stub_align));
12742
12743   for (stub_sec = htab->stub_bfd->sections;
12744        stub_sec != NULL;
12745        stub_sec = stub_sec->next)
12746     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12747       {
12748         stub_sec_count += 1;
12749         if (stub_sec->rawsize != stub_sec->size)
12750           break;
12751       }
12752
12753   if (stub_sec != NULL
12754       || (htab->glink_eh_frame != NULL
12755           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12756     {
12757       htab->stub_error = TRUE;
12758       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12759     }
12760
12761   if (htab->stub_error)
12762     return FALSE;
12763
12764   if (stats != NULL)
12765     {
12766       *stats = bfd_malloc (500);
12767       if (*stats == NULL)
12768         return FALSE;
12769
12770       sprintf (*stats, _("linker stubs in %u group%s\n"
12771                          "  branch       %lu\n"
12772                          "  toc adjust   %lu\n"
12773                          "  long branch  %lu\n"
12774                          "  long toc adj %lu\n"
12775                          "  plt call     %lu\n"
12776                          "  plt call toc %lu"),
12777                stub_sec_count,
12778                stub_sec_count == 1 ? "" : "s",
12779                htab->stub_count[ppc_stub_long_branch - 1],
12780                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12781                htab->stub_count[ppc_stub_plt_branch - 1],
12782                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12783                htab->stub_count[ppc_stub_plt_call - 1],
12784                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12785     }
12786   return TRUE;
12787 }
12788
12789 /* This function undoes the changes made by add_symbol_adjust.  */
12790
12791 static bfd_boolean
12792 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12793 {
12794   struct ppc_link_hash_entry *eh;
12795
12796   if (h->root.type == bfd_link_hash_indirect)
12797     return TRUE;
12798
12799   eh = (struct ppc_link_hash_entry *) h;
12800   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12801     return TRUE;
12802
12803   eh->elf.root.type = bfd_link_hash_undefined;
12804   return TRUE;
12805 }
12806
12807 void
12808 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12809 {
12810   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12811
12812   if (htab != NULL)
12813     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12814 }
12815
12816 /* What to do when ld finds relocations against symbols defined in
12817    discarded sections.  */
12818
12819 static unsigned int
12820 ppc64_elf_action_discarded (asection *sec)
12821 {
12822   if (strcmp (".opd", sec->name) == 0)
12823     return 0;
12824
12825   if (strcmp (".toc", sec->name) == 0)
12826     return 0;
12827
12828   if (strcmp (".toc1", sec->name) == 0)
12829     return 0;
12830
12831   return _bfd_elf_default_action_discarded (sec);
12832 }
12833
12834 /* The RELOCATE_SECTION function is called by the ELF backend linker
12835    to handle the relocations for a section.
12836
12837    The relocs are always passed as Rela structures; if the section
12838    actually uses Rel structures, the r_addend field will always be
12839    zero.
12840
12841    This function is responsible for adjust the section contents as
12842    necessary, and (if using Rela relocs and generating a
12843    relocatable output file) adjusting the reloc addend as
12844    necessary.
12845
12846    This function does not have to worry about setting the reloc
12847    address or the reloc symbol index.
12848
12849    LOCAL_SYMS is a pointer to the swapped in local symbols.
12850
12851    LOCAL_SECTIONS is an array giving the section in the input file
12852    corresponding to the st_shndx field of each local symbol.
12853
12854    The global hash table entry for the global symbols can be found
12855    via elf_sym_hashes (input_bfd).
12856
12857    When generating relocatable output, this function must handle
12858    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12859    going to be the section symbol corresponding to the output
12860    section, which means that the addend must be adjusted
12861    accordingly.  */
12862
12863 static bfd_boolean
12864 ppc64_elf_relocate_section (bfd *output_bfd,
12865                             struct bfd_link_info *info,
12866                             bfd *input_bfd,
12867                             asection *input_section,
12868                             bfd_byte *contents,
12869                             Elf_Internal_Rela *relocs,
12870                             Elf_Internal_Sym *local_syms,
12871                             asection **local_sections)
12872 {
12873   struct ppc_link_hash_table *htab;
12874   Elf_Internal_Shdr *symtab_hdr;
12875   struct elf_link_hash_entry **sym_hashes;
12876   Elf_Internal_Rela *rel;
12877   Elf_Internal_Rela *relend;
12878   Elf_Internal_Rela outrel;
12879   bfd_byte *loc;
12880   struct got_entry **local_got_ents;
12881   bfd_vma TOCstart;
12882   bfd_boolean ret = TRUE;
12883   bfd_boolean is_opd;
12884   /* Assume 'at' branch hints.  */
12885   bfd_boolean is_isa_v2 = TRUE;
12886   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12887
12888   /* Initialize howto table if needed.  */
12889   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12890     ppc_howto_init ();
12891
12892   htab = ppc_hash_table (info);
12893   if (htab == NULL)
12894     return FALSE;
12895
12896   /* Don't relocate stub sections.  */
12897   if (input_section->owner == htab->stub_bfd)
12898     return TRUE;
12899
12900   BFD_ASSERT (is_ppc64_elf (input_bfd));
12901
12902   local_got_ents = elf_local_got_ents (input_bfd);
12903   TOCstart = elf_gp (output_bfd);
12904   symtab_hdr = &elf_symtab_hdr (input_bfd);
12905   sym_hashes = elf_sym_hashes (input_bfd);
12906   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12907
12908   rel = relocs;
12909   relend = relocs + input_section->reloc_count;
12910   for (; rel < relend; rel++)
12911     {
12912       enum elf_ppc64_reloc_type r_type;
12913       bfd_vma addend;
12914       bfd_reloc_status_type r;
12915       Elf_Internal_Sym *sym;
12916       asection *sec;
12917       struct elf_link_hash_entry *h_elf;
12918       struct ppc_link_hash_entry *h;
12919       struct ppc_link_hash_entry *fdh;
12920       const char *sym_name;
12921       unsigned long r_symndx, toc_symndx;
12922       bfd_vma toc_addend;
12923       unsigned char tls_mask, tls_gd, tls_type;
12924       unsigned char sym_type;
12925       bfd_vma relocation;
12926       bfd_boolean unresolved_reloc;
12927       bfd_boolean warned;
12928       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12929       unsigned int insn;
12930       unsigned int mask;
12931       struct ppc_stub_hash_entry *stub_entry;
12932       bfd_vma max_br_offset;
12933       bfd_vma from;
12934       const Elf_Internal_Rela orig_rel = *rel;
12935
12936       r_type = ELF64_R_TYPE (rel->r_info);
12937       r_symndx = ELF64_R_SYM (rel->r_info);
12938
12939       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12940          symbol of the previous ADDR64 reloc.  The symbol gives us the
12941          proper TOC base to use.  */
12942       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12943           && rel != relocs
12944           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12945           && is_opd)
12946         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12947
12948       sym = NULL;
12949       sec = NULL;
12950       h_elf = NULL;
12951       sym_name = NULL;
12952       unresolved_reloc = FALSE;
12953       warned = FALSE;
12954
12955       if (r_symndx < symtab_hdr->sh_info)
12956         {
12957           /* It's a local symbol.  */
12958           struct _opd_sec_data *opd;
12959
12960           sym = local_syms + r_symndx;
12961           sec = local_sections[r_symndx];
12962           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12963           sym_type = ELF64_ST_TYPE (sym->st_info);
12964           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12965           opd = get_opd_info (sec);
12966           if (opd != NULL && opd->adjust != NULL)
12967             {
12968               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12969               if (adjust == -1)
12970                 relocation = 0;
12971               else
12972                 {
12973                   /* If this is a relocation against the opd section sym
12974                      and we have edited .opd, adjust the reloc addend so
12975                      that ld -r and ld --emit-relocs output is correct.
12976                      If it is a reloc against some other .opd symbol,
12977                      then the symbol value will be adjusted later.  */
12978                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12979                     rel->r_addend += adjust;
12980                   else
12981                     relocation += adjust;
12982                 }
12983             }
12984         }
12985       else
12986         {
12987           bfd_boolean ignored;
12988
12989           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12990                                    r_symndx, symtab_hdr, sym_hashes,
12991                                    h_elf, sec, relocation,
12992                                    unresolved_reloc, warned, ignored);
12993           sym_name = h_elf->root.root.string;
12994           sym_type = h_elf->type;
12995           if (sec != NULL
12996               && sec->owner == output_bfd
12997               && strcmp (sec->name, ".opd") == 0)
12998             {
12999               /* This is a symbol defined in a linker script.  All
13000                  such are defined in output sections, even those
13001                  defined by simple assignment from a symbol defined in
13002                  an input section.  Transfer the symbol to an
13003                  appropriate input .opd section, so that a branch to
13004                  this symbol will be mapped to the location specified
13005                  by the opd entry.  */
13006               struct bfd_link_order *lo;
13007               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13008                 if (lo->type == bfd_indirect_link_order)
13009                   {
13010                     asection *isec = lo->u.indirect.section;
13011                     if (h_elf->root.u.def.value >= isec->output_offset
13012                         && h_elf->root.u.def.value < (isec->output_offset
13013                                                       + isec->size))
13014                       {
13015                         h_elf->root.u.def.value -= isec->output_offset;
13016                         h_elf->root.u.def.section = isec;
13017                         sec = isec;
13018                         break;
13019                       }
13020                   }
13021             }
13022         }
13023       h = (struct ppc_link_hash_entry *) h_elf;
13024
13025       if (sec != NULL && discarded_section (sec))
13026         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13027                                          rel, 1, relend,
13028                                          ppc64_elf_howto_table[r_type], 0,
13029                                          contents);
13030
13031       if (info->relocatable)
13032         continue;
13033
13034       if (h != NULL && &h->elf == htab->elf.hgot)
13035         {
13036           relocation = (TOCstart
13037                         + htab->stub_group[input_section->id].toc_off);
13038           sec = bfd_abs_section_ptr;
13039           unresolved_reloc = FALSE;
13040         }
13041
13042       /* TLS optimizations.  Replace instruction sequences and relocs
13043          based on information we collected in tls_optimize.  We edit
13044          RELOCS so that --emit-relocs will output something sensible
13045          for the final instruction stream.  */
13046       tls_mask = 0;
13047       tls_gd = 0;
13048       toc_symndx = 0;
13049       if (h != NULL)
13050         tls_mask = h->tls_mask;
13051       else if (local_got_ents != NULL)
13052         {
13053           struct plt_entry **local_plt = (struct plt_entry **)
13054             (local_got_ents + symtab_hdr->sh_info);
13055           unsigned char *lgot_masks = (unsigned char *)
13056             (local_plt + symtab_hdr->sh_info);
13057           tls_mask = lgot_masks[r_symndx];
13058         }
13059       if (tls_mask == 0
13060           && (r_type == R_PPC64_TLS
13061               || r_type == R_PPC64_TLSGD
13062               || r_type == R_PPC64_TLSLD))
13063         {
13064           /* Check for toc tls entries.  */
13065           unsigned char *toc_tls;
13066
13067           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13068                              &local_syms, rel, input_bfd))
13069             return FALSE;
13070
13071           if (toc_tls)
13072             tls_mask = *toc_tls;
13073         }
13074
13075       /* Check that tls relocs are used with tls syms, and non-tls
13076          relocs are used with non-tls syms.  */
13077       if (r_symndx != STN_UNDEF
13078           && r_type != R_PPC64_NONE
13079           && (h == NULL
13080               || h->elf.root.type == bfd_link_hash_defined
13081               || h->elf.root.type == bfd_link_hash_defweak)
13082           && (IS_PPC64_TLS_RELOC (r_type)
13083               != (sym_type == STT_TLS
13084                   || (sym_type == STT_SECTION
13085                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13086         {
13087           if (tls_mask != 0
13088               && (r_type == R_PPC64_TLS
13089                   || r_type == R_PPC64_TLSGD
13090                   || r_type == R_PPC64_TLSLD))
13091             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13092             ;
13093           else
13094             info->callbacks->einfo
13095               (!IS_PPC64_TLS_RELOC (r_type)
13096                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13097                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13098                input_bfd, input_section, rel->r_offset,
13099                ppc64_elf_howto_table[r_type]->name,
13100                sym_name);
13101         }
13102
13103       /* Ensure reloc mapping code below stays sane.  */
13104       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13105           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13106           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13107           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13108           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13109           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13110           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13111           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13112           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13113           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13114         abort ();
13115
13116       switch (r_type)
13117         {
13118         default:
13119           break;
13120
13121         case R_PPC64_LO_DS_OPT:
13122           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13123           if ((insn & (0x3f << 26)) != 58u << 26)
13124             abort ();
13125           insn += (14u << 26) - (58u << 26);
13126           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13127           r_type = R_PPC64_TOC16_LO;
13128           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13129           break;
13130
13131         case R_PPC64_TOC16:
13132         case R_PPC64_TOC16_LO:
13133         case R_PPC64_TOC16_DS:
13134         case R_PPC64_TOC16_LO_DS:
13135           {
13136             /* Check for toc tls entries.  */
13137             unsigned char *toc_tls;
13138             int retval;
13139
13140             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13141                                    &local_syms, rel, input_bfd);
13142             if (retval == 0)
13143               return FALSE;
13144
13145             if (toc_tls)
13146               {
13147                 tls_mask = *toc_tls;
13148                 if (r_type == R_PPC64_TOC16_DS
13149                     || r_type == R_PPC64_TOC16_LO_DS)
13150                   {
13151                     if (tls_mask != 0
13152                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13153                       goto toctprel;
13154                   }
13155                 else
13156                   {
13157                     /* If we found a GD reloc pair, then we might be
13158                        doing a GD->IE transition.  */
13159                     if (retval == 2)
13160                       {
13161                         tls_gd = TLS_TPRELGD;
13162                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13163                           goto tls_ldgd_opt;
13164                       }
13165                     else if (retval == 3)
13166                       {
13167                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13168                           goto tls_ldgd_opt;
13169                       }
13170                   }
13171               }
13172           }
13173           break;
13174
13175         case R_PPC64_GOT_TPREL16_HI:
13176         case R_PPC64_GOT_TPREL16_HA:
13177           if (tls_mask != 0
13178               && (tls_mask & TLS_TPREL) == 0)
13179             {
13180               rel->r_offset -= d_offset;
13181               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13182               r_type = R_PPC64_NONE;
13183               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13184             }
13185           break;
13186
13187         case R_PPC64_GOT_TPREL16_DS:
13188         case R_PPC64_GOT_TPREL16_LO_DS:
13189           if (tls_mask != 0
13190               && (tls_mask & TLS_TPREL) == 0)
13191             {
13192             toctprel:
13193               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13194               insn &= 31 << 21;
13195               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13196               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13197               r_type = R_PPC64_TPREL16_HA;
13198               if (toc_symndx != 0)
13199                 {
13200                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13201                   rel->r_addend = toc_addend;
13202                   /* We changed the symbol.  Start over in order to
13203                      get h, sym, sec etc. right.  */
13204                   rel--;
13205                   continue;
13206                 }
13207               else
13208                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13209             }
13210           break;
13211
13212         case R_PPC64_TLS:
13213           if (tls_mask != 0
13214               && (tls_mask & TLS_TPREL) == 0)
13215             {
13216               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13217               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13218               if (insn == 0)
13219                 abort ();
13220               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13221               /* Was PPC64_TLS which sits on insn boundary, now
13222                  PPC64_TPREL16_LO which is at low-order half-word.  */
13223               rel->r_offset += d_offset;
13224               r_type = R_PPC64_TPREL16_LO;
13225               if (toc_symndx != 0)
13226                 {
13227                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13228                   rel->r_addend = toc_addend;
13229                   /* We changed the symbol.  Start over in order to
13230                      get h, sym, sec etc. right.  */
13231                   rel--;
13232                   continue;
13233                 }
13234               else
13235                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13236             }
13237           break;
13238
13239         case R_PPC64_GOT_TLSGD16_HI:
13240         case R_PPC64_GOT_TLSGD16_HA:
13241           tls_gd = TLS_TPRELGD;
13242           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13243             goto tls_gdld_hi;
13244           break;
13245
13246         case R_PPC64_GOT_TLSLD16_HI:
13247         case R_PPC64_GOT_TLSLD16_HA:
13248           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13249             {
13250             tls_gdld_hi:
13251               if ((tls_mask & tls_gd) != 0)
13252                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13253                           + R_PPC64_GOT_TPREL16_DS);
13254               else
13255                 {
13256                   rel->r_offset -= d_offset;
13257                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13258                   r_type = R_PPC64_NONE;
13259                 }
13260               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13261             }
13262           break;
13263
13264         case R_PPC64_GOT_TLSGD16:
13265         case R_PPC64_GOT_TLSGD16_LO:
13266           tls_gd = TLS_TPRELGD;
13267           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13268             goto tls_ldgd_opt;
13269           break;
13270
13271         case R_PPC64_GOT_TLSLD16:
13272         case R_PPC64_GOT_TLSLD16_LO:
13273           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13274             {
13275               unsigned int insn1, insn2, insn3;
13276               bfd_vma offset;
13277
13278             tls_ldgd_opt:
13279               offset = (bfd_vma) -1;
13280               /* If not using the newer R_PPC64_TLSGD/LD to mark
13281                  __tls_get_addr calls, we must trust that the call
13282                  stays with its arg setup insns, ie. that the next
13283                  reloc is the __tls_get_addr call associated with
13284                  the current reloc.  Edit both insns.  */
13285               if (input_section->has_tls_get_addr_call
13286                   && rel + 1 < relend
13287                   && branch_reloc_hash_match (input_bfd, rel + 1,
13288                                               htab->tls_get_addr,
13289                                               htab->tls_get_addr_fd))
13290                 offset = rel[1].r_offset;
13291               if ((tls_mask & tls_gd) != 0)
13292                 {
13293                   /* IE */
13294                   insn1 = bfd_get_32 (output_bfd,
13295                                       contents + rel->r_offset - d_offset);
13296                   insn1 &= (1 << 26) - (1 << 2);
13297                   insn1 |= 58 << 26;    /* ld */
13298                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13299                   if (offset != (bfd_vma) -1)
13300                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13301                   if ((tls_mask & TLS_EXPLICIT) == 0)
13302                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13303                               + R_PPC64_GOT_TPREL16_DS);
13304                   else
13305                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13306                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13307                 }
13308               else
13309                 {
13310                   /* LE */
13311                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13312                   insn2 = 0x38630000;   /* addi 3,3,0 */
13313                   if (tls_gd == 0)
13314                     {
13315                       /* Was an LD reloc.  */
13316                       if (toc_symndx)
13317                         sec = local_sections[toc_symndx];
13318                       for (r_symndx = 0;
13319                            r_symndx < symtab_hdr->sh_info;
13320                            r_symndx++)
13321                         if (local_sections[r_symndx] == sec)
13322                           break;
13323                       if (r_symndx >= symtab_hdr->sh_info)
13324                         r_symndx = STN_UNDEF;
13325                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13326                       if (r_symndx != STN_UNDEF)
13327                         rel->r_addend -= (local_syms[r_symndx].st_value
13328                                           + sec->output_offset
13329                                           + sec->output_section->vma);
13330                     }
13331                   else if (toc_symndx != 0)
13332                     {
13333                       r_symndx = toc_symndx;
13334                       rel->r_addend = toc_addend;
13335                     }
13336                   r_type = R_PPC64_TPREL16_HA;
13337                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13338                   if (offset != (bfd_vma) -1)
13339                     {
13340                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13341                                                     R_PPC64_TPREL16_LO);
13342                       rel[1].r_offset = offset + d_offset;
13343                       rel[1].r_addend = rel->r_addend;
13344                     }
13345                 }
13346               bfd_put_32 (output_bfd, insn1,
13347                           contents + rel->r_offset - d_offset);
13348               if (offset != (bfd_vma) -1)
13349                 {
13350                   insn3 = bfd_get_32 (output_bfd,
13351                                       contents + offset + 4);
13352                   if (insn3 == NOP
13353                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13354                     {
13355                       rel[1].r_offset += 4;
13356                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13357                       insn2 = NOP;
13358                     }
13359                   bfd_put_32 (output_bfd, insn2, contents + offset);
13360                 }
13361               if ((tls_mask & tls_gd) == 0
13362                   && (tls_gd == 0 || toc_symndx != 0))
13363                 {
13364                   /* We changed the symbol.  Start over in order
13365                      to get h, sym, sec etc. right.  */
13366                   rel--;
13367                   continue;
13368                 }
13369             }
13370           break;
13371
13372         case R_PPC64_TLSGD:
13373           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13374             {
13375               unsigned int insn2, insn3;
13376               bfd_vma offset = rel->r_offset;
13377
13378               if ((tls_mask & TLS_TPRELGD) != 0)
13379                 {
13380                   /* IE */
13381                   r_type = R_PPC64_NONE;
13382                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13383                 }
13384               else
13385                 {
13386                   /* LE */
13387                   if (toc_symndx != 0)
13388                     {
13389                       r_symndx = toc_symndx;
13390                       rel->r_addend = toc_addend;
13391                     }
13392                   r_type = R_PPC64_TPREL16_LO;
13393                   rel->r_offset = offset + d_offset;
13394                   insn2 = 0x38630000;   /* addi 3,3,0 */
13395                 }
13396               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13397               /* Zap the reloc on the _tls_get_addr call too.  */
13398               BFD_ASSERT (offset == rel[1].r_offset);
13399               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13400               insn3 = bfd_get_32 (output_bfd,
13401                                   contents + offset + 4);
13402               if (insn3 == NOP
13403                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13404                 {
13405                   rel->r_offset += 4;
13406                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13407                   insn2 = NOP;
13408                 }
13409               bfd_put_32 (output_bfd, insn2, contents + offset);
13410               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13411                 {
13412                   rel--;
13413                   continue;
13414                 }
13415             }
13416           break;
13417
13418         case R_PPC64_TLSLD:
13419           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13420             {
13421               unsigned int insn2, insn3;
13422               bfd_vma offset = rel->r_offset;
13423
13424               if (toc_symndx)
13425                 sec = local_sections[toc_symndx];
13426               for (r_symndx = 0;
13427                    r_symndx < symtab_hdr->sh_info;
13428                    r_symndx++)
13429                 if (local_sections[r_symndx] == sec)
13430                   break;
13431               if (r_symndx >= symtab_hdr->sh_info)
13432                 r_symndx = STN_UNDEF;
13433               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13434               if (r_symndx != STN_UNDEF)
13435                 rel->r_addend -= (local_syms[r_symndx].st_value
13436                                   + sec->output_offset
13437                                   + sec->output_section->vma);
13438
13439               r_type = R_PPC64_TPREL16_LO;
13440               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13441               rel->r_offset = offset + d_offset;
13442               /* Zap the reloc on the _tls_get_addr call too.  */
13443               BFD_ASSERT (offset == rel[1].r_offset);
13444               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13445               insn2 = 0x38630000;       /* addi 3,3,0 */
13446               insn3 = bfd_get_32 (output_bfd,
13447                                   contents + offset + 4);
13448               if (insn3 == NOP
13449                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13450                 {
13451                   rel->r_offset += 4;
13452                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13453                   insn2 = NOP;
13454                 }
13455               bfd_put_32 (output_bfd, insn2, contents + offset);
13456               rel--;
13457               continue;
13458             }
13459           break;
13460
13461         case R_PPC64_DTPMOD64:
13462           if (rel + 1 < relend
13463               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13464               && rel[1].r_offset == rel->r_offset + 8)
13465             {
13466               if ((tls_mask & TLS_GD) == 0)
13467                 {
13468                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13469                   if ((tls_mask & TLS_TPRELGD) != 0)
13470                     r_type = R_PPC64_TPREL64;
13471                   else
13472                     {
13473                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13474                       r_type = R_PPC64_NONE;
13475                     }
13476                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13477                 }
13478             }
13479           else
13480             {
13481               if ((tls_mask & TLS_LD) == 0)
13482                 {
13483                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13484                   r_type = R_PPC64_NONE;
13485                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13486                 }
13487             }
13488           break;
13489
13490         case R_PPC64_TPREL64:
13491           if ((tls_mask & TLS_TPREL) == 0)
13492             {
13493               r_type = R_PPC64_NONE;
13494               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13495             }
13496           break;
13497
13498         case R_PPC64_REL16_HA:
13499           /* If we are generating a non-PIC executable, edit
13500              .  0:      addis 2,12,.TOC.-0b@ha
13501              .          addi 2,2,.TOC.-0b@l
13502              used by ELFv2 global entry points to set up r2, to
13503              .          lis 2,.TOC.@ha
13504              .          addi 2,2,.TOC.@l
13505              if .TOC. is in range.  */
13506           if (!info->shared
13507               && h != NULL && &h->elf == htab->elf.hgot
13508               && rel + 1 < relend
13509               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13510               && rel[1].r_offset == rel->r_offset + 4
13511               && rel[1].r_addend == rel->r_addend + 4
13512               && relocation + 0x80008000 <= 0xffffffff)
13513             {
13514               unsigned int insn1, insn2;
13515               bfd_vma offset = rel->r_offset - d_offset;
13516               insn1 = bfd_get_32 (output_bfd, contents + offset);
13517               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13518               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13519                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13520                 {
13521                   r_type = R_PPC64_ADDR16_HA;
13522                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13523                   rel->r_addend -= d_offset;
13524                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13525                   rel[1].r_addend -= d_offset + 4;
13526                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13527                 }
13528             }
13529           break;
13530         }
13531
13532       /* Handle other relocations that tweak non-addend part of insn.  */
13533       insn = 0;
13534       max_br_offset = 1 << 25;
13535       addend = rel->r_addend;
13536       reloc_dest = DEST_NORMAL;
13537       switch (r_type)
13538         {
13539         default:
13540           break;
13541
13542         case R_PPC64_TOCSAVE:
13543           if (relocation + addend == (rel->r_offset
13544                                       + input_section->output_offset
13545                                       + input_section->output_section->vma)
13546               && tocsave_find (htab, NO_INSERT,
13547                                &local_syms, rel, input_bfd))
13548             {
13549               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13550               if (insn == NOP
13551                   || insn == CROR_151515 || insn == CROR_313131)
13552                 bfd_put_32 (input_bfd,
13553                             STD_R2_0R1 + STK_TOC (htab),
13554                             contents + rel->r_offset);
13555             }
13556           break;
13557
13558           /* Branch taken prediction relocations.  */
13559         case R_PPC64_ADDR14_BRTAKEN:
13560         case R_PPC64_REL14_BRTAKEN:
13561           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13562           /* Fall thru.  */
13563
13564           /* Branch not taken prediction relocations.  */
13565         case R_PPC64_ADDR14_BRNTAKEN:
13566         case R_PPC64_REL14_BRNTAKEN:
13567           insn |= bfd_get_32 (output_bfd,
13568                               contents + rel->r_offset) & ~(0x01 << 21);
13569           /* Fall thru.  */
13570
13571         case R_PPC64_REL14:
13572           max_br_offset = 1 << 15;
13573           /* Fall thru.  */
13574
13575         case R_PPC64_REL24:
13576           /* Calls to functions with a different TOC, such as calls to
13577              shared objects, need to alter the TOC pointer.  This is
13578              done using a linkage stub.  A REL24 branching to these
13579              linkage stubs needs to be followed by a nop, as the nop
13580              will be replaced with an instruction to restore the TOC
13581              base pointer.  */
13582           fdh = h;
13583           if (h != NULL
13584               && h->oh != NULL
13585               && h->oh->is_func_descriptor)
13586             fdh = ppc_follow_link (h->oh);
13587           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13588                                            htab);
13589           if (stub_entry != NULL
13590               && (stub_entry->stub_type == ppc_stub_plt_call
13591                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13592                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13593                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13594             {
13595               bfd_boolean can_plt_call = FALSE;
13596
13597               /* All of these stubs will modify r2, so there must be a
13598                  branch and link followed by a nop.  The nop is
13599                  replaced by an insn to restore r2.  */
13600               if (rel->r_offset + 8 <= input_section->size)
13601                 {
13602                   unsigned long br;
13603
13604                   br = bfd_get_32 (input_bfd,
13605                                    contents + rel->r_offset);
13606                   if ((br & 1) != 0)
13607                     {
13608                       unsigned long nop;
13609
13610                       nop = bfd_get_32 (input_bfd,
13611                                         contents + rel->r_offset + 4);
13612                       if (nop == NOP
13613                           || nop == CROR_151515 || nop == CROR_313131)
13614                         {
13615                           if (h != NULL
13616                               && (h == htab->tls_get_addr_fd
13617                                   || h == htab->tls_get_addr)
13618                               && !htab->no_tls_get_addr_opt)
13619                             {
13620                               /* Special stub used, leave nop alone.  */
13621                             }
13622                           else
13623                             bfd_put_32 (input_bfd,
13624                                         LD_R2_0R1 + STK_TOC (htab),
13625                                         contents + rel->r_offset + 4);
13626                           can_plt_call = TRUE;
13627                         }
13628                     }
13629                 }
13630
13631               if (!can_plt_call && h != NULL)
13632                 {
13633                   const char *name = h->elf.root.root.string;
13634
13635                   if (*name == '.')
13636                     ++name;
13637
13638                   if (strncmp (name, "__libc_start_main", 17) == 0
13639                       && (name[17] == 0 || name[17] == '@'))
13640                     {
13641                       /* Allow crt1 branch to go via a toc adjusting
13642                          stub.  Other calls that never return could do
13643                          the same, if we could detect such.  */
13644                       can_plt_call = TRUE;
13645                     }
13646                 }
13647
13648               if (!can_plt_call)
13649                 {
13650                   /* g++ as of 20130507 emits self-calls without a
13651                      following nop.  This is arguably wrong since we
13652                      have conflicting information.  On the one hand a
13653                      global symbol and on the other a local call
13654                      sequence, but don't error for this special case.
13655                      It isn't possible to cheaply verify we have
13656                      exactly such a call.  Allow all calls to the same
13657                      section.  */
13658                   asection *code_sec = sec;
13659
13660                   if (get_opd_info (sec) != NULL)
13661                     {
13662                       bfd_vma off = (relocation + addend
13663                                      - sec->output_section->vma
13664                                      - sec->output_offset);
13665
13666                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13667                     }
13668                   if (code_sec == input_section)
13669                     can_plt_call = TRUE;
13670                 }
13671
13672               if (!can_plt_call)
13673                 {
13674                   info->callbacks->einfo
13675                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13676                        "recompile with -fPIC\n"),
13677                      input_bfd, input_section, rel->r_offset, sym_name);
13678
13679                   bfd_set_error (bfd_error_bad_value);
13680                   ret = FALSE;
13681                 }
13682
13683               if (can_plt_call
13684                   && (stub_entry->stub_type == ppc_stub_plt_call
13685                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13686                 unresolved_reloc = FALSE;
13687             }
13688
13689           if ((stub_entry == NULL
13690                || stub_entry->stub_type == ppc_stub_long_branch
13691                || stub_entry->stub_type == ppc_stub_plt_branch)
13692               && get_opd_info (sec) != NULL)
13693             {
13694               /* The branch destination is the value of the opd entry. */
13695               bfd_vma off = (relocation + addend
13696                              - sec->output_section->vma
13697                              - sec->output_offset);
13698               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13699               if (dest != (bfd_vma) -1)
13700                 {
13701                   relocation = dest;
13702                   addend = 0;
13703                   reloc_dest = DEST_OPD;
13704                 }
13705             }
13706
13707           /* If the branch is out of reach we ought to have a long
13708              branch stub.  */
13709           from = (rel->r_offset
13710                   + input_section->output_offset
13711                   + input_section->output_section->vma);
13712
13713           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13714                                                   ? fdh->elf.other
13715                                                   : sym->st_other);
13716
13717           if (stub_entry != NULL
13718               && (stub_entry->stub_type == ppc_stub_long_branch
13719                   || stub_entry->stub_type == ppc_stub_plt_branch)
13720               && (r_type == R_PPC64_ADDR14_BRTAKEN
13721                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13722                   || (relocation + addend - from + max_br_offset
13723                       < 2 * max_br_offset)))
13724             /* Don't use the stub if this branch is in range.  */
13725             stub_entry = NULL;
13726
13727           if (stub_entry != NULL)
13728             {
13729               /* Munge up the value and addend so that we call the stub
13730                  rather than the procedure directly.  */
13731               relocation = (stub_entry->stub_offset
13732                             + stub_entry->stub_sec->output_offset
13733                             + stub_entry->stub_sec->output_section->vma);
13734               addend = 0;
13735               reloc_dest = DEST_STUB;
13736
13737               if ((stub_entry->stub_type == ppc_stub_plt_call
13738                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13739                   && (ALWAYS_EMIT_R2SAVE
13740                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13741                   && rel + 1 < relend
13742                   && rel[1].r_offset == rel->r_offset + 4
13743                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13744                 relocation += 4;
13745             }
13746
13747           if (insn != 0)
13748             {
13749               if (is_isa_v2)
13750                 {
13751                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13752                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13753                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13754                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13755                     insn |= 0x02 << 21;
13756                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13757                     insn |= 0x08 << 21;
13758                   else
13759                     break;
13760                 }
13761               else
13762                 {
13763                   /* Invert 'y' bit if not the default.  */
13764                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13765                     insn ^= 0x01 << 21;
13766                 }
13767
13768               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13769             }
13770
13771           /* NOP out calls to undefined weak functions.
13772              We can thus call a weak function without first
13773              checking whether the function is defined.  */
13774           else if (h != NULL
13775                    && h->elf.root.type == bfd_link_hash_undefweak
13776                    && h->elf.dynindx == -1
13777                    && r_type == R_PPC64_REL24
13778                    && relocation == 0
13779                    && addend == 0)
13780             {
13781               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13782               continue;
13783             }
13784           break;
13785         }
13786
13787       /* Set `addend'.  */
13788       tls_type = 0;
13789       switch (r_type)
13790         {
13791         default:
13792           info->callbacks->einfo
13793             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13794              input_bfd, (int) r_type, sym_name);
13795
13796           bfd_set_error (bfd_error_bad_value);
13797           ret = FALSE;
13798           continue;
13799
13800         case R_PPC64_NONE:
13801         case R_PPC64_TLS:
13802         case R_PPC64_TLSGD:
13803         case R_PPC64_TLSLD:
13804         case R_PPC64_TOCSAVE:
13805         case R_PPC64_GNU_VTINHERIT:
13806         case R_PPC64_GNU_VTENTRY:
13807           continue;
13808
13809           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13810              address in the GOT as relocation value instead of the
13811              symbol's value itself.  Also, create a GOT entry for the
13812              symbol and put the symbol value there.  */
13813         case R_PPC64_GOT_TLSGD16:
13814         case R_PPC64_GOT_TLSGD16_LO:
13815         case R_PPC64_GOT_TLSGD16_HI:
13816         case R_PPC64_GOT_TLSGD16_HA:
13817           tls_type = TLS_TLS | TLS_GD;
13818           goto dogot;
13819
13820         case R_PPC64_GOT_TLSLD16:
13821         case R_PPC64_GOT_TLSLD16_LO:
13822         case R_PPC64_GOT_TLSLD16_HI:
13823         case R_PPC64_GOT_TLSLD16_HA:
13824           tls_type = TLS_TLS | TLS_LD;
13825           goto dogot;
13826
13827         case R_PPC64_GOT_TPREL16_DS:
13828         case R_PPC64_GOT_TPREL16_LO_DS:
13829         case R_PPC64_GOT_TPREL16_HI:
13830         case R_PPC64_GOT_TPREL16_HA:
13831           tls_type = TLS_TLS | TLS_TPREL;
13832           goto dogot;
13833
13834         case R_PPC64_GOT_DTPREL16_DS:
13835         case R_PPC64_GOT_DTPREL16_LO_DS:
13836         case R_PPC64_GOT_DTPREL16_HI:
13837         case R_PPC64_GOT_DTPREL16_HA:
13838           tls_type = TLS_TLS | TLS_DTPREL;
13839           goto dogot;
13840
13841         case R_PPC64_GOT16:
13842         case R_PPC64_GOT16_LO:
13843         case R_PPC64_GOT16_HI:
13844         case R_PPC64_GOT16_HA:
13845         case R_PPC64_GOT16_DS:
13846         case R_PPC64_GOT16_LO_DS:
13847         dogot:
13848           {
13849             /* Relocation is to the entry for this symbol in the global
13850                offset table.  */
13851             asection *got;
13852             bfd_vma *offp;
13853             bfd_vma off;
13854             unsigned long indx = 0;
13855             struct got_entry *ent;
13856
13857             if (tls_type == (TLS_TLS | TLS_LD)
13858                 && (h == NULL
13859                     || !h->elf.def_dynamic))
13860               ent = ppc64_tlsld_got (input_bfd);
13861             else
13862               {
13863
13864                 if (h != NULL)
13865                   {
13866                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13867                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13868                                                           &h->elf)
13869                         || (info->shared
13870                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13871                       /* This is actually a static link, or it is a
13872                          -Bsymbolic link and the symbol is defined
13873                          locally, or the symbol was forced to be local
13874                          because of a version file.  */
13875                       ;
13876                     else
13877                       {
13878                         BFD_ASSERT (h->elf.dynindx != -1);
13879                         indx = h->elf.dynindx;
13880                         unresolved_reloc = FALSE;
13881                       }
13882                     ent = h->elf.got.glist;
13883                   }
13884                 else
13885                   {
13886                     if (local_got_ents == NULL)
13887                       abort ();
13888                     ent = local_got_ents[r_symndx];
13889                   }
13890
13891                 for (; ent != NULL; ent = ent->next)
13892                   if (ent->addend == orig_rel.r_addend
13893                       && ent->owner == input_bfd
13894                       && ent->tls_type == tls_type)
13895                     break;
13896               }
13897
13898             if (ent == NULL)
13899               abort ();
13900             if (ent->is_indirect)
13901               ent = ent->got.ent;
13902             offp = &ent->got.offset;
13903             got = ppc64_elf_tdata (ent->owner)->got;
13904             if (got == NULL)
13905               abort ();
13906
13907             /* The offset must always be a multiple of 8.  We use the
13908                least significant bit to record whether we have already
13909                processed this entry.  */
13910             off = *offp;
13911             if ((off & 1) != 0)
13912               off &= ~1;
13913             else
13914               {
13915                 /* Generate relocs for the dynamic linker, except in
13916                    the case of TLSLD where we'll use one entry per
13917                    module.  */
13918                 asection *relgot;
13919                 bfd_boolean ifunc;
13920
13921                 *offp = off | 1;
13922                 relgot = NULL;
13923                 ifunc = (h != NULL
13924                          ? h->elf.type == STT_GNU_IFUNC
13925                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13926                 if (ifunc)
13927                   relgot = htab->elf.irelplt;
13928                 else if ((info->shared || indx != 0)
13929                          && (h == NULL
13930                              || (tls_type == (TLS_TLS | TLS_LD)
13931                                  && !h->elf.def_dynamic)
13932                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13933                              || h->elf.root.type != bfd_link_hash_undefweak))
13934                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13935                 if (relgot != NULL)
13936                   {
13937                     outrel.r_offset = (got->output_section->vma
13938                                        + got->output_offset
13939                                        + off);
13940                     outrel.r_addend = addend;
13941                     if (tls_type & (TLS_LD | TLS_GD))
13942                       {
13943                         outrel.r_addend = 0;
13944                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13945                         if (tls_type == (TLS_TLS | TLS_GD))
13946                           {
13947                             loc = relgot->contents;
13948                             loc += (relgot->reloc_count++
13949                                     * sizeof (Elf64_External_Rela));
13950                             bfd_elf64_swap_reloca_out (output_bfd,
13951                                                        &outrel, loc);
13952                             outrel.r_offset += 8;
13953                             outrel.r_addend = addend;
13954                             outrel.r_info
13955                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13956                           }
13957                       }
13958                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13959                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13960                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13961                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13962                     else if (indx != 0)
13963                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13964                     else
13965                       {
13966                         if (ifunc)
13967                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13968                         else
13969                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13970
13971                         /* Write the .got section contents for the sake
13972                            of prelink.  */
13973                         loc = got->contents + off;
13974                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13975                                     loc);
13976                       }
13977
13978                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13979                       {
13980                         outrel.r_addend += relocation;
13981                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13982                           outrel.r_addend -= htab->elf.tls_sec->vma;
13983                       }
13984                     loc = relgot->contents;
13985                     loc += (relgot->reloc_count++
13986                             * sizeof (Elf64_External_Rela));
13987                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13988                   }
13989
13990                 /* Init the .got section contents here if we're not
13991                    emitting a reloc.  */
13992                 else
13993                   {
13994                     relocation += addend;
13995                     if (tls_type == (TLS_TLS | TLS_LD))
13996                       relocation = 1;
13997                     else if (tls_type != 0)
13998                       {
13999                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14000                         if (tls_type == (TLS_TLS | TLS_TPREL))
14001                           relocation += DTP_OFFSET - TP_OFFSET;
14002
14003                         if (tls_type == (TLS_TLS | TLS_GD))
14004                           {
14005                             bfd_put_64 (output_bfd, relocation,
14006                                         got->contents + off + 8);
14007                             relocation = 1;
14008                           }
14009                       }
14010
14011                     bfd_put_64 (output_bfd, relocation,
14012                                 got->contents + off);
14013                   }
14014               }
14015
14016             if (off >= (bfd_vma) -2)
14017               abort ();
14018
14019             relocation = got->output_section->vma + got->output_offset + off;
14020             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14021           }
14022           break;
14023
14024         case R_PPC64_PLT16_HA:
14025         case R_PPC64_PLT16_HI:
14026         case R_PPC64_PLT16_LO:
14027         case R_PPC64_PLT32:
14028         case R_PPC64_PLT64:
14029           /* Relocation is to the entry for this symbol in the
14030              procedure linkage table.  */
14031
14032           /* Resolve a PLT reloc against a local symbol directly,
14033              without using the procedure linkage table.  */
14034           if (h == NULL)
14035             break;
14036
14037           /* It's possible that we didn't make a PLT entry for this
14038              symbol.  This happens when statically linking PIC code,
14039              or when using -Bsymbolic.  Go find a match if there is a
14040              PLT entry.  */
14041           if (htab->elf.splt != NULL)
14042             {
14043               struct plt_entry *ent;
14044               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14045                 if (ent->plt.offset != (bfd_vma) -1
14046                     && ent->addend == orig_rel.r_addend)
14047                   {
14048                     relocation = (htab->elf.splt->output_section->vma
14049                                   + htab->elf.splt->output_offset
14050                                   + ent->plt.offset);
14051                     unresolved_reloc = FALSE;
14052                     break;
14053                   }
14054             }
14055           break;
14056
14057         case R_PPC64_TOC:
14058           /* Relocation value is TOC base.  */
14059           relocation = TOCstart;
14060           if (r_symndx == STN_UNDEF)
14061             relocation += htab->stub_group[input_section->id].toc_off;
14062           else if (unresolved_reloc)
14063             ;
14064           else if (sec != NULL && sec->id <= htab->top_id)
14065             relocation += htab->stub_group[sec->id].toc_off;
14066           else
14067             unresolved_reloc = TRUE;
14068           goto dodyn;
14069
14070           /* TOC16 relocs.  We want the offset relative to the TOC base,
14071              which is the address of the start of the TOC plus 0x8000.
14072              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14073              in this order.  */
14074         case R_PPC64_TOC16:
14075         case R_PPC64_TOC16_LO:
14076         case R_PPC64_TOC16_HI:
14077         case R_PPC64_TOC16_DS:
14078         case R_PPC64_TOC16_LO_DS:
14079         case R_PPC64_TOC16_HA:
14080           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14081           break;
14082
14083           /* Relocate against the beginning of the section.  */
14084         case R_PPC64_SECTOFF:
14085         case R_PPC64_SECTOFF_LO:
14086         case R_PPC64_SECTOFF_HI:
14087         case R_PPC64_SECTOFF_DS:
14088         case R_PPC64_SECTOFF_LO_DS:
14089         case R_PPC64_SECTOFF_HA:
14090           if (sec != NULL)
14091             addend -= sec->output_section->vma;
14092           break;
14093
14094         case R_PPC64_REL16:
14095         case R_PPC64_REL16_LO:
14096         case R_PPC64_REL16_HI:
14097         case R_PPC64_REL16_HA:
14098           break;
14099
14100         case R_PPC64_REL14:
14101         case R_PPC64_REL14_BRNTAKEN:
14102         case R_PPC64_REL14_BRTAKEN:
14103         case R_PPC64_REL24:
14104           break;
14105
14106         case R_PPC64_TPREL16:
14107         case R_PPC64_TPREL16_LO:
14108         case R_PPC64_TPREL16_HI:
14109         case R_PPC64_TPREL16_HA:
14110         case R_PPC64_TPREL16_DS:
14111         case R_PPC64_TPREL16_LO_DS:
14112         case R_PPC64_TPREL16_HIGH:
14113         case R_PPC64_TPREL16_HIGHA:
14114         case R_PPC64_TPREL16_HIGHER:
14115         case R_PPC64_TPREL16_HIGHERA:
14116         case R_PPC64_TPREL16_HIGHEST:
14117         case R_PPC64_TPREL16_HIGHESTA:
14118           if (h != NULL
14119               && h->elf.root.type == bfd_link_hash_undefweak
14120               && h->elf.dynindx == -1)
14121             {
14122               /* Make this relocation against an undefined weak symbol
14123                  resolve to zero.  This is really just a tweak, since
14124                  code using weak externs ought to check that they are
14125                  defined before using them.  */
14126               bfd_byte *p = contents + rel->r_offset - d_offset;
14127
14128               insn = bfd_get_32 (output_bfd, p);
14129               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14130               if (insn != 0)
14131                 bfd_put_32 (output_bfd, insn, p);
14132               break;
14133             }
14134           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14135           if (info->shared)
14136             /* The TPREL16 relocs shouldn't really be used in shared
14137                libs as they will result in DT_TEXTREL being set, but
14138                support them anyway.  */
14139             goto dodyn;
14140           break;
14141
14142         case R_PPC64_DTPREL16:
14143         case R_PPC64_DTPREL16_LO:
14144         case R_PPC64_DTPREL16_HI:
14145         case R_PPC64_DTPREL16_HA:
14146         case R_PPC64_DTPREL16_DS:
14147         case R_PPC64_DTPREL16_LO_DS:
14148         case R_PPC64_DTPREL16_HIGH:
14149         case R_PPC64_DTPREL16_HIGHA:
14150         case R_PPC64_DTPREL16_HIGHER:
14151         case R_PPC64_DTPREL16_HIGHERA:
14152         case R_PPC64_DTPREL16_HIGHEST:
14153         case R_PPC64_DTPREL16_HIGHESTA:
14154           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14155           break;
14156
14157         case R_PPC64_DTPMOD64:
14158           relocation = 1;
14159           addend = 0;
14160           goto dodyn;
14161
14162         case R_PPC64_TPREL64:
14163           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14164           goto dodyn;
14165
14166         case R_PPC64_DTPREL64:
14167           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14168           /* Fall thru */
14169
14170           /* Relocations that may need to be propagated if this is a
14171              dynamic object.  */
14172         case R_PPC64_REL30:
14173         case R_PPC64_REL32:
14174         case R_PPC64_REL64:
14175         case R_PPC64_ADDR14:
14176         case R_PPC64_ADDR14_BRNTAKEN:
14177         case R_PPC64_ADDR14_BRTAKEN:
14178         case R_PPC64_ADDR16:
14179         case R_PPC64_ADDR16_DS:
14180         case R_PPC64_ADDR16_HA:
14181         case R_PPC64_ADDR16_HI:
14182         case R_PPC64_ADDR16_HIGH:
14183         case R_PPC64_ADDR16_HIGHA:
14184         case R_PPC64_ADDR16_HIGHER:
14185         case R_PPC64_ADDR16_HIGHERA:
14186         case R_PPC64_ADDR16_HIGHEST:
14187         case R_PPC64_ADDR16_HIGHESTA:
14188         case R_PPC64_ADDR16_LO:
14189         case R_PPC64_ADDR16_LO_DS:
14190         case R_PPC64_ADDR24:
14191         case R_PPC64_ADDR32:
14192         case R_PPC64_ADDR64:
14193         case R_PPC64_UADDR16:
14194         case R_PPC64_UADDR32:
14195         case R_PPC64_UADDR64:
14196         dodyn:
14197           if ((input_section->flags & SEC_ALLOC) == 0)
14198             break;
14199
14200           if (NO_OPD_RELOCS && is_opd)
14201             break;
14202
14203           if ((info->shared
14204                && (h == NULL
14205                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14206                    || h->elf.root.type != bfd_link_hash_undefweak)
14207                && (must_be_dyn_reloc (info, r_type)
14208                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14209               || (ELIMINATE_COPY_RELOCS
14210                   && !info->shared
14211                   && h != NULL
14212                   && h->elf.dynindx != -1
14213                   && !h->elf.non_got_ref
14214                   && !h->elf.def_regular)
14215               || (!info->shared
14216                   && (h != NULL
14217                       ? h->elf.type == STT_GNU_IFUNC
14218                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14219             {
14220               bfd_boolean skip, relocate;
14221               asection *sreloc;
14222               bfd_vma out_off;
14223
14224               /* When generating a dynamic object, these relocations
14225                  are copied into the output file to be resolved at run
14226                  time.  */
14227
14228               skip = FALSE;
14229               relocate = FALSE;
14230
14231               out_off = _bfd_elf_section_offset (output_bfd, info,
14232                                                  input_section, rel->r_offset);
14233               if (out_off == (bfd_vma) -1)
14234                 skip = TRUE;
14235               else if (out_off == (bfd_vma) -2)
14236                 skip = TRUE, relocate = TRUE;
14237               out_off += (input_section->output_section->vma
14238                           + input_section->output_offset);
14239               outrel.r_offset = out_off;
14240               outrel.r_addend = rel->r_addend;
14241
14242               /* Optimize unaligned reloc use.  */
14243               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14244                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14245                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14246               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14247                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14248                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14249               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14250                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14251                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14252
14253               if (skip)
14254                 memset (&outrel, 0, sizeof outrel);
14255               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14256                        && !is_opd
14257                        && r_type != R_PPC64_TOC)
14258                 {
14259                   BFD_ASSERT (h->elf.dynindx != -1);
14260                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14261                 }
14262               else
14263                 {
14264                   /* This symbol is local, or marked to become local,
14265                      or this is an opd section reloc which must point
14266                      at a local function.  */
14267                   outrel.r_addend += relocation;
14268                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14269                     {
14270                       if (is_opd && h != NULL)
14271                         {
14272                           /* Lie about opd entries.  This case occurs
14273                              when building shared libraries and we
14274                              reference a function in another shared
14275                              lib.  The same thing happens for a weak
14276                              definition in an application that's
14277                              overridden by a strong definition in a
14278                              shared lib.  (I believe this is a generic
14279                              bug in binutils handling of weak syms.)
14280                              In these cases we won't use the opd
14281                              entry in this lib.  */
14282                           unresolved_reloc = FALSE;
14283                         }
14284                       if (!is_opd
14285                           && r_type == R_PPC64_ADDR64
14286                           && (h != NULL
14287                               ? h->elf.type == STT_GNU_IFUNC
14288                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14289                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14290                       else
14291                         {
14292                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14293
14294                           /* We need to relocate .opd contents for ld.so.
14295                              Prelink also wants simple and consistent rules
14296                              for relocs.  This make all RELATIVE relocs have
14297                              *r_offset equal to r_addend.  */
14298                           relocate = TRUE;
14299                         }
14300                     }
14301                   else
14302                     {
14303                       long indx = 0;
14304
14305                       if (h != NULL
14306                           ? h->elf.type == STT_GNU_IFUNC
14307                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14308                         {
14309                           info->callbacks->einfo
14310                             (_("%P: %H: %s for indirect "
14311                                "function `%T' unsupported\n"),
14312                              input_bfd, input_section, rel->r_offset,
14313                              ppc64_elf_howto_table[r_type]->name,
14314                              sym_name);
14315                           ret = FALSE;
14316                         }
14317                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14318                         ;
14319                       else if (sec == NULL || sec->owner == NULL)
14320                         {
14321                           bfd_set_error (bfd_error_bad_value);
14322                           return FALSE;
14323                         }
14324                       else
14325                         {
14326                           asection *osec;
14327
14328                           osec = sec->output_section;
14329                           indx = elf_section_data (osec)->dynindx;
14330
14331                           if (indx == 0)
14332                             {
14333                               if ((osec->flags & SEC_READONLY) == 0
14334                                   && htab->elf.data_index_section != NULL)
14335                                 osec = htab->elf.data_index_section;
14336                               else
14337                                 osec = htab->elf.text_index_section;
14338                               indx = elf_section_data (osec)->dynindx;
14339                             }
14340                           BFD_ASSERT (indx != 0);
14341
14342                           /* We are turning this relocation into one
14343                              against a section symbol, so subtract out
14344                              the output section's address but not the
14345                              offset of the input section in the output
14346                              section.  */
14347                           outrel.r_addend -= osec->vma;
14348                         }
14349
14350                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14351                     }
14352                 }
14353
14354               sreloc = elf_section_data (input_section)->sreloc;
14355               if (h != NULL
14356                   ? h->elf.type == STT_GNU_IFUNC
14357                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14358                 sreloc = htab->elf.irelplt;
14359               if (sreloc == NULL)
14360                 abort ();
14361
14362               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14363                   >= sreloc->size)
14364                 abort ();
14365               loc = sreloc->contents;
14366               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14367               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14368
14369               /* If this reloc is against an external symbol, it will
14370                  be computed at runtime, so there's no need to do
14371                  anything now.  However, for the sake of prelink ensure
14372                  that the section contents are a known value.  */
14373               if (! relocate)
14374                 {
14375                   unresolved_reloc = FALSE;
14376                   /* The value chosen here is quite arbitrary as ld.so
14377                      ignores section contents except for the special
14378                      case of .opd where the contents might be accessed
14379                      before relocation.  Choose zero, as that won't
14380                      cause reloc overflow.  */
14381                   relocation = 0;
14382                   addend = 0;
14383                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14384                      to improve backward compatibility with older
14385                      versions of ld.  */
14386                   if (r_type == R_PPC64_ADDR64)
14387                     addend = outrel.r_addend;
14388                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14389                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14390                     addend = (input_section->output_section->vma
14391                               + input_section->output_offset
14392                               + rel->r_offset);
14393                 }
14394             }
14395           break;
14396
14397         case R_PPC64_COPY:
14398         case R_PPC64_GLOB_DAT:
14399         case R_PPC64_JMP_SLOT:
14400         case R_PPC64_JMP_IREL:
14401         case R_PPC64_RELATIVE:
14402           /* We shouldn't ever see these dynamic relocs in relocatable
14403              files.  */
14404           /* Fall through.  */
14405
14406         case R_PPC64_PLTGOT16:
14407         case R_PPC64_PLTGOT16_DS:
14408         case R_PPC64_PLTGOT16_HA:
14409         case R_PPC64_PLTGOT16_HI:
14410         case R_PPC64_PLTGOT16_LO:
14411         case R_PPC64_PLTGOT16_LO_DS:
14412         case R_PPC64_PLTREL32:
14413         case R_PPC64_PLTREL64:
14414           /* These ones haven't been implemented yet.  */
14415
14416           info->callbacks->einfo
14417             (_("%P: %B: %s is not supported for `%T'\n"),
14418              input_bfd,
14419              ppc64_elf_howto_table[r_type]->name, sym_name);
14420
14421           bfd_set_error (bfd_error_invalid_operation);
14422           ret = FALSE;
14423           continue;
14424         }
14425
14426       /* Multi-instruction sequences that access the TOC can be
14427          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14428          to             nop;           addi rb,r2,x;  */
14429       switch (r_type)
14430         {
14431         default:
14432           break;
14433
14434         case R_PPC64_GOT_TLSLD16_HI:
14435         case R_PPC64_GOT_TLSGD16_HI:
14436         case R_PPC64_GOT_TPREL16_HI:
14437         case R_PPC64_GOT_DTPREL16_HI:
14438         case R_PPC64_GOT16_HI:
14439         case R_PPC64_TOC16_HI:
14440           /* These relocs would only be useful if building up an
14441              offset to later add to r2, perhaps in an indexed
14442              addressing mode instruction.  Don't try to optimize.
14443              Unfortunately, the possibility of someone building up an
14444              offset like this or even with the HA relocs, means that
14445              we need to check the high insn when optimizing the low
14446              insn.  */
14447           break;
14448
14449         case R_PPC64_GOT_TLSLD16_HA:
14450         case R_PPC64_GOT_TLSGD16_HA:
14451         case R_PPC64_GOT_TPREL16_HA:
14452         case R_PPC64_GOT_DTPREL16_HA:
14453         case R_PPC64_GOT16_HA:
14454         case R_PPC64_TOC16_HA:
14455           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14456               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14457             {
14458               bfd_byte *p = contents + (rel->r_offset & ~3);
14459               bfd_put_32 (input_bfd, NOP, p);
14460             }
14461           break;
14462
14463         case R_PPC64_GOT_TLSLD16_LO:
14464         case R_PPC64_GOT_TLSGD16_LO:
14465         case R_PPC64_GOT_TPREL16_LO_DS:
14466         case R_PPC64_GOT_DTPREL16_LO_DS:
14467         case R_PPC64_GOT16_LO:
14468         case R_PPC64_GOT16_LO_DS:
14469         case R_PPC64_TOC16_LO:
14470         case R_PPC64_TOC16_LO_DS:
14471           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14472               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14473             {
14474               bfd_byte *p = contents + (rel->r_offset & ~3);
14475               insn = bfd_get_32 (input_bfd, p);
14476               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14477                 {
14478                   /* Transform addic to addi when we change reg.  */
14479                   insn &= ~((0x3f << 26) | (0x1f << 16));
14480                   insn |= (14u << 26) | (2 << 16);
14481                 }
14482               else
14483                 {
14484                   insn &= ~(0x1f << 16);
14485                   insn |= 2 << 16;
14486                 }
14487               bfd_put_32 (input_bfd, insn, p);
14488             }
14489           break;
14490         }
14491
14492       /* Do any further special processing.  */
14493       switch (r_type)
14494         {
14495         default:
14496           break;
14497
14498         case R_PPC64_REL16_HA:
14499         case R_PPC64_ADDR16_HA:
14500         case R_PPC64_ADDR16_HIGHA:
14501         case R_PPC64_ADDR16_HIGHERA:
14502         case R_PPC64_ADDR16_HIGHESTA:
14503         case R_PPC64_TOC16_HA:
14504         case R_PPC64_SECTOFF_HA:
14505         case R_PPC64_TPREL16_HA:
14506         case R_PPC64_TPREL16_HIGHA:
14507         case R_PPC64_TPREL16_HIGHERA:
14508         case R_PPC64_TPREL16_HIGHESTA:
14509         case R_PPC64_DTPREL16_HA:
14510         case R_PPC64_DTPREL16_HIGHA:
14511         case R_PPC64_DTPREL16_HIGHERA:
14512         case R_PPC64_DTPREL16_HIGHESTA:
14513           /* It's just possible that this symbol is a weak symbol
14514              that's not actually defined anywhere. In that case,
14515              'sec' would be NULL, and we should leave the symbol
14516              alone (it will be set to zero elsewhere in the link).  */
14517           if (sec == NULL)
14518             break;
14519           /* Fall thru */
14520
14521         case R_PPC64_GOT16_HA:
14522         case R_PPC64_PLTGOT16_HA:
14523         case R_PPC64_PLT16_HA:
14524         case R_PPC64_GOT_TLSGD16_HA:
14525         case R_PPC64_GOT_TLSLD16_HA:
14526         case R_PPC64_GOT_TPREL16_HA:
14527         case R_PPC64_GOT_DTPREL16_HA:
14528           /* Add 0x10000 if sign bit in 0:15 is set.
14529              Bits 0:15 are not used.  */
14530           addend += 0x8000;
14531           break;
14532
14533         case R_PPC64_ADDR16_DS:
14534         case R_PPC64_ADDR16_LO_DS:
14535         case R_PPC64_GOT16_DS:
14536         case R_PPC64_GOT16_LO_DS:
14537         case R_PPC64_PLT16_LO_DS:
14538         case R_PPC64_SECTOFF_DS:
14539         case R_PPC64_SECTOFF_LO_DS:
14540         case R_PPC64_TOC16_DS:
14541         case R_PPC64_TOC16_LO_DS:
14542         case R_PPC64_PLTGOT16_DS:
14543         case R_PPC64_PLTGOT16_LO_DS:
14544         case R_PPC64_GOT_TPREL16_DS:
14545         case R_PPC64_GOT_TPREL16_LO_DS:
14546         case R_PPC64_GOT_DTPREL16_DS:
14547         case R_PPC64_GOT_DTPREL16_LO_DS:
14548         case R_PPC64_TPREL16_DS:
14549         case R_PPC64_TPREL16_LO_DS:
14550         case R_PPC64_DTPREL16_DS:
14551         case R_PPC64_DTPREL16_LO_DS:
14552           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14553           mask = 3;
14554           /* If this reloc is against an lq insn, then the value must be
14555              a multiple of 16.  This is somewhat of a hack, but the
14556              "correct" way to do this by defining _DQ forms of all the
14557              _DS relocs bloats all reloc switches in this file.  It
14558              doesn't seem to make much sense to use any of these relocs
14559              in data, so testing the insn should be safe.  */
14560           if ((insn & (0x3f << 26)) == (56u << 26))
14561             mask = 15;
14562           if (((relocation + addend) & mask) != 0)
14563             {
14564               info->callbacks->einfo
14565                 (_("%P: %H: error: %s not a multiple of %u\n"),
14566                  input_bfd, input_section, rel->r_offset,
14567                  ppc64_elf_howto_table[r_type]->name,
14568                  mask + 1);
14569               bfd_set_error (bfd_error_bad_value);
14570               ret = FALSE;
14571               continue;
14572             }
14573           break;
14574         }
14575
14576       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14577          because such sections are not SEC_ALLOC and thus ld.so will
14578          not process them.  */
14579       if (unresolved_reloc
14580           && !((input_section->flags & SEC_DEBUGGING) != 0
14581                && h->elf.def_dynamic)
14582           && _bfd_elf_section_offset (output_bfd, info, input_section,
14583                                       rel->r_offset) != (bfd_vma) -1)
14584         {
14585           info->callbacks->einfo
14586             (_("%P: %H: unresolvable %s against `%T'\n"),
14587              input_bfd, input_section, rel->r_offset,
14588              ppc64_elf_howto_table[(int) r_type]->name,
14589              h->elf.root.root.string);
14590           ret = FALSE;
14591         }
14592
14593       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14594                                     input_bfd,
14595                                     input_section,
14596                                     contents,
14597                                     rel->r_offset,
14598                                     relocation,
14599                                     addend);
14600
14601       if (r != bfd_reloc_ok)
14602         {
14603           char *more_info = NULL;
14604           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14605
14606           if (reloc_dest != DEST_NORMAL)
14607             {
14608               more_info = bfd_malloc (strlen (reloc_name) + 8);
14609               if (more_info != NULL)
14610                 {
14611                   strcpy (more_info, reloc_name);
14612                   strcat (more_info, (reloc_dest == DEST_OPD
14613                                       ? " (OPD)" : " (stub)"));
14614                   reloc_name = more_info;
14615                 }
14616             }
14617
14618           if (r == bfd_reloc_overflow)
14619             {
14620               if (warned)
14621                 continue;
14622               if (h != NULL
14623                   && h->elf.root.type == bfd_link_hash_undefweak
14624                   && ppc64_elf_howto_table[r_type]->pc_relative)
14625                 {
14626                   /* Assume this is a call protected by other code that
14627                      detects the symbol is undefined.  If this is the case,
14628                      we can safely ignore the overflow.  If not, the
14629                      program is hosed anyway, and a little warning isn't
14630                      going to help.  */
14631
14632                   continue;
14633                 }
14634
14635               if (!((*info->callbacks->reloc_overflow)
14636                     (info, &h->elf.root, sym_name,
14637                      reloc_name, orig_rel.r_addend,
14638                      input_bfd, input_section, rel->r_offset)))
14639                 return FALSE;
14640             }
14641           else
14642             {
14643               info->callbacks->einfo
14644                 (_("%P: %H: %s against `%T': error %d\n"),
14645                  input_bfd, input_section, rel->r_offset,
14646                  reloc_name, sym_name, (int) r);
14647               ret = FALSE;
14648             }
14649           if (more_info != NULL)
14650             free (more_info);
14651         }
14652     }
14653
14654   /* If we're emitting relocations, then shortly after this function
14655      returns, reloc offsets and addends for this section will be
14656      adjusted.  Worse, reloc symbol indices will be for the output
14657      file rather than the input.  Save a copy of the relocs for
14658      opd_entry_value.  */
14659   if (is_opd && (info->emitrelocations || info->relocatable))
14660     {
14661       bfd_size_type amt;
14662       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14663       rel = bfd_alloc (input_bfd, amt);
14664       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14665       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14666       if (rel == NULL)
14667         return FALSE;
14668       memcpy (rel, relocs, amt);
14669     }
14670   return ret;
14671 }
14672
14673 /* Adjust the value of any local symbols in opd sections.  */
14674
14675 static int
14676 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14677                               const char *name ATTRIBUTE_UNUSED,
14678                               Elf_Internal_Sym *elfsym,
14679                               asection *input_sec,
14680                               struct elf_link_hash_entry *h)
14681 {
14682   struct _opd_sec_data *opd;
14683   long adjust;
14684   bfd_vma value;
14685
14686   if (h != NULL)
14687     return 1;
14688
14689   opd = get_opd_info (input_sec);
14690   if (opd == NULL || opd->adjust == NULL)
14691     return 1;
14692
14693   value = elfsym->st_value - input_sec->output_offset;
14694   if (!info->relocatable)
14695     value -= input_sec->output_section->vma;
14696
14697   adjust = opd->adjust[value / 8];
14698   if (adjust == -1)
14699     return 2;
14700
14701   elfsym->st_value += adjust;
14702   return 1;
14703 }
14704
14705 /* Finish up dynamic symbol handling.  We set the contents of various
14706    dynamic sections here.  */
14707
14708 static bfd_boolean
14709 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14710                                  struct bfd_link_info *info,
14711                                  struct elf_link_hash_entry *h,
14712                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14713 {
14714   struct ppc_link_hash_table *htab;
14715   struct plt_entry *ent;
14716   Elf_Internal_Rela rela;
14717   bfd_byte *loc;
14718
14719   htab = ppc_hash_table (info);
14720   if (htab == NULL)
14721     return FALSE;
14722
14723   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14724     if (ent->plt.offset != (bfd_vma) -1)
14725       {
14726         /* This symbol has an entry in the procedure linkage
14727            table.  Set it up.  */
14728         if (!htab->elf.dynamic_sections_created
14729             || h->dynindx == -1)
14730           {
14731             BFD_ASSERT (h->type == STT_GNU_IFUNC
14732                         && h->def_regular
14733                         && (h->root.type == bfd_link_hash_defined
14734                             || h->root.type == bfd_link_hash_defweak));
14735             rela.r_offset = (htab->elf.iplt->output_section->vma
14736                              + htab->elf.iplt->output_offset
14737                              + ent->plt.offset);
14738             if (htab->opd_abi)
14739               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14740             else
14741               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14742             rela.r_addend = (h->root.u.def.value
14743                              + h->root.u.def.section->output_offset
14744                              + h->root.u.def.section->output_section->vma
14745                              + ent->addend);
14746             loc = (htab->elf.irelplt->contents
14747                    + (htab->elf.irelplt->reloc_count++
14748                       * sizeof (Elf64_External_Rela)));
14749           }
14750         else
14751           {
14752             rela.r_offset = (htab->elf.splt->output_section->vma
14753                              + htab->elf.splt->output_offset
14754                              + ent->plt.offset);
14755             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14756             rela.r_addend = ent->addend;
14757             loc = (htab->elf.srelplt->contents
14758                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14759                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14760           }
14761         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14762
14763         if (!htab->opd_abi)
14764           {
14765             if (!h->def_regular)
14766               {
14767                 /* Mark the symbol as undefined, rather than as
14768                    defined in glink.  Leave the value if there were
14769                    any relocations where pointer equality matters
14770                    (this is a clue for the dynamic linker, to make
14771                    function pointer comparisons work between an
14772                    application and shared library), otherwise set it
14773                    to zero.  */
14774                 sym->st_shndx = SHN_UNDEF;
14775                 if (!h->pointer_equality_needed)
14776                   sym->st_value = 0;
14777                 else if (!h->ref_regular_nonweak)
14778                   {
14779                     /* This breaks function pointer comparisons, but
14780                        that is better than breaking tests for a NULL
14781                        function pointer.  */
14782                     sym->st_value = 0;
14783                   }
14784               }
14785           }
14786       }
14787
14788   if (h->needs_copy)
14789     {
14790       /* This symbol needs a copy reloc.  Set it up.  */
14791
14792       if (h->dynindx == -1
14793           || (h->root.type != bfd_link_hash_defined
14794               && h->root.type != bfd_link_hash_defweak)
14795           || htab->relbss == NULL)
14796         abort ();
14797
14798       rela.r_offset = (h->root.u.def.value
14799                        + h->root.u.def.section->output_section->vma
14800                        + h->root.u.def.section->output_offset);
14801       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14802       rela.r_addend = 0;
14803       loc = htab->relbss->contents;
14804       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14805       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14806     }
14807
14808   return TRUE;
14809 }
14810
14811 /* Used to decide how to sort relocs in an optimal manner for the
14812    dynamic linker, before writing them out.  */
14813
14814 static enum elf_reloc_type_class
14815 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14816                             const asection *rel_sec,
14817                             const Elf_Internal_Rela *rela)
14818 {
14819   enum elf_ppc64_reloc_type r_type;
14820   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14821
14822   if (rel_sec == htab->elf.irelplt)
14823     return reloc_class_ifunc;
14824
14825   r_type = ELF64_R_TYPE (rela->r_info);
14826   switch (r_type)
14827     {
14828     case R_PPC64_RELATIVE:
14829       return reloc_class_relative;
14830     case R_PPC64_JMP_SLOT:
14831       return reloc_class_plt;
14832     case R_PPC64_COPY:
14833       return reloc_class_copy;
14834     default:
14835       return reloc_class_normal;
14836     }
14837 }
14838
14839 /* Finish up the dynamic sections.  */
14840
14841 static bfd_boolean
14842 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14843                                    struct bfd_link_info *info)
14844 {
14845   struct ppc_link_hash_table *htab;
14846   bfd *dynobj;
14847   asection *sdyn;
14848
14849   htab = ppc_hash_table (info);
14850   if (htab == NULL)
14851     return FALSE;
14852
14853   dynobj = htab->elf.dynobj;
14854   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14855
14856   if (htab->elf.dynamic_sections_created)
14857     {
14858       Elf64_External_Dyn *dyncon, *dynconend;
14859
14860       if (sdyn == NULL || htab->elf.sgot == NULL)
14861         abort ();
14862
14863       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14864       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14865       for (; dyncon < dynconend; dyncon++)
14866         {
14867           Elf_Internal_Dyn dyn;
14868           asection *s;
14869
14870           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14871
14872           switch (dyn.d_tag)
14873             {
14874             default:
14875               continue;
14876
14877             case DT_PPC64_GLINK:
14878               s = htab->glink;
14879               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14880               /* We stupidly defined DT_PPC64_GLINK to be the start
14881                  of glink rather than the first entry point, which is
14882                  what ld.so needs, and now have a bigger stub to
14883                  support automatic multiple TOCs.  */
14884               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14885               break;
14886
14887             case DT_PPC64_OPD:
14888               s = bfd_get_section_by_name (output_bfd, ".opd");
14889               if (s == NULL)
14890                 continue;
14891               dyn.d_un.d_ptr = s->vma;
14892               break;
14893
14894             case DT_PPC64_OPT:
14895               if (htab->do_multi_toc && htab->multi_toc_needed)
14896                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14897               break;
14898
14899             case DT_PPC64_OPDSZ:
14900               s = bfd_get_section_by_name (output_bfd, ".opd");
14901               if (s == NULL)
14902                 continue;
14903               dyn.d_un.d_val = s->size;
14904               break;
14905
14906             case DT_PLTGOT:
14907               s = htab->elf.splt;
14908               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14909               break;
14910
14911             case DT_JMPREL:
14912               s = htab->elf.srelplt;
14913               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14914               break;
14915
14916             case DT_PLTRELSZ:
14917               dyn.d_un.d_val = htab->elf.srelplt->size;
14918               break;
14919
14920             case DT_RELASZ:
14921               /* Don't count procedure linkage table relocs in the
14922                  overall reloc count.  */
14923               s = htab->elf.srelplt;
14924               if (s == NULL)
14925                 continue;
14926               dyn.d_un.d_val -= s->size;
14927               break;
14928
14929             case DT_RELA:
14930               /* We may not be using the standard ELF linker script.
14931                  If .rela.plt is the first .rela section, we adjust
14932                  DT_RELA to not include it.  */
14933               s = htab->elf.srelplt;
14934               if (s == NULL)
14935                 continue;
14936               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14937                 continue;
14938               dyn.d_un.d_ptr += s->size;
14939               break;
14940             }
14941
14942           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14943         }
14944     }
14945
14946   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14947     {
14948       /* Fill in the first entry in the global offset table.
14949          We use it to hold the link-time TOCbase.  */
14950       bfd_put_64 (output_bfd,
14951                   elf_gp (output_bfd) + TOC_BASE_OFF,
14952                   htab->elf.sgot->contents);
14953
14954       /* Set .got entry size.  */
14955       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14956     }
14957
14958   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14959     {
14960       /* Set .plt entry size.  */
14961       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14962         = PLT_ENTRY_SIZE (htab);
14963     }
14964
14965   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14966      brlt ourselves if emitrelocations.  */
14967   if (htab->brlt != NULL
14968       && htab->brlt->reloc_count != 0
14969       && !_bfd_elf_link_output_relocs (output_bfd,
14970                                        htab->brlt,
14971                                        elf_section_data (htab->brlt)->rela.hdr,
14972                                        elf_section_data (htab->brlt)->relocs,
14973                                        NULL))
14974     return FALSE;
14975
14976   if (htab->glink != NULL
14977       && htab->glink->reloc_count != 0
14978       && !_bfd_elf_link_output_relocs (output_bfd,
14979                                        htab->glink,
14980                                        elf_section_data (htab->glink)->rela.hdr,
14981                                        elf_section_data (htab->glink)->relocs,
14982                                        NULL))
14983     return FALSE;
14984
14985
14986   if (htab->glink_eh_frame != NULL
14987       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14988       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14989                                            htab->glink_eh_frame,
14990                                            htab->glink_eh_frame->contents))
14991     return FALSE;
14992
14993   /* We need to handle writing out multiple GOT sections ourselves,
14994      since we didn't add them to DYNOBJ.  We know dynobj is the first
14995      bfd.  */
14996   while ((dynobj = dynobj->link_next) != NULL)
14997     {
14998       asection *s;
14999
15000       if (!is_ppc64_elf (dynobj))
15001         continue;
15002
15003       s = ppc64_elf_tdata (dynobj)->got;
15004       if (s != NULL
15005           && s->size != 0
15006           && s->output_section != bfd_abs_section_ptr
15007           && !bfd_set_section_contents (output_bfd, s->output_section,
15008                                         s->contents, s->output_offset,
15009                                         s->size))
15010         return FALSE;
15011       s = ppc64_elf_tdata (dynobj)->relgot;
15012       if (s != NULL
15013           && s->size != 0
15014           && s->output_section != bfd_abs_section_ptr
15015           && !bfd_set_section_contents (output_bfd, s->output_section,
15016                                         s->contents, s->output_offset,
15017                                         s->size))
15018         return FALSE;
15019     }
15020
15021   return TRUE;
15022 }
15023
15024 #include "elf64-target.h"
15025
15026 /* FreeBSD support */
15027
15028 #undef  TARGET_LITTLE_SYM
15029 #undef  TARGET_LITTLE_NAME
15030
15031 #undef  TARGET_BIG_SYM
15032 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15033 #undef  TARGET_BIG_NAME
15034 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15035
15036 #undef  ELF_OSABI
15037 #define ELF_OSABI       ELFOSABI_FREEBSD
15038
15039 #undef  elf64_bed
15040 #define elf64_bed       elf64_powerpc_fbsd_bed
15041
15042 #include "elf64-target.h"
15043