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     return NULL;
4172
4173   /* And the branch hash table.  */
4174   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175                             sizeof (struct ppc_branch_hash_entry)))
4176     return NULL;
4177
4178   htab->tocsave_htab = htab_try_create (1024,
4179                                         tocsave_htab_hash,
4180                                         tocsave_htab_eq,
4181                                         NULL);
4182   if (htab->tocsave_htab == NULL)
4183     return NULL;
4184
4185   /* Initializing two fields of the union is just cosmetic.  We really
4186      only care about glist, but when compiled on a 32-bit host the
4187      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4188      debugger inspection of these fields look nicer.  */
4189   htab->elf.init_got_refcount.refcount = 0;
4190   htab->elf.init_got_refcount.glist = NULL;
4191   htab->elf.init_plt_refcount.refcount = 0;
4192   htab->elf.init_plt_refcount.glist = NULL;
4193   htab->elf.init_got_offset.offset = 0;
4194   htab->elf.init_got_offset.glist = NULL;
4195   htab->elf.init_plt_offset.offset = 0;
4196   htab->elf.init_plt_offset.glist = NULL;
4197
4198   return &htab->elf.root;
4199 }
4200
4201 /* Free the derived linker hash table.  */
4202
4203 static void
4204 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4205 {
4206   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4207
4208   bfd_hash_table_free (&htab->stub_hash_table);
4209   bfd_hash_table_free (&htab->branch_hash_table);
4210   if (htab->tocsave_htab)
4211     htab_delete (htab->tocsave_htab);
4212   _bfd_elf_link_hash_table_free (hash);
4213 }
4214
4215 /* Create sections for linker generated code.  */
4216
4217 static bfd_boolean
4218 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4219 {
4220   struct ppc_link_hash_table *htab;
4221   flagword flags;
4222
4223   htab = ppc_hash_table (info);
4224
4225   /* Create .sfpr for code to save and restore fp regs.  */
4226   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4227            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4228   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4229                                                    flags);
4230   if (htab->sfpr == NULL
4231       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4232     return FALSE;
4233
4234   /* Create .glink for lazy dynamic linking support.  */
4235   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4236                                                     flags);
4237   if (htab->glink == NULL
4238       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4239     return FALSE;
4240
4241   if (!info->no_ld_generated_unwind_info)
4242     {
4243       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4244                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4246                                                                  ".eh_frame",
4247                                                                  flags);
4248       if (htab->glink_eh_frame == NULL
4249           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4250         return FALSE;
4251     }
4252
4253   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4254   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4255   if (htab->elf.iplt == NULL
4256       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4257     return FALSE;
4258
4259   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4260            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4261   htab->elf.irelplt
4262     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4263   if (htab->elf.irelplt == NULL
4264       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4265     return FALSE;
4266
4267   /* Create branch lookup table for plt_branch stubs.  */
4268   flags = (SEC_ALLOC | SEC_LOAD
4269            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4271                                                    flags);
4272   if (htab->brlt == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4274     return FALSE;
4275
4276   if (!info->shared)
4277     return TRUE;
4278
4279   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4280            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4281   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4282                                                       ".rela.branch_lt",
4283                                                       flags);
4284   if (htab->relbrlt == NULL
4285       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4286     return FALSE;
4287
4288   return TRUE;
4289 }
4290
4291 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4292
4293 bfd_boolean
4294 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4295 {
4296   struct ppc_link_hash_table *htab;
4297
4298   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4299
4300 /* Always hook our dynamic sections into the first bfd, which is the
4301    linker created stub bfd.  This ensures that the GOT header is at
4302    the start of the output TOC section.  */
4303   htab = ppc_hash_table (info);
4304   if (htab == NULL)
4305     return FALSE;
4306   htab->stub_bfd = abfd;
4307   htab->elf.dynobj = abfd;
4308
4309   if (info->relocatable)
4310     return TRUE;
4311
4312   return create_linkage_sections (htab->elf.dynobj, info);
4313 }
4314
4315 /* Build a name for an entry in the stub hash table.  */
4316
4317 static char *
4318 ppc_stub_name (const asection *input_section,
4319                const asection *sym_sec,
4320                const struct ppc_link_hash_entry *h,
4321                const Elf_Internal_Rela *rel)
4322 {
4323   char *stub_name;
4324   ssize_t len;
4325
4326   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4327      offsets from a sym as a branch target?  In fact, we could
4328      probably assume the addend is always zero.  */
4329   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4330
4331   if (h)
4332     {
4333       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4334       stub_name = bfd_malloc (len);
4335       if (stub_name == NULL)
4336         return stub_name;
4337
4338       len = sprintf (stub_name, "%08x.%s+%x",
4339                      input_section->id & 0xffffffff,
4340                      h->elf.root.root.string,
4341                      (int) rel->r_addend & 0xffffffff);
4342     }
4343   else
4344     {
4345       len = 8 + 1 + 8 + 1 + 8 + 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.%x:%x+%x",
4351                      input_section->id & 0xffffffff,
4352                      sym_sec->id & 0xffffffff,
4353                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4354                      (int) rel->r_addend & 0xffffffff);
4355     }
4356   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4357     stub_name[len - 2] = 0;
4358   return stub_name;
4359 }
4360
4361 /* Look up an entry in the stub hash.  Stub entries are cached because
4362    creating the stub name takes a bit of time.  */
4363
4364 static struct ppc_stub_hash_entry *
4365 ppc_get_stub_entry (const asection *input_section,
4366                     const asection *sym_sec,
4367                     struct ppc_link_hash_entry *h,
4368                     const Elf_Internal_Rela *rel,
4369                     struct ppc_link_hash_table *htab)
4370 {
4371   struct ppc_stub_hash_entry *stub_entry;
4372   const asection *id_sec;
4373
4374   /* If this input section is part of a group of sections sharing one
4375      stub section, then use the id of the first section in the group.
4376      Stub names need to include a section id, as there may well be
4377      more than one stub used to reach say, printf, and we need to
4378      distinguish between them.  */
4379   id_sec = htab->stub_group[input_section->id].link_sec;
4380
4381   if (h != NULL && h->u.stub_cache != NULL
4382       && h->u.stub_cache->h == h
4383       && h->u.stub_cache->id_sec == id_sec)
4384     {
4385       stub_entry = h->u.stub_cache;
4386     }
4387   else
4388     {
4389       char *stub_name;
4390
4391       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4392       if (stub_name == NULL)
4393         return NULL;
4394
4395       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4396                                          stub_name, FALSE, FALSE);
4397       if (h != NULL)
4398         h->u.stub_cache = stub_entry;
4399
4400       free (stub_name);
4401     }
4402
4403   return stub_entry;
4404 }
4405
4406 /* Add a new stub entry to the stub hash.  Not all fields of the new
4407    stub entry are initialised.  */
4408
4409 static struct ppc_stub_hash_entry *
4410 ppc_add_stub (const char *stub_name,
4411               asection *section,
4412               struct bfd_link_info *info)
4413 {
4414   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4415   asection *link_sec;
4416   asection *stub_sec;
4417   struct ppc_stub_hash_entry *stub_entry;
4418
4419   link_sec = htab->stub_group[section->id].link_sec;
4420   stub_sec = htab->stub_group[section->id].stub_sec;
4421   if (stub_sec == NULL)
4422     {
4423       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4424       if (stub_sec == NULL)
4425         {
4426           size_t namelen;
4427           bfd_size_type len;
4428           char *s_name;
4429
4430           namelen = strlen (link_sec->name);
4431           len = namelen + sizeof (STUB_SUFFIX);
4432           s_name = bfd_alloc (htab->stub_bfd, len);
4433           if (s_name == NULL)
4434             return NULL;
4435
4436           memcpy (s_name, link_sec->name, namelen);
4437           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4438           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4439           if (stub_sec == NULL)
4440             return NULL;
4441           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4442         }
4443       htab->stub_group[section->id].stub_sec = stub_sec;
4444     }
4445
4446   /* Enter this entry into the linker stub hash table.  */
4447   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4448                                      TRUE, FALSE);
4449   if (stub_entry == NULL)
4450     {
4451       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4452                               section->owner, stub_name);
4453       return NULL;
4454     }
4455
4456   stub_entry->stub_sec = stub_sec;
4457   stub_entry->stub_offset = 0;
4458   stub_entry->id_sec = link_sec;
4459   return stub_entry;
4460 }
4461
4462 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4463    not already done.  */
4464
4465 static bfd_boolean
4466 create_got_section (bfd *abfd, struct bfd_link_info *info)
4467 {
4468   asection *got, *relgot;
4469   flagword flags;
4470   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4471
4472   if (!is_ppc64_elf (abfd))
4473     return FALSE;
4474   if (htab == NULL)
4475     return FALSE;
4476
4477   if (!htab->elf.sgot
4478       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4479     return FALSE;
4480
4481   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4482            | SEC_LINKER_CREATED);
4483
4484   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4485   if (!got
4486       || !bfd_set_section_alignment (abfd, got, 3))
4487     return FALSE;
4488
4489   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4490                                                flags | SEC_READONLY);
4491   if (!relgot
4492       || ! bfd_set_section_alignment (abfd, relgot, 3))
4493     return FALSE;
4494
4495   ppc64_elf_tdata (abfd)->got = got;
4496   ppc64_elf_tdata (abfd)->relgot = relgot;
4497   return TRUE;
4498 }
4499
4500 /* Create the dynamic sections, and set up shortcuts.  */
4501
4502 static bfd_boolean
4503 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4504 {
4505   struct ppc_link_hash_table *htab;
4506
4507   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4508     return FALSE;
4509
4510   htab = ppc_hash_table (info);
4511   if (htab == NULL)
4512     return FALSE;
4513
4514   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4515   if (!info->shared)
4516     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4517
4518   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4519       || (!info->shared && !htab->relbss))
4520     abort ();
4521
4522   return TRUE;
4523 }
4524
4525 /* Follow indirect and warning symbol links.  */
4526
4527 static inline struct bfd_link_hash_entry *
4528 follow_link (struct bfd_link_hash_entry *h)
4529 {
4530   while (h->type == bfd_link_hash_indirect
4531          || h->type == bfd_link_hash_warning)
4532     h = h->u.i.link;
4533   return h;
4534 }
4535
4536 static inline struct elf_link_hash_entry *
4537 elf_follow_link (struct elf_link_hash_entry *h)
4538 {
4539   return (struct elf_link_hash_entry *) follow_link (&h->root);
4540 }
4541
4542 static inline struct ppc_link_hash_entry *
4543 ppc_follow_link (struct ppc_link_hash_entry *h)
4544 {
4545   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4546 }
4547
4548 /* Merge PLT info on FROM with that on TO.  */
4549
4550 static void
4551 move_plt_plist (struct ppc_link_hash_entry *from,
4552                 struct ppc_link_hash_entry *to)
4553 {
4554   if (from->elf.plt.plist != NULL)
4555     {
4556       if (to->elf.plt.plist != NULL)
4557         {
4558           struct plt_entry **entp;
4559           struct plt_entry *ent;
4560
4561           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4562             {
4563               struct plt_entry *dent;
4564
4565               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4566                 if (dent->addend == ent->addend)
4567                   {
4568                     dent->plt.refcount += ent->plt.refcount;
4569                     *entp = ent->next;
4570                     break;
4571                   }
4572               if (dent == NULL)
4573                 entp = &ent->next;
4574             }
4575           *entp = to->elf.plt.plist;
4576         }
4577
4578       to->elf.plt.plist = from->elf.plt.plist;
4579       from->elf.plt.plist = NULL;
4580     }
4581 }
4582
4583 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4584
4585 static void
4586 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4587                                 struct elf_link_hash_entry *dir,
4588                                 struct elf_link_hash_entry *ind)
4589 {
4590   struct ppc_link_hash_entry *edir, *eind;
4591
4592   edir = (struct ppc_link_hash_entry *) dir;
4593   eind = (struct ppc_link_hash_entry *) ind;
4594
4595   edir->is_func |= eind->is_func;
4596   edir->is_func_descriptor |= eind->is_func_descriptor;
4597   edir->tls_mask |= eind->tls_mask;
4598   if (eind->oh != NULL)
4599     edir->oh = ppc_follow_link (eind->oh);
4600
4601   /* If called to transfer flags for a weakdef during processing
4602      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4603      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4604   if (!(ELIMINATE_COPY_RELOCS
4605         && eind->elf.root.type != bfd_link_hash_indirect
4606         && edir->elf.dynamic_adjusted))
4607     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4608
4609   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4610   edir->elf.ref_regular |= eind->elf.ref_regular;
4611   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4612   edir->elf.needs_plt |= eind->elf.needs_plt;
4613   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4614
4615   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4616   if (eind->dyn_relocs != NULL)
4617     {
4618       if (edir->dyn_relocs != NULL)
4619         {
4620           struct elf_dyn_relocs **pp;
4621           struct elf_dyn_relocs *p;
4622
4623           /* Add reloc counts against the indirect sym to the direct sym
4624              list.  Merge any entries against the same section.  */
4625           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4626             {
4627               struct elf_dyn_relocs *q;
4628
4629               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4630                 if (q->sec == p->sec)
4631                   {
4632                     q->pc_count += p->pc_count;
4633                     q->count += p->count;
4634                     *pp = p->next;
4635                     break;
4636                   }
4637               if (q == NULL)
4638                 pp = &p->next;
4639             }
4640           *pp = edir->dyn_relocs;
4641         }
4642
4643       edir->dyn_relocs = eind->dyn_relocs;
4644       eind->dyn_relocs = NULL;
4645     }
4646
4647   /* If we were called to copy over info for a weak sym, that's all.
4648      You might think dyn_relocs need not be copied over;  After all,
4649      both syms will be dynamic or both non-dynamic so we're just
4650      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4651      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4652      dyn_relocs in read-only sections, and it does so on what is the
4653      DIR sym here.  */
4654   if (eind->elf.root.type != bfd_link_hash_indirect)
4655     return;
4656
4657   /* Copy over got entries that we may have already seen to the
4658      symbol which just became indirect.  */
4659   if (eind->elf.got.glist != NULL)
4660     {
4661       if (edir->elf.got.glist != NULL)
4662         {
4663           struct got_entry **entp;
4664           struct got_entry *ent;
4665
4666           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4667             {
4668               struct got_entry *dent;
4669
4670               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4671                 if (dent->addend == ent->addend
4672                     && dent->owner == ent->owner
4673                     && dent->tls_type == ent->tls_type)
4674                   {
4675                     dent->got.refcount += ent->got.refcount;
4676                     *entp = ent->next;
4677                     break;
4678                   }
4679               if (dent == NULL)
4680                 entp = &ent->next;
4681             }
4682           *entp = edir->elf.got.glist;
4683         }
4684
4685       edir->elf.got.glist = eind->elf.got.glist;
4686       eind->elf.got.glist = NULL;
4687     }
4688
4689   /* And plt entries.  */
4690   move_plt_plist (eind, edir);
4691
4692   if (eind->elf.dynindx != -1)
4693     {
4694       if (edir->elf.dynindx != -1)
4695         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4696                                 edir->elf.dynstr_index);
4697       edir->elf.dynindx = eind->elf.dynindx;
4698       edir->elf.dynstr_index = eind->elf.dynstr_index;
4699       eind->elf.dynindx = -1;
4700       eind->elf.dynstr_index = 0;
4701     }
4702 }
4703
4704 /* Find the function descriptor hash entry from the given function code
4705    hash entry FH.  Link the entries via their OH fields.  */
4706
4707 static struct ppc_link_hash_entry *
4708 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4709 {
4710   struct ppc_link_hash_entry *fdh = fh->oh;
4711
4712   if (fdh == NULL)
4713     {
4714       const char *fd_name = fh->elf.root.root.string + 1;
4715
4716       fdh = (struct ppc_link_hash_entry *)
4717         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4718       if (fdh == NULL)
4719         return fdh;
4720
4721       fdh->is_func_descriptor = 1;
4722       fdh->oh = fh;
4723       fh->is_func = 1;
4724       fh->oh = fdh;
4725     }
4726
4727   return ppc_follow_link (fdh);
4728 }
4729
4730 /* Make a fake function descriptor sym for the code sym FH.  */
4731
4732 static struct ppc_link_hash_entry *
4733 make_fdh (struct bfd_link_info *info,
4734           struct ppc_link_hash_entry *fh)
4735 {
4736   bfd *abfd;
4737   asymbol *newsym;
4738   struct bfd_link_hash_entry *bh;
4739   struct ppc_link_hash_entry *fdh;
4740
4741   abfd = fh->elf.root.u.undef.abfd;
4742   newsym = bfd_make_empty_symbol (abfd);
4743   newsym->name = fh->elf.root.root.string + 1;
4744   newsym->section = bfd_und_section_ptr;
4745   newsym->value = 0;
4746   newsym->flags = BSF_WEAK;
4747
4748   bh = NULL;
4749   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4750                                          newsym->flags, newsym->section,
4751                                          newsym->value, NULL, FALSE, FALSE,
4752                                          &bh))
4753     return NULL;
4754
4755   fdh = (struct ppc_link_hash_entry *) bh;
4756   fdh->elf.non_elf = 0;
4757   fdh->fake = 1;
4758   fdh->is_func_descriptor = 1;
4759   fdh->oh = fh;
4760   fh->is_func = 1;
4761   fh->oh = fdh;
4762   return fdh;
4763 }
4764
4765 /* Fix function descriptor symbols defined in .opd sections to be
4766    function type.  */
4767
4768 static bfd_boolean
4769 ppc64_elf_add_symbol_hook (bfd *ibfd,
4770                            struct bfd_link_info *info,
4771                            Elf_Internal_Sym *isym,
4772                            const char **name,
4773                            flagword *flags ATTRIBUTE_UNUSED,
4774                            asection **sec,
4775                            bfd_vma *value ATTRIBUTE_UNUSED)
4776 {
4777   if ((ibfd->flags & DYNAMIC) == 0
4778       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4779     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4780
4781   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4782     {
4783       if ((ibfd->flags & DYNAMIC) == 0)
4784         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4785     }
4786   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4787     ;
4788   else if (*sec != NULL
4789            && strcmp ((*sec)->name, ".opd") == 0)
4790     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4791
4792   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4793     {
4794       if (abiversion (ibfd) == 0)
4795         set_abiversion (ibfd, 2);
4796       else if (abiversion (ibfd) == 1)
4797         {
4798           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4799                                     " for ABI version 1\n"), name);
4800           bfd_set_error (bfd_error_bad_value);
4801           return FALSE;
4802         }
4803     }
4804
4805   return TRUE;
4806 }
4807
4808 /* Merge non-visibility st_other attributes: local entry point.  */
4809
4810 static void
4811 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4812                                   const Elf_Internal_Sym *isym,
4813                                   bfd_boolean definition,
4814                                   bfd_boolean dynamic)
4815 {
4816   if (definition && !dynamic)
4817     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4818                 | ELF_ST_VISIBILITY (h->other));
4819 }
4820
4821 /* This function makes an old ABI object reference to ".bar" cause the
4822    inclusion of a new ABI object archive that defines "bar".
4823    NAME is a symbol defined in an archive.  Return a symbol in the hash
4824    table that might be satisfied by the archive symbols.  */
4825
4826 static struct elf_link_hash_entry *
4827 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4828                                  struct bfd_link_info *info,
4829                                  const char *name)
4830 {
4831   struct elf_link_hash_entry *h;
4832   char *dot_name;
4833   size_t len;
4834
4835   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4836   if (h != NULL
4837       /* Don't return this sym if it is a fake function descriptor
4838          created by add_symbol_adjust.  */
4839       && !(h->root.type == bfd_link_hash_undefweak
4840            && ((struct ppc_link_hash_entry *) h)->fake))
4841     return h;
4842
4843   if (name[0] == '.')
4844     return h;
4845
4846   len = strlen (name);
4847   dot_name = bfd_alloc (abfd, len + 2);
4848   if (dot_name == NULL)
4849     return (struct elf_link_hash_entry *) 0 - 1;
4850   dot_name[0] = '.';
4851   memcpy (dot_name + 1, name, len + 1);
4852   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4853   bfd_release (abfd, dot_name);
4854   return h;
4855 }
4856
4857 /* This function satisfies all old ABI object references to ".bar" if a
4858    new ABI object defines "bar".  Well, at least, undefined dot symbols
4859    are made weak.  This stops later archive searches from including an
4860    object if we already have a function descriptor definition.  It also
4861    prevents the linker complaining about undefined symbols.
4862    We also check and correct mismatched symbol visibility here.  The
4863    most restrictive visibility of the function descriptor and the
4864    function entry symbol is used.  */
4865
4866 static bfd_boolean
4867 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4868 {
4869   struct ppc_link_hash_table *htab;
4870   struct ppc_link_hash_entry *fdh;
4871
4872   if (eh->elf.root.type == bfd_link_hash_indirect)
4873     return TRUE;
4874
4875   if (eh->elf.root.type == bfd_link_hash_warning)
4876     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4877
4878   if (eh->elf.root.root.string[0] != '.')
4879     abort ();
4880
4881   htab = ppc_hash_table (info);
4882   if (htab == NULL)
4883     return FALSE;
4884
4885   fdh = lookup_fdh (eh, htab);
4886   if (fdh == NULL)
4887     {
4888       if (!info->relocatable
4889           && (eh->elf.root.type == bfd_link_hash_undefined
4890               || eh->elf.root.type == bfd_link_hash_undefweak)
4891           && eh->elf.ref_regular)
4892         {
4893           /* Make an undefweak function descriptor sym, which is enough to
4894              pull in an --as-needed shared lib, but won't cause link
4895              errors.  Archives are handled elsewhere.  */
4896           fdh = make_fdh (info, eh);
4897           if (fdh == NULL)
4898             return FALSE;
4899           fdh->elf.ref_regular = 1;
4900         }
4901     }
4902   else
4903     {
4904       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4905       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4906       if (entry_vis < descr_vis)
4907         fdh->elf.other += entry_vis - descr_vis;
4908       else if (entry_vis > descr_vis)
4909         eh->elf.other += descr_vis - entry_vis;
4910
4911       if ((fdh->elf.root.type == bfd_link_hash_defined
4912            || fdh->elf.root.type == bfd_link_hash_defweak)
4913           && eh->elf.root.type == bfd_link_hash_undefined)
4914         {
4915           eh->elf.root.type = bfd_link_hash_undefweak;
4916           eh->was_undefined = 1;
4917           htab->twiddled_syms = 1;
4918         }
4919     }
4920
4921   return TRUE;
4922 }
4923
4924 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4925
4926 static bfd_boolean
4927 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4928 {
4929   struct ppc_link_hash_table *htab;
4930   struct ppc_link_hash_entry **p, *eh;
4931
4932   if (!is_ppc64_elf (info->output_bfd))
4933     return TRUE;
4934   htab = ppc_hash_table (info);
4935   if (htab == NULL)
4936     return FALSE;
4937
4938   if (is_ppc64_elf (ibfd))
4939     {
4940       p = &htab->dot_syms;
4941       while ((eh = *p) != NULL)
4942         {
4943           *p = NULL;
4944           if (&eh->elf == htab->elf.hgot)
4945             ;
4946           else if (htab->elf.hgot == NULL
4947                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4948             htab->elf.hgot = &eh->elf;
4949           else if (!add_symbol_adjust (eh, info))
4950             return FALSE;
4951           p = &eh->u.next_dot_sym;
4952         }
4953     }
4954
4955   /* Clear the list for non-ppc64 input files.  */
4956   p = &htab->dot_syms;
4957   while ((eh = *p) != NULL)
4958     {
4959       *p = NULL;
4960       p = &eh->u.next_dot_sym;
4961     }
4962
4963   /* We need to fix the undefs list for any syms we have twiddled to
4964      undef_weak.  */
4965   if (htab->twiddled_syms)
4966     {
4967       bfd_link_repair_undef_list (&htab->elf.root);
4968       htab->twiddled_syms = 0;
4969     }
4970   return TRUE;
4971 }
4972
4973 /* Undo hash table changes when an --as-needed input file is determined
4974    not to be needed.  */
4975
4976 static bfd_boolean
4977 ppc64_elf_notice_as_needed (bfd *ibfd,
4978                             struct bfd_link_info *info,
4979                             enum notice_asneeded_action act)
4980 {
4981   if (act == notice_not_needed)
4982     {
4983       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4984
4985       if (htab == NULL)
4986         return FALSE;
4987
4988       htab->dot_syms = NULL;
4989     }
4990   return _bfd_elf_notice_as_needed (ibfd, info, act);
4991 }
4992
4993 /* If --just-symbols against a final linked binary, then assume we need
4994    toc adjusting stubs when calling functions defined there.  */
4995
4996 static void
4997 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4998 {
4999   if ((sec->flags & SEC_CODE) != 0
5000       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5001       && is_ppc64_elf (sec->owner))
5002     {
5003       if (abiversion (sec->owner) >= 2
5004           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5005         sec->has_toc_reloc = 1;
5006     }
5007   _bfd_elf_link_just_syms (sec, info);
5008 }
5009
5010 static struct plt_entry **
5011 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5012                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5013 {
5014   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5015   struct plt_entry **local_plt;
5016   unsigned char *local_got_tls_masks;
5017
5018   if (local_got_ents == NULL)
5019     {
5020       bfd_size_type size = symtab_hdr->sh_info;
5021
5022       size *= (sizeof (*local_got_ents)
5023                + sizeof (*local_plt)
5024                + sizeof (*local_got_tls_masks));
5025       local_got_ents = bfd_zalloc (abfd, size);
5026       if (local_got_ents == NULL)
5027         return NULL;
5028       elf_local_got_ents (abfd) = local_got_ents;
5029     }
5030
5031   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5032     {
5033       struct got_entry *ent;
5034
5035       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5036         if (ent->addend == r_addend
5037             && ent->owner == abfd
5038             && ent->tls_type == tls_type)
5039           break;
5040       if (ent == NULL)
5041         {
5042           bfd_size_type amt = sizeof (*ent);
5043           ent = bfd_alloc (abfd, amt);
5044           if (ent == NULL)
5045             return FALSE;
5046           ent->next = local_got_ents[r_symndx];
5047           ent->addend = r_addend;
5048           ent->owner = abfd;
5049           ent->tls_type = tls_type;
5050           ent->is_indirect = FALSE;
5051           ent->got.refcount = 0;
5052           local_got_ents[r_symndx] = ent;
5053         }
5054       ent->got.refcount += 1;
5055     }
5056
5057   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5058   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5059   local_got_tls_masks[r_symndx] |= tls_type;
5060
5061   return local_plt + r_symndx;
5062 }
5063
5064 static bfd_boolean
5065 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5066 {
5067   struct plt_entry *ent;
5068
5069   for (ent = *plist; ent != NULL; ent = ent->next)
5070     if (ent->addend == addend)
5071       break;
5072   if (ent == NULL)
5073     {
5074       bfd_size_type amt = sizeof (*ent);
5075       ent = bfd_alloc (abfd, amt);
5076       if (ent == NULL)
5077         return FALSE;
5078       ent->next = *plist;
5079       ent->addend = addend;
5080       ent->plt.refcount = 0;
5081       *plist = ent;
5082     }
5083   ent->plt.refcount += 1;
5084   return TRUE;
5085 }
5086
5087 static bfd_boolean
5088 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5089 {
5090   return (r_type == R_PPC64_REL24
5091           || r_type == R_PPC64_REL14
5092           || r_type == R_PPC64_REL14_BRTAKEN
5093           || r_type == R_PPC64_REL14_BRNTAKEN
5094           || r_type == R_PPC64_ADDR24
5095           || r_type == R_PPC64_ADDR14
5096           || r_type == R_PPC64_ADDR14_BRTAKEN
5097           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5098 }
5099
5100 /* Look through the relocs for a section during the first phase, and
5101    calculate needed space in the global offset table, procedure
5102    linkage table, and dynamic reloc sections.  */
5103
5104 static bfd_boolean
5105 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5106                         asection *sec, const Elf_Internal_Rela *relocs)
5107 {
5108   struct ppc_link_hash_table *htab;
5109   Elf_Internal_Shdr *symtab_hdr;
5110   struct elf_link_hash_entry **sym_hashes;
5111   const Elf_Internal_Rela *rel;
5112   const Elf_Internal_Rela *rel_end;
5113   asection *sreloc;
5114   asection **opd_sym_map;
5115   struct elf_link_hash_entry *tga, *dottga;
5116
5117   if (info->relocatable)
5118     return TRUE;
5119
5120   /* Don't do anything special with non-loaded, non-alloced sections.
5121      In particular, any relocs in such sections should not affect GOT
5122      and PLT reference counting (ie. we don't allow them to create GOT
5123      or PLT entries), there's no possibility or desire to optimize TLS
5124      relocs, and there's not much point in propagating relocs to shared
5125      libs that the dynamic linker won't relocate.  */
5126   if ((sec->flags & SEC_ALLOC) == 0)
5127     return TRUE;
5128
5129   BFD_ASSERT (is_ppc64_elf (abfd));
5130
5131   htab = ppc_hash_table (info);
5132   if (htab == NULL)
5133     return FALSE;
5134
5135   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5136                               FALSE, FALSE, TRUE);
5137   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5138                                  FALSE, FALSE, TRUE);
5139   symtab_hdr = &elf_symtab_hdr (abfd);
5140   sym_hashes = elf_sym_hashes (abfd);
5141   sreloc = NULL;
5142   opd_sym_map = NULL;
5143   if (strcmp (sec->name, ".opd") == 0)
5144     {
5145       /* Garbage collection needs some extra help with .opd sections.
5146          We don't want to necessarily keep everything referenced by
5147          relocs in .opd, as that would keep all functions.  Instead,
5148          if we reference an .opd symbol (a function descriptor), we
5149          want to keep the function code symbol's section.  This is
5150          easy for global symbols, but for local syms we need to keep
5151          information about the associated function section.  */
5152       bfd_size_type amt;
5153
5154       if (abiversion (abfd) == 0)
5155         set_abiversion (abfd, 1);
5156       else if (abiversion (abfd) == 2)
5157         {
5158           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5159                                   abiversion (abfd));
5160           bfd_set_error (bfd_error_bad_value);
5161           return FALSE;
5162         }
5163       amt = sec->size * sizeof (*opd_sym_map) / 8;
5164       opd_sym_map = bfd_zalloc (abfd, amt);
5165       if (opd_sym_map == NULL)
5166         return FALSE;
5167       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5168       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5169       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5170     }
5171
5172   rel_end = relocs + sec->reloc_count;
5173   for (rel = relocs; rel < rel_end; rel++)
5174     {
5175       unsigned long r_symndx;
5176       struct elf_link_hash_entry *h;
5177       enum elf_ppc64_reloc_type r_type;
5178       int tls_type;
5179       struct _ppc64_elf_section_data *ppc64_sec;
5180       struct plt_entry **ifunc;
5181
5182       r_symndx = ELF64_R_SYM (rel->r_info);
5183       if (r_symndx < symtab_hdr->sh_info)
5184         h = NULL;
5185       else
5186         {
5187           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5188           h = elf_follow_link (h);
5189
5190           /* PR15323, ref flags aren't set for references in the same
5191              object.  */
5192           h->root.non_ir_ref = 1;
5193
5194           if (h == htab->elf.hgot)
5195             sec->has_toc_reloc = 1;
5196         }
5197
5198       tls_type = 0;
5199       ifunc = NULL;
5200       if (h != NULL)
5201         {
5202           if (h->type == STT_GNU_IFUNC)
5203             {
5204               h->needs_plt = 1;
5205               ifunc = &h->plt.plist;
5206             }
5207         }
5208       else
5209         {
5210           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5211                                                           abfd, r_symndx);
5212           if (isym == NULL)
5213             return FALSE;
5214
5215           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5216             {
5217               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5218                                              rel->r_addend, PLT_IFUNC);
5219               if (ifunc == NULL)
5220                 return FALSE;
5221             }
5222         }
5223       r_type = ELF64_R_TYPE (rel->r_info);
5224       if (is_branch_reloc (r_type))
5225         {
5226           if (h != NULL && (h == tga || h == dottga))
5227             {
5228               if (rel != relocs
5229                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5230                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5231                 /* We have a new-style __tls_get_addr call with a marker
5232                    reloc.  */
5233                 ;
5234               else
5235                 /* Mark this section as having an old-style call.  */
5236                 sec->has_tls_get_addr_call = 1;
5237             }
5238
5239           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5240           if (ifunc != NULL
5241               && !update_plt_info (abfd, ifunc, rel->r_addend))
5242             return FALSE;
5243         }
5244
5245       switch (r_type)
5246         {
5247         case R_PPC64_TLSGD:
5248         case R_PPC64_TLSLD:
5249           /* These special tls relocs tie a call to __tls_get_addr with
5250              its parameter symbol.  */
5251           break;
5252
5253         case R_PPC64_GOT_TLSLD16:
5254         case R_PPC64_GOT_TLSLD16_LO:
5255         case R_PPC64_GOT_TLSLD16_HI:
5256         case R_PPC64_GOT_TLSLD16_HA:
5257           tls_type = TLS_TLS | TLS_LD;
5258           goto dogottls;
5259
5260         case R_PPC64_GOT_TLSGD16:
5261         case R_PPC64_GOT_TLSGD16_LO:
5262         case R_PPC64_GOT_TLSGD16_HI:
5263         case R_PPC64_GOT_TLSGD16_HA:
5264           tls_type = TLS_TLS | TLS_GD;
5265           goto dogottls;
5266
5267         case R_PPC64_GOT_TPREL16_DS:
5268         case R_PPC64_GOT_TPREL16_LO_DS:
5269         case R_PPC64_GOT_TPREL16_HI:
5270         case R_PPC64_GOT_TPREL16_HA:
5271           if (!info->executable)
5272             info->flags |= DF_STATIC_TLS;
5273           tls_type = TLS_TLS | TLS_TPREL;
5274           goto dogottls;
5275
5276         case R_PPC64_GOT_DTPREL16_DS:
5277         case R_PPC64_GOT_DTPREL16_LO_DS:
5278         case R_PPC64_GOT_DTPREL16_HI:
5279         case R_PPC64_GOT_DTPREL16_HA:
5280           tls_type = TLS_TLS | TLS_DTPREL;
5281         dogottls:
5282           sec->has_tls_reloc = 1;
5283           /* Fall thru */
5284
5285         case R_PPC64_GOT16:
5286         case R_PPC64_GOT16_DS:
5287         case R_PPC64_GOT16_HA:
5288         case R_PPC64_GOT16_HI:
5289         case R_PPC64_GOT16_LO:
5290         case R_PPC64_GOT16_LO_DS:
5291           /* This symbol requires a global offset table entry.  */
5292           sec->has_toc_reloc = 1;
5293           if (r_type == R_PPC64_GOT_TLSLD16
5294               || r_type == R_PPC64_GOT_TLSGD16
5295               || r_type == R_PPC64_GOT_TPREL16_DS
5296               || r_type == R_PPC64_GOT_DTPREL16_DS
5297               || r_type == R_PPC64_GOT16
5298               || r_type == R_PPC64_GOT16_DS)
5299             {
5300               htab->do_multi_toc = 1;
5301               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5302             }
5303
5304           if (ppc64_elf_tdata (abfd)->got == NULL
5305               && !create_got_section (abfd, info))
5306             return FALSE;
5307
5308           if (h != NULL)
5309             {
5310               struct ppc_link_hash_entry *eh;
5311               struct got_entry *ent;
5312
5313               eh = (struct ppc_link_hash_entry *) h;
5314               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5315                 if (ent->addend == rel->r_addend
5316                     && ent->owner == abfd
5317                     && ent->tls_type == tls_type)
5318                   break;
5319               if (ent == NULL)
5320                 {
5321                   bfd_size_type amt = sizeof (*ent);
5322                   ent = bfd_alloc (abfd, amt);
5323                   if (ent == NULL)
5324                     return FALSE;
5325                   ent->next = eh->elf.got.glist;
5326                   ent->addend = rel->r_addend;
5327                   ent->owner = abfd;
5328                   ent->tls_type = tls_type;
5329                   ent->is_indirect = FALSE;
5330                   ent->got.refcount = 0;
5331                   eh->elf.got.glist = ent;
5332                 }
5333               ent->got.refcount += 1;
5334               eh->tls_mask |= tls_type;
5335             }
5336           else
5337             /* This is a global offset table entry for a local symbol.  */
5338             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5339                                         rel->r_addend, tls_type))
5340               return FALSE;
5341
5342           /* We may also need a plt entry if the symbol turns out to be
5343              an ifunc.  */
5344           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5345             {
5346               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5347                 return FALSE;
5348             }
5349           break;
5350
5351         case R_PPC64_PLT16_HA:
5352         case R_PPC64_PLT16_HI:
5353         case R_PPC64_PLT16_LO:
5354         case R_PPC64_PLT32:
5355         case R_PPC64_PLT64:
5356           /* This symbol requires a procedure linkage table entry.  We
5357              actually build the entry in adjust_dynamic_symbol,
5358              because this might be a case of linking PIC code without
5359              linking in any dynamic objects, in which case we don't
5360              need to generate a procedure linkage table after all.  */
5361           if (h == NULL)
5362             {
5363               /* It does not make sense to have a procedure linkage
5364                  table entry for a local symbol.  */
5365               bfd_set_error (bfd_error_bad_value);
5366               return FALSE;
5367             }
5368           else
5369             {
5370               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5371                 return FALSE;
5372               h->needs_plt = 1;
5373               if (h->root.root.string[0] == '.'
5374                   && h->root.root.string[1] != '\0')
5375                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5376             }
5377           break;
5378
5379           /* The following relocations don't need to propagate the
5380              relocation if linking a shared object since they are
5381              section relative.  */
5382         case R_PPC64_SECTOFF:
5383         case R_PPC64_SECTOFF_LO:
5384         case R_PPC64_SECTOFF_HI:
5385         case R_PPC64_SECTOFF_HA:
5386         case R_PPC64_SECTOFF_DS:
5387         case R_PPC64_SECTOFF_LO_DS:
5388         case R_PPC64_DTPREL16:
5389         case R_PPC64_DTPREL16_LO:
5390         case R_PPC64_DTPREL16_HI:
5391         case R_PPC64_DTPREL16_HA:
5392         case R_PPC64_DTPREL16_DS:
5393         case R_PPC64_DTPREL16_LO_DS:
5394         case R_PPC64_DTPREL16_HIGH:
5395         case R_PPC64_DTPREL16_HIGHA:
5396         case R_PPC64_DTPREL16_HIGHER:
5397         case R_PPC64_DTPREL16_HIGHERA:
5398         case R_PPC64_DTPREL16_HIGHEST:
5399         case R_PPC64_DTPREL16_HIGHESTA:
5400           break;
5401
5402           /* Nor do these.  */
5403         case R_PPC64_REL16:
5404         case R_PPC64_REL16_LO:
5405         case R_PPC64_REL16_HI:
5406         case R_PPC64_REL16_HA:
5407           break;
5408
5409         case R_PPC64_TOC16:
5410         case R_PPC64_TOC16_DS:
5411           htab->do_multi_toc = 1;
5412           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5413         case R_PPC64_TOC16_LO:
5414         case R_PPC64_TOC16_HI:
5415         case R_PPC64_TOC16_HA:
5416         case R_PPC64_TOC16_LO_DS:
5417           sec->has_toc_reloc = 1;
5418           break;
5419
5420           /* This relocation describes the C++ object vtable hierarchy.
5421              Reconstruct it for later use during GC.  */
5422         case R_PPC64_GNU_VTINHERIT:
5423           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5424             return FALSE;
5425           break;
5426
5427           /* This relocation describes which C++ vtable entries are actually
5428              used.  Record for later use during GC.  */
5429         case R_PPC64_GNU_VTENTRY:
5430           BFD_ASSERT (h != NULL);
5431           if (h != NULL
5432               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5433             return FALSE;
5434           break;
5435
5436         case R_PPC64_REL14:
5437         case R_PPC64_REL14_BRTAKEN:
5438         case R_PPC64_REL14_BRNTAKEN:
5439           {
5440             asection *dest = NULL;
5441
5442             /* Heuristic: If jumping outside our section, chances are
5443                we are going to need a stub.  */
5444             if (h != NULL)
5445               {
5446                 /* If the sym is weak it may be overridden later, so
5447                    don't assume we know where a weak sym lives.  */
5448                 if (h->root.type == bfd_link_hash_defined)
5449                   dest = h->root.u.def.section;
5450               }
5451             else
5452               {
5453                 Elf_Internal_Sym *isym;
5454
5455                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5456                                               abfd, r_symndx);
5457                 if (isym == NULL)
5458                   return FALSE;
5459
5460                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5461               }
5462
5463             if (dest != sec)
5464               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5465           }
5466           /* Fall through.  */
5467
5468         case R_PPC64_REL24:
5469           if (h != NULL && ifunc == NULL)
5470             {
5471               /* We may need a .plt entry if the function this reloc
5472                  refers to is in a shared lib.  */
5473               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5474                 return FALSE;
5475               h->needs_plt = 1;
5476               if (h->root.root.string[0] == '.'
5477                   && h->root.root.string[1] != '\0')
5478                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5479               if (h == tga || h == dottga)
5480                 sec->has_tls_reloc = 1;
5481             }
5482           break;
5483
5484         case R_PPC64_TPREL64:
5485           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5486           if (!info->executable)
5487             info->flags |= DF_STATIC_TLS;
5488           goto dotlstoc;
5489
5490         case R_PPC64_DTPMOD64:
5491           if (rel + 1 < rel_end
5492               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5493               && rel[1].r_offset == rel->r_offset + 8)
5494             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5495           else
5496             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5497           goto dotlstoc;
5498
5499         case R_PPC64_DTPREL64:
5500           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5501           if (rel != relocs
5502               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5503               && rel[-1].r_offset == rel->r_offset - 8)
5504             /* This is the second reloc of a dtpmod, dtprel pair.
5505                Don't mark with TLS_DTPREL.  */
5506             goto dodyn;
5507
5508         dotlstoc:
5509           sec->has_tls_reloc = 1;
5510           if (h != NULL)
5511             {
5512               struct ppc_link_hash_entry *eh;
5513               eh = (struct ppc_link_hash_entry *) h;
5514               eh->tls_mask |= tls_type;
5515             }
5516           else
5517             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5518                                         rel->r_addend, tls_type))
5519               return FALSE;
5520
5521           ppc64_sec = ppc64_elf_section_data (sec);
5522           if (ppc64_sec->sec_type != sec_toc)
5523             {
5524               bfd_size_type amt;
5525
5526               /* One extra to simplify get_tls_mask.  */
5527               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5528               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5529               if (ppc64_sec->u.toc.symndx == NULL)
5530                 return FALSE;
5531               amt = sec->size * sizeof (bfd_vma) / 8;
5532               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5533               if (ppc64_sec->u.toc.add == NULL)
5534                 return FALSE;
5535               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5536               ppc64_sec->sec_type = sec_toc;
5537             }
5538           BFD_ASSERT (rel->r_offset % 8 == 0);
5539           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5540           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5541
5542           /* Mark the second slot of a GD or LD entry.
5543              -1 to indicate GD and -2 to indicate LD.  */
5544           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5545             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5546           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5547             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5548           goto dodyn;
5549
5550         case R_PPC64_TPREL16:
5551         case R_PPC64_TPREL16_LO:
5552         case R_PPC64_TPREL16_HI:
5553         case R_PPC64_TPREL16_HA:
5554         case R_PPC64_TPREL16_DS:
5555         case R_PPC64_TPREL16_LO_DS:
5556         case R_PPC64_TPREL16_HIGH:
5557         case R_PPC64_TPREL16_HIGHA:
5558         case R_PPC64_TPREL16_HIGHER:
5559         case R_PPC64_TPREL16_HIGHERA:
5560         case R_PPC64_TPREL16_HIGHEST:
5561         case R_PPC64_TPREL16_HIGHESTA:
5562           if (info->shared)
5563             {
5564               if (!info->executable)
5565                 info->flags |= DF_STATIC_TLS;
5566               goto dodyn;
5567             }
5568           break;
5569
5570         case R_PPC64_ADDR64:
5571           if (opd_sym_map != NULL
5572               && rel + 1 < rel_end
5573               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5574             {
5575               if (h != NULL)
5576                 {
5577                   if (h->root.root.string[0] == '.'
5578                       && h->root.root.string[1] != 0
5579                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5580                     ;
5581                   else
5582                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5583                 }
5584               else
5585                 {
5586                   asection *s;
5587                   Elf_Internal_Sym *isym;
5588
5589                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5590                                                 abfd, r_symndx);
5591                   if (isym == NULL)
5592                     return FALSE;
5593
5594                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5595                   if (s != NULL && s != sec)
5596                     opd_sym_map[rel->r_offset / 8] = s;
5597                 }
5598             }
5599           /* Fall through.  */
5600
5601         case R_PPC64_ADDR16:
5602         case R_PPC64_ADDR16_DS:
5603         case R_PPC64_ADDR16_HA:
5604         case R_PPC64_ADDR16_HI:
5605         case R_PPC64_ADDR16_HIGH:
5606         case R_PPC64_ADDR16_HIGHA:
5607         case R_PPC64_ADDR16_HIGHER:
5608         case R_PPC64_ADDR16_HIGHERA:
5609         case R_PPC64_ADDR16_HIGHEST:
5610         case R_PPC64_ADDR16_HIGHESTA:
5611         case R_PPC64_ADDR16_LO:
5612         case R_PPC64_ADDR16_LO_DS:
5613           if (h != NULL && !info->shared && abiversion (abfd) == 2
5614               && rel->r_addend == 0)
5615             {
5616               /* We may need a .plt entry if this reloc refers to a
5617                  function in a shared lib.  */
5618               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5619                 return FALSE;
5620               h->pointer_equality_needed = 1;
5621             }
5622           /* Fall through.  */
5623
5624         case R_PPC64_REL30:
5625         case R_PPC64_REL32:
5626         case R_PPC64_REL64:
5627         case R_PPC64_ADDR14:
5628         case R_PPC64_ADDR14_BRNTAKEN:
5629         case R_PPC64_ADDR14_BRTAKEN:
5630         case R_PPC64_ADDR24:
5631         case R_PPC64_ADDR32:
5632         case R_PPC64_UADDR16:
5633         case R_PPC64_UADDR32:
5634         case R_PPC64_UADDR64:
5635         case R_PPC64_TOC:
5636           if (h != NULL && !info->shared)
5637             /* We may need a copy reloc.  */
5638             h->non_got_ref = 1;
5639
5640           /* Don't propagate .opd relocs.  */
5641           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5642             break;
5643
5644           /* If we are creating a shared library, and this is a reloc
5645              against a global symbol, or a non PC relative reloc
5646              against a local symbol, then we need to copy the reloc
5647              into the shared library.  However, if we are linking with
5648              -Bsymbolic, we do not need to copy a reloc against a
5649              global symbol which is defined in an object we are
5650              including in the link (i.e., DEF_REGULAR is set).  At
5651              this point we have not seen all the input files, so it is
5652              possible that DEF_REGULAR is not set now but will be set
5653              later (it is never cleared).  In case of a weak definition,
5654              DEF_REGULAR may be cleared later by a strong definition in
5655              a shared library.  We account for that possibility below by
5656              storing information in the dyn_relocs field of the hash
5657              table entry.  A similar situation occurs when creating
5658              shared libraries and symbol visibility changes render the
5659              symbol local.
5660
5661              If on the other hand, we are creating an executable, we
5662              may need to keep relocations for symbols satisfied by a
5663              dynamic library if we manage to avoid copy relocs for the
5664              symbol.  */
5665         dodyn:
5666           if ((info->shared
5667                && (must_be_dyn_reloc (info, r_type)
5668                    || (h != NULL
5669                        && (!SYMBOLIC_BIND (info, h)
5670                            || h->root.type == bfd_link_hash_defweak
5671                            || !h->def_regular))))
5672               || (ELIMINATE_COPY_RELOCS
5673                   && !info->shared
5674                   && h != NULL
5675                   && (h->root.type == bfd_link_hash_defweak
5676                       || !h->def_regular))
5677               || (!info->shared
5678                   && ifunc != NULL))
5679             {
5680               /* We must copy these reloc types into the output file.
5681                  Create a reloc section in dynobj and make room for
5682                  this reloc.  */
5683               if (sreloc == NULL)
5684                 {
5685                   sreloc = _bfd_elf_make_dynamic_reloc_section
5686                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5687
5688                   if (sreloc == NULL)
5689                     return FALSE;
5690                 }
5691
5692               /* If this is a global symbol, we count the number of
5693                  relocations we need for this symbol.  */
5694               if (h != NULL)
5695                 {
5696                   struct elf_dyn_relocs *p;
5697                   struct elf_dyn_relocs **head;
5698
5699                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5700                   p = *head;
5701                   if (p == NULL || p->sec != sec)
5702                     {
5703                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5704                       if (p == NULL)
5705                         return FALSE;
5706                       p->next = *head;
5707                       *head = p;
5708                       p->sec = sec;
5709                       p->count = 0;
5710                       p->pc_count = 0;
5711                     }
5712                   p->count += 1;
5713                   if (!must_be_dyn_reloc (info, r_type))
5714                     p->pc_count += 1;
5715                 }
5716               else
5717                 {
5718                   /* Track dynamic relocs needed for local syms too.
5719                      We really need local syms available to do this
5720                      easily.  Oh well.  */
5721                   struct ppc_dyn_relocs *p;
5722                   struct ppc_dyn_relocs **head;
5723                   bfd_boolean is_ifunc;
5724                   asection *s;
5725                   void *vpp;
5726                   Elf_Internal_Sym *isym;
5727
5728                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5729                                                 abfd, r_symndx);
5730                   if (isym == NULL)
5731                     return FALSE;
5732
5733                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5734                   if (s == NULL)
5735                     s = sec;
5736
5737                   vpp = &elf_section_data (s)->local_dynrel;
5738                   head = (struct ppc_dyn_relocs **) vpp;
5739                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5740                   p = *head;
5741                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5742                     p = p->next;
5743                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5744                     {
5745                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5746                       if (p == NULL)
5747                         return FALSE;
5748                       p->next = *head;
5749                       *head = p;
5750                       p->sec = sec;
5751                       p->ifunc = is_ifunc;
5752                       p->count = 0;
5753                     }
5754                   p->count += 1;
5755                 }
5756             }
5757           break;
5758
5759         default:
5760           break;
5761         }
5762     }
5763
5764   return TRUE;
5765 }
5766
5767 /* Merge backend specific data from an object file to the output
5768    object file when linking.  */
5769
5770 static bfd_boolean
5771 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5772 {
5773   unsigned long iflags, oflags;
5774
5775   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5776     return TRUE;
5777
5778   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5779     return TRUE;
5780
5781   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5782     return FALSE;
5783
5784   iflags = elf_elfheader (ibfd)->e_flags;
5785   oflags = elf_elfheader (obfd)->e_flags;
5786
5787   if (!elf_flags_init (obfd) || oflags == 0)
5788     {
5789       elf_flags_init (obfd) = TRUE;
5790       elf_elfheader (obfd)->e_flags = iflags;
5791     }
5792   else if (iflags == oflags || iflags == 0)
5793     ;
5794   else if (iflags & ~EF_PPC64_ABI)
5795     {
5796       (*_bfd_error_handler)
5797         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5798       bfd_set_error (bfd_error_bad_value);
5799       return FALSE;
5800     }
5801   else
5802     {
5803       (*_bfd_error_handler)
5804         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5805          ibfd, iflags, oflags);
5806       bfd_set_error (bfd_error_bad_value);
5807       return FALSE;
5808     }
5809
5810   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5811   _bfd_elf_merge_object_attributes (ibfd, obfd);
5812
5813   return TRUE;
5814 }
5815
5816 static bfd_boolean
5817 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5818 {
5819   /* Print normal ELF private data.  */
5820   _bfd_elf_print_private_bfd_data (abfd, ptr);
5821
5822   if (elf_elfheader (abfd)->e_flags != 0)
5823     {
5824       FILE *file = ptr;
5825
5826       /* xgettext:c-format */
5827       fprintf (file, _("private flags = 0x%lx:"),
5828                elf_elfheader (abfd)->e_flags);
5829
5830       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5831         fprintf (file, _(" [abiv%ld]"),
5832                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5833       fputc ('\n', file);
5834     }
5835
5836   return TRUE;
5837 }
5838
5839 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5840    of the code entry point, and its section.  */
5841
5842 static bfd_vma
5843 opd_entry_value (asection *opd_sec,
5844                  bfd_vma offset,
5845                  asection **code_sec,
5846                  bfd_vma *code_off,
5847                  bfd_boolean in_code_sec)
5848 {
5849   bfd *opd_bfd = opd_sec->owner;
5850   Elf_Internal_Rela *relocs;
5851   Elf_Internal_Rela *lo, *hi, *look;
5852   bfd_vma val;
5853
5854   /* No relocs implies we are linking a --just-symbols object, or looking
5855      at a final linked executable with addr2line or somesuch.  */
5856   if (opd_sec->reloc_count == 0)
5857     {
5858       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5859
5860       if (contents == NULL)
5861         {
5862           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5863             return (bfd_vma) -1;
5864           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5865         }
5866
5867       val = bfd_get_64 (opd_bfd, contents + offset);
5868       if (code_sec != NULL)
5869         {
5870           asection *sec, *likely = NULL;
5871
5872           if (in_code_sec)
5873             {
5874               sec = *code_sec;
5875               if (sec->vma <= val
5876                   && val < sec->vma + sec->size)
5877                 likely = sec;
5878               else
5879                 val = -1;
5880             }
5881           else
5882             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5883               if (sec->vma <= val
5884                   && (sec->flags & SEC_LOAD) != 0
5885                   && (sec->flags & SEC_ALLOC) != 0)
5886                 likely = sec;
5887           if (likely != NULL)
5888             {
5889               *code_sec = likely;
5890               if (code_off != NULL)
5891                 *code_off = val - likely->vma;
5892             }
5893         }
5894       return val;
5895     }
5896
5897   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5898
5899   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5900   if (relocs == NULL)
5901     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5902
5903   /* Go find the opd reloc at the sym address.  */
5904   lo = relocs;
5905   BFD_ASSERT (lo != NULL);
5906   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5907   val = (bfd_vma) -1;
5908   while (lo < hi)
5909     {
5910       look = lo + (hi - lo) / 2;
5911       if (look->r_offset < offset)
5912         lo = look + 1;
5913       else if (look->r_offset > offset)
5914         hi = look;
5915       else
5916         {
5917           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5918
5919           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5920               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5921             {
5922               unsigned long symndx = ELF64_R_SYM (look->r_info);
5923               asection *sec;
5924
5925               if (symndx < symtab_hdr->sh_info
5926                   || elf_sym_hashes (opd_bfd) == NULL)
5927                 {
5928                   Elf_Internal_Sym *sym;
5929
5930                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5931                   if (sym == NULL)
5932                     {
5933                       size_t symcnt = symtab_hdr->sh_info;
5934                       if (elf_sym_hashes (opd_bfd) == NULL)
5935                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5936                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5937                                                   0, NULL, NULL, NULL);
5938                       if (sym == NULL)
5939                         break;
5940                       symtab_hdr->contents = (bfd_byte *) sym;
5941                     }
5942
5943                   sym += symndx;
5944                   val = sym->st_value;
5945                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5946                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5947                 }
5948               else
5949                 {
5950                   struct elf_link_hash_entry **sym_hashes;
5951                   struct elf_link_hash_entry *rh;
5952
5953                   sym_hashes = elf_sym_hashes (opd_bfd);
5954                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5955                   if (rh != NULL)
5956                     {
5957                       rh = elf_follow_link (rh);
5958                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5959                                   || rh->root.type == bfd_link_hash_defweak);
5960                       val = rh->root.u.def.value;
5961                       sec = rh->root.u.def.section;
5962                     }
5963                   else
5964                     {
5965                       /* Handle the odd case where we can be called
5966                          during bfd_elf_link_add_symbols before the
5967                          symbol hashes have been fully populated.  */
5968                       Elf_Internal_Sym *sym;
5969
5970                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5971                                                   symndx, NULL, NULL, NULL);
5972                       if (sym == NULL)
5973                         break;
5974
5975                       val = sym->st_value;
5976                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5977                       free (sym);
5978                     }
5979                 }
5980               val += look->r_addend;
5981               if (code_off != NULL)
5982                 *code_off = val;
5983               if (code_sec != NULL)
5984                 {
5985                   if (in_code_sec && *code_sec != sec)
5986                     return -1;
5987                   else
5988                     *code_sec = sec;
5989                 }
5990               if (sec != NULL && sec->output_section != NULL)
5991                 val += sec->output_section->vma + sec->output_offset;
5992             }
5993           break;
5994         }
5995     }
5996
5997   return val;
5998 }
5999
6000 /* If the ELF symbol SYM might be a function in SEC, return the
6001    function size and set *CODE_OFF to the function's entry point,
6002    otherwise return zero.  */
6003
6004 static bfd_size_type
6005 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6006                               bfd_vma *code_off)
6007 {
6008   bfd_size_type size;
6009
6010   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6011                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6012     return 0;
6013
6014   size = 0;
6015   if (!(sym->flags & BSF_SYNTHETIC))
6016     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6017
6018   if (strcmp (sym->section->name, ".opd") == 0)
6019     {
6020       if (opd_entry_value (sym->section, sym->value,
6021                            &sec, code_off, TRUE) == (bfd_vma) -1)
6022         return 0;
6023       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6024          symbol.  This size has nothing to do with the code size of the
6025          function, which is what we're supposed to return, but the
6026          code size isn't available without looking up the dot-sym.
6027          However, doing that would be a waste of time particularly
6028          since elf_find_function will look at the dot-sym anyway.
6029          Now, elf_find_function will keep the largest size of any
6030          function sym found at the code address of interest, so return
6031          1 here to avoid it incorrectly caching a larger function size
6032          for a small function.  This does mean we return the wrong
6033          size for a new-ABI function of size 24, but all that does is
6034          disable caching for such functions.  */
6035       if (size == 24)
6036         size = 1;
6037     }
6038   else
6039     {
6040       if (sym->section != sec)
6041         return 0;
6042       *code_off = sym->value;
6043     }
6044   if (size == 0)
6045     size = 1;
6046   return size;
6047 }
6048
6049 /* Return true if symbol is defined in a regular object file.  */
6050
6051 static bfd_boolean
6052 is_static_defined (struct elf_link_hash_entry *h)
6053 {
6054   return ((h->root.type == bfd_link_hash_defined
6055            || h->root.type == bfd_link_hash_defweak)
6056           && h->root.u.def.section != NULL
6057           && h->root.u.def.section->output_section != NULL);
6058 }
6059
6060 /* If FDH is a function descriptor symbol, return the associated code
6061    entry symbol if it is defined.  Return NULL otherwise.  */
6062
6063 static struct ppc_link_hash_entry *
6064 defined_code_entry (struct ppc_link_hash_entry *fdh)
6065 {
6066   if (fdh->is_func_descriptor)
6067     {
6068       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6069       if (fh->elf.root.type == bfd_link_hash_defined
6070           || fh->elf.root.type == bfd_link_hash_defweak)
6071         return fh;
6072     }
6073   return NULL;
6074 }
6075
6076 /* If FH is a function code entry symbol, return the associated
6077    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6078
6079 static struct ppc_link_hash_entry *
6080 defined_func_desc (struct ppc_link_hash_entry *fh)
6081 {
6082   if (fh->oh != NULL
6083       && fh->oh->is_func_descriptor)
6084     {
6085       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6086       if (fdh->elf.root.type == bfd_link_hash_defined
6087           || fdh->elf.root.type == bfd_link_hash_defweak)
6088         return fdh;
6089     }
6090   return NULL;
6091 }
6092
6093 /* Mark all our entry sym sections, both opd and code section.  */
6094
6095 static void
6096 ppc64_elf_gc_keep (struct bfd_link_info *info)
6097 {
6098   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6099   struct bfd_sym_chain *sym;
6100
6101   if (htab == NULL)
6102     return;
6103
6104   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6105     {
6106       struct ppc_link_hash_entry *eh, *fh;
6107       asection *sec;
6108
6109       eh = (struct ppc_link_hash_entry *)
6110         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6111       if (eh == NULL)
6112         continue;
6113       if (eh->elf.root.type != bfd_link_hash_defined
6114           && eh->elf.root.type != bfd_link_hash_defweak)
6115         continue;
6116
6117       fh = defined_code_entry (eh);
6118       if (fh != NULL)
6119         {
6120           sec = fh->elf.root.u.def.section;
6121           sec->flags |= SEC_KEEP;
6122         }
6123       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6124                && opd_entry_value (eh->elf.root.u.def.section,
6125                                    eh->elf.root.u.def.value,
6126                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6127         sec->flags |= SEC_KEEP;
6128
6129       sec = eh->elf.root.u.def.section;
6130       sec->flags |= SEC_KEEP;
6131     }
6132 }
6133
6134 /* Mark sections containing dynamically referenced symbols.  When
6135    building shared libraries, we must assume that any visible symbol is
6136    referenced.  */
6137
6138 static bfd_boolean
6139 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6140 {
6141   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6142   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6143   struct ppc_link_hash_entry *fdh;
6144
6145   /* Dynamic linking info is on the func descriptor sym.  */
6146   fdh = defined_func_desc (eh);
6147   if (fdh != NULL)
6148     eh = fdh;
6149
6150   if ((eh->elf.root.type == bfd_link_hash_defined
6151        || eh->elf.root.type == bfd_link_hash_defweak)
6152       && (eh->elf.ref_dynamic
6153           || (!info->executable
6154               && eh->elf.def_regular
6155               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6156               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6157               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6158                   || !bfd_hide_sym_by_version (info->version_info,
6159                                                eh->elf.root.root.string)))))
6160     {
6161       asection *code_sec;
6162       struct ppc_link_hash_entry *fh;
6163
6164       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6165
6166       /* Function descriptor syms cause the associated
6167          function code sym section to be marked.  */
6168       fh = defined_code_entry (eh);
6169       if (fh != NULL)
6170         {
6171           code_sec = fh->elf.root.u.def.section;
6172           code_sec->flags |= SEC_KEEP;
6173         }
6174       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6175                && opd_entry_value (eh->elf.root.u.def.section,
6176                                    eh->elf.root.u.def.value,
6177                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6178         code_sec->flags |= SEC_KEEP;
6179     }
6180
6181   return TRUE;
6182 }
6183
6184 /* Return the section that should be marked against GC for a given
6185    relocation.  */
6186
6187 static asection *
6188 ppc64_elf_gc_mark_hook (asection *sec,
6189                         struct bfd_link_info *info,
6190                         Elf_Internal_Rela *rel,
6191                         struct elf_link_hash_entry *h,
6192                         Elf_Internal_Sym *sym)
6193 {
6194   asection *rsec;
6195
6196   /* Syms return NULL if we're marking .opd, so we avoid marking all
6197      function sections, as all functions are referenced in .opd.  */
6198   rsec = NULL;
6199   if (get_opd_info (sec) != NULL)
6200     return rsec;
6201
6202   if (h != NULL)
6203     {
6204       enum elf_ppc64_reloc_type r_type;
6205       struct ppc_link_hash_entry *eh, *fh, *fdh;
6206
6207       r_type = ELF64_R_TYPE (rel->r_info);
6208       switch (r_type)
6209         {
6210         case R_PPC64_GNU_VTINHERIT:
6211         case R_PPC64_GNU_VTENTRY:
6212           break;
6213
6214         default:
6215           switch (h->root.type)
6216             {
6217             case bfd_link_hash_defined:
6218             case bfd_link_hash_defweak:
6219               eh = (struct ppc_link_hash_entry *) h;
6220               fdh = defined_func_desc (eh);
6221               if (fdh != NULL)
6222                 eh = fdh;
6223
6224               /* Function descriptor syms cause the associated
6225                  function code sym section to be marked.  */
6226               fh = defined_code_entry (eh);
6227               if (fh != NULL)
6228                 {
6229                   /* They also mark their opd section.  */
6230                   eh->elf.root.u.def.section->gc_mark = 1;
6231
6232                   rsec = fh->elf.root.u.def.section;
6233                 }
6234               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6235                        && opd_entry_value (eh->elf.root.u.def.section,
6236                                            eh->elf.root.u.def.value,
6237                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6238                 eh->elf.root.u.def.section->gc_mark = 1;
6239               else
6240                 rsec = h->root.u.def.section;
6241               break;
6242
6243             case bfd_link_hash_common:
6244               rsec = h->root.u.c.p->section;
6245               break;
6246
6247             default:
6248               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6249             }
6250         }
6251     }
6252   else
6253     {
6254       struct _opd_sec_data *opd;
6255
6256       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6257       opd = get_opd_info (rsec);
6258       if (opd != NULL && opd->func_sec != NULL)
6259         {
6260           rsec->gc_mark = 1;
6261
6262           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6263         }
6264     }
6265
6266   return rsec;
6267 }
6268
6269 /* Update the .got, .plt. and dynamic reloc reference counts for the
6270    section being removed.  */
6271
6272 static bfd_boolean
6273 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6274                          asection *sec, const Elf_Internal_Rela *relocs)
6275 {
6276   struct ppc_link_hash_table *htab;
6277   Elf_Internal_Shdr *symtab_hdr;
6278   struct elf_link_hash_entry **sym_hashes;
6279   struct got_entry **local_got_ents;
6280   const Elf_Internal_Rela *rel, *relend;
6281
6282   if (info->relocatable)
6283     return TRUE;
6284
6285   if ((sec->flags & SEC_ALLOC) == 0)
6286     return TRUE;
6287
6288   elf_section_data (sec)->local_dynrel = NULL;
6289
6290   htab = ppc_hash_table (info);
6291   if (htab == NULL)
6292     return FALSE;
6293
6294   symtab_hdr = &elf_symtab_hdr (abfd);
6295   sym_hashes = elf_sym_hashes (abfd);
6296   local_got_ents = elf_local_got_ents (abfd);
6297
6298   relend = relocs + sec->reloc_count;
6299   for (rel = relocs; rel < relend; rel++)
6300     {
6301       unsigned long r_symndx;
6302       enum elf_ppc64_reloc_type r_type;
6303       struct elf_link_hash_entry *h = NULL;
6304       unsigned char tls_type = 0;
6305
6306       r_symndx = ELF64_R_SYM (rel->r_info);
6307       r_type = ELF64_R_TYPE (rel->r_info);
6308       if (r_symndx >= symtab_hdr->sh_info)
6309         {
6310           struct ppc_link_hash_entry *eh;
6311           struct elf_dyn_relocs **pp;
6312           struct elf_dyn_relocs *p;
6313
6314           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6315           h = elf_follow_link (h);
6316           eh = (struct ppc_link_hash_entry *) h;
6317
6318           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6319             if (p->sec == sec)
6320               {
6321                 /* Everything must go for SEC.  */
6322                 *pp = p->next;
6323                 break;
6324               }
6325         }
6326
6327       if (is_branch_reloc (r_type))
6328         {
6329           struct plt_entry **ifunc = NULL;
6330           if (h != NULL)
6331             {
6332               if (h->type == STT_GNU_IFUNC)
6333                 ifunc = &h->plt.plist;
6334             }
6335           else if (local_got_ents != NULL)
6336             {
6337               struct plt_entry **local_plt = (struct plt_entry **)
6338                 (local_got_ents + symtab_hdr->sh_info);
6339               unsigned char *local_got_tls_masks = (unsigned char *)
6340                 (local_plt + symtab_hdr->sh_info);
6341               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6342                 ifunc = local_plt + r_symndx;
6343             }
6344           if (ifunc != NULL)
6345             {
6346               struct plt_entry *ent;
6347
6348               for (ent = *ifunc; ent != NULL; ent = ent->next)
6349                 if (ent->addend == rel->r_addend)
6350                   break;
6351               if (ent == NULL)
6352                 abort ();
6353               if (ent->plt.refcount > 0)
6354                 ent->plt.refcount -= 1;
6355               continue;
6356             }
6357         }
6358
6359       switch (r_type)
6360         {
6361         case R_PPC64_GOT_TLSLD16:
6362         case R_PPC64_GOT_TLSLD16_LO:
6363         case R_PPC64_GOT_TLSLD16_HI:
6364         case R_PPC64_GOT_TLSLD16_HA:
6365           tls_type = TLS_TLS | TLS_LD;
6366           goto dogot;
6367
6368         case R_PPC64_GOT_TLSGD16:
6369         case R_PPC64_GOT_TLSGD16_LO:
6370         case R_PPC64_GOT_TLSGD16_HI:
6371         case R_PPC64_GOT_TLSGD16_HA:
6372           tls_type = TLS_TLS | TLS_GD;
6373           goto dogot;
6374
6375         case R_PPC64_GOT_TPREL16_DS:
6376         case R_PPC64_GOT_TPREL16_LO_DS:
6377         case R_PPC64_GOT_TPREL16_HI:
6378         case R_PPC64_GOT_TPREL16_HA:
6379           tls_type = TLS_TLS | TLS_TPREL;
6380           goto dogot;
6381
6382         case R_PPC64_GOT_DTPREL16_DS:
6383         case R_PPC64_GOT_DTPREL16_LO_DS:
6384         case R_PPC64_GOT_DTPREL16_HI:
6385         case R_PPC64_GOT_DTPREL16_HA:
6386           tls_type = TLS_TLS | TLS_DTPREL;
6387           goto dogot;
6388
6389         case R_PPC64_GOT16:
6390         case R_PPC64_GOT16_DS:
6391         case R_PPC64_GOT16_HA:
6392         case R_PPC64_GOT16_HI:
6393         case R_PPC64_GOT16_LO:
6394         case R_PPC64_GOT16_LO_DS:
6395         dogot:
6396           {
6397             struct got_entry *ent;
6398
6399             if (h != NULL)
6400               ent = h->got.glist;
6401             else
6402               ent = local_got_ents[r_symndx];
6403
6404             for (; ent != NULL; ent = ent->next)
6405               if (ent->addend == rel->r_addend
6406                   && ent->owner == abfd
6407                   && ent->tls_type == tls_type)
6408                 break;
6409             if (ent == NULL)
6410               abort ();
6411             if (ent->got.refcount > 0)
6412               ent->got.refcount -= 1;
6413           }
6414           break;
6415
6416         case R_PPC64_PLT16_HA:
6417         case R_PPC64_PLT16_HI:
6418         case R_PPC64_PLT16_LO:
6419         case R_PPC64_PLT32:
6420         case R_PPC64_PLT64:
6421         case R_PPC64_REL14:
6422         case R_PPC64_REL14_BRNTAKEN:
6423         case R_PPC64_REL14_BRTAKEN:
6424         case R_PPC64_REL24:
6425           if (h != NULL)
6426             {
6427               struct plt_entry *ent;
6428
6429               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6430                 if (ent->addend == rel->r_addend)
6431                   break;
6432               if (ent != NULL && ent->plt.refcount > 0)
6433                 ent->plt.refcount -= 1;
6434             }
6435           break;
6436
6437         default:
6438           break;
6439         }
6440     }
6441   return TRUE;
6442 }
6443
6444 /* The maximum size of .sfpr.  */
6445 #define SFPR_MAX (218*4)
6446
6447 struct sfpr_def_parms
6448 {
6449   const char name[12];
6450   unsigned char lo, hi;
6451   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6452   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6453 };
6454
6455 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6456
6457 static bfd_boolean
6458 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6459 {
6460   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6461   unsigned int i;
6462   size_t len = strlen (parm->name);
6463   bfd_boolean writing = FALSE;
6464   char sym[16];
6465
6466   if (htab == NULL)
6467     return FALSE;
6468
6469   memcpy (sym, parm->name, len);
6470   sym[len + 2] = 0;
6471
6472   for (i = parm->lo; i <= parm->hi; i++)
6473     {
6474       struct elf_link_hash_entry *h;
6475
6476       sym[len + 0] = i / 10 + '0';
6477       sym[len + 1] = i % 10 + '0';
6478       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6479       if (h != NULL
6480           && !h->def_regular)
6481         {
6482           h->root.type = bfd_link_hash_defined;
6483           h->root.u.def.section = htab->sfpr;
6484           h->root.u.def.value = htab->sfpr->size;
6485           h->type = STT_FUNC;
6486           h->def_regular = 1;
6487           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6488           writing = TRUE;
6489           if (htab->sfpr->contents == NULL)
6490             {
6491               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6492               if (htab->sfpr->contents == NULL)
6493                 return FALSE;
6494             }
6495         }
6496       if (writing)
6497         {
6498           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6499           if (i != parm->hi)
6500             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6501           else
6502             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6503           htab->sfpr->size = p - htab->sfpr->contents;
6504         }
6505     }
6506
6507   return TRUE;
6508 }
6509
6510 static bfd_byte *
6511 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6512 {
6513   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6514   return p + 4;
6515 }
6516
6517 static bfd_byte *
6518 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6519 {
6520   p = savegpr0 (abfd, p, r);
6521   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6522   p = p + 4;
6523   bfd_put_32 (abfd, BLR, p);
6524   return p + 4;
6525 }
6526
6527 static bfd_byte *
6528 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6529 {
6530   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6531   return p + 4;
6532 }
6533
6534 static bfd_byte *
6535 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 {
6537   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6538   p = p + 4;
6539   p = restgpr0 (abfd, p, r);
6540   bfd_put_32 (abfd, MTLR_R0, p);
6541   p = p + 4;
6542   if (r == 29)
6543     {
6544       p = restgpr0 (abfd, p, 30);
6545       p = restgpr0 (abfd, p, 31);
6546     }
6547   bfd_put_32 (abfd, BLR, p);
6548   return p + 4;
6549 }
6550
6551 static bfd_byte *
6552 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6553 {
6554   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6555   return p + 4;
6556 }
6557
6558 static bfd_byte *
6559 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6560 {
6561   p = savegpr1 (abfd, p, r);
6562   bfd_put_32 (abfd, BLR, p);
6563   return p + 4;
6564 }
6565
6566 static bfd_byte *
6567 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6568 {
6569   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6570   return p + 4;
6571 }
6572
6573 static bfd_byte *
6574 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6575 {
6576   p = restgpr1 (abfd, p, r);
6577   bfd_put_32 (abfd, BLR, p);
6578   return p + 4;
6579 }
6580
6581 static bfd_byte *
6582 savefpr (bfd *abfd, bfd_byte *p, int r)
6583 {
6584   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585   return p + 4;
6586 }
6587
6588 static bfd_byte *
6589 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591   p = savefpr (abfd, p, r);
6592   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6593   p = p + 4;
6594   bfd_put_32 (abfd, BLR, p);
6595   return p + 4;
6596 }
6597
6598 static bfd_byte *
6599 restfpr (bfd *abfd, bfd_byte *p, int r)
6600 {
6601   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6602   return p + 4;
6603 }
6604
6605 static bfd_byte *
6606 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 {
6608   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6609   p = p + 4;
6610   p = restfpr (abfd, p, r);
6611   bfd_put_32 (abfd, MTLR_R0, p);
6612   p = p + 4;
6613   if (r == 29)
6614     {
6615       p = restfpr (abfd, p, 30);
6616       p = restfpr (abfd, p, 31);
6617     }
6618   bfd_put_32 (abfd, BLR, p);
6619   return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   p = savefpr (abfd, p, r);
6626   bfd_put_32 (abfd, BLR, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = restfpr (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 savevr (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6642   p = p + 4;
6643   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6644   return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   p = savevr (abfd, p, r);
6651   bfd_put_32 (abfd, BLR, p);
6652   return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 restvr (bfd *abfd, bfd_byte *p, int r)
6657 {
6658   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6659   p = p + 4;
6660   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6661   return p + 4;
6662 }
6663
6664 static bfd_byte *
6665 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6666 {
6667   p = restvr (abfd, p, r);
6668   bfd_put_32 (abfd, BLR, p);
6669   return p + 4;
6670 }
6671
6672 /* Called via elf_link_hash_traverse to transfer dynamic linking
6673    information on function code symbol entries to their corresponding
6674    function descriptor symbol entries.  */
6675
6676 static bfd_boolean
6677 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6678 {
6679   struct bfd_link_info *info;
6680   struct ppc_link_hash_table *htab;
6681   struct plt_entry *ent;
6682   struct ppc_link_hash_entry *fh;
6683   struct ppc_link_hash_entry *fdh;
6684   bfd_boolean force_local;
6685
6686   fh = (struct ppc_link_hash_entry *) h;
6687   if (fh->elf.root.type == bfd_link_hash_indirect)
6688     return TRUE;
6689
6690   info = inf;
6691   htab = ppc_hash_table (info);
6692   if (htab == NULL)
6693     return FALSE;
6694
6695   /* Resolve undefined references to dot-symbols as the value
6696      in the function descriptor, if we have one in a regular object.
6697      This is to satisfy cases like ".quad .foo".  Calls to functions
6698      in dynamic objects are handled elsewhere.  */
6699   if (fh->elf.root.type == bfd_link_hash_undefweak
6700       && fh->was_undefined
6701       && (fdh = defined_func_desc (fh)) != NULL
6702       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6703       && opd_entry_value (fdh->elf.root.u.def.section,
6704                           fdh->elf.root.u.def.value,
6705                           &fh->elf.root.u.def.section,
6706                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6707     {
6708       fh->elf.root.type = fdh->elf.root.type;
6709       fh->elf.forced_local = 1;
6710       fh->elf.def_regular = fdh->elf.def_regular;
6711       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6712     }
6713
6714   /* If this is a function code symbol, transfer dynamic linking
6715      information to the function descriptor symbol.  */
6716   if (!fh->is_func)
6717     return TRUE;
6718
6719   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6720     if (ent->plt.refcount > 0)
6721       break;
6722   if (ent == NULL
6723       || fh->elf.root.root.string[0] != '.'
6724       || fh->elf.root.root.string[1] == '\0')
6725     return TRUE;
6726
6727   /* Find the corresponding function descriptor symbol.  Create it
6728      as undefined if necessary.  */
6729
6730   fdh = lookup_fdh (fh, htab);
6731   if (fdh == NULL
6732       && !info->executable
6733       && (fh->elf.root.type == bfd_link_hash_undefined
6734           || fh->elf.root.type == bfd_link_hash_undefweak))
6735     {
6736       fdh = make_fdh (info, fh);
6737       if (fdh == NULL)
6738         return FALSE;
6739     }
6740
6741   /* Fake function descriptors are made undefweak.  If the function
6742      code symbol is strong undefined, make the fake sym the same.
6743      If the function code symbol is defined, then force the fake
6744      descriptor local;  We can't support overriding of symbols in a
6745      shared library on a fake descriptor.  */
6746
6747   if (fdh != NULL
6748       && fdh->fake
6749       && fdh->elf.root.type == bfd_link_hash_undefweak)
6750     {
6751       if (fh->elf.root.type == bfd_link_hash_undefined)
6752         {
6753           fdh->elf.root.type = bfd_link_hash_undefined;
6754           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6755         }
6756       else if (fh->elf.root.type == bfd_link_hash_defined
6757                || fh->elf.root.type == bfd_link_hash_defweak)
6758         {
6759           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6760         }
6761     }
6762
6763   if (fdh != NULL
6764       && !fdh->elf.forced_local
6765       && (!info->executable
6766           || fdh->elf.def_dynamic
6767           || fdh->elf.ref_dynamic
6768           || (fdh->elf.root.type == bfd_link_hash_undefweak
6769               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6770     {
6771       if (fdh->elf.dynindx == -1)
6772         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6773           return FALSE;
6774       fdh->elf.ref_regular |= fh->elf.ref_regular;
6775       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6776       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6777       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6778       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6779         {
6780           move_plt_plist (fh, fdh);
6781           fdh->elf.needs_plt = 1;
6782         }
6783       fdh->is_func_descriptor = 1;
6784       fdh->oh = fh;
6785       fh->oh = fdh;
6786     }
6787
6788   /* Now that the info is on the function descriptor, clear the
6789      function code sym info.  Any function code syms for which we
6790      don't have a definition in a regular file, we force local.
6791      This prevents a shared library from exporting syms that have
6792      been imported from another library.  Function code syms that
6793      are really in the library we must leave global to prevent the
6794      linker dragging in a definition from a static library.  */
6795   force_local = (!fh->elf.def_regular
6796                  || fdh == NULL
6797                  || !fdh->elf.def_regular
6798                  || fdh->elf.forced_local);
6799   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6800
6801   return TRUE;
6802 }
6803
6804 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6805    this hook to a) provide some gcc support functions, and b) transfer
6806    dynamic linking information gathered so far on function code symbol
6807    entries, to their corresponding function descriptor symbol entries.  */
6808
6809 static bfd_boolean
6810 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6811                             struct bfd_link_info *info)
6812 {
6813   struct ppc_link_hash_table *htab;
6814   unsigned int i;
6815   static const struct sfpr_def_parms funcs[] =
6816     {
6817       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6818       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6819       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6820       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6821       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6822       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6823       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6824       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6825       { "._savef", 14, 31, savefpr, savefpr1_tail },
6826       { "._restf", 14, 31, restfpr, restfpr1_tail },
6827       { "_savevr_", 20, 31, savevr, savevr_tail },
6828       { "_restvr_", 20, 31, restvr, restvr_tail }
6829     };
6830
6831   htab = ppc_hash_table (info);
6832   if (htab == NULL)
6833     return FALSE;
6834
6835   if (!info->relocatable
6836       && htab->elf.hgot != NULL)
6837     {
6838       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6839       /* Make .TOC. defined so as to prevent it being made dynamic.
6840          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6841       htab->elf.hgot->type = STT_OBJECT;
6842       htab->elf.hgot->root.type = bfd_link_hash_defined;
6843       htab->elf.hgot->root.u.def.value = 0;
6844       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6845       htab->elf.hgot->def_regular = 1;
6846       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6847                                | STV_HIDDEN);
6848     }
6849
6850   if (htab->sfpr == NULL)
6851     /* We don't have any relocs.  */
6852     return TRUE;
6853
6854   /* Provide any missing _save* and _rest* functions.  */
6855   htab->sfpr->size = 0;
6856   if (!info->relocatable)
6857     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6858       if (!sfpr_define (info, &funcs[i]))
6859         return FALSE;
6860
6861   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6862
6863   if (htab->sfpr->size == 0)
6864     htab->sfpr->flags |= SEC_EXCLUDE;
6865
6866   return TRUE;
6867 }
6868
6869 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6870
6871 static bfd_boolean
6872 readonly_dynrelocs (struct elf_link_hash_entry *h)
6873 {
6874   struct ppc_link_hash_entry *eh;
6875   struct elf_dyn_relocs *p;
6876
6877   eh = (struct ppc_link_hash_entry *) h;
6878   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6879     {
6880       asection *s = p->sec->output_section;
6881
6882       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6883         return TRUE;
6884     }
6885   return FALSE;
6886 }
6887
6888 /* Adjust a symbol defined by a dynamic object and referenced by a
6889    regular object.  The current definition is in some section of the
6890    dynamic object, but we're not including those sections.  We have to
6891    change the definition to something the rest of the link can
6892    understand.  */
6893
6894 static bfd_boolean
6895 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6896                                  struct elf_link_hash_entry *h)
6897 {
6898   struct ppc_link_hash_table *htab;
6899   asection *s;
6900
6901   htab = ppc_hash_table (info);
6902   if (htab == NULL)
6903     return FALSE;
6904
6905   /* Deal with function syms.  */
6906   if (h->type == STT_FUNC
6907       || h->type == STT_GNU_IFUNC
6908       || h->needs_plt)
6909     {
6910       /* Clear procedure linkage table information for any symbol that
6911          won't need a .plt entry.  */
6912       struct plt_entry *ent;
6913       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6914         if (ent->plt.refcount > 0)
6915           break;
6916       if (ent == NULL
6917           || (h->type != STT_GNU_IFUNC
6918               && (SYMBOL_CALLS_LOCAL (info, h)
6919                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6920                       && h->root.type == bfd_link_hash_undefweak))))
6921         {
6922           h->plt.plist = NULL;
6923           h->needs_plt = 0;
6924         }
6925       else if (abiversion (info->output_bfd) == 2)
6926         {
6927           /* After adjust_dynamic_symbol, non_got_ref set in the
6928              non-shared case means that we have allocated space in
6929              .dynbss for the symbol and thus dyn_relocs for this
6930              symbol should be discarded.
6931              If we get here we know we are making a PLT entry for this
6932              symbol, and in an executable we'd normally resolve
6933              relocations against this symbol to the PLT entry.  Allow
6934              dynamic relocs if the reference is weak, and the dynamic
6935              relocs will not cause text relocation.  */
6936           if (!h->ref_regular_nonweak
6937               && h->non_got_ref
6938               && h->type != STT_GNU_IFUNC
6939               && !readonly_dynrelocs (h))
6940             h->non_got_ref = 0;
6941
6942           /* If making a plt entry, then we don't need copy relocs.  */
6943           return TRUE;
6944         }
6945     }
6946   else
6947     h->plt.plist = NULL;
6948
6949   /* If this is a weak symbol, and there is a real definition, the
6950      processor independent code will have arranged for us to see the
6951      real definition first, and we can just use the same value.  */
6952   if (h->u.weakdef != NULL)
6953     {
6954       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6955                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6956       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6957       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6958       if (ELIMINATE_COPY_RELOCS)
6959         h->non_got_ref = h->u.weakdef->non_got_ref;
6960       return TRUE;
6961     }
6962
6963   /* If we are creating a shared library, we must presume that the
6964      only references to the symbol are via the global offset table.
6965      For such cases we need not do anything here; the relocations will
6966      be handled correctly by relocate_section.  */
6967   if (info->shared)
6968     return TRUE;
6969
6970   /* If there are no references to this symbol that do not use the
6971      GOT, we don't need to generate a copy reloc.  */
6972   if (!h->non_got_ref)
6973     return TRUE;
6974
6975   /* Don't generate a copy reloc for symbols defined in the executable.  */
6976   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6977     return TRUE;
6978
6979   /* If we didn't find any dynamic relocs in read-only sections, then
6980      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6981   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6982     {
6983       h->non_got_ref = 0;
6984       return TRUE;
6985     }
6986
6987   if (h->plt.plist != NULL)
6988     {
6989       /* We should never get here, but unfortunately there are versions
6990          of gcc out there that improperly (for this ABI) put initialized
6991          function pointers, vtable refs and suchlike in read-only
6992          sections.  Allow them to proceed, but warn that this might
6993          break at runtime.  */
6994       info->callbacks->einfo
6995         (_("%P: copy reloc against `%T' requires lazy plt linking; "
6996            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6997          h->root.root.string);
6998     }
6999
7000   /* This is a reference to a symbol defined by a dynamic object which
7001      is not a function.  */
7002
7003   /* We must allocate the symbol in our .dynbss section, which will
7004      become part of the .bss section of the executable.  There will be
7005      an entry for this symbol in the .dynsym section.  The dynamic
7006      object will contain position independent code, so all references
7007      from the dynamic object to this symbol will go through the global
7008      offset table.  The dynamic linker will use the .dynsym entry to
7009      determine the address it must put in the global offset table, so
7010      both the dynamic object and the regular object will refer to the
7011      same memory location for the variable.  */
7012
7013   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7014      to copy the initial value out of the dynamic object and into the
7015      runtime process image.  We need to remember the offset into the
7016      .rela.bss section we are going to use.  */
7017   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7018     {
7019       htab->relbss->size += sizeof (Elf64_External_Rela);
7020       h->needs_copy = 1;
7021     }
7022
7023   s = htab->dynbss;
7024
7025   return _bfd_elf_adjust_dynamic_copy (h, s);
7026 }
7027
7028 /* If given a function descriptor symbol, hide both the function code
7029    sym and the descriptor.  */
7030 static void
7031 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7032                        struct elf_link_hash_entry *h,
7033                        bfd_boolean force_local)
7034 {
7035   struct ppc_link_hash_entry *eh;
7036   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7037
7038   eh = (struct ppc_link_hash_entry *) h;
7039   if (eh->is_func_descriptor)
7040     {
7041       struct ppc_link_hash_entry *fh = eh->oh;
7042
7043       if (fh == NULL)
7044         {
7045           const char *p, *q;
7046           struct ppc_link_hash_table *htab;
7047           char save;
7048
7049           /* We aren't supposed to use alloca in BFD because on
7050              systems which do not have alloca the version in libiberty
7051              calls xmalloc, which might cause the program to crash
7052              when it runs out of memory.  This function doesn't have a
7053              return status, so there's no way to gracefully return an
7054              error.  So cheat.  We know that string[-1] can be safely
7055              accessed;  It's either a string in an ELF string table,
7056              or allocated in an objalloc structure.  */
7057
7058           p = eh->elf.root.root.string - 1;
7059           save = *p;
7060           *(char *) p = '.';
7061           htab = ppc_hash_table (info);
7062           if (htab == NULL)
7063             return;
7064
7065           fh = (struct ppc_link_hash_entry *)
7066             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7067           *(char *) p = save;
7068
7069           /* Unfortunately, if it so happens that the string we were
7070              looking for was allocated immediately before this string,
7071              then we overwrote the string terminator.  That's the only
7072              reason the lookup should fail.  */
7073           if (fh == NULL)
7074             {
7075               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7076               while (q >= eh->elf.root.root.string && *q == *p)
7077                 --q, --p;
7078               if (q < eh->elf.root.root.string && *p == '.')
7079                 fh = (struct ppc_link_hash_entry *)
7080                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7081             }
7082           if (fh != NULL)
7083             {
7084               eh->oh = fh;
7085               fh->oh = eh;
7086             }
7087         }
7088       if (fh != NULL)
7089         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7090     }
7091 }
7092
7093 static bfd_boolean
7094 get_sym_h (struct elf_link_hash_entry **hp,
7095            Elf_Internal_Sym **symp,
7096            asection **symsecp,
7097            unsigned char **tls_maskp,
7098            Elf_Internal_Sym **locsymsp,
7099            unsigned long r_symndx,
7100            bfd *ibfd)
7101 {
7102   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7103
7104   if (r_symndx >= symtab_hdr->sh_info)
7105     {
7106       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7107       struct elf_link_hash_entry *h;
7108
7109       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7110       h = elf_follow_link (h);
7111
7112       if (hp != NULL)
7113         *hp = h;
7114
7115       if (symp != NULL)
7116         *symp = NULL;
7117
7118       if (symsecp != NULL)
7119         {
7120           asection *symsec = NULL;
7121           if (h->root.type == bfd_link_hash_defined
7122               || h->root.type == bfd_link_hash_defweak)
7123             symsec = h->root.u.def.section;
7124           *symsecp = symsec;
7125         }
7126
7127       if (tls_maskp != NULL)
7128         {
7129           struct ppc_link_hash_entry *eh;
7130
7131           eh = (struct ppc_link_hash_entry *) h;
7132           *tls_maskp = &eh->tls_mask;
7133         }
7134     }
7135   else
7136     {
7137       Elf_Internal_Sym *sym;
7138       Elf_Internal_Sym *locsyms = *locsymsp;
7139
7140       if (locsyms == NULL)
7141         {
7142           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7143           if (locsyms == NULL)
7144             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7145                                             symtab_hdr->sh_info,
7146                                             0, NULL, NULL, NULL);
7147           if (locsyms == NULL)
7148             return FALSE;
7149           *locsymsp = locsyms;
7150         }
7151       sym = locsyms + r_symndx;
7152
7153       if (hp != NULL)
7154         *hp = NULL;
7155
7156       if (symp != NULL)
7157         *symp = sym;
7158
7159       if (symsecp != NULL)
7160         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7161
7162       if (tls_maskp != NULL)
7163         {
7164           struct got_entry **lgot_ents;
7165           unsigned char *tls_mask;
7166
7167           tls_mask = NULL;
7168           lgot_ents = elf_local_got_ents (ibfd);
7169           if (lgot_ents != NULL)
7170             {
7171               struct plt_entry **local_plt = (struct plt_entry **)
7172                 (lgot_ents + symtab_hdr->sh_info);
7173               unsigned char *lgot_masks = (unsigned char *)
7174                 (local_plt + symtab_hdr->sh_info);
7175               tls_mask = &lgot_masks[r_symndx];
7176             }
7177           *tls_maskp = tls_mask;
7178         }
7179     }
7180   return TRUE;
7181 }
7182
7183 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7184    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7185    type suitable for optimization, and 1 otherwise.  */
7186
7187 static int
7188 get_tls_mask (unsigned char **tls_maskp,
7189               unsigned long *toc_symndx,
7190               bfd_vma *toc_addend,
7191               Elf_Internal_Sym **locsymsp,
7192               const Elf_Internal_Rela *rel,
7193               bfd *ibfd)
7194 {
7195   unsigned long r_symndx;
7196   int next_r;
7197   struct elf_link_hash_entry *h;
7198   Elf_Internal_Sym *sym;
7199   asection *sec;
7200   bfd_vma off;
7201
7202   r_symndx = ELF64_R_SYM (rel->r_info);
7203   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7204     return 0;
7205
7206   if ((*tls_maskp != NULL && **tls_maskp != 0)
7207       || sec == NULL
7208       || ppc64_elf_section_data (sec) == NULL
7209       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7210     return 1;
7211
7212   /* Look inside a TOC section too.  */
7213   if (h != NULL)
7214     {
7215       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7216       off = h->root.u.def.value;
7217     }
7218   else
7219     off = sym->st_value;
7220   off += rel->r_addend;
7221   BFD_ASSERT (off % 8 == 0);
7222   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7223   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7224   if (toc_symndx != NULL)
7225     *toc_symndx = r_symndx;
7226   if (toc_addend != NULL)
7227     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7228   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7229     return 0;
7230   if ((h == NULL || is_static_defined (h))
7231       && (next_r == -1 || next_r == -2))
7232     return 1 - next_r;
7233   return 1;
7234 }
7235
7236 /* Find (or create) an entry in the tocsave hash table.  */
7237
7238 static struct tocsave_entry *
7239 tocsave_find (struct ppc_link_hash_table *htab,
7240               enum insert_option insert,
7241               Elf_Internal_Sym **local_syms,
7242               const Elf_Internal_Rela *irela,
7243               bfd *ibfd)
7244 {
7245   unsigned long r_indx;
7246   struct elf_link_hash_entry *h;
7247   Elf_Internal_Sym *sym;
7248   struct tocsave_entry ent, *p;
7249   hashval_t hash;
7250   struct tocsave_entry **slot;
7251
7252   r_indx = ELF64_R_SYM (irela->r_info);
7253   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7254     return NULL;
7255   if (ent.sec == NULL || ent.sec->output_section == NULL)
7256     {
7257       (*_bfd_error_handler)
7258         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7259       return NULL;
7260     }
7261
7262   if (h != NULL)
7263     ent.offset = h->root.u.def.value;
7264   else
7265     ent.offset = sym->st_value;
7266   ent.offset += irela->r_addend;
7267
7268   hash = tocsave_htab_hash (&ent);
7269   slot = ((struct tocsave_entry **)
7270           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7271   if (slot == NULL)
7272     return NULL;
7273
7274   if (*slot == NULL)
7275     {
7276       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7277       if (p == NULL)
7278         return NULL;
7279       *p = ent;
7280       *slot = p;
7281     }
7282   return *slot;
7283 }
7284
7285 /* Adjust all global syms defined in opd sections.  In gcc generated
7286    code for the old ABI, these will already have been done.  */
7287
7288 static bfd_boolean
7289 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7290 {
7291   struct ppc_link_hash_entry *eh;
7292   asection *sym_sec;
7293   struct _opd_sec_data *opd;
7294
7295   if (h->root.type == bfd_link_hash_indirect)
7296     return TRUE;
7297
7298   if (h->root.type != bfd_link_hash_defined
7299       && h->root.type != bfd_link_hash_defweak)
7300     return TRUE;
7301
7302   eh = (struct ppc_link_hash_entry *) h;
7303   if (eh->adjust_done)
7304     return TRUE;
7305
7306   sym_sec = eh->elf.root.u.def.section;
7307   opd = get_opd_info (sym_sec);
7308   if (opd != NULL && opd->adjust != NULL)
7309     {
7310       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7311       if (adjust == -1)
7312         {
7313           /* This entry has been deleted.  */
7314           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7315           if (dsec == NULL)
7316             {
7317               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7318                 if (discarded_section (dsec))
7319                   {
7320                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7321                     break;
7322                   }
7323             }
7324           eh->elf.root.u.def.value = 0;
7325           eh->elf.root.u.def.section = dsec;
7326         }
7327       else
7328         eh->elf.root.u.def.value += adjust;
7329       eh->adjust_done = 1;
7330     }
7331   return TRUE;
7332 }
7333
7334 /* Handles decrementing dynamic reloc counts for the reloc specified by
7335    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7336    have already been determined.  */
7337
7338 static bfd_boolean
7339 dec_dynrel_count (bfd_vma r_info,
7340                   asection *sec,
7341                   struct bfd_link_info *info,
7342                   Elf_Internal_Sym **local_syms,
7343                   struct elf_link_hash_entry *h,
7344                   Elf_Internal_Sym *sym)
7345 {
7346   enum elf_ppc64_reloc_type r_type;
7347   asection *sym_sec = NULL;
7348
7349   /* Can this reloc be dynamic?  This switch, and later tests here
7350      should be kept in sync with the code in check_relocs.  */
7351   r_type = ELF64_R_TYPE (r_info);
7352   switch (r_type)
7353     {
7354     default:
7355       return TRUE;
7356
7357     case R_PPC64_TPREL16:
7358     case R_PPC64_TPREL16_LO:
7359     case R_PPC64_TPREL16_HI:
7360     case R_PPC64_TPREL16_HA:
7361     case R_PPC64_TPREL16_DS:
7362     case R_PPC64_TPREL16_LO_DS:
7363     case R_PPC64_TPREL16_HIGH:
7364     case R_PPC64_TPREL16_HIGHA:
7365     case R_PPC64_TPREL16_HIGHER:
7366     case R_PPC64_TPREL16_HIGHERA:
7367     case R_PPC64_TPREL16_HIGHEST:
7368     case R_PPC64_TPREL16_HIGHESTA:
7369       if (!info->shared)
7370         return TRUE;
7371
7372     case R_PPC64_TPREL64:
7373     case R_PPC64_DTPMOD64:
7374     case R_PPC64_DTPREL64:
7375     case R_PPC64_ADDR64:
7376     case R_PPC64_REL30:
7377     case R_PPC64_REL32:
7378     case R_PPC64_REL64:
7379     case R_PPC64_ADDR14:
7380     case R_PPC64_ADDR14_BRNTAKEN:
7381     case R_PPC64_ADDR14_BRTAKEN:
7382     case R_PPC64_ADDR16:
7383     case R_PPC64_ADDR16_DS:
7384     case R_PPC64_ADDR16_HA:
7385     case R_PPC64_ADDR16_HI:
7386     case R_PPC64_ADDR16_HIGH:
7387     case R_PPC64_ADDR16_HIGHA:
7388     case R_PPC64_ADDR16_HIGHER:
7389     case R_PPC64_ADDR16_HIGHERA:
7390     case R_PPC64_ADDR16_HIGHEST:
7391     case R_PPC64_ADDR16_HIGHESTA:
7392     case R_PPC64_ADDR16_LO:
7393     case R_PPC64_ADDR16_LO_DS:
7394     case R_PPC64_ADDR24:
7395     case R_PPC64_ADDR32:
7396     case R_PPC64_UADDR16:
7397     case R_PPC64_UADDR32:
7398     case R_PPC64_UADDR64:
7399     case R_PPC64_TOC:
7400       break;
7401     }
7402
7403   if (local_syms != NULL)
7404     {
7405       unsigned long r_symndx;
7406       bfd *ibfd = sec->owner;
7407
7408       r_symndx = ELF64_R_SYM (r_info);
7409       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7410         return FALSE;
7411     }
7412
7413   if ((info->shared
7414        && (must_be_dyn_reloc (info, r_type)
7415            || (h != NULL
7416                && (!SYMBOLIC_BIND (info, h)
7417                    || h->root.type == bfd_link_hash_defweak
7418                    || !h->def_regular))))
7419       || (ELIMINATE_COPY_RELOCS
7420           && !info->shared
7421           && h != NULL
7422           && (h->root.type == bfd_link_hash_defweak
7423               || !h->def_regular)))
7424     ;
7425   else
7426     return TRUE;
7427
7428   if (h != NULL)
7429     {
7430       struct elf_dyn_relocs *p;
7431       struct elf_dyn_relocs **pp;
7432       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7433
7434       /* elf_gc_sweep may have already removed all dyn relocs associated
7435          with local syms for a given section.  Also, symbol flags are
7436          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7437          report a dynreloc miscount.  */
7438       if (*pp == NULL && info->gc_sections)
7439         return TRUE;
7440
7441       while ((p = *pp) != NULL)
7442         {
7443           if (p->sec == sec)
7444             {
7445               if (!must_be_dyn_reloc (info, r_type))
7446                 p->pc_count -= 1;
7447               p->count -= 1;
7448               if (p->count == 0)
7449                 *pp = p->next;
7450               return TRUE;
7451             }
7452           pp = &p->next;
7453         }
7454     }
7455   else
7456     {
7457       struct ppc_dyn_relocs *p;
7458       struct ppc_dyn_relocs **pp;
7459       void *vpp;
7460       bfd_boolean is_ifunc;
7461
7462       if (local_syms == NULL)
7463         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7464       if (sym_sec == NULL)
7465         sym_sec = sec;
7466
7467       vpp = &elf_section_data (sym_sec)->local_dynrel;
7468       pp = (struct ppc_dyn_relocs **) vpp;
7469
7470       if (*pp == NULL && info->gc_sections)
7471         return TRUE;
7472
7473       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7474       while ((p = *pp) != NULL)
7475         {
7476           if (p->sec == sec && p->ifunc == is_ifunc)
7477             {
7478               p->count -= 1;
7479               if (p->count == 0)
7480                 *pp = p->next;
7481               return TRUE;
7482             }
7483           pp = &p->next;
7484         }
7485     }
7486
7487   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7488                           sec->owner, sec);
7489   bfd_set_error (bfd_error_bad_value);
7490   return FALSE;
7491 }
7492
7493 /* Remove unused Official Procedure Descriptor entries.  Currently we
7494    only remove those associated with functions in discarded link-once
7495    sections, or weakly defined functions that have been overridden.  It
7496    would be possible to remove many more entries for statically linked
7497    applications.  */
7498
7499 bfd_boolean
7500 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7501 {
7502   bfd *ibfd;
7503   bfd_boolean some_edited = FALSE;
7504   asection *need_pad = NULL;
7505
7506   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7507     {
7508       asection *sec;
7509       Elf_Internal_Rela *relstart, *rel, *relend;
7510       Elf_Internal_Shdr *symtab_hdr;
7511       Elf_Internal_Sym *local_syms;
7512       bfd_vma offset;
7513       struct _opd_sec_data *opd;
7514       bfd_boolean need_edit, add_aux_fields;
7515       bfd_size_type cnt_16b = 0;
7516
7517       if (!is_ppc64_elf (ibfd))
7518         continue;
7519
7520       sec = bfd_get_section_by_name (ibfd, ".opd");
7521       if (sec == NULL || sec->size == 0)
7522         continue;
7523
7524       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7525         continue;
7526
7527       if (sec->output_section == bfd_abs_section_ptr)
7528         continue;
7529
7530       /* Look through the section relocs.  */
7531       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7532         continue;
7533
7534       local_syms = NULL;
7535       symtab_hdr = &elf_symtab_hdr (ibfd);
7536
7537       /* Read the relocations.  */
7538       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7539                                             info->keep_memory);
7540       if (relstart == NULL)
7541         return FALSE;
7542
7543       /* First run through the relocs to check they are sane, and to
7544          determine whether we need to edit this opd section.  */
7545       need_edit = FALSE;
7546       need_pad = sec;
7547       offset = 0;
7548       relend = relstart + sec->reloc_count;
7549       for (rel = relstart; rel < relend; )
7550         {
7551           enum elf_ppc64_reloc_type r_type;
7552           unsigned long r_symndx;
7553           asection *sym_sec;
7554           struct elf_link_hash_entry *h;
7555           Elf_Internal_Sym *sym;
7556
7557           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7558              only interested in the reloc pointing to a function entry
7559              point.  */
7560           if (rel->r_offset != offset
7561               || rel + 1 >= relend
7562               || (rel + 1)->r_offset != offset + 8)
7563             {
7564               /* If someone messes with .opd alignment then after a
7565                  "ld -r" we might have padding in the middle of .opd.
7566                  Also, there's nothing to prevent someone putting
7567                  something silly in .opd with the assembler.  No .opd
7568                  optimization for them!  */
7569             broken_opd:
7570               (*_bfd_error_handler)
7571                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7572               need_edit = FALSE;
7573               break;
7574             }
7575
7576           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7577               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7578             {
7579               (*_bfd_error_handler)
7580                 (_("%B: unexpected reloc type %u in .opd section"),
7581                  ibfd, r_type);
7582               need_edit = FALSE;
7583               break;
7584             }
7585
7586           r_symndx = ELF64_R_SYM (rel->r_info);
7587           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7588                           r_symndx, ibfd))
7589             goto error_ret;
7590
7591           if (sym_sec == NULL || sym_sec->owner == NULL)
7592             {
7593               const char *sym_name;
7594               if (h != NULL)
7595                 sym_name = h->root.root.string;
7596               else
7597                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7598                                              sym_sec);
7599
7600               (*_bfd_error_handler)
7601                 (_("%B: undefined sym `%s' in .opd section"),
7602                  ibfd, sym_name);
7603               need_edit = FALSE;
7604               break;
7605             }
7606
7607           /* opd entries are always for functions defined in the
7608              current input bfd.  If the symbol isn't defined in the
7609              input bfd, then we won't be using the function in this
7610              bfd;  It must be defined in a linkonce section in another
7611              bfd, or is weak.  It's also possible that we are
7612              discarding the function due to a linker script /DISCARD/,
7613              which we test for via the output_section.  */
7614           if (sym_sec->owner != ibfd
7615               || sym_sec->output_section == bfd_abs_section_ptr)
7616             need_edit = TRUE;
7617
7618           rel += 2;
7619           if (rel == relend
7620               || (rel + 1 == relend && rel->r_offset == offset + 16))
7621             {
7622               if (sec->size == offset + 24)
7623                 {
7624                   need_pad = NULL;
7625                   break;
7626                 }
7627               if (rel == relend && sec->size == offset + 16)
7628                 {
7629                   cnt_16b++;
7630                   break;
7631                 }
7632               goto broken_opd;
7633             }
7634
7635           if (rel->r_offset == offset + 24)
7636             offset += 24;
7637           else if (rel->r_offset != offset + 16)
7638             goto broken_opd;
7639           else if (rel + 1 < relend
7640                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7641                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7642             {
7643               offset += 16;
7644               cnt_16b++;
7645             }
7646           else if (rel + 2 < relend
7647                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7648                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7649             {
7650               offset += 24;
7651               rel += 1;
7652             }
7653           else
7654             goto broken_opd;
7655         }
7656
7657       add_aux_fields = non_overlapping && cnt_16b > 0;
7658
7659       if (need_edit || add_aux_fields)
7660         {
7661           Elf_Internal_Rela *write_rel;
7662           Elf_Internal_Shdr *rel_hdr;
7663           bfd_byte *rptr, *wptr;
7664           bfd_byte *new_contents;
7665           bfd_boolean skip;
7666           long opd_ent_size;
7667           bfd_size_type amt;
7668
7669           new_contents = NULL;
7670           amt = sec->size * sizeof (long) / 8;
7671           opd = &ppc64_elf_section_data (sec)->u.opd;
7672           opd->adjust = bfd_zalloc (sec->owner, amt);
7673           if (opd->adjust == NULL)
7674             return FALSE;
7675           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7676
7677           /* This seems a waste of time as input .opd sections are all
7678              zeros as generated by gcc, but I suppose there's no reason
7679              this will always be so.  We might start putting something in
7680              the third word of .opd entries.  */
7681           if ((sec->flags & SEC_IN_MEMORY) == 0)
7682             {
7683               bfd_byte *loc;
7684               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7685                 {
7686                   if (loc != NULL)
7687                     free (loc);
7688                 error_ret:
7689                   if (local_syms != NULL
7690                       && symtab_hdr->contents != (unsigned char *) local_syms)
7691                     free (local_syms);
7692                   if (elf_section_data (sec)->relocs != relstart)
7693                     free (relstart);
7694                   return FALSE;
7695                 }
7696               sec->contents = loc;
7697               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7698             }
7699
7700           elf_section_data (sec)->relocs = relstart;
7701
7702           new_contents = sec->contents;
7703           if (add_aux_fields)
7704             {
7705               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7706               if (new_contents == NULL)
7707                 return FALSE;
7708               need_pad = FALSE;
7709             }
7710           wptr = new_contents;
7711           rptr = sec->contents;
7712
7713           write_rel = relstart;
7714           skip = FALSE;
7715           offset = 0;
7716           opd_ent_size = 0;
7717           for (rel = relstart; rel < relend; rel++)
7718             {
7719               unsigned long r_symndx;
7720               asection *sym_sec;
7721               struct elf_link_hash_entry *h;
7722               Elf_Internal_Sym *sym;
7723
7724               r_symndx = ELF64_R_SYM (rel->r_info);
7725               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7726                               r_symndx, ibfd))
7727                 goto error_ret;
7728
7729               if (rel->r_offset == offset)
7730                 {
7731                   struct ppc_link_hash_entry *fdh = NULL;
7732
7733                   /* See if the .opd entry is full 24 byte or
7734                      16 byte (with fd_aux entry overlapped with next
7735                      fd_func).  */
7736                   opd_ent_size = 24;
7737                   if ((rel + 2 == relend && sec->size == offset + 16)
7738                       || (rel + 3 < relend
7739                           && rel[2].r_offset == offset + 16
7740                           && rel[3].r_offset == offset + 24
7741                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7742                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7743                     opd_ent_size = 16;
7744
7745                   if (h != NULL
7746                       && h->root.root.string[0] == '.')
7747                     {
7748                       struct ppc_link_hash_table *htab;
7749
7750                       htab = ppc_hash_table (info);
7751                       if (htab != NULL)
7752                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7753                                           htab);
7754                       if (fdh != NULL
7755                           && fdh->elf.root.type != bfd_link_hash_defined
7756                           && fdh->elf.root.type != bfd_link_hash_defweak)
7757                         fdh = NULL;
7758                     }
7759
7760                   skip = (sym_sec->owner != ibfd
7761                           || sym_sec->output_section == bfd_abs_section_ptr);
7762                   if (skip)
7763                     {
7764                       if (fdh != NULL && sym_sec->owner == ibfd)
7765                         {
7766                           /* Arrange for the function descriptor sym
7767                              to be dropped.  */
7768                           fdh->elf.root.u.def.value = 0;
7769                           fdh->elf.root.u.def.section = sym_sec;
7770                         }
7771                       opd->adjust[rel->r_offset / 8] = -1;
7772                     }
7773                   else
7774                     {
7775                       /* We'll be keeping this opd entry.  */
7776
7777                       if (fdh != NULL)
7778                         {
7779                           /* Redefine the function descriptor symbol to
7780                              this location in the opd section.  It is
7781                              necessary to update the value here rather
7782                              than using an array of adjustments as we do
7783                              for local symbols, because various places
7784                              in the generic ELF code use the value
7785                              stored in u.def.value.  */
7786                           fdh->elf.root.u.def.value = wptr - new_contents;
7787                           fdh->adjust_done = 1;
7788                         }
7789
7790                       /* Local syms are a bit tricky.  We could
7791                          tweak them as they can be cached, but
7792                          we'd need to look through the local syms
7793                          for the function descriptor sym which we
7794                          don't have at the moment.  So keep an
7795                          array of adjustments.  */
7796                       opd->adjust[rel->r_offset / 8]
7797                         = (wptr - new_contents) - (rptr - sec->contents);
7798
7799                       if (wptr != rptr)
7800                         memcpy (wptr, rptr, opd_ent_size);
7801                       wptr += opd_ent_size;
7802                       if (add_aux_fields && opd_ent_size == 16)
7803                         {
7804                           memset (wptr, '\0', 8);
7805                           wptr += 8;
7806                         }
7807                     }
7808                   rptr += opd_ent_size;
7809                   offset += opd_ent_size;
7810                 }
7811
7812               if (skip)
7813                 {
7814                   if (!NO_OPD_RELOCS
7815                       && !info->relocatable
7816                       && !dec_dynrel_count (rel->r_info, sec, info,
7817                                             NULL, h, sym))
7818                     goto error_ret;
7819                 }
7820               else
7821                 {
7822                   /* We need to adjust any reloc offsets to point to the
7823                      new opd entries.  While we're at it, we may as well
7824                      remove redundant relocs.  */
7825                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7826                   if (write_rel != rel)
7827                     memcpy (write_rel, rel, sizeof (*rel));
7828                   ++write_rel;
7829                 }
7830             }
7831
7832           sec->size = wptr - new_contents;
7833           sec->reloc_count = write_rel - relstart;
7834           if (add_aux_fields)
7835             {
7836               free (sec->contents);
7837               sec->contents = new_contents;
7838             }
7839
7840           /* Fudge the header size too, as this is used later in
7841              elf_bfd_final_link if we are emitting relocs.  */
7842           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7843           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7844           some_edited = TRUE;
7845         }
7846       else if (elf_section_data (sec)->relocs != relstart)
7847         free (relstart);
7848
7849       if (local_syms != NULL
7850           && symtab_hdr->contents != (unsigned char *) local_syms)
7851         {
7852           if (!info->keep_memory)
7853             free (local_syms);
7854           else
7855             symtab_hdr->contents = (unsigned char *) local_syms;
7856         }
7857     }
7858
7859   if (some_edited)
7860     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7861
7862   /* If we are doing a final link and the last .opd entry is just 16 byte
7863      long, add a 8 byte padding after it.  */
7864   if (need_pad != NULL && !info->relocatable)
7865     {
7866       bfd_byte *p;
7867
7868       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7869         {
7870           BFD_ASSERT (need_pad->size > 0);
7871
7872           p = bfd_malloc (need_pad->size + 8);
7873           if (p == NULL)
7874             return FALSE;
7875
7876           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7877                                           p, 0, need_pad->size))
7878             return FALSE;
7879
7880           need_pad->contents = p;
7881           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7882         }
7883       else
7884         {
7885           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7886           if (p == NULL)
7887             return FALSE;
7888
7889           need_pad->contents = p;
7890         }
7891
7892       memset (need_pad->contents + need_pad->size, 0, 8);
7893       need_pad->size += 8;
7894     }
7895
7896   return TRUE;
7897 }
7898
7899 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7900
7901 asection *
7902 ppc64_elf_tls_setup (struct bfd_link_info *info,
7903                      int no_tls_get_addr_opt,
7904                      int *no_multi_toc)
7905 {
7906   struct ppc_link_hash_table *htab;
7907
7908   htab = ppc_hash_table (info);
7909   if (htab == NULL)
7910     return NULL;
7911
7912   if (abiversion (info->output_bfd) == 1)
7913     htab->opd_abi = 1;
7914
7915   if (*no_multi_toc)
7916     htab->do_multi_toc = 0;
7917   else if (!htab->do_multi_toc)
7918     *no_multi_toc = 1;
7919
7920   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7921                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7922                                               FALSE, FALSE, TRUE));
7923   /* Move dynamic linking info to the function descriptor sym.  */
7924   if (htab->tls_get_addr != NULL)
7925     func_desc_adjust (&htab->tls_get_addr->elf, info);
7926   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7927                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7928                                                  FALSE, FALSE, TRUE));
7929   if (!no_tls_get_addr_opt)
7930     {
7931       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7932
7933       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7934                                   FALSE, FALSE, TRUE);
7935       if (opt != NULL)
7936         func_desc_adjust (opt, info);
7937       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7938                                      FALSE, FALSE, TRUE);
7939       if (opt_fd != NULL
7940           && (opt_fd->root.type == bfd_link_hash_defined
7941               || opt_fd->root.type == bfd_link_hash_defweak))
7942         {
7943           /* If glibc supports an optimized __tls_get_addr call stub,
7944              signalled by the presence of __tls_get_addr_opt, and we'll
7945              be calling __tls_get_addr via a plt call stub, then
7946              make __tls_get_addr point to __tls_get_addr_opt.  */
7947           tga_fd = &htab->tls_get_addr_fd->elf;
7948           if (htab->elf.dynamic_sections_created
7949               && tga_fd != NULL
7950               && (tga_fd->type == STT_FUNC
7951                   || tga_fd->needs_plt)
7952               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7953                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7954                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7955             {
7956               struct plt_entry *ent;
7957
7958               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7959                 if (ent->plt.refcount > 0)
7960                   break;
7961               if (ent != NULL)
7962                 {
7963                   tga_fd->root.type = bfd_link_hash_indirect;
7964                   tga_fd->root.u.i.link = &opt_fd->root;
7965                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7966                   if (opt_fd->dynindx != -1)
7967                     {
7968                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7969                       opt_fd->dynindx = -1;
7970                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7971                                               opt_fd->dynstr_index);
7972                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7973                         return NULL;
7974                     }
7975                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7976                   tga = &htab->tls_get_addr->elf;
7977                   if (opt != NULL && tga != NULL)
7978                     {
7979                       tga->root.type = bfd_link_hash_indirect;
7980                       tga->root.u.i.link = &opt->root;
7981                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7982                       _bfd_elf_link_hash_hide_symbol (info, opt,
7983                                                       tga->forced_local);
7984                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7985                     }
7986                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7987                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7988                   if (htab->tls_get_addr != NULL)
7989                     {
7990                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7991                       htab->tls_get_addr->is_func = 1;
7992                     }
7993                 }
7994             }
7995         }
7996       else
7997         no_tls_get_addr_opt = TRUE;
7998     }
7999   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8000   return _bfd_elf_tls_setup (info->output_bfd, info);
8001 }
8002
8003 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8004    HASH1 or HASH2.  */
8005
8006 static bfd_boolean
8007 branch_reloc_hash_match (const bfd *ibfd,
8008                          const Elf_Internal_Rela *rel,
8009                          const struct ppc_link_hash_entry *hash1,
8010                          const struct ppc_link_hash_entry *hash2)
8011 {
8012   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8013   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8014   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8015
8016   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8017     {
8018       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8019       struct elf_link_hash_entry *h;
8020
8021       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8022       h = elf_follow_link (h);
8023       if (h == &hash1->elf || h == &hash2->elf)
8024         return TRUE;
8025     }
8026   return FALSE;
8027 }
8028
8029 /* Run through all the TLS relocs looking for optimization
8030    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8031    a preliminary section layout so that we know the TLS segment
8032    offsets.  We can't optimize earlier because some optimizations need
8033    to know the tp offset, and we need to optimize before allocating
8034    dynamic relocations.  */
8035
8036 bfd_boolean
8037 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8038 {
8039   bfd *ibfd;
8040   asection *sec;
8041   struct ppc_link_hash_table *htab;
8042   unsigned char *toc_ref;
8043   int pass;
8044
8045   if (info->relocatable || !info->executable)
8046     return TRUE;
8047
8048   htab = ppc_hash_table (info);
8049   if (htab == NULL)
8050     return FALSE;
8051
8052   /* Make two passes over the relocs.  On the first pass, mark toc
8053      entries involved with tls relocs, and check that tls relocs
8054      involved in setting up a tls_get_addr call are indeed followed by
8055      such a call.  If they are not, we can't do any tls optimization.
8056      On the second pass twiddle tls_mask flags to notify
8057      relocate_section that optimization can be done, and adjust got
8058      and plt refcounts.  */
8059   toc_ref = NULL;
8060   for (pass = 0; pass < 2; ++pass)
8061     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8062       {
8063         Elf_Internal_Sym *locsyms = NULL;
8064         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8065
8066         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8067           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8068             {
8069               Elf_Internal_Rela *relstart, *rel, *relend;
8070               bfd_boolean found_tls_get_addr_arg = 0;
8071
8072               /* Read the relocations.  */
8073               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8074                                                     info->keep_memory);
8075               if (relstart == NULL)
8076                 return FALSE;
8077
8078               relend = relstart + sec->reloc_count;
8079               for (rel = relstart; rel < relend; rel++)
8080                 {
8081                   enum elf_ppc64_reloc_type r_type;
8082                   unsigned long r_symndx;
8083                   struct elf_link_hash_entry *h;
8084                   Elf_Internal_Sym *sym;
8085                   asection *sym_sec;
8086                   unsigned char *tls_mask;
8087                   unsigned char tls_set, tls_clear, tls_type = 0;
8088                   bfd_vma value;
8089                   bfd_boolean ok_tprel, is_local;
8090                   long toc_ref_index = 0;
8091                   int expecting_tls_get_addr = 0;
8092                   bfd_boolean ret = FALSE;
8093
8094                   r_symndx = ELF64_R_SYM (rel->r_info);
8095                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8096                                   r_symndx, ibfd))
8097                     {
8098                     err_free_rel:
8099                       if (elf_section_data (sec)->relocs != relstart)
8100                         free (relstart);
8101                       if (toc_ref != NULL)
8102                         free (toc_ref);
8103                       if (locsyms != NULL
8104                           && (elf_symtab_hdr (ibfd).contents
8105                               != (unsigned char *) locsyms))
8106                         free (locsyms);
8107                       return ret;
8108                     }
8109
8110                   if (h != NULL)
8111                     {
8112                       if (h->root.type == bfd_link_hash_defined
8113                           || h->root.type == bfd_link_hash_defweak)
8114                         value = h->root.u.def.value;
8115                       else if (h->root.type == bfd_link_hash_undefweak)
8116                         value = 0;
8117                       else
8118                         {
8119                           found_tls_get_addr_arg = 0;
8120                           continue;
8121                         }
8122                     }
8123                   else
8124                     /* Symbols referenced by TLS relocs must be of type
8125                        STT_TLS.  So no need for .opd local sym adjust.  */
8126                     value = sym->st_value;
8127
8128                   ok_tprel = FALSE;
8129                   is_local = FALSE;
8130                   if (h == NULL
8131                       || !h->def_dynamic)
8132                     {
8133                       is_local = TRUE;
8134                       if (h != NULL
8135                           && h->root.type == bfd_link_hash_undefweak)
8136                         ok_tprel = TRUE;
8137                       else
8138                         {
8139                           value += sym_sec->output_offset;
8140                           value += sym_sec->output_section->vma;
8141                           value -= htab->elf.tls_sec->vma;
8142                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8143                                       < (bfd_vma) 1 << 32);
8144                         }
8145                     }
8146
8147                   r_type = ELF64_R_TYPE (rel->r_info);
8148                   /* If this section has old-style __tls_get_addr calls
8149                      without marker relocs, then check that each
8150                      __tls_get_addr call reloc is preceded by a reloc
8151                      that conceivably belongs to the __tls_get_addr arg
8152                      setup insn.  If we don't find matching arg setup
8153                      relocs, don't do any tls optimization.  */
8154                   if (pass == 0
8155                       && sec->has_tls_get_addr_call
8156                       && h != NULL
8157                       && (h == &htab->tls_get_addr->elf
8158                           || h == &htab->tls_get_addr_fd->elf)
8159                       && !found_tls_get_addr_arg
8160                       && is_branch_reloc (r_type))
8161                     {
8162                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8163                                                 "TLS optimization disabled\n"),
8164                                               ibfd, sec, rel->r_offset);
8165                       ret = TRUE;
8166                       goto err_free_rel;
8167                     }
8168
8169                   found_tls_get_addr_arg = 0;
8170                   switch (r_type)
8171                     {
8172                     case R_PPC64_GOT_TLSLD16:
8173                     case R_PPC64_GOT_TLSLD16_LO:
8174                       expecting_tls_get_addr = 1;
8175                       found_tls_get_addr_arg = 1;
8176                       /* Fall thru */
8177
8178                     case R_PPC64_GOT_TLSLD16_HI:
8179                     case R_PPC64_GOT_TLSLD16_HA:
8180                       /* These relocs should never be against a symbol
8181                          defined in a shared lib.  Leave them alone if
8182                          that turns out to be the case.  */
8183                       if (!is_local)
8184                         continue;
8185
8186                       /* LD -> LE */
8187                       tls_set = 0;
8188                       tls_clear = TLS_LD;
8189                       tls_type = TLS_TLS | TLS_LD;
8190                       break;
8191
8192                     case R_PPC64_GOT_TLSGD16:
8193                     case R_PPC64_GOT_TLSGD16_LO:
8194                       expecting_tls_get_addr = 1;
8195                       found_tls_get_addr_arg = 1;
8196                       /* Fall thru */
8197
8198                     case R_PPC64_GOT_TLSGD16_HI:
8199                     case R_PPC64_GOT_TLSGD16_HA:
8200                       if (ok_tprel)
8201                         /* GD -> LE */
8202                         tls_set = 0;
8203                       else
8204                         /* GD -> IE */
8205                         tls_set = TLS_TLS | TLS_TPRELGD;
8206                       tls_clear = TLS_GD;
8207                       tls_type = TLS_TLS | TLS_GD;
8208                       break;
8209
8210                     case R_PPC64_GOT_TPREL16_DS:
8211                     case R_PPC64_GOT_TPREL16_LO_DS:
8212                     case R_PPC64_GOT_TPREL16_HI:
8213                     case R_PPC64_GOT_TPREL16_HA:
8214                       if (ok_tprel)
8215                         {
8216                           /* IE -> LE */
8217                           tls_set = 0;
8218                           tls_clear = TLS_TPREL;
8219                           tls_type = TLS_TLS | TLS_TPREL;
8220                           break;
8221                         }
8222                       continue;
8223
8224                     case R_PPC64_TLSGD:
8225                     case R_PPC64_TLSLD:
8226                       found_tls_get_addr_arg = 1;
8227                       /* Fall thru */
8228
8229                     case R_PPC64_TLS:
8230                     case R_PPC64_TOC16:
8231                     case R_PPC64_TOC16_LO:
8232                       if (sym_sec == NULL || sym_sec != toc)
8233                         continue;
8234
8235                       /* Mark this toc entry as referenced by a TLS
8236                          code sequence.  We can do that now in the
8237                          case of R_PPC64_TLS, and after checking for
8238                          tls_get_addr for the TOC16 relocs.  */
8239                       if (toc_ref == NULL)
8240                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8241                       if (toc_ref == NULL)
8242                         goto err_free_rel;
8243
8244                       if (h != NULL)
8245                         value = h->root.u.def.value;
8246                       else
8247                         value = sym->st_value;
8248                       value += rel->r_addend;
8249                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8250                       toc_ref_index = (value + toc->output_offset) / 8;
8251                       if (r_type == R_PPC64_TLS
8252                           || r_type == R_PPC64_TLSGD
8253                           || r_type == R_PPC64_TLSLD)
8254                         {
8255                           toc_ref[toc_ref_index] = 1;
8256                           continue;
8257                         }
8258
8259                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8260                         continue;
8261
8262                       tls_set = 0;
8263                       tls_clear = 0;
8264                       expecting_tls_get_addr = 2;
8265                       break;
8266
8267                     case R_PPC64_TPREL64:
8268                       if (pass == 0
8269                           || sec != toc
8270                           || toc_ref == NULL
8271                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8272                         continue;
8273                       if (ok_tprel)
8274                         {
8275                           /* IE -> LE */
8276                           tls_set = TLS_EXPLICIT;
8277                           tls_clear = TLS_TPREL;
8278                           break;
8279                         }
8280                       continue;
8281
8282                     case R_PPC64_DTPMOD64:
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 (rel + 1 < relend
8289                           && (rel[1].r_info
8290                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8291                           && rel[1].r_offset == rel->r_offset + 8)
8292                         {
8293                           if (ok_tprel)
8294                             /* GD -> LE */
8295                             tls_set = TLS_EXPLICIT | TLS_GD;
8296                           else
8297                             /* GD -> IE */
8298                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8299                           tls_clear = TLS_GD;
8300                         }
8301                       else
8302                         {
8303                           if (!is_local)
8304                             continue;
8305
8306                           /* LD -> LE */
8307                           tls_set = TLS_EXPLICIT;
8308                           tls_clear = TLS_LD;
8309                         }
8310                       break;
8311
8312                     default:
8313                       continue;
8314                     }
8315
8316                   if (pass == 0)
8317                     {
8318                       if (!expecting_tls_get_addr
8319                           || !sec->has_tls_get_addr_call)
8320                         continue;
8321
8322                       if (rel + 1 < relend
8323                           && branch_reloc_hash_match (ibfd, rel + 1,
8324                                                       htab->tls_get_addr,
8325                                                       htab->tls_get_addr_fd))
8326                         {
8327                           if (expecting_tls_get_addr == 2)
8328                             {
8329                               /* Check for toc tls entries.  */
8330                               unsigned char *toc_tls;
8331                               int retval;
8332
8333                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8334                                                      &locsyms,
8335                                                      rel, ibfd);
8336                               if (retval == 0)
8337                                 goto err_free_rel;
8338                               if (toc_tls != NULL)
8339                                 {
8340                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8341                                     found_tls_get_addr_arg = 1;
8342                                   if (retval > 1)
8343                                     toc_ref[toc_ref_index] = 1;
8344                                 }
8345                             }
8346                           continue;
8347                         }
8348
8349                       if (expecting_tls_get_addr != 1)
8350                         continue;
8351
8352                       /* Uh oh, we didn't find the expected call.  We
8353                          could just mark this symbol to exclude it
8354                          from tls optimization but it's safer to skip
8355                          the entire optimization.  */
8356                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8357                                                 "TLS optimization disabled\n"),
8358                                               ibfd, sec, rel->r_offset);
8359                       ret = TRUE;
8360                       goto err_free_rel;
8361                     }
8362
8363                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8364                     {
8365                       struct plt_entry *ent;
8366                       for (ent = htab->tls_get_addr->elf.plt.plist;
8367                            ent != NULL;
8368                            ent = ent->next)
8369                         if (ent->addend == 0)
8370                           {
8371                             if (ent->plt.refcount > 0)
8372                               {
8373                                 ent->plt.refcount -= 1;
8374                                 expecting_tls_get_addr = 0;
8375                               }
8376                             break;
8377                           }
8378                     }
8379
8380                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8381                     {
8382                       struct plt_entry *ent;
8383                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8384                            ent != NULL;
8385                            ent = ent->next)
8386                         if (ent->addend == 0)
8387                           {
8388                             if (ent->plt.refcount > 0)
8389                               ent->plt.refcount -= 1;
8390                             break;
8391                           }
8392                     }
8393
8394                   if (tls_clear == 0)
8395                     continue;
8396
8397                   if ((tls_set & TLS_EXPLICIT) == 0)
8398                     {
8399                       struct got_entry *ent;
8400
8401                       /* Adjust got entry for this reloc.  */
8402                       if (h != NULL)
8403                         ent = h->got.glist;
8404                       else
8405                         ent = elf_local_got_ents (ibfd)[r_symndx];
8406
8407                       for (; ent != NULL; ent = ent->next)
8408                         if (ent->addend == rel->r_addend
8409                             && ent->owner == ibfd
8410                             && ent->tls_type == tls_type)
8411                           break;
8412                       if (ent == NULL)
8413                         abort ();
8414
8415                       if (tls_set == 0)
8416                         {
8417                           /* We managed to get rid of a got entry.  */
8418                           if (ent->got.refcount > 0)
8419                             ent->got.refcount -= 1;
8420                         }
8421                     }
8422                   else
8423                     {
8424                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8425                          we'll lose one or two dyn relocs.  */
8426                       if (!dec_dynrel_count (rel->r_info, sec, info,
8427                                              NULL, h, sym))
8428                         return FALSE;
8429
8430                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8431                         {
8432                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8433                                                  NULL, h, sym))
8434                             return FALSE;
8435                         }
8436                     }
8437
8438                   *tls_mask |= tls_set;
8439                   *tls_mask &= ~tls_clear;
8440                 }
8441
8442               if (elf_section_data (sec)->relocs != relstart)
8443                 free (relstart);
8444             }
8445
8446         if (locsyms != NULL
8447             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8448           {
8449             if (!info->keep_memory)
8450               free (locsyms);
8451             else
8452               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8453           }
8454       }
8455
8456   if (toc_ref != NULL)
8457     free (toc_ref);
8458   return TRUE;
8459 }
8460
8461 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8462    the values of any global symbols in a toc section that has been
8463    edited.  Globals in toc sections should be a rarity, so this function
8464    sets a flag if any are found in toc sections other than the one just
8465    edited, so that futher hash table traversals can be avoided.  */
8466
8467 struct adjust_toc_info
8468 {
8469   asection *toc;
8470   unsigned long *skip;
8471   bfd_boolean global_toc_syms;
8472 };
8473
8474 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8475
8476 static bfd_boolean
8477 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8478 {
8479   struct ppc_link_hash_entry *eh;
8480   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8481   unsigned long i;
8482
8483   if (h->root.type != bfd_link_hash_defined
8484       && h->root.type != bfd_link_hash_defweak)
8485     return TRUE;
8486
8487   eh = (struct ppc_link_hash_entry *) h;
8488   if (eh->adjust_done)
8489     return TRUE;
8490
8491   if (eh->elf.root.u.def.section == toc_inf->toc)
8492     {
8493       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8494         i = toc_inf->toc->rawsize >> 3;
8495       else
8496         i = eh->elf.root.u.def.value >> 3;
8497
8498       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8499         {
8500           (*_bfd_error_handler)
8501             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8502           do
8503             ++i;
8504           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8505           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8506         }
8507
8508       eh->elf.root.u.def.value -= toc_inf->skip[i];
8509       eh->adjust_done = 1;
8510     }
8511   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8512     toc_inf->global_toc_syms = TRUE;
8513
8514   return TRUE;
8515 }
8516
8517 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8518
8519 static bfd_boolean
8520 ok_lo_toc_insn (unsigned int insn)
8521 {
8522   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8523           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8524           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8525           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8526           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8527           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8528           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8529           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8530           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8531           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8532           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8533           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8534           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8535           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8536           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8537               && (insn & 3) != 1)
8538           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8539               && ((insn & 3) == 0 || (insn & 3) == 3))
8540           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8541 }
8542
8543 /* Examine all relocs referencing .toc sections in order to remove
8544    unused .toc entries.  */
8545
8546 bfd_boolean
8547 ppc64_elf_edit_toc (struct bfd_link_info *info)
8548 {
8549   bfd *ibfd;
8550   struct adjust_toc_info toc_inf;
8551   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552
8553   htab->do_toc_opt = 1;
8554   toc_inf.global_toc_syms = TRUE;
8555   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8556     {
8557       asection *toc, *sec;
8558       Elf_Internal_Shdr *symtab_hdr;
8559       Elf_Internal_Sym *local_syms;
8560       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8561       unsigned long *skip, *drop;
8562       unsigned char *used;
8563       unsigned char *keep, last, some_unused;
8564
8565       if (!is_ppc64_elf (ibfd))
8566         continue;
8567
8568       toc = bfd_get_section_by_name (ibfd, ".toc");
8569       if (toc == NULL
8570           || toc->size == 0
8571           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8572           || discarded_section (toc))
8573         continue;
8574
8575       toc_relocs = NULL;
8576       local_syms = NULL;
8577       symtab_hdr = &elf_symtab_hdr (ibfd);
8578
8579       /* Look at sections dropped from the final link.  */
8580       skip = NULL;
8581       relstart = NULL;
8582       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8583         {
8584           if (sec->reloc_count == 0
8585               || !discarded_section (sec)
8586               || get_opd_info (sec)
8587               || (sec->flags & SEC_ALLOC) == 0
8588               || (sec->flags & SEC_DEBUGGING) != 0)
8589             continue;
8590
8591           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8592           if (relstart == NULL)
8593             goto error_ret;
8594
8595           /* Run through the relocs to see which toc entries might be
8596              unused.  */
8597           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8598             {
8599               enum elf_ppc64_reloc_type r_type;
8600               unsigned long r_symndx;
8601               asection *sym_sec;
8602               struct elf_link_hash_entry *h;
8603               Elf_Internal_Sym *sym;
8604               bfd_vma val;
8605
8606               r_type = ELF64_R_TYPE (rel->r_info);
8607               switch (r_type)
8608                 {
8609                 default:
8610                   continue;
8611
8612                 case R_PPC64_TOC16:
8613                 case R_PPC64_TOC16_LO:
8614                 case R_PPC64_TOC16_HI:
8615                 case R_PPC64_TOC16_HA:
8616                 case R_PPC64_TOC16_DS:
8617                 case R_PPC64_TOC16_LO_DS:
8618                   break;
8619                 }
8620
8621               r_symndx = ELF64_R_SYM (rel->r_info);
8622               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8623                               r_symndx, ibfd))
8624                 goto error_ret;
8625
8626               if (sym_sec != toc)
8627                 continue;
8628
8629               if (h != NULL)
8630                 val = h->root.u.def.value;
8631               else
8632                 val = sym->st_value;
8633               val += rel->r_addend;
8634
8635               if (val >= toc->size)
8636                 continue;
8637
8638               /* Anything in the toc ought to be aligned to 8 bytes.
8639                  If not, don't mark as unused.  */
8640               if (val & 7)
8641                 continue;
8642
8643               if (skip == NULL)
8644                 {
8645                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8646                   if (skip == NULL)
8647                     goto error_ret;
8648                 }
8649
8650               skip[val >> 3] = ref_from_discarded;
8651             }
8652
8653           if (elf_section_data (sec)->relocs != relstart)
8654             free (relstart);
8655         }
8656
8657       /* For largetoc loads of address constants, we can convert
8658          .  addis rx,2,addr@got@ha
8659          .  ld ry,addr@got@l(rx)
8660          to
8661          .  addis rx,2,addr@toc@ha
8662          .  addi ry,rx,addr@toc@l
8663          when addr is within 2G of the toc pointer.  This then means
8664          that the word storing "addr" in the toc is no longer needed.  */
8665
8666       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8667           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8668           && toc->reloc_count != 0)
8669         {
8670           /* Read toc relocs.  */
8671           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8672                                                   info->keep_memory);
8673           if (toc_relocs == NULL)
8674             goto error_ret;
8675
8676           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8677             {
8678               enum elf_ppc64_reloc_type r_type;
8679               unsigned long r_symndx;
8680               asection *sym_sec;
8681               struct elf_link_hash_entry *h;
8682               Elf_Internal_Sym *sym;
8683               bfd_vma val, addr;
8684
8685               r_type = ELF64_R_TYPE (rel->r_info);
8686               if (r_type != R_PPC64_ADDR64)
8687                 continue;
8688
8689               r_symndx = ELF64_R_SYM (rel->r_info);
8690               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8691                               r_symndx, ibfd))
8692                 goto error_ret;
8693
8694               if (sym_sec == NULL
8695                   || discarded_section (sym_sec))
8696                 continue;
8697
8698               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8699                 continue;
8700
8701               if (h != NULL)
8702                 {
8703                   if (h->type == STT_GNU_IFUNC)
8704                     continue;
8705                   val = h->root.u.def.value;
8706                 }
8707               else
8708                 {
8709                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8710                     continue;
8711                   val = sym->st_value;
8712                 }
8713               val += rel->r_addend;
8714               val += sym_sec->output_section->vma + sym_sec->output_offset;
8715
8716               /* We don't yet know the exact toc pointer value, but we
8717                  know it will be somewhere in the toc section.  Don't
8718                  optimize if the difference from any possible toc
8719                  pointer is outside [ff..f80008000, 7fff7fff].  */
8720               addr = toc->output_section->vma + TOC_BASE_OFF;
8721               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8722                 continue;
8723
8724               addr = toc->output_section->vma + toc->output_section->rawsize;
8725               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8726                 continue;
8727
8728               if (skip == NULL)
8729                 {
8730                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8731                   if (skip == NULL)
8732                     goto error_ret;
8733                 }
8734
8735               skip[rel->r_offset >> 3]
8736                 |= can_optimize | ((rel - toc_relocs) << 2);
8737             }
8738         }
8739
8740       if (skip == NULL)
8741         continue;
8742
8743       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8744       if (used == NULL)
8745         {
8746         error_ret:
8747           if (local_syms != NULL
8748               && symtab_hdr->contents != (unsigned char *) local_syms)
8749             free (local_syms);
8750           if (sec != NULL
8751               && relstart != NULL
8752               && elf_section_data (sec)->relocs != relstart)
8753             free (relstart);
8754           if (toc_relocs != NULL
8755               && elf_section_data (toc)->relocs != toc_relocs)
8756             free (toc_relocs);
8757           if (skip != NULL)
8758             free (skip);
8759           return FALSE;
8760         }
8761
8762       /* Now check all kept sections that might reference the toc.
8763          Check the toc itself last.  */
8764       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8765                   : ibfd->sections);
8766            sec != NULL;
8767            sec = (sec == toc ? NULL
8768                   : sec->next == NULL ? toc
8769                   : sec->next == toc && toc->next ? toc->next
8770                   : sec->next))
8771         {
8772           int repeat;
8773
8774           if (sec->reloc_count == 0
8775               || discarded_section (sec)
8776               || get_opd_info (sec)
8777               || (sec->flags & SEC_ALLOC) == 0
8778               || (sec->flags & SEC_DEBUGGING) != 0)
8779             continue;
8780
8781           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8782                                                 info->keep_memory);
8783           if (relstart == NULL)
8784             goto error_ret;
8785
8786           /* Mark toc entries referenced as used.  */
8787           do
8788             {
8789               repeat = 0;
8790               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8791                 {
8792                   enum elf_ppc64_reloc_type r_type;
8793                   unsigned long r_symndx;
8794                   asection *sym_sec;
8795                   struct elf_link_hash_entry *h;
8796                   Elf_Internal_Sym *sym;
8797                   bfd_vma val;
8798                   enum {no_check, check_lo, check_ha} insn_check;
8799
8800                   r_type = ELF64_R_TYPE (rel->r_info);
8801                   switch (r_type)
8802                     {
8803                     default:
8804                       insn_check = no_check;
8805                       break;
8806
8807                     case R_PPC64_GOT_TLSLD16_HA:
8808                     case R_PPC64_GOT_TLSGD16_HA:
8809                     case R_PPC64_GOT_TPREL16_HA:
8810                     case R_PPC64_GOT_DTPREL16_HA:
8811                     case R_PPC64_GOT16_HA:
8812                     case R_PPC64_TOC16_HA:
8813                       insn_check = check_ha;
8814                       break;
8815
8816                     case R_PPC64_GOT_TLSLD16_LO:
8817                     case R_PPC64_GOT_TLSGD16_LO:
8818                     case R_PPC64_GOT_TPREL16_LO_DS:
8819                     case R_PPC64_GOT_DTPREL16_LO_DS:
8820                     case R_PPC64_GOT16_LO:
8821                     case R_PPC64_GOT16_LO_DS:
8822                     case R_PPC64_TOC16_LO:
8823                     case R_PPC64_TOC16_LO_DS:
8824                       insn_check = check_lo;
8825                       break;
8826                     }
8827
8828                   if (insn_check != no_check)
8829                     {
8830                       bfd_vma off = rel->r_offset & ~3;
8831                       unsigned char buf[4];
8832                       unsigned int insn;
8833
8834                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8835                         {
8836                           free (used);
8837                           goto error_ret;
8838                         }
8839                       insn = bfd_get_32 (ibfd, buf);
8840                       if (insn_check == check_lo
8841                           ? !ok_lo_toc_insn (insn)
8842                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8843                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8844                         {
8845                           char str[12];
8846
8847                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8848                           sprintf (str, "%#08x", insn);
8849                           info->callbacks->einfo
8850                             (_("%P: %H: toc optimization is not supported for"
8851                                " %s instruction.\n"),
8852                              ibfd, sec, rel->r_offset & ~3, str);
8853                         }
8854                     }
8855
8856                   switch (r_type)
8857                     {
8858                     case R_PPC64_TOC16:
8859                     case R_PPC64_TOC16_LO:
8860                     case R_PPC64_TOC16_HI:
8861                     case R_PPC64_TOC16_HA:
8862                     case R_PPC64_TOC16_DS:
8863                     case R_PPC64_TOC16_LO_DS:
8864                       /* In case we're taking addresses of toc entries.  */
8865                     case R_PPC64_ADDR64:
8866                       break;
8867
8868                     default:
8869                       continue;
8870                     }
8871
8872                   r_symndx = ELF64_R_SYM (rel->r_info);
8873                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8874                                   r_symndx, ibfd))
8875                     {
8876                       free (used);
8877                       goto error_ret;
8878                     }
8879
8880                   if (sym_sec != toc)
8881                     continue;
8882
8883                   if (h != NULL)
8884                     val = h->root.u.def.value;
8885                   else
8886                     val = sym->st_value;
8887                   val += rel->r_addend;
8888
8889                   if (val >= toc->size)
8890                     continue;
8891
8892                   if ((skip[val >> 3] & can_optimize) != 0)
8893                     {
8894                       bfd_vma off;
8895                       unsigned char opc;
8896
8897                       switch (r_type)
8898                         {
8899                         case R_PPC64_TOC16_HA:
8900                           break;
8901
8902                         case R_PPC64_TOC16_LO_DS:
8903                           off = rel->r_offset;
8904                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8905                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8906                                                          off, 1))
8907                             {
8908                               free (used);
8909                               goto error_ret;
8910                             }
8911                           if ((opc & (0x3f << 2)) == (58u << 2))
8912                             break;
8913                           /* Fall thru */
8914
8915                         default:
8916                           /* Wrong sort of reloc, or not a ld.  We may
8917                              as well clear ref_from_discarded too.  */
8918                           skip[val >> 3] = 0;
8919                         }
8920                     }
8921
8922                   if (sec != toc)
8923                     used[val >> 3] = 1;
8924                   /* For the toc section, we only mark as used if this
8925                      entry itself isn't unused.  */
8926                   else if ((used[rel->r_offset >> 3]
8927                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8928                            && !used[val >> 3])
8929                     {
8930                       /* Do all the relocs again, to catch reference
8931                          chains.  */
8932                       repeat = 1;
8933                       used[val >> 3] = 1;
8934                     }
8935                 }
8936             }
8937           while (repeat);
8938
8939           if (elf_section_data (sec)->relocs != relstart)
8940             free (relstart);
8941         }
8942
8943       /* Merge the used and skip arrays.  Assume that TOC
8944          doublewords not appearing as either used or unused belong
8945          to to an entry more than one doubleword in size.  */
8946       for (drop = skip, keep = used, last = 0, some_unused = 0;
8947            drop < skip + (toc->size + 7) / 8;
8948            ++drop, ++keep)
8949         {
8950           if (*keep)
8951             {
8952               *drop &= ~ref_from_discarded;
8953               if ((*drop & can_optimize) != 0)
8954                 some_unused = 1;
8955               last = 0;
8956             }
8957           else if ((*drop & ref_from_discarded) != 0)
8958             {
8959               some_unused = 1;
8960               last = ref_from_discarded;
8961             }
8962           else
8963             *drop = last;
8964         }
8965
8966       free (used);
8967
8968       if (some_unused)
8969         {
8970           bfd_byte *contents, *src;
8971           unsigned long off;
8972           Elf_Internal_Sym *sym;
8973           bfd_boolean local_toc_syms = FALSE;
8974
8975           /* Shuffle the toc contents, and at the same time convert the
8976              skip array from booleans into offsets.  */
8977           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8978             goto error_ret;
8979
8980           elf_section_data (toc)->this_hdr.contents = contents;
8981
8982           for (src = contents, off = 0, drop = skip;
8983                src < contents + toc->size;
8984                src += 8, ++drop)
8985             {
8986               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8987                 off += 8;
8988               else if (off != 0)
8989                 {
8990                   *drop = off;
8991                   memcpy (src - off, src, 8);
8992                 }
8993             }
8994           *drop = off;
8995           toc->rawsize = toc->size;
8996           toc->size = src - contents - off;
8997
8998           /* Adjust addends for relocs against the toc section sym,
8999              and optimize any accesses we can.  */
9000           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9001             {
9002               if (sec->reloc_count == 0
9003                   || discarded_section (sec))
9004                 continue;
9005
9006               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9007                                                     info->keep_memory);
9008               if (relstart == NULL)
9009                 goto error_ret;
9010
9011               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9012                 {
9013                   enum elf_ppc64_reloc_type r_type;
9014                   unsigned long r_symndx;
9015                   asection *sym_sec;
9016                   struct elf_link_hash_entry *h;
9017                   bfd_vma val;
9018
9019                   r_type = ELF64_R_TYPE (rel->r_info);
9020                   switch (r_type)
9021                     {
9022                     default:
9023                       continue;
9024
9025                     case R_PPC64_TOC16:
9026                     case R_PPC64_TOC16_LO:
9027                     case R_PPC64_TOC16_HI:
9028                     case R_PPC64_TOC16_HA:
9029                     case R_PPC64_TOC16_DS:
9030                     case R_PPC64_TOC16_LO_DS:
9031                     case R_PPC64_ADDR64:
9032                       break;
9033                     }
9034
9035                   r_symndx = ELF64_R_SYM (rel->r_info);
9036                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9037                                   r_symndx, ibfd))
9038                     goto error_ret;
9039
9040                   if (sym_sec != toc)
9041                     continue;
9042
9043                   if (h != NULL)
9044                     val = h->root.u.def.value;
9045                   else
9046                     {
9047                       val = sym->st_value;
9048                       if (val != 0)
9049                         local_toc_syms = TRUE;
9050                     }
9051
9052                   val += rel->r_addend;
9053
9054                   if (val > toc->rawsize)
9055                     val = toc->rawsize;
9056                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9057                     continue;
9058                   else if ((skip[val >> 3] & can_optimize) != 0)
9059                     {
9060                       Elf_Internal_Rela *tocrel
9061                         = toc_relocs + (skip[val >> 3] >> 2);
9062                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9063
9064                       switch (r_type)
9065                         {
9066                         case R_PPC64_TOC16_HA:
9067                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9068                           break;
9069
9070                         case R_PPC64_TOC16_LO_DS:
9071                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9072                           break;
9073
9074                         default:
9075                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9076                             ppc_howto_init ();
9077                           info->callbacks->einfo
9078                             (_("%P: %H: %s references "
9079                                "optimized away TOC entry\n"),
9080                              ibfd, sec, rel->r_offset,
9081                              ppc64_elf_howto_table[r_type]->name);
9082                           bfd_set_error (bfd_error_bad_value);
9083                           goto error_ret;
9084                         }
9085                       rel->r_addend = tocrel->r_addend;
9086                       elf_section_data (sec)->relocs = relstart;
9087                       continue;
9088                     }
9089
9090                   if (h != NULL || sym->st_value != 0)
9091                     continue;
9092
9093                   rel->r_addend -= skip[val >> 3];
9094                   elf_section_data (sec)->relocs = relstart;
9095                 }
9096
9097               if (elf_section_data (sec)->relocs != relstart)
9098                 free (relstart);
9099             }
9100
9101           /* We shouldn't have local or global symbols defined in the TOC,
9102              but handle them anyway.  */
9103           if (local_syms != NULL)
9104             for (sym = local_syms;
9105                  sym < local_syms + symtab_hdr->sh_info;
9106                  ++sym)
9107               if (sym->st_value != 0
9108                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9109                 {
9110                   unsigned long i;
9111
9112                   if (sym->st_value > toc->rawsize)
9113                     i = toc->rawsize >> 3;
9114                   else
9115                     i = sym->st_value >> 3;
9116
9117                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9118                     {
9119                       if (local_toc_syms)
9120                         (*_bfd_error_handler)
9121                           (_("%s defined on removed toc entry"),
9122                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9123                       do
9124                         ++i;
9125                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9126                       sym->st_value = (bfd_vma) i << 3;
9127                     }
9128
9129                   sym->st_value -= skip[i];
9130                   symtab_hdr->contents = (unsigned char *) local_syms;
9131                 }
9132
9133           /* Adjust any global syms defined in this toc input section.  */
9134           if (toc_inf.global_toc_syms)
9135             {
9136               toc_inf.toc = toc;
9137               toc_inf.skip = skip;
9138               toc_inf.global_toc_syms = FALSE;
9139               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9140                                       &toc_inf);
9141             }
9142
9143           if (toc->reloc_count != 0)
9144             {
9145               Elf_Internal_Shdr *rel_hdr;
9146               Elf_Internal_Rela *wrel;
9147               bfd_size_type sz;
9148
9149               /* Remove unused toc relocs, and adjust those we keep.  */
9150               if (toc_relocs == NULL)
9151                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9152                                                         info->keep_memory);
9153               if (toc_relocs == NULL)
9154                 goto error_ret;
9155
9156               wrel = toc_relocs;
9157               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9158                 if ((skip[rel->r_offset >> 3]
9159                      & (ref_from_discarded | can_optimize)) == 0)
9160                   {
9161                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9162                     wrel->r_info = rel->r_info;
9163                     wrel->r_addend = rel->r_addend;
9164                     ++wrel;
9165                   }
9166                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9167                                             &local_syms, NULL, NULL))
9168                   goto error_ret;
9169
9170               elf_section_data (toc)->relocs = toc_relocs;
9171               toc->reloc_count = wrel - toc_relocs;
9172               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9173               sz = rel_hdr->sh_entsize;
9174               rel_hdr->sh_size = toc->reloc_count * sz;
9175             }
9176         }
9177       else if (toc_relocs != NULL
9178                && elf_section_data (toc)->relocs != toc_relocs)
9179         free (toc_relocs);
9180
9181       if (local_syms != NULL
9182           && symtab_hdr->contents != (unsigned char *) local_syms)
9183         {
9184           if (!info->keep_memory)
9185             free (local_syms);
9186           else
9187             symtab_hdr->contents = (unsigned char *) local_syms;
9188         }
9189       free (skip);
9190     }
9191
9192   return TRUE;
9193 }
9194
9195 /* Return true iff input section I references the TOC using
9196    instructions limited to +/-32k offsets.  */
9197
9198 bfd_boolean
9199 ppc64_elf_has_small_toc_reloc (asection *i)
9200 {
9201   return (is_ppc64_elf (i->owner)
9202           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9203 }
9204
9205 /* Allocate space for one GOT entry.  */
9206
9207 static void
9208 allocate_got (struct elf_link_hash_entry *h,
9209               struct bfd_link_info *info,
9210               struct got_entry *gent)
9211 {
9212   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9213   bfd_boolean dyn;
9214   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9215   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9216                  ? 16 : 8);
9217   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9218                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9219   asection *got = ppc64_elf_tdata (gent->owner)->got;
9220
9221   gent->got.offset = got->size;
9222   got->size += entsize;
9223
9224   dyn = htab->elf.dynamic_sections_created;
9225   if (h->type == STT_GNU_IFUNC)
9226     {
9227       htab->elf.irelplt->size += rentsize;
9228       htab->got_reli_size += rentsize;
9229     }
9230   else if ((info->shared
9231             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9232            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9233                || h->root.type != bfd_link_hash_undefweak))
9234     {
9235       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9236       relgot->size += rentsize;
9237     }
9238 }
9239
9240 /* This function merges got entries in the same toc group.  */
9241
9242 static void
9243 merge_got_entries (struct got_entry **pent)
9244 {
9245   struct got_entry *ent, *ent2;
9246
9247   for (ent = *pent; ent != NULL; ent = ent->next)
9248     if (!ent->is_indirect)
9249       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9250         if (!ent2->is_indirect
9251             && ent2->addend == ent->addend
9252             && ent2->tls_type == ent->tls_type
9253             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9254           {
9255             ent2->is_indirect = TRUE;
9256             ent2->got.ent = ent;
9257           }
9258 }
9259
9260 /* Allocate space in .plt, .got and associated reloc sections for
9261    dynamic relocs.  */
9262
9263 static bfd_boolean
9264 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9265 {
9266   struct bfd_link_info *info;
9267   struct ppc_link_hash_table *htab;
9268   asection *s;
9269   struct ppc_link_hash_entry *eh;
9270   struct elf_dyn_relocs *p;
9271   struct got_entry **pgent, *gent;
9272
9273   if (h->root.type == bfd_link_hash_indirect)
9274     return TRUE;
9275
9276   info = (struct bfd_link_info *) inf;
9277   htab = ppc_hash_table (info);
9278   if (htab == NULL)
9279     return FALSE;
9280
9281   if ((htab->elf.dynamic_sections_created
9282        && h->dynindx != -1
9283        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9284       || h->type == STT_GNU_IFUNC)
9285     {
9286       struct plt_entry *pent;
9287       bfd_boolean doneone = FALSE;
9288       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9289         if (pent->plt.refcount > 0)
9290           {
9291             if (!htab->elf.dynamic_sections_created
9292                 || h->dynindx == -1)
9293               {
9294                 s = htab->elf.iplt;
9295                 pent->plt.offset = s->size;
9296                 s->size += PLT_ENTRY_SIZE (htab);
9297                 s = htab->elf.irelplt;
9298               }
9299             else
9300               {
9301                 /* If this is the first .plt entry, make room for the special
9302                    first entry.  */
9303                 s = htab->elf.splt;
9304                 if (s->size == 0)
9305                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9306
9307                 pent->plt.offset = s->size;
9308
9309                 /* Make room for this entry.  */
9310                 s->size += PLT_ENTRY_SIZE (htab);
9311
9312                 /* Make room for the .glink code.  */
9313                 s = htab->glink;
9314                 if (s->size == 0)
9315                   s->size += GLINK_CALL_STUB_SIZE;
9316                 if (htab->opd_abi)
9317                   {
9318                     /* We need bigger stubs past index 32767.  */
9319                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9320                       s->size += 4;
9321                     s->size += 2*4;
9322                   }
9323                 else
9324                   s->size += 4;
9325
9326                 /* We also need to make an entry in the .rela.plt section.  */
9327                 s = htab->elf.srelplt;
9328               }
9329             s->size += sizeof (Elf64_External_Rela);
9330             doneone = TRUE;
9331           }
9332         else
9333           pent->plt.offset = (bfd_vma) -1;
9334       if (!doneone)
9335         {
9336           h->plt.plist = NULL;
9337           h->needs_plt = 0;
9338         }
9339     }
9340   else
9341     {
9342       h->plt.plist = NULL;
9343       h->needs_plt = 0;
9344     }
9345
9346   eh = (struct ppc_link_hash_entry *) h;
9347   /* Run through the TLS GD got entries first if we're changing them
9348      to TPREL.  */
9349   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9350     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9351       if (gent->got.refcount > 0
9352           && (gent->tls_type & TLS_GD) != 0)
9353         {
9354           /* This was a GD entry that has been converted to TPREL.  If
9355              there happens to be a TPREL entry we can use that one.  */
9356           struct got_entry *ent;
9357           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9358             if (ent->got.refcount > 0
9359                 && (ent->tls_type & TLS_TPREL) != 0
9360                 && ent->addend == gent->addend
9361                 && ent->owner == gent->owner)
9362               {
9363                 gent->got.refcount = 0;
9364                 break;
9365               }
9366
9367           /* If not, then we'll be using our own TPREL entry.  */
9368           if (gent->got.refcount != 0)
9369             gent->tls_type = TLS_TLS | TLS_TPREL;
9370         }
9371
9372   /* Remove any list entry that won't generate a word in the GOT before
9373      we call merge_got_entries.  Otherwise we risk merging to empty
9374      entries.  */
9375   pgent = &h->got.glist;
9376   while ((gent = *pgent) != NULL)
9377     if (gent->got.refcount > 0)
9378       {
9379         if ((gent->tls_type & TLS_LD) != 0
9380             && !h->def_dynamic)
9381           {
9382             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9383             *pgent = gent->next;
9384           }
9385         else
9386           pgent = &gent->next;
9387       }
9388     else
9389       *pgent = gent->next;
9390
9391   if (!htab->do_multi_toc)
9392     merge_got_entries (&h->got.glist);
9393
9394   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9395     if (!gent->is_indirect)
9396       {
9397         /* Make sure this symbol is output as a dynamic symbol.
9398            Undefined weak syms won't yet be marked as dynamic,
9399            nor will all TLS symbols.  */
9400         if (h->dynindx == -1
9401             && !h->forced_local
9402             && h->type != STT_GNU_IFUNC
9403             && htab->elf.dynamic_sections_created)
9404           {
9405             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9406               return FALSE;
9407           }
9408
9409         if (!is_ppc64_elf (gent->owner))
9410           abort ();
9411
9412         allocate_got (h, info, gent);
9413       }
9414
9415   if (eh->dyn_relocs == NULL
9416       || (!htab->elf.dynamic_sections_created
9417           && h->type != STT_GNU_IFUNC))
9418     return TRUE;
9419
9420   /* In the shared -Bsymbolic case, discard space allocated for
9421      dynamic pc-relative relocs against symbols which turn out to be
9422      defined in regular objects.  For the normal shared case, discard
9423      space for relocs that have become local due to symbol visibility
9424      changes.  */
9425
9426   if (info->shared)
9427     {
9428       /* Relocs that use pc_count are those that appear on a call insn,
9429          or certain REL relocs (see must_be_dyn_reloc) that can be
9430          generated via assembly.  We want calls to protected symbols to
9431          resolve directly to the function rather than going via the plt.
9432          If people want function pointer comparisons to work as expected
9433          then they should avoid writing weird assembly.  */
9434       if (SYMBOL_CALLS_LOCAL (info, h))
9435         {
9436           struct elf_dyn_relocs **pp;
9437
9438           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9439             {
9440               p->count -= p->pc_count;
9441               p->pc_count = 0;
9442               if (p->count == 0)
9443                 *pp = p->next;
9444               else
9445                 pp = &p->next;
9446             }
9447         }
9448
9449       /* Also discard relocs on undefined weak syms with non-default
9450          visibility.  */
9451       if (eh->dyn_relocs != NULL
9452           && h->root.type == bfd_link_hash_undefweak)
9453         {
9454           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9455             eh->dyn_relocs = NULL;
9456
9457           /* Make sure this symbol is output as a dynamic symbol.
9458              Undefined weak syms won't yet be marked as dynamic.  */
9459           else if (h->dynindx == -1
9460                    && !h->forced_local)
9461             {
9462               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9463                 return FALSE;
9464             }
9465         }
9466     }
9467   else if (h->type == STT_GNU_IFUNC)
9468     {
9469       if (!h->non_got_ref)
9470         eh->dyn_relocs = NULL;
9471     }
9472   else if (ELIMINATE_COPY_RELOCS)
9473     {
9474       /* For the non-shared case, discard space for relocs against
9475          symbols which turn out to need copy relocs or are not
9476          dynamic.  */
9477
9478       if (!h->non_got_ref
9479           && !h->def_regular)
9480         {
9481           /* Make sure this symbol is output as a dynamic symbol.
9482              Undefined weak syms won't yet be marked as dynamic.  */
9483           if (h->dynindx == -1
9484               && !h->forced_local)
9485             {
9486               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9487                 return FALSE;
9488             }
9489
9490           /* If that succeeded, we know we'll be keeping all the
9491              relocs.  */
9492           if (h->dynindx != -1)
9493             goto keep;
9494         }
9495
9496       eh->dyn_relocs = NULL;
9497
9498     keep: ;
9499     }
9500
9501   /* Finally, allocate space.  */
9502   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9503     {
9504       asection *sreloc = elf_section_data (p->sec)->sreloc;
9505       if (eh->elf.type == STT_GNU_IFUNC)
9506         sreloc = htab->elf.irelplt;
9507       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9508     }
9509
9510   return TRUE;
9511 }
9512
9513 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9514    to set up space for global entry stubs.  These are put in glink,
9515    after the branch table.  */
9516
9517 static bfd_boolean
9518 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9519 {
9520   struct bfd_link_info *info;
9521   struct ppc_link_hash_table *htab;
9522   struct plt_entry *pent;
9523   asection *s;
9524
9525   if (h->root.type == bfd_link_hash_indirect)
9526     return TRUE;
9527
9528   if (!h->pointer_equality_needed)
9529     return TRUE;
9530
9531   if (h->def_regular)
9532     return TRUE;
9533
9534   info = inf;
9535   htab = ppc_hash_table (info);
9536   if (htab == NULL)
9537     return FALSE;
9538
9539   s = htab->glink;
9540   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9541     if (pent->plt.offset != (bfd_vma) -1
9542         && pent->addend == 0)
9543       {
9544         /* For ELFv2, if this symbol is not defined in a regular file
9545            and we are not generating a shared library or pie, then we
9546            need to define the symbol in the executable on a call stub.
9547            This is to avoid text relocations.  */
9548         s->size = (s->size + 15) & -16;
9549         h->root.u.def.section = s;
9550         h->root.u.def.value = s->size;
9551         s->size += 16;
9552         break;
9553       }
9554   return TRUE;
9555 }
9556
9557 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9558    read-only sections.  */
9559
9560 static bfd_boolean
9561 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9562 {
9563   if (h->root.type == bfd_link_hash_indirect)
9564     return TRUE;
9565
9566   if (readonly_dynrelocs (h))
9567     {
9568       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9569
9570       /* Not an error, just cut short the traversal.  */
9571       return FALSE;
9572     }
9573   return TRUE;
9574 }
9575
9576 /* Set the sizes of the dynamic sections.  */
9577
9578 static bfd_boolean
9579 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9580                                  struct bfd_link_info *info)
9581 {
9582   struct ppc_link_hash_table *htab;
9583   bfd *dynobj;
9584   asection *s;
9585   bfd_boolean relocs;
9586   bfd *ibfd;
9587   struct got_entry *first_tlsld;
9588
9589   htab = ppc_hash_table (info);
9590   if (htab == NULL)
9591     return FALSE;
9592
9593   dynobj = htab->elf.dynobj;
9594   if (dynobj == NULL)
9595     abort ();
9596
9597   if (htab->elf.dynamic_sections_created)
9598     {
9599       /* Set the contents of the .interp section to the interpreter.  */
9600       if (info->executable)
9601         {
9602           s = bfd_get_linker_section (dynobj, ".interp");
9603           if (s == NULL)
9604             abort ();
9605           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9606           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9607         }
9608     }
9609
9610   /* Set up .got offsets for local syms, and space for local dynamic
9611      relocs.  */
9612   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9613     {
9614       struct got_entry **lgot_ents;
9615       struct got_entry **end_lgot_ents;
9616       struct plt_entry **local_plt;
9617       struct plt_entry **end_local_plt;
9618       unsigned char *lgot_masks;
9619       bfd_size_type locsymcount;
9620       Elf_Internal_Shdr *symtab_hdr;
9621
9622       if (!is_ppc64_elf (ibfd))
9623         continue;
9624
9625       for (s = ibfd->sections; s != NULL; s = s->next)
9626         {
9627           struct ppc_dyn_relocs *p;
9628
9629           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9630             {
9631               if (!bfd_is_abs_section (p->sec)
9632                   && bfd_is_abs_section (p->sec->output_section))
9633                 {
9634                   /* Input section has been discarded, either because
9635                      it is a copy of a linkonce section or due to
9636                      linker script /DISCARD/, so we'll be discarding
9637                      the relocs too.  */
9638                 }
9639               else if (p->count != 0)
9640                 {
9641                   asection *srel = elf_section_data (p->sec)->sreloc;
9642                   if (p->ifunc)
9643                     srel = htab->elf.irelplt;
9644                   srel->size += p->count * sizeof (Elf64_External_Rela);
9645                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9646                     info->flags |= DF_TEXTREL;
9647                 }
9648             }
9649         }
9650
9651       lgot_ents = elf_local_got_ents (ibfd);
9652       if (!lgot_ents)
9653         continue;
9654
9655       symtab_hdr = &elf_symtab_hdr (ibfd);
9656       locsymcount = symtab_hdr->sh_info;
9657       end_lgot_ents = lgot_ents + locsymcount;
9658       local_plt = (struct plt_entry **) end_lgot_ents;
9659       end_local_plt = local_plt + locsymcount;
9660       lgot_masks = (unsigned char *) end_local_plt;
9661       s = ppc64_elf_tdata (ibfd)->got;
9662       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9663         {
9664           struct got_entry **pent, *ent;
9665
9666           pent = lgot_ents;
9667           while ((ent = *pent) != NULL)
9668             if (ent->got.refcount > 0)
9669               {
9670                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9671                   {
9672                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9673                     *pent = ent->next;
9674                   }
9675                 else
9676                   {
9677                     unsigned int ent_size = 8;
9678                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9679
9680                     ent->got.offset = s->size;
9681                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9682                       {
9683                         ent_size *= 2;
9684                         rel_size *= 2;
9685                       }
9686                     s->size += ent_size;
9687                     if ((*lgot_masks & PLT_IFUNC) != 0)
9688                       {
9689                         htab->elf.irelplt->size += rel_size;
9690                         htab->got_reli_size += rel_size;
9691                       }
9692                     else if (info->shared)
9693                       {
9694                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9695                         srel->size += rel_size;
9696                       }
9697                     pent = &ent->next;
9698                   }
9699               }
9700             else
9701               *pent = ent->next;
9702         }
9703
9704       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9705       for (; local_plt < end_local_plt; ++local_plt)
9706         {
9707           struct plt_entry *ent;
9708
9709           for (ent = *local_plt; ent != NULL; ent = ent->next)
9710             if (ent->plt.refcount > 0)
9711               {
9712                 s = htab->elf.iplt;
9713                 ent->plt.offset = s->size;
9714                 s->size += PLT_ENTRY_SIZE (htab);
9715
9716                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9717               }
9718             else
9719               ent->plt.offset = (bfd_vma) -1;
9720         }
9721     }
9722
9723   /* Allocate global sym .plt and .got entries, and space for global
9724      sym dynamic relocs.  */
9725   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9726   /* Stash the end of glink branch table.  */
9727   if (htab->glink != NULL)
9728     htab->glink->rawsize = htab->glink->size;
9729
9730   if (!htab->opd_abi && !info->shared)
9731     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9732
9733   first_tlsld = NULL;
9734   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9735     {
9736       struct got_entry *ent;
9737
9738       if (!is_ppc64_elf (ibfd))
9739         continue;
9740
9741       ent = ppc64_tlsld_got (ibfd);
9742       if (ent->got.refcount > 0)
9743         {
9744           if (!htab->do_multi_toc && first_tlsld != NULL)
9745             {
9746               ent->is_indirect = TRUE;
9747               ent->got.ent = first_tlsld;
9748             }
9749           else
9750             {
9751               if (first_tlsld == NULL)
9752                 first_tlsld = ent;
9753               s = ppc64_elf_tdata (ibfd)->got;
9754               ent->got.offset = s->size;
9755               ent->owner = ibfd;
9756               s->size += 16;
9757               if (info->shared)
9758                 {
9759                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9760                   srel->size += sizeof (Elf64_External_Rela);
9761                 }
9762             }
9763         }
9764       else
9765         ent->got.offset = (bfd_vma) -1;
9766     }
9767
9768   /* We now have determined the sizes of the various dynamic sections.
9769      Allocate memory for them.  */
9770   relocs = FALSE;
9771   for (s = dynobj->sections; s != NULL; s = s->next)
9772     {
9773       if ((s->flags & SEC_LINKER_CREATED) == 0)
9774         continue;
9775
9776       if (s == htab->brlt || s == htab->relbrlt)
9777         /* These haven't been allocated yet;  don't strip.  */
9778         continue;
9779       else if (s == htab->elf.sgot
9780                || s == htab->elf.splt
9781                || s == htab->elf.iplt
9782                || s == htab->glink
9783                || s == htab->dynbss)
9784         {
9785           /* Strip this section if we don't need it; see the
9786              comment below.  */
9787         }
9788       else if (s == htab->glink_eh_frame)
9789         {
9790           if (!bfd_is_abs_section (s->output_section))
9791             /* Not sized yet.  */
9792             continue;
9793         }
9794       else if (CONST_STRNEQ (s->name, ".rela"))
9795         {
9796           if (s->size != 0)
9797             {
9798               if (s != htab->elf.srelplt)
9799                 relocs = TRUE;
9800
9801               /* We use the reloc_count field as a counter if we need
9802                  to copy relocs into the output file.  */
9803               s->reloc_count = 0;
9804             }
9805         }
9806       else
9807         {
9808           /* It's not one of our sections, so don't allocate space.  */
9809           continue;
9810         }
9811
9812       if (s->size == 0)
9813         {
9814           /* If we don't need this section, strip it from the
9815              output file.  This is mostly to handle .rela.bss and
9816              .rela.plt.  We must create both sections in
9817              create_dynamic_sections, because they must be created
9818              before the linker maps input sections to output
9819              sections.  The linker does that before
9820              adjust_dynamic_symbol is called, and it is that
9821              function which decides whether anything needs to go
9822              into these sections.  */
9823           s->flags |= SEC_EXCLUDE;
9824           continue;
9825         }
9826
9827       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9828         continue;
9829
9830       /* Allocate memory for the section contents.  We use bfd_zalloc
9831          here in case unused entries are not reclaimed before the
9832          section's contents are written out.  This should not happen,
9833          but this way if it does we get a R_PPC64_NONE reloc in .rela
9834          sections instead of garbage.
9835          We also rely on the section contents being zero when writing
9836          the GOT.  */
9837       s->contents = bfd_zalloc (dynobj, s->size);
9838       if (s->contents == NULL)
9839         return FALSE;
9840     }
9841
9842   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9843     {
9844       if (!is_ppc64_elf (ibfd))
9845         continue;
9846
9847       s = ppc64_elf_tdata (ibfd)->got;
9848       if (s != NULL && s != htab->elf.sgot)
9849         {
9850           if (s->size == 0)
9851             s->flags |= SEC_EXCLUDE;
9852           else
9853             {
9854               s->contents = bfd_zalloc (ibfd, s->size);
9855               if (s->contents == NULL)
9856                 return FALSE;
9857             }
9858         }
9859       s = ppc64_elf_tdata (ibfd)->relgot;
9860       if (s != NULL)
9861         {
9862           if (s->size == 0)
9863             s->flags |= SEC_EXCLUDE;
9864           else
9865             {
9866               s->contents = bfd_zalloc (ibfd, s->size);
9867               if (s->contents == NULL)
9868                 return FALSE;
9869               relocs = TRUE;
9870               s->reloc_count = 0;
9871             }
9872         }
9873     }
9874
9875   if (htab->elf.dynamic_sections_created)
9876     {
9877       bfd_boolean tls_opt;
9878
9879       /* Add some entries to the .dynamic section.  We fill in the
9880          values later, in ppc64_elf_finish_dynamic_sections, but we
9881          must add the entries now so that we get the correct size for
9882          the .dynamic section.  The DT_DEBUG entry is filled in by the
9883          dynamic linker and used by the debugger.  */
9884 #define add_dynamic_entry(TAG, VAL) \
9885   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9886
9887       if (info->executable)
9888         {
9889           if (!add_dynamic_entry (DT_DEBUG, 0))
9890             return FALSE;
9891         }
9892
9893       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9894         {
9895           if (!add_dynamic_entry (DT_PLTGOT, 0)
9896               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9897               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9898               || !add_dynamic_entry (DT_JMPREL, 0)
9899               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9900             return FALSE;
9901         }
9902
9903       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9904         {
9905           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9906               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9907             return FALSE;
9908         }
9909
9910       tls_opt = (!htab->no_tls_get_addr_opt
9911                  && htab->tls_get_addr_fd != NULL
9912                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9913       if (tls_opt || !htab->opd_abi)
9914         {
9915           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9916             return FALSE;
9917         }
9918
9919       if (relocs)
9920         {
9921           if (!add_dynamic_entry (DT_RELA, 0)
9922               || !add_dynamic_entry (DT_RELASZ, 0)
9923               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9924             return FALSE;
9925
9926           /* If any dynamic relocs apply to a read-only section,
9927              then we need a DT_TEXTREL entry.  */
9928           if ((info->flags & DF_TEXTREL) == 0)
9929             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9930
9931           if ((info->flags & DF_TEXTREL) != 0)
9932             {
9933               if (!add_dynamic_entry (DT_TEXTREL, 0))
9934                 return FALSE;
9935             }
9936         }
9937     }
9938 #undef add_dynamic_entry
9939
9940   return TRUE;
9941 }
9942
9943 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9944
9945 static bfd_boolean
9946 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9947 {
9948   if (h->plt.plist != NULL
9949       && !h->def_regular
9950       && !h->pointer_equality_needed)
9951     return FALSE;
9952
9953   return _bfd_elf_hash_symbol (h);
9954 }
9955
9956 /* Determine the type of stub needed, if any, for a call.  */
9957
9958 static inline enum ppc_stub_type
9959 ppc_type_of_stub (asection *input_sec,
9960                   const Elf_Internal_Rela *rel,
9961                   struct ppc_link_hash_entry **hash,
9962                   struct plt_entry **plt_ent,
9963                   bfd_vma destination,
9964                   unsigned long local_off)
9965 {
9966   struct ppc_link_hash_entry *h = *hash;
9967   bfd_vma location;
9968   bfd_vma branch_offset;
9969   bfd_vma max_branch_offset;
9970   enum elf_ppc64_reloc_type r_type;
9971
9972   if (h != NULL)
9973     {
9974       struct plt_entry *ent;
9975       struct ppc_link_hash_entry *fdh = h;
9976       if (h->oh != NULL
9977           && h->oh->is_func_descriptor)
9978         {
9979           fdh = ppc_follow_link (h->oh);
9980           *hash = fdh;
9981         }
9982
9983       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9984         if (ent->addend == rel->r_addend
9985             && ent->plt.offset != (bfd_vma) -1)
9986           {
9987             *plt_ent = ent;
9988             return ppc_stub_plt_call;
9989           }
9990
9991       /* Here, we know we don't have a plt entry.  If we don't have a
9992          either a defined function descriptor or a defined entry symbol
9993          in a regular object file, then it is pointless trying to make
9994          any other type of stub.  */
9995       if (!is_static_defined (&fdh->elf)
9996           && !is_static_defined (&h->elf))
9997         return ppc_stub_none;
9998     }
9999   else if (elf_local_got_ents (input_sec->owner) != NULL)
10000     {
10001       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10002       struct plt_entry **local_plt = (struct plt_entry **)
10003         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10004       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10005
10006       if (local_plt[r_symndx] != NULL)
10007         {
10008           struct plt_entry *ent;
10009
10010           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10011             if (ent->addend == rel->r_addend
10012                 && ent->plt.offset != (bfd_vma) -1)
10013               {
10014                 *plt_ent = ent;
10015                 return ppc_stub_plt_call;
10016               }
10017         }
10018     }
10019
10020   /* Determine where the call point is.  */
10021   location = (input_sec->output_offset
10022               + input_sec->output_section->vma
10023               + rel->r_offset);
10024
10025   branch_offset = destination - location;
10026   r_type = ELF64_R_TYPE (rel->r_info);
10027
10028   /* Determine if a long branch stub is needed.  */
10029   max_branch_offset = 1 << 25;
10030   if (r_type != R_PPC64_REL24)
10031     max_branch_offset = 1 << 15;
10032
10033   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10034     /* We need a stub.  Figure out whether a long_branch or plt_branch
10035        is needed later.  */
10036     return ppc_stub_long_branch;
10037
10038   return ppc_stub_none;
10039 }
10040
10041 /* With power7 weakly ordered memory model, it is possible for ld.so
10042    to update a plt entry in one thread and have another thread see a
10043    stale zero toc entry.  To avoid this we need some sort of acquire
10044    barrier in the call stub.  One solution is to make the load of the
10045    toc word seem to appear to depend on the load of the function entry
10046    word.  Another solution is to test for r2 being zero, and branch to
10047    the appropriate glink entry if so.
10048
10049    .    fake dep barrier        compare
10050    .    ld 12,xxx(2)            ld 12,xxx(2)
10051    .    mtctr 12                mtctr 12
10052    .    xor 11,12,12            ld 2,xxx+8(2)
10053    .    add 2,2,11              cmpldi 2,0
10054    .    ld 2,xxx+8(2)           bnectr+
10055    .    bctr                    b <glink_entry>
10056
10057    The solution involving the compare turns out to be faster, so
10058    that's what we use unless the branch won't reach.  */
10059
10060 #define ALWAYS_USE_FAKE_DEP 0
10061 #define ALWAYS_EMIT_R2SAVE 0
10062
10063 #define PPC_LO(v) ((v) & 0xffff)
10064 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10065 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10066
10067 static inline unsigned int
10068 plt_stub_size (struct ppc_link_hash_table *htab,
10069                struct ppc_stub_hash_entry *stub_entry,
10070                bfd_vma off)
10071 {
10072   unsigned size = 12;
10073
10074   if (ALWAYS_EMIT_R2SAVE
10075       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10076     size += 4;
10077   if (PPC_HA (off) != 0)
10078     size += 4;
10079   if (htab->opd_abi)
10080     {
10081       size += 4;
10082       if (htab->plt_static_chain)
10083         size += 4;
10084       if (htab->plt_thread_safe)
10085         size += 8;
10086       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10087         size += 4;
10088     }
10089   if (stub_entry->h != NULL
10090       && (stub_entry->h == htab->tls_get_addr_fd
10091           || stub_entry->h == htab->tls_get_addr)
10092       && !htab->no_tls_get_addr_opt)
10093     size += 13 * 4;
10094   return size;
10095 }
10096
10097 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10098    then return the padding needed to do so.  */
10099 static inline unsigned int
10100 plt_stub_pad (struct ppc_link_hash_table *htab,
10101               struct ppc_stub_hash_entry *stub_entry,
10102               bfd_vma plt_off)
10103 {
10104   int stub_align = 1 << htab->plt_stub_align;
10105   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10106   bfd_vma stub_off = stub_entry->stub_sec->size;
10107
10108   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10109       > (stub_size & -stub_align))
10110     return stub_align - (stub_off & (stub_align - 1));
10111   return 0;
10112 }
10113
10114 /* Build a .plt call stub.  */
10115
10116 static inline bfd_byte *
10117 build_plt_stub (struct ppc_link_hash_table *htab,
10118                 struct ppc_stub_hash_entry *stub_entry,
10119                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10120 {
10121   bfd *obfd = htab->stub_bfd;
10122   bfd_boolean plt_load_toc = htab->opd_abi;
10123   bfd_boolean plt_static_chain = htab->plt_static_chain;
10124   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10125   bfd_boolean use_fake_dep = plt_thread_safe;
10126   bfd_vma cmp_branch_off = 0;
10127
10128   if (!ALWAYS_USE_FAKE_DEP
10129       && plt_load_toc
10130       && plt_thread_safe
10131       && !(stub_entry->h != NULL
10132            && (stub_entry->h == htab->tls_get_addr_fd
10133                || stub_entry->h == htab->tls_get_addr)
10134            && !htab->no_tls_get_addr_opt))
10135     {
10136       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10137       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10138                           / PLT_ENTRY_SIZE (htab));
10139       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10140       bfd_vma to, from;
10141
10142       if (pltindex > 32768)
10143         glinkoff += (pltindex - 32768) * 4;
10144       to = (glinkoff
10145             + htab->glink->output_offset
10146             + htab->glink->output_section->vma);
10147       from = (p - stub_entry->stub_sec->contents
10148               + 4 * (ALWAYS_EMIT_R2SAVE
10149                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10150               + 4 * (PPC_HA (offset) != 0)
10151               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10152                      != PPC_HA (offset))
10153               + 4 * (plt_static_chain != 0)
10154               + 20
10155               + stub_entry->stub_sec->output_offset
10156               + stub_entry->stub_sec->output_section->vma);
10157       cmp_branch_off = to - from;
10158       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10159     }
10160
10161   if (PPC_HA (offset) != 0)
10162     {
10163       if (r != NULL)
10164         {
10165           if (ALWAYS_EMIT_R2SAVE
10166               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10167             r[0].r_offset += 4;
10168           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10169           r[1].r_offset = r[0].r_offset + 4;
10170           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10171           r[1].r_addend = r[0].r_addend;
10172           if (plt_load_toc)
10173             {
10174               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10175                 {
10176                   r[2].r_offset = r[1].r_offset + 4;
10177                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10178                   r[2].r_addend = r[0].r_addend;
10179                 }
10180               else
10181                 {
10182                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10183                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10184                   r[2].r_addend = r[0].r_addend + 8;
10185                   if (plt_static_chain)
10186                     {
10187                       r[3].r_offset = r[2].r_offset + 4;
10188                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10189                       r[3].r_addend = r[0].r_addend + 16;
10190                     }
10191                 }
10192             }
10193         }
10194       if (ALWAYS_EMIT_R2SAVE
10195           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10196         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10197       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10198       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10199       if (plt_load_toc
10200           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10201         {
10202           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10203           offset = 0;
10204         }
10205       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10206       if (plt_load_toc)
10207         {
10208           if (use_fake_dep)
10209             {
10210               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10211               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10212             }
10213           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10214           if (plt_static_chain)
10215             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10216         }
10217     }
10218   else
10219     {
10220       if (r != NULL)
10221         {
10222           if (ALWAYS_EMIT_R2SAVE
10223               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10224             r[0].r_offset += 4;
10225           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10226           if (plt_load_toc)
10227             {
10228               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10229                 {
10230                   r[1].r_offset = r[0].r_offset + 4;
10231                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10232                   r[1].r_addend = r[0].r_addend;
10233                 }
10234               else
10235                 {
10236                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10237                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10238                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10239                   if (plt_static_chain)
10240                     {
10241                       r[2].r_offset = r[1].r_offset + 4;
10242                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10243                       r[2].r_addend = r[0].r_addend + 8;
10244                     }
10245                 }
10246             }
10247         }
10248       if (ALWAYS_EMIT_R2SAVE
10249           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10250         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10251       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10252       if (plt_load_toc
10253           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10254         {
10255           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10256           offset = 0;
10257         }
10258       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10259       if (plt_load_toc)
10260         {
10261           if (use_fake_dep)
10262             {
10263               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10264               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10265             }
10266           if (plt_static_chain)
10267             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10268           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10269         }
10270     }
10271   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10272     {
10273       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10274       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10275       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10276     }
10277   else
10278     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10279   return p;
10280 }
10281
10282 /* Build a special .plt call stub for __tls_get_addr.  */
10283
10284 #define LD_R11_0R3      0xe9630000
10285 #define LD_R12_0R3      0xe9830000
10286 #define MR_R0_R3        0x7c601b78
10287 #define CMPDI_R11_0     0x2c2b0000
10288 #define ADD_R3_R12_R13  0x7c6c6a14
10289 #define BEQLR           0x4d820020
10290 #define MR_R3_R0        0x7c030378
10291 #define STD_R11_0R1     0xf9610000
10292 #define BCTRL           0x4e800421
10293 #define LD_R11_0R1      0xe9610000
10294 #define MTLR_R11        0x7d6803a6
10295
10296 static inline bfd_byte *
10297 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10298                          struct ppc_stub_hash_entry *stub_entry,
10299                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10300 {
10301   bfd *obfd = htab->stub_bfd;
10302
10303   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10304   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10305   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10306   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10307   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10308   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10309   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10310   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10311   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10312
10313   if (r != NULL)
10314     r[0].r_offset += 9 * 4;
10315   p = build_plt_stub (htab, stub_entry, p, offset, r);
10316   bfd_put_32 (obfd, BCTRL, p - 4);
10317
10318   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10319   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10320   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10321   bfd_put_32 (obfd, BLR, p),                    p += 4;
10322
10323   return p;
10324 }
10325
10326 static Elf_Internal_Rela *
10327 get_relocs (asection *sec, int count)
10328 {
10329   Elf_Internal_Rela *relocs;
10330   struct bfd_elf_section_data *elfsec_data;
10331
10332   elfsec_data = elf_section_data (sec);
10333   relocs = elfsec_data->relocs;
10334   if (relocs == NULL)
10335     {
10336       bfd_size_type relsize;
10337       relsize = sec->reloc_count * sizeof (*relocs);
10338       relocs = bfd_alloc (sec->owner, relsize);
10339       if (relocs == NULL)
10340         return NULL;
10341       elfsec_data->relocs = relocs;
10342       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10343                                           sizeof (Elf_Internal_Shdr));
10344       if (elfsec_data->rela.hdr == NULL)
10345         return NULL;
10346       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10347                                         * sizeof (Elf64_External_Rela));
10348       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10349       sec->reloc_count = 0;
10350     }
10351   relocs += sec->reloc_count;
10352   sec->reloc_count += count;
10353   return relocs;
10354 }
10355
10356 static bfd_vma
10357 get_r2off (struct bfd_link_info *info,
10358            struct ppc_stub_hash_entry *stub_entry)
10359 {
10360   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10361   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10362
10363   if (r2off == 0)
10364     {
10365       /* Support linking -R objects.  Get the toc pointer from the
10366          opd entry.  */
10367       char buf[8];
10368       if (!htab->opd_abi)
10369         return r2off;
10370       asection *opd = stub_entry->h->elf.root.u.def.section;
10371       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10372
10373       if (strcmp (opd->name, ".opd") != 0
10374           || opd->reloc_count != 0)
10375         {
10376           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10377                                   stub_entry->h->elf.root.root.string);
10378           bfd_set_error (bfd_error_bad_value);
10379           return 0;
10380         }
10381       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10382         return 0;
10383       r2off = bfd_get_64 (opd->owner, buf);
10384       r2off -= elf_gp (info->output_bfd);
10385     }
10386   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10387   return r2off;
10388 }
10389
10390 static bfd_boolean
10391 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10392 {
10393   struct ppc_stub_hash_entry *stub_entry;
10394   struct ppc_branch_hash_entry *br_entry;
10395   struct bfd_link_info *info;
10396   struct ppc_link_hash_table *htab;
10397   bfd_byte *loc;
10398   bfd_byte *p;
10399   bfd_vma dest, off;
10400   int size;
10401   Elf_Internal_Rela *r;
10402   asection *plt;
10403
10404   /* Massage our args to the form they really have.  */
10405   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10406   info = in_arg;
10407
10408   htab = ppc_hash_table (info);
10409   if (htab == NULL)
10410     return FALSE;
10411
10412   /* Make a note of the offset within the stubs for this entry.  */
10413   stub_entry->stub_offset = stub_entry->stub_sec->size;
10414   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10415
10416   htab->stub_count[stub_entry->stub_type - 1] += 1;
10417   switch (stub_entry->stub_type)
10418     {
10419     case ppc_stub_long_branch:
10420     case ppc_stub_long_branch_r2off:
10421       /* Branches are relative.  This is where we are going to.  */
10422       dest = (stub_entry->target_value
10423               + stub_entry->target_section->output_offset
10424               + stub_entry->target_section->output_section->vma);
10425       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10426       off = dest;
10427
10428       /* And this is where we are coming from.  */
10429       off -= (stub_entry->stub_offset
10430               + stub_entry->stub_sec->output_offset
10431               + stub_entry->stub_sec->output_section->vma);
10432
10433       size = 4;
10434       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10435         {
10436           bfd_vma r2off = get_r2off (info, stub_entry);
10437
10438           if (r2off == 0)
10439             {
10440               htab->stub_error = TRUE;
10441               return FALSE;
10442             }
10443           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10444           loc += 4;
10445           size = 12;
10446           if (PPC_HA (r2off) != 0)
10447             {
10448               size = 16;
10449               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10450               loc += 4;
10451             }
10452           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10453           loc += 4;
10454           off -= size - 4;
10455         }
10456       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10457
10458       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10459         {
10460           info->callbacks->einfo
10461             (_("%P: long branch stub `%s' offset overflow\n"),
10462              stub_entry->root.string);
10463           htab->stub_error = TRUE;
10464           return FALSE;
10465         }
10466
10467       if (info->emitrelocations)
10468         {
10469           r = get_relocs (stub_entry->stub_sec, 1);
10470           if (r == NULL)
10471             return FALSE;
10472           r->r_offset = loc - stub_entry->stub_sec->contents;
10473           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10474           r->r_addend = dest;
10475           if (stub_entry->h != NULL)
10476             {
10477               struct elf_link_hash_entry **hashes;
10478               unsigned long symndx;
10479               struct ppc_link_hash_entry *h;
10480
10481               hashes = elf_sym_hashes (htab->stub_bfd);
10482               if (hashes == NULL)
10483                 {
10484                   bfd_size_type hsize;
10485
10486                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10487                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10488                   if (hashes == NULL)
10489                     return FALSE;
10490                   elf_sym_hashes (htab->stub_bfd) = hashes;
10491                   htab->stub_globals = 1;
10492                 }
10493               symndx = htab->stub_globals++;
10494               h = stub_entry->h;
10495               hashes[symndx] = &h->elf;
10496               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10497               if (h->oh != NULL && h->oh->is_func)
10498                 h = ppc_follow_link (h->oh);
10499               if (h->elf.root.u.def.section != stub_entry->target_section)
10500                 /* H is an opd symbol.  The addend must be zero.  */
10501                 r->r_addend = 0;
10502               else
10503                 {
10504                   off = (h->elf.root.u.def.value
10505                          + h->elf.root.u.def.section->output_offset
10506                          + h->elf.root.u.def.section->output_section->vma);
10507                   r->r_addend -= off;
10508                 }
10509             }
10510         }
10511       break;
10512
10513     case ppc_stub_plt_branch:
10514     case ppc_stub_plt_branch_r2off:
10515       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10516                                          stub_entry->root.string + 9,
10517                                          FALSE, FALSE);
10518       if (br_entry == NULL)
10519         {
10520           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10521                                   stub_entry->root.string);
10522           htab->stub_error = TRUE;
10523           return FALSE;
10524         }
10525
10526       dest = (stub_entry->target_value
10527               + stub_entry->target_section->output_offset
10528               + stub_entry->target_section->output_section->vma);
10529       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10530         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10531
10532       bfd_put_64 (htab->brlt->owner, dest,
10533                   htab->brlt->contents + br_entry->offset);
10534
10535       if (br_entry->iter == htab->stub_iteration)
10536         {
10537           br_entry->iter = 0;
10538
10539           if (htab->relbrlt != NULL)
10540             {
10541               /* Create a reloc for the branch lookup table entry.  */
10542               Elf_Internal_Rela rela;
10543               bfd_byte *rl;
10544
10545               rela.r_offset = (br_entry->offset
10546                                + htab->brlt->output_offset
10547                                + htab->brlt->output_section->vma);
10548               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10549               rela.r_addend = dest;
10550
10551               rl = htab->relbrlt->contents;
10552               rl += (htab->relbrlt->reloc_count++
10553                      * sizeof (Elf64_External_Rela));
10554               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10555             }
10556           else if (info->emitrelocations)
10557             {
10558               r = get_relocs (htab->brlt, 1);
10559               if (r == NULL)
10560                 return FALSE;
10561               /* brlt, being SEC_LINKER_CREATED does not go through the
10562                  normal reloc processing.  Symbols and offsets are not
10563                  translated from input file to output file form, so
10564                  set up the offset per the output file.  */
10565               r->r_offset = (br_entry->offset
10566                              + htab->brlt->output_offset
10567                              + htab->brlt->output_section->vma);
10568               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10569               r->r_addend = dest;
10570             }
10571         }
10572
10573       dest = (br_entry->offset
10574               + htab->brlt->output_offset
10575               + htab->brlt->output_section->vma);
10576
10577       off = (dest
10578              - elf_gp (htab->brlt->output_section->owner)
10579              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10580
10581       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10582         {
10583           info->callbacks->einfo
10584             (_("%P: linkage table error against `%T'\n"),
10585              stub_entry->root.string);
10586           bfd_set_error (bfd_error_bad_value);
10587           htab->stub_error = TRUE;
10588           return FALSE;
10589         }
10590
10591       if (info->emitrelocations)
10592         {
10593           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10594           if (r == NULL)
10595             return FALSE;
10596           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10597           if (bfd_big_endian (info->output_bfd))
10598             r[0].r_offset += 2;
10599           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10600             r[0].r_offset += 4;
10601           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10602           r[0].r_addend = dest;
10603           if (PPC_HA (off) != 0)
10604             {
10605               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10606               r[1].r_offset = r[0].r_offset + 4;
10607               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10608               r[1].r_addend = r[0].r_addend;
10609             }
10610         }
10611
10612       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10613         {
10614           if (PPC_HA (off) != 0)
10615             {
10616               size = 16;
10617               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10618               loc += 4;
10619               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10620             }
10621           else
10622             {
10623               size = 12;
10624               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10625             }
10626         }
10627       else
10628         {
10629           bfd_vma r2off = get_r2off (info, stub_entry);
10630
10631           if (r2off == 0 && htab->opd_abi)
10632             {
10633               htab->stub_error = TRUE;
10634               return FALSE;
10635             }
10636
10637           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10638           loc += 4;
10639           size = 16;
10640           if (PPC_HA (off) != 0)
10641             {
10642               size += 4;
10643               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10644               loc += 4;
10645               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10646             }
10647           else
10648             bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10649
10650           if (PPC_HA (r2off) != 0)
10651             {
10652               size += 4;
10653               loc += 4;
10654               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10655             }
10656           if (PPC_LO (r2off) != 0)
10657             {
10658               size += 4;
10659               loc += 4;
10660               bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10661             }
10662         }
10663       loc += 4;
10664       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10665       loc += 4;
10666       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10667       break;
10668
10669     case ppc_stub_plt_call:
10670     case ppc_stub_plt_call_r2save:
10671       if (stub_entry->h != NULL
10672           && stub_entry->h->is_func_descriptor
10673           && stub_entry->h->oh != NULL)
10674         {
10675           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10676
10677           /* If the old-ABI "dot-symbol" is undefined make it weak so
10678              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10679              FIXME: We used to define the symbol on one of the call
10680              stubs instead, which is why we test symbol section id
10681              against htab->top_id in various places.  Likely all
10682              these checks could now disappear.  */
10683           if (fh->elf.root.type == bfd_link_hash_undefined)
10684             fh->elf.root.type = bfd_link_hash_undefweak;
10685           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10686           fh->was_undefined = 0;
10687         }
10688
10689       /* Now build the stub.  */
10690       dest = stub_entry->plt_ent->plt.offset & ~1;
10691       if (dest >= (bfd_vma) -2)
10692         abort ();
10693
10694       plt = htab->elf.splt;
10695       if (!htab->elf.dynamic_sections_created
10696           || stub_entry->h == NULL
10697           || stub_entry->h->elf.dynindx == -1)
10698         plt = htab->elf.iplt;
10699
10700       dest += plt->output_offset + plt->output_section->vma;
10701
10702       if (stub_entry->h == NULL
10703           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10704         {
10705           Elf_Internal_Rela rela;
10706           bfd_byte *rl;
10707
10708           rela.r_offset = dest;
10709           if (htab->opd_abi)
10710             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10711           else
10712             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10713           rela.r_addend = (stub_entry->target_value
10714                            + stub_entry->target_section->output_offset
10715                            + stub_entry->target_section->output_section->vma);
10716
10717           rl = (htab->elf.irelplt->contents
10718                 + (htab->elf.irelplt->reloc_count++
10719                    * sizeof (Elf64_External_Rela)));
10720           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10721           stub_entry->plt_ent->plt.offset |= 1;
10722         }
10723
10724       off = (dest
10725              - elf_gp (plt->output_section->owner)
10726              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10727
10728       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10729         {
10730           info->callbacks->einfo
10731             (_("%P: linkage table error against `%T'\n"),
10732              stub_entry->h != NULL
10733              ? stub_entry->h->elf.root.root.string
10734              : "<local sym>");
10735           bfd_set_error (bfd_error_bad_value);
10736           htab->stub_error = TRUE;
10737           return FALSE;
10738         }
10739
10740       if (htab->plt_stub_align != 0)
10741         {
10742           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10743
10744           stub_entry->stub_sec->size += pad;
10745           stub_entry->stub_offset = stub_entry->stub_sec->size;
10746           loc += pad;
10747         }
10748
10749       r = NULL;
10750       if (info->emitrelocations)
10751         {
10752           r = get_relocs (stub_entry->stub_sec,
10753                           ((PPC_HA (off) != 0)
10754                            + (htab->opd_abi
10755                               ? 2 + (htab->plt_static_chain
10756                                      && PPC_HA (off + 16) == PPC_HA (off))
10757                               : 1)));
10758           if (r == NULL)
10759             return FALSE;
10760           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10761           if (bfd_big_endian (info->output_bfd))
10762             r[0].r_offset += 2;
10763           r[0].r_addend = dest;
10764         }
10765       if (stub_entry->h != NULL
10766           && (stub_entry->h == htab->tls_get_addr_fd
10767               || stub_entry->h == htab->tls_get_addr)
10768           && !htab->no_tls_get_addr_opt)
10769         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10770       else
10771         p = build_plt_stub (htab, stub_entry, loc, off, r);
10772       size = p - loc;
10773       break;
10774
10775     default:
10776       BFD_FAIL ();
10777       return FALSE;
10778     }
10779
10780   stub_entry->stub_sec->size += size;
10781
10782   if (htab->emit_stub_syms)
10783     {
10784       struct elf_link_hash_entry *h;
10785       size_t len1, len2;
10786       char *name;
10787       const char *const stub_str[] = { "long_branch",
10788                                        "long_branch_r2off",
10789                                        "plt_branch",
10790                                        "plt_branch_r2off",
10791                                        "plt_call",
10792                                        "plt_call" };
10793
10794       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10795       len2 = strlen (stub_entry->root.string);
10796       name = bfd_malloc (len1 + len2 + 2);
10797       if (name == NULL)
10798         return FALSE;
10799       memcpy (name, stub_entry->root.string, 9);
10800       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10801       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10802       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10803       if (h == NULL)
10804         return FALSE;
10805       if (h->root.type == bfd_link_hash_new)
10806         {
10807           h->root.type = bfd_link_hash_defined;
10808           h->root.u.def.section = stub_entry->stub_sec;
10809           h->root.u.def.value = stub_entry->stub_offset;
10810           h->ref_regular = 1;
10811           h->def_regular = 1;
10812           h->ref_regular_nonweak = 1;
10813           h->forced_local = 1;
10814           h->non_elf = 0;
10815         }
10816     }
10817
10818   return TRUE;
10819 }
10820
10821 /* As above, but don't actually build the stub.  Just bump offset so
10822    we know stub section sizes, and select plt_branch stubs where
10823    long_branch stubs won't do.  */
10824
10825 static bfd_boolean
10826 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10827 {
10828   struct ppc_stub_hash_entry *stub_entry;
10829   struct bfd_link_info *info;
10830   struct ppc_link_hash_table *htab;
10831   bfd_vma off;
10832   int size;
10833
10834   /* Massage our args to the form they really have.  */
10835   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10836   info = in_arg;
10837
10838   htab = ppc_hash_table (info);
10839   if (htab == NULL)
10840     return FALSE;
10841
10842   if (stub_entry->stub_type == ppc_stub_plt_call
10843       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10844     {
10845       asection *plt;
10846       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10847       if (off >= (bfd_vma) -2)
10848         abort ();
10849       plt = htab->elf.splt;
10850       if (!htab->elf.dynamic_sections_created
10851           || stub_entry->h == NULL
10852           || stub_entry->h->elf.dynindx == -1)
10853         plt = htab->elf.iplt;
10854       off += (plt->output_offset
10855               + plt->output_section->vma
10856               - elf_gp (plt->output_section->owner)
10857               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10858
10859       size = plt_stub_size (htab, stub_entry, off);
10860       if (htab->plt_stub_align)
10861         size += plt_stub_pad (htab, stub_entry, off);
10862       if (info->emitrelocations)
10863         {
10864           stub_entry->stub_sec->reloc_count
10865             += ((PPC_HA (off) != 0)
10866                 + (htab->opd_abi
10867                    ? 2 + (htab->plt_static_chain
10868                           && PPC_HA (off + 16) == PPC_HA (off))
10869                    : 1));
10870           stub_entry->stub_sec->flags |= SEC_RELOC;
10871         }
10872     }
10873   else
10874     {
10875       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10876          variants.  */
10877       bfd_vma r2off = 0;
10878       bfd_vma local_off = 0;
10879
10880       off = (stub_entry->target_value
10881              + stub_entry->target_section->output_offset
10882              + stub_entry->target_section->output_section->vma);
10883       off -= (stub_entry->stub_sec->size
10884               + stub_entry->stub_sec->output_offset
10885               + stub_entry->stub_sec->output_section->vma);
10886
10887       /* Reset the stub type from the plt variant in case we now
10888          can reach with a shorter stub.  */
10889       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10890         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10891
10892       size = 4;
10893       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10894         {
10895           r2off = get_r2off (info, stub_entry);
10896           if (r2off == 0 && htab->opd_abi)
10897             {
10898               htab->stub_error = TRUE;
10899               return FALSE;
10900             }
10901           size = 12;
10902           if (PPC_HA (r2off) != 0)
10903             size = 16;
10904           off -= size - 4;
10905         }
10906
10907       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10908
10909       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10910          Do the same for -R objects without function descriptors.  */
10911       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10912           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10913               && r2off == 0))
10914         {
10915           struct ppc_branch_hash_entry *br_entry;
10916
10917           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10918                                              stub_entry->root.string + 9,
10919                                              TRUE, FALSE);
10920           if (br_entry == NULL)
10921             {
10922               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10923                                       stub_entry->root.string);
10924               htab->stub_error = TRUE;
10925               return FALSE;
10926             }
10927
10928           if (br_entry->iter != htab->stub_iteration)
10929             {
10930               br_entry->iter = htab->stub_iteration;
10931               br_entry->offset = htab->brlt->size;
10932               htab->brlt->size += 8;
10933
10934               if (htab->relbrlt != NULL)
10935                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10936               else if (info->emitrelocations)
10937                 {
10938                   htab->brlt->reloc_count += 1;
10939                   htab->brlt->flags |= SEC_RELOC;
10940                 }
10941             }
10942
10943           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10944           off = (br_entry->offset
10945                  + htab->brlt->output_offset
10946                  + htab->brlt->output_section->vma
10947                  - elf_gp (htab->brlt->output_section->owner)
10948                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10949
10950           if (info->emitrelocations)
10951             {
10952               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10953               stub_entry->stub_sec->flags |= SEC_RELOC;
10954             }
10955
10956           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10957             {
10958               size = 12;
10959               if (PPC_HA (off) != 0)
10960                 size = 16;
10961             }
10962           else
10963             {
10964               size = 16;
10965               if (PPC_HA (off) != 0)
10966                 size += 4;
10967
10968               if (PPC_HA (r2off) != 0)
10969                 size += 4;
10970               if (PPC_LO (r2off) != 0)
10971                 size += 4;
10972             }
10973         }
10974       else if (info->emitrelocations)
10975         {
10976           stub_entry->stub_sec->reloc_count += 1;
10977           stub_entry->stub_sec->flags |= SEC_RELOC;
10978         }
10979     }
10980
10981   stub_entry->stub_sec->size += size;
10982   return TRUE;
10983 }
10984
10985 /* Set up various things so that we can make a list of input sections
10986    for each output section included in the link.  Returns -1 on error,
10987    0 when no stubs will be needed, and 1 on success.  */
10988
10989 int
10990 ppc64_elf_setup_section_lists
10991   (struct bfd_link_info *info,
10992    asection *(*add_stub_section) (const char *, asection *),
10993    void (*layout_sections_again) (void))
10994 {
10995   bfd *input_bfd;
10996   int top_id, top_index, id;
10997   asection *section;
10998   asection **input_list;
10999   bfd_size_type amt;
11000   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11001
11002   if (htab == NULL)
11003     return -1;
11004   /* Stash our params away.  */
11005   htab->add_stub_section = add_stub_section;
11006   htab->layout_sections_again = layout_sections_again;
11007
11008   /* Find the top input section id.  */
11009   for (input_bfd = info->input_bfds, top_id = 3;
11010        input_bfd != NULL;
11011        input_bfd = input_bfd->link_next)
11012     {
11013       for (section = input_bfd->sections;
11014            section != NULL;
11015            section = section->next)
11016         {
11017           if (top_id < section->id)
11018             top_id = section->id;
11019         }
11020     }
11021
11022   htab->top_id = top_id;
11023   amt = sizeof (struct map_stub) * (top_id + 1);
11024   htab->stub_group = bfd_zmalloc (amt);
11025   if (htab->stub_group == NULL)
11026     return -1;
11027
11028   /* Set toc_off for com, und, abs and ind sections.  */
11029   for (id = 0; id < 3; id++)
11030     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11031
11032   /* We can't use output_bfd->section_count here to find the top output
11033      section index as some sections may have been removed, and
11034      strip_excluded_output_sections doesn't renumber the indices.  */
11035   for (section = info->output_bfd->sections, top_index = 0;
11036        section != NULL;
11037        section = section->next)
11038     {
11039       if (top_index < section->index)
11040         top_index = section->index;
11041     }
11042
11043   htab->top_index = top_index;
11044   amt = sizeof (asection *) * (top_index + 1);
11045   input_list = bfd_zmalloc (amt);
11046   htab->input_list = input_list;
11047   if (input_list == NULL)
11048     return -1;
11049
11050   return 1;
11051 }
11052
11053 /* Set up for first pass at multitoc partitioning.  */
11054
11055 void
11056 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11057 {
11058   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11059
11060   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11061   htab->toc_bfd = NULL;
11062   htab->toc_first_sec = NULL;
11063 }
11064
11065 /* The linker repeatedly calls this function for each TOC input section
11066    and linker generated GOT section.  Group input bfds such that the toc
11067    within a group is less than 64k in size.  */
11068
11069 bfd_boolean
11070 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11071 {
11072   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11073   bfd_vma addr, off, limit;
11074
11075   if (htab == NULL)
11076     return FALSE;
11077
11078   if (!htab->second_toc_pass)
11079     {
11080       /* Keep track of the first .toc or .got section for this input bfd.  */
11081       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11082
11083       if (new_bfd)
11084         {
11085           htab->toc_bfd = isec->owner;
11086           htab->toc_first_sec = isec;
11087         }
11088
11089       addr = isec->output_offset + isec->output_section->vma;
11090       off = addr - htab->toc_curr;
11091       limit = 0x80008000;
11092       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11093         limit = 0x10000;
11094       if (off + isec->size > limit)
11095         {
11096           addr = (htab->toc_first_sec->output_offset
11097                   + htab->toc_first_sec->output_section->vma);
11098           htab->toc_curr = addr;
11099         }
11100
11101       /* toc_curr is the base address of this toc group.  Set elf_gp
11102          for the input section to be the offset relative to the
11103          output toc base plus 0x8000.  Making the input elf_gp an
11104          offset allows us to move the toc as a whole without
11105          recalculating input elf_gp.  */
11106       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11107       off += TOC_BASE_OFF;
11108
11109       /* Die if someone uses a linker script that doesn't keep input
11110          file .toc and .got together.  */
11111       if (new_bfd
11112           && elf_gp (isec->owner) != 0
11113           && elf_gp (isec->owner) != off)
11114         return FALSE;
11115
11116       elf_gp (isec->owner) = off;
11117       return TRUE;
11118     }
11119
11120   /* During the second pass toc_first_sec points to the start of
11121      a toc group, and toc_curr is used to track the old elf_gp.
11122      We use toc_bfd to ensure we only look at each bfd once.  */
11123   if (htab->toc_bfd == isec->owner)
11124     return TRUE;
11125   htab->toc_bfd = isec->owner;
11126
11127   if (htab->toc_first_sec == NULL
11128       || htab->toc_curr != elf_gp (isec->owner))
11129     {
11130       htab->toc_curr = elf_gp (isec->owner);
11131       htab->toc_first_sec = isec;
11132     }
11133   addr = (htab->toc_first_sec->output_offset
11134           + htab->toc_first_sec->output_section->vma);
11135   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11136   elf_gp (isec->owner) = off;
11137
11138   return TRUE;
11139 }
11140
11141 /* Called via elf_link_hash_traverse to merge GOT entries for global
11142    symbol H.  */
11143
11144 static bfd_boolean
11145 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11146 {
11147   if (h->root.type == bfd_link_hash_indirect)
11148     return TRUE;
11149
11150   merge_got_entries (&h->got.glist);
11151
11152   return TRUE;
11153 }
11154
11155 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11156    symbol H.  */
11157
11158 static bfd_boolean
11159 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11160 {
11161   struct got_entry *gent;
11162
11163   if (h->root.type == bfd_link_hash_indirect)
11164     return TRUE;
11165
11166   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11167     if (!gent->is_indirect)
11168       allocate_got (h, (struct bfd_link_info *) inf, gent);
11169   return TRUE;
11170 }
11171
11172 /* Called on the first multitoc pass after the last call to
11173    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11174    entries.  */
11175
11176 bfd_boolean
11177 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11178 {
11179   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11180   struct bfd *ibfd, *ibfd2;
11181   bfd_boolean done_something;
11182
11183   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11184
11185   if (!htab->do_multi_toc)
11186     return FALSE;
11187
11188   /* Merge global sym got entries within a toc group.  */
11189   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11190
11191   /* And tlsld_got.  */
11192   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11193     {
11194       struct got_entry *ent, *ent2;
11195
11196       if (!is_ppc64_elf (ibfd))
11197         continue;
11198
11199       ent = ppc64_tlsld_got (ibfd);
11200       if (!ent->is_indirect
11201           && ent->got.offset != (bfd_vma) -1)
11202         {
11203           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11204             {
11205               if (!is_ppc64_elf (ibfd2))
11206                 continue;
11207
11208               ent2 = ppc64_tlsld_got (ibfd2);
11209               if (!ent2->is_indirect
11210                   && ent2->got.offset != (bfd_vma) -1
11211                   && elf_gp (ibfd2) == elf_gp (ibfd))
11212                 {
11213                   ent2->is_indirect = TRUE;
11214                   ent2->got.ent = ent;
11215                 }
11216             }
11217         }
11218     }
11219
11220   /* Zap sizes of got sections.  */
11221   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11222   htab->elf.irelplt->size -= htab->got_reli_size;
11223   htab->got_reli_size = 0;
11224
11225   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11226     {
11227       asection *got, *relgot;
11228
11229       if (!is_ppc64_elf (ibfd))
11230         continue;
11231
11232       got = ppc64_elf_tdata (ibfd)->got;
11233       if (got != NULL)
11234         {
11235           got->rawsize = got->size;
11236           got->size = 0;
11237           relgot = ppc64_elf_tdata (ibfd)->relgot;
11238           relgot->rawsize = relgot->size;
11239           relgot->size = 0;
11240         }
11241     }
11242
11243   /* Now reallocate the got, local syms first.  We don't need to
11244      allocate section contents again since we never increase size.  */
11245   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11246     {
11247       struct got_entry **lgot_ents;
11248       struct got_entry **end_lgot_ents;
11249       struct plt_entry **local_plt;
11250       struct plt_entry **end_local_plt;
11251       unsigned char *lgot_masks;
11252       bfd_size_type locsymcount;
11253       Elf_Internal_Shdr *symtab_hdr;
11254       asection *s;
11255
11256       if (!is_ppc64_elf (ibfd))
11257         continue;
11258
11259       lgot_ents = elf_local_got_ents (ibfd);
11260       if (!lgot_ents)
11261         continue;
11262
11263       symtab_hdr = &elf_symtab_hdr (ibfd);
11264       locsymcount = symtab_hdr->sh_info;
11265       end_lgot_ents = lgot_ents + locsymcount;
11266       local_plt = (struct plt_entry **) end_lgot_ents;
11267       end_local_plt = local_plt + locsymcount;
11268       lgot_masks = (unsigned char *) end_local_plt;
11269       s = ppc64_elf_tdata (ibfd)->got;
11270       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11271         {
11272           struct got_entry *ent;
11273
11274           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11275             {
11276               unsigned int ent_size = 8;
11277               unsigned int rel_size = sizeof (Elf64_External_Rela);
11278
11279               ent->got.offset = s->size;
11280               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11281                 {
11282                   ent_size *= 2;
11283                   rel_size *= 2;
11284                 }
11285               s->size += ent_size;
11286               if ((*lgot_masks & PLT_IFUNC) != 0)
11287                 {
11288                   htab->elf.irelplt->size += rel_size;
11289                   htab->got_reli_size += rel_size;
11290                 }
11291               else if (info->shared)
11292                 {
11293                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11294                   srel->size += rel_size;
11295                 }
11296             }
11297         }
11298     }
11299
11300   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11301
11302   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11303     {
11304       struct got_entry *ent;
11305
11306       if (!is_ppc64_elf (ibfd))
11307         continue;
11308
11309       ent = ppc64_tlsld_got (ibfd);
11310       if (!ent->is_indirect
11311           && ent->got.offset != (bfd_vma) -1)
11312         {
11313           asection *s = ppc64_elf_tdata (ibfd)->got;
11314           ent->got.offset = s->size;
11315           s->size += 16;
11316           if (info->shared)
11317             {
11318               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11319               srel->size += sizeof (Elf64_External_Rela);
11320             }
11321         }
11322     }
11323
11324   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11325   if (!done_something)
11326     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11327       {
11328         asection *got;
11329
11330         if (!is_ppc64_elf (ibfd))
11331           continue;
11332
11333         got = ppc64_elf_tdata (ibfd)->got;
11334         if (got != NULL)
11335           {
11336             done_something = got->rawsize != got->size;
11337             if (done_something)
11338               break;
11339           }
11340       }
11341
11342   if (done_something)
11343     (*htab->layout_sections_again) ();
11344
11345   /* Set up for second pass over toc sections to recalculate elf_gp
11346      on input sections.  */
11347   htab->toc_bfd = NULL;
11348   htab->toc_first_sec = NULL;
11349   htab->second_toc_pass = TRUE;
11350   return done_something;
11351 }
11352
11353 /* Called after second pass of multitoc partitioning.  */
11354
11355 void
11356 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11357 {
11358   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11359
11360   /* After the second pass, toc_curr tracks the TOC offset used
11361      for code sections below in ppc64_elf_next_input_section.  */
11362   htab->toc_curr = TOC_BASE_OFF;
11363 }
11364
11365 /* No toc references were found in ISEC.  If the code in ISEC makes no
11366    calls, then there's no need to use toc adjusting stubs when branching
11367    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11368    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11369    needed, and 2 if a cyclical call-graph was found but no other reason
11370    for a stub was detected.  If called from the top level, a return of
11371    2 means the same as a return of 0.  */
11372
11373 static int
11374 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11375 {
11376   int ret;
11377
11378   /* Mark this section as checked.  */
11379   isec->call_check_done = 1;
11380
11381   /* We know none of our code bearing sections will need toc stubs.  */
11382   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11383     return 0;
11384
11385   if (isec->size == 0)
11386     return 0;
11387
11388   if (isec->output_section == NULL)
11389     return 0;
11390
11391   ret = 0;
11392   if (isec->reloc_count != 0)
11393     {
11394       Elf_Internal_Rela *relstart, *rel;
11395       Elf_Internal_Sym *local_syms;
11396       struct ppc_link_hash_table *htab;
11397
11398       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11399                                             info->keep_memory);
11400       if (relstart == NULL)
11401         return -1;
11402
11403       /* Look for branches to outside of this section.  */
11404       local_syms = NULL;
11405       htab = ppc_hash_table (info);
11406       if (htab == NULL)
11407         return -1;
11408
11409       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11410         {
11411           enum elf_ppc64_reloc_type r_type;
11412           unsigned long r_symndx;
11413           struct elf_link_hash_entry *h;
11414           struct ppc_link_hash_entry *eh;
11415           Elf_Internal_Sym *sym;
11416           asection *sym_sec;
11417           struct _opd_sec_data *opd;
11418           bfd_vma sym_value;
11419           bfd_vma dest;
11420
11421           r_type = ELF64_R_TYPE (rel->r_info);
11422           if (r_type != R_PPC64_REL24
11423               && r_type != R_PPC64_REL14
11424               && r_type != R_PPC64_REL14_BRTAKEN
11425               && r_type != R_PPC64_REL14_BRNTAKEN)
11426             continue;
11427
11428           r_symndx = ELF64_R_SYM (rel->r_info);
11429           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11430                           isec->owner))
11431             {
11432               ret = -1;
11433               break;
11434             }
11435
11436           /* Calls to dynamic lib functions go through a plt call stub
11437              that uses r2.  */
11438           eh = (struct ppc_link_hash_entry *) h;
11439           if (eh != NULL
11440               && (eh->elf.plt.plist != NULL
11441                   || (eh->oh != NULL
11442                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11443             {
11444               ret = 1;
11445               break;
11446             }
11447
11448           if (sym_sec == NULL)
11449             /* Ignore other undefined symbols.  */
11450             continue;
11451
11452           /* Assume branches to other sections not included in the
11453              link need stubs too, to cover -R and absolute syms.  */
11454           if (sym_sec->output_section == NULL)
11455             {
11456               ret = 1;
11457               break;
11458             }
11459
11460           if (h == NULL)
11461             sym_value = sym->st_value;
11462           else
11463             {
11464               if (h->root.type != bfd_link_hash_defined
11465                   && h->root.type != bfd_link_hash_defweak)
11466                 abort ();
11467               sym_value = h->root.u.def.value;
11468             }
11469           sym_value += rel->r_addend;
11470
11471           /* If this branch reloc uses an opd sym, find the code section.  */
11472           opd = get_opd_info (sym_sec);
11473           if (opd != NULL)
11474             {
11475               if (h == NULL && opd->adjust != NULL)
11476                 {
11477                   long adjust;
11478
11479                   adjust = opd->adjust[sym->st_value / 8];
11480                   if (adjust == -1)
11481                     /* Assume deleted functions won't ever be called.  */
11482                     continue;
11483                   sym_value += adjust;
11484                 }
11485
11486               dest = opd_entry_value (sym_sec, sym_value,
11487                                       &sym_sec, NULL, FALSE);
11488               if (dest == (bfd_vma) -1)
11489                 continue;
11490             }
11491           else
11492             dest = (sym_value
11493                     + sym_sec->output_offset
11494                     + sym_sec->output_section->vma);
11495
11496           /* Ignore branch to self.  */
11497           if (sym_sec == isec)
11498             continue;
11499
11500           /* If the called function uses the toc, we need a stub.  */
11501           if (sym_sec->has_toc_reloc
11502               || sym_sec->makes_toc_func_call)
11503             {
11504               ret = 1;
11505               break;
11506             }
11507
11508           /* Assume any branch that needs a long branch stub might in fact
11509              need a plt_branch stub.  A plt_branch stub uses r2.  */
11510           else if (dest - (isec->output_offset
11511                            + isec->output_section->vma
11512                            + rel->r_offset) + (1 << 25)
11513                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11514                                                              ? h->other
11515                                                              : sym->st_other))
11516             {
11517               ret = 1;
11518               break;
11519             }
11520
11521           /* If calling back to a section in the process of being
11522              tested, we can't say for sure that no toc adjusting stubs
11523              are needed, so don't return zero.  */
11524           else if (sym_sec->call_check_in_progress)
11525             ret = 2;
11526
11527           /* Branches to another section that itself doesn't have any TOC
11528              references are OK.  Recursively call ourselves to check.  */
11529           else if (!sym_sec->call_check_done)
11530             {
11531               int recur;
11532
11533               /* Mark current section as indeterminate, so that other
11534                  sections that call back to current won't be marked as
11535                  known.  */
11536               isec->call_check_in_progress = 1;
11537               recur = toc_adjusting_stub_needed (info, sym_sec);
11538               isec->call_check_in_progress = 0;
11539
11540               if (recur != 0)
11541                 {
11542                   ret = recur;
11543                   if (recur != 2)
11544                     break;
11545                 }
11546             }
11547         }
11548
11549       if (local_syms != NULL
11550           && (elf_symtab_hdr (isec->owner).contents
11551               != (unsigned char *) local_syms))
11552         free (local_syms);
11553       if (elf_section_data (isec)->relocs != relstart)
11554         free (relstart);
11555     }
11556
11557   if ((ret & 1) == 0
11558       && isec->map_head.s != NULL
11559       && (strcmp (isec->output_section->name, ".init") == 0
11560           || strcmp (isec->output_section->name, ".fini") == 0))
11561     {
11562       if (isec->map_head.s->has_toc_reloc
11563           || isec->map_head.s->makes_toc_func_call)
11564         ret = 1;
11565       else if (!isec->map_head.s->call_check_done)
11566         {
11567           int recur;
11568           isec->call_check_in_progress = 1;
11569           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11570           isec->call_check_in_progress = 0;
11571           if (recur != 0)
11572             ret = recur;
11573         }
11574     }
11575
11576   if (ret == 1)
11577     isec->makes_toc_func_call = 1;
11578
11579   return ret;
11580 }
11581
11582 /* The linker repeatedly calls this function for each input section,
11583    in the order that input sections are linked into output sections.
11584    Build lists of input sections to determine groupings between which
11585    we may insert linker stubs.  */
11586
11587 bfd_boolean
11588 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11589 {
11590   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11591
11592   if (htab == NULL)
11593     return FALSE;
11594
11595   if ((isec->output_section->flags & SEC_CODE) != 0
11596       && isec->output_section->index <= htab->top_index)
11597     {
11598       asection **list = htab->input_list + isec->output_section->index;
11599       /* Steal the link_sec pointer for our list.  */
11600 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11601       /* This happens to make the list in reverse order,
11602          which is what we want.  */
11603       PREV_SEC (isec) = *list;
11604       *list = isec;
11605     }
11606
11607   if (htab->multi_toc_needed)
11608     {
11609       /* Analyse sections that aren't already flagged as needing a
11610          valid toc pointer.  Exclude .fixup for the linux kernel.
11611          .fixup contains branches, but only back to the function that
11612          hit an exception.  */
11613       if (!(isec->has_toc_reloc
11614             || (isec->flags & SEC_CODE) == 0
11615             || strcmp (isec->name, ".fixup") == 0
11616             || isec->call_check_done))
11617         {
11618           if (toc_adjusting_stub_needed (info, isec) < 0)
11619             return FALSE;
11620         }
11621       /* Make all sections use the TOC assigned for this object file.
11622          This will be wrong for pasted sections;  We fix that in
11623          check_pasted_section().  */
11624       if (elf_gp (isec->owner) != 0)
11625         htab->toc_curr = elf_gp (isec->owner);
11626     }
11627
11628   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11629   return TRUE;
11630 }
11631
11632 /* Check that all .init and .fini sections use the same toc, if they
11633    have toc relocs.  */
11634
11635 static bfd_boolean
11636 check_pasted_section (struct bfd_link_info *info, const char *name)
11637 {
11638   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11639
11640   if (o != NULL)
11641     {
11642       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11643       bfd_vma toc_off = 0;
11644       asection *i;
11645
11646       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11647         if (i->has_toc_reloc)
11648           {
11649             if (toc_off == 0)
11650               toc_off = htab->stub_group[i->id].toc_off;
11651             else if (toc_off != htab->stub_group[i->id].toc_off)
11652               return FALSE;
11653           }
11654
11655       if (toc_off == 0)
11656         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11657           if (i->makes_toc_func_call)
11658             {
11659               toc_off = htab->stub_group[i->id].toc_off;
11660               break;
11661             }
11662
11663       /* Make sure the whole pasted function uses the same toc offset.  */
11664       if (toc_off != 0)
11665         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11666           htab->stub_group[i->id].toc_off = toc_off;
11667     }
11668   return TRUE;
11669 }
11670
11671 bfd_boolean
11672 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11673 {
11674   return (check_pasted_section (info, ".init")
11675           & check_pasted_section (info, ".fini"));
11676 }
11677
11678 /* See whether we can group stub sections together.  Grouping stub
11679    sections may result in fewer stubs.  More importantly, we need to
11680    put all .init* and .fini* stubs at the beginning of the .init or
11681    .fini output sections respectively, because glibc splits the
11682    _init and _fini functions into multiple parts.  Putting a stub in
11683    the middle of a function is not a good idea.  */
11684
11685 static void
11686 group_sections (struct ppc_link_hash_table *htab,
11687                 bfd_size_type stub_group_size,
11688                 bfd_boolean stubs_always_before_branch)
11689 {
11690   asection **list;
11691   bfd_size_type stub14_group_size;
11692   bfd_boolean suppress_size_errors;
11693
11694   suppress_size_errors = FALSE;
11695   stub14_group_size = stub_group_size;
11696   if (stub_group_size == 1)
11697     {
11698       /* Default values.  */
11699       if (stubs_always_before_branch)
11700         {
11701           stub_group_size = 0x1e00000;
11702           stub14_group_size = 0x7800;
11703         }
11704       else
11705         {
11706           stub_group_size = 0x1c00000;
11707           stub14_group_size = 0x7000;
11708         }
11709       suppress_size_errors = TRUE;
11710     }
11711
11712   list = htab->input_list + htab->top_index;
11713   do
11714     {
11715       asection *tail = *list;
11716       while (tail != NULL)
11717         {
11718           asection *curr;
11719           asection *prev;
11720           bfd_size_type total;
11721           bfd_boolean big_sec;
11722           bfd_vma curr_toc;
11723
11724           curr = tail;
11725           total = tail->size;
11726           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11727                              && ppc64_elf_section_data (tail)->has_14bit_branch
11728                              ? stub14_group_size : stub_group_size);
11729           if (big_sec && !suppress_size_errors)
11730             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11731                                      tail->owner, tail);
11732           curr_toc = htab->stub_group[tail->id].toc_off;
11733
11734           while ((prev = PREV_SEC (curr)) != NULL
11735                  && ((total += curr->output_offset - prev->output_offset)
11736                      < (ppc64_elf_section_data (prev) != NULL
11737                         && ppc64_elf_section_data (prev)->has_14bit_branch
11738                         ? stub14_group_size : stub_group_size))
11739                  && htab->stub_group[prev->id].toc_off == curr_toc)
11740             curr = prev;
11741
11742           /* OK, the size from the start of CURR to the end is less
11743              than stub_group_size and thus can be handled by one stub
11744              section.  (or the tail section is itself larger than
11745              stub_group_size, in which case we may be toast.)  We
11746              should really be keeping track of the total size of stubs
11747              added here, as stubs contribute to the final output
11748              section size.  That's a little tricky, and this way will
11749              only break if stubs added make the total size more than
11750              2^25, ie. for the default stub_group_size, if stubs total
11751              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11752           do
11753             {
11754               prev = PREV_SEC (tail);
11755               /* Set up this stub group.  */
11756               htab->stub_group[tail->id].link_sec = curr;
11757             }
11758           while (tail != curr && (tail = prev) != NULL);
11759
11760           /* But wait, there's more!  Input sections up to stub_group_size
11761              bytes before the stub section can be handled by it too.
11762              Don't do this if we have a really large section after the
11763              stubs, as adding more stubs increases the chance that
11764              branches may not reach into the stub section.  */
11765           if (!stubs_always_before_branch && !big_sec)
11766             {
11767               total = 0;
11768               while (prev != NULL
11769                      && ((total += tail->output_offset - prev->output_offset)
11770                          < (ppc64_elf_section_data (prev) != NULL
11771                             && ppc64_elf_section_data (prev)->has_14bit_branch
11772                             ? stub14_group_size : stub_group_size))
11773                      && htab->stub_group[prev->id].toc_off == curr_toc)
11774                 {
11775                   tail = prev;
11776                   prev = PREV_SEC (tail);
11777                   htab->stub_group[tail->id].link_sec = curr;
11778                 }
11779             }
11780           tail = prev;
11781         }
11782     }
11783   while (list-- != htab->input_list);
11784   free (htab->input_list);
11785 #undef PREV_SEC
11786 }
11787
11788 static const unsigned char glink_eh_frame_cie[] =
11789 {
11790   0, 0, 0, 16,                          /* length.  */
11791   0, 0, 0, 0,                           /* id.  */
11792   1,                                    /* CIE version.  */
11793   'z', 'R', 0,                          /* Augmentation string.  */
11794   4,                                    /* Code alignment.  */
11795   0x78,                                 /* Data alignment.  */
11796   65,                                   /* RA reg.  */
11797   1,                                    /* Augmentation size.  */
11798   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11799   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11800 };
11801
11802 /* Stripping output sections is normally done before dynamic section
11803    symbols have been allocated.  This function is called later, and
11804    handles cases like htab->brlt which is mapped to its own output
11805    section.  */
11806
11807 static void
11808 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11809 {
11810   if (isec->size == 0
11811       && isec->output_section->size == 0
11812       && !(isec->output_section->flags & SEC_KEEP)
11813       && !bfd_section_removed_from_list (info->output_bfd,
11814                                          isec->output_section)
11815       && elf_section_data (isec->output_section)->dynindx == 0)
11816     {
11817       isec->output_section->flags |= SEC_EXCLUDE;
11818       bfd_section_list_remove (info->output_bfd, isec->output_section);
11819       info->output_bfd->section_count--;
11820     }
11821 }
11822
11823 /* Determine and set the size of the stub section for a final link.
11824
11825    The basic idea here is to examine all the relocations looking for
11826    PC-relative calls to a target that is unreachable with a "bl"
11827    instruction.  */
11828
11829 bfd_boolean
11830 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11831                       bfd_boolean plt_static_chain, int plt_thread_safe,
11832                       int plt_stub_align)
11833 {
11834   bfd_size_type stub_group_size;
11835   bfd_boolean stubs_always_before_branch;
11836   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11837
11838   if (htab == NULL)
11839     return FALSE;
11840
11841   htab->plt_static_chain = plt_static_chain;
11842   htab->plt_stub_align = plt_stub_align;
11843   if (plt_thread_safe == -1 && !info->executable)
11844     plt_thread_safe = 1;
11845   if (!htab->opd_abi)
11846     plt_thread_safe = 0;
11847   else if (plt_thread_safe == -1)
11848     {
11849       static const char *const thread_starter[] =
11850         {
11851           "pthread_create",
11852           /* libstdc++ */
11853           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11854           /* librt */
11855           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11856           "mq_notify", "create_timer",
11857           /* libanl */
11858           "getaddrinfo_a",
11859           /* libgomp */
11860           "GOMP_parallel_start",
11861           "GOMP_parallel_loop_static_start",
11862           "GOMP_parallel_loop_dynamic_start",
11863           "GOMP_parallel_loop_guided_start",
11864           "GOMP_parallel_loop_runtime_start",
11865           "GOMP_parallel_sections_start",
11866         };
11867       unsigned i;
11868
11869       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11870         {
11871           struct elf_link_hash_entry *h;
11872           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11873                                     FALSE, FALSE, TRUE);
11874           plt_thread_safe = h != NULL && h->ref_regular;
11875           if (plt_thread_safe)
11876             break;
11877         }
11878     }
11879   htab->plt_thread_safe = plt_thread_safe;
11880   stubs_always_before_branch = group_size < 0;
11881   if (group_size < 0)
11882     stub_group_size = -group_size;
11883   else
11884     stub_group_size = group_size;
11885
11886   group_sections (htab, stub_group_size, stubs_always_before_branch);
11887
11888   while (1)
11889     {
11890       bfd *input_bfd;
11891       unsigned int bfd_indx;
11892       asection *stub_sec;
11893
11894       htab->stub_iteration += 1;
11895
11896       for (input_bfd = info->input_bfds, bfd_indx = 0;
11897            input_bfd != NULL;
11898            input_bfd = input_bfd->link_next, bfd_indx++)
11899         {
11900           Elf_Internal_Shdr *symtab_hdr;
11901           asection *section;
11902           Elf_Internal_Sym *local_syms = NULL;
11903
11904           if (!is_ppc64_elf (input_bfd))
11905             continue;
11906
11907           /* We'll need the symbol table in a second.  */
11908           symtab_hdr = &elf_symtab_hdr (input_bfd);
11909           if (symtab_hdr->sh_info == 0)
11910             continue;
11911
11912           /* Walk over each section attached to the input bfd.  */
11913           for (section = input_bfd->sections;
11914                section != NULL;
11915                section = section->next)
11916             {
11917               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11918
11919               /* If there aren't any relocs, then there's nothing more
11920                  to do.  */
11921               if ((section->flags & SEC_RELOC) == 0
11922                   || (section->flags & SEC_ALLOC) == 0
11923                   || (section->flags & SEC_LOAD) == 0
11924                   || (section->flags & SEC_CODE) == 0
11925                   || section->reloc_count == 0)
11926                 continue;
11927
11928               /* If this section is a link-once section that will be
11929                  discarded, then don't create any stubs.  */
11930               if (section->output_section == NULL
11931                   || section->output_section->owner != info->output_bfd)
11932                 continue;
11933
11934               /* Get the relocs.  */
11935               internal_relocs
11936                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11937                                              info->keep_memory);
11938               if (internal_relocs == NULL)
11939                 goto error_ret_free_local;
11940
11941               /* Now examine each relocation.  */
11942               irela = internal_relocs;
11943               irelaend = irela + section->reloc_count;
11944               for (; irela < irelaend; irela++)
11945                 {
11946                   enum elf_ppc64_reloc_type r_type;
11947                   unsigned int r_indx;
11948                   enum ppc_stub_type stub_type;
11949                   struct ppc_stub_hash_entry *stub_entry;
11950                   asection *sym_sec, *code_sec;
11951                   bfd_vma sym_value, code_value;
11952                   bfd_vma destination;
11953                   unsigned long local_off;
11954                   bfd_boolean ok_dest;
11955                   struct ppc_link_hash_entry *hash;
11956                   struct ppc_link_hash_entry *fdh;
11957                   struct elf_link_hash_entry *h;
11958                   Elf_Internal_Sym *sym;
11959                   char *stub_name;
11960                   const asection *id_sec;
11961                   struct _opd_sec_data *opd;
11962                   struct plt_entry *plt_ent;
11963
11964                   r_type = ELF64_R_TYPE (irela->r_info);
11965                   r_indx = ELF64_R_SYM (irela->r_info);
11966
11967                   if (r_type >= R_PPC64_max)
11968                     {
11969                       bfd_set_error (bfd_error_bad_value);
11970                       goto error_ret_free_internal;
11971                     }
11972
11973                   /* Only look for stubs on branch instructions.  */
11974                   if (r_type != R_PPC64_REL24
11975                       && r_type != R_PPC64_REL14
11976                       && r_type != R_PPC64_REL14_BRTAKEN
11977                       && r_type != R_PPC64_REL14_BRNTAKEN)
11978                     continue;
11979
11980                   /* Now determine the call target, its name, value,
11981                      section.  */
11982                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11983                                   r_indx, input_bfd))
11984                     goto error_ret_free_internal;
11985                   hash = (struct ppc_link_hash_entry *) h;
11986
11987                   ok_dest = FALSE;
11988                   fdh = NULL;
11989                   sym_value = 0;
11990                   if (hash == NULL)
11991                     {
11992                       sym_value = sym->st_value;
11993                       ok_dest = TRUE;
11994                     }
11995                   else if (hash->elf.root.type == bfd_link_hash_defined
11996                            || hash->elf.root.type == bfd_link_hash_defweak)
11997                     {
11998                       sym_value = hash->elf.root.u.def.value;
11999                       if (sym_sec->output_section != NULL)
12000                         ok_dest = TRUE;
12001                     }
12002                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12003                            || hash->elf.root.type == bfd_link_hash_undefined)
12004                     {
12005                       /* Recognise an old ABI func code entry sym, and
12006                          use the func descriptor sym instead if it is
12007                          defined.  */
12008                       if (hash->elf.root.root.string[0] == '.'
12009                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12010                         {
12011                           if (fdh->elf.root.type == bfd_link_hash_defined
12012                               || fdh->elf.root.type == bfd_link_hash_defweak)
12013                             {
12014                               sym_sec = fdh->elf.root.u.def.section;
12015                               sym_value = fdh->elf.root.u.def.value;
12016                               if (sym_sec->output_section != NULL)
12017                                 ok_dest = TRUE;
12018                             }
12019                           else
12020                             fdh = NULL;
12021                         }
12022                     }
12023                   else
12024                     {
12025                       bfd_set_error (bfd_error_bad_value);
12026                       goto error_ret_free_internal;
12027                     }
12028
12029                   destination = 0;
12030                   local_off = 0;
12031                   if (ok_dest)
12032                     {
12033                       sym_value += irela->r_addend;
12034                       destination = (sym_value
12035                                      + sym_sec->output_offset
12036                                      + sym_sec->output_section->vma);
12037                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12038                                                             ? hash->elf.other
12039                                                             : sym->st_other);
12040                     }
12041
12042                   code_sec = sym_sec;
12043                   code_value = sym_value;
12044                   opd = get_opd_info (sym_sec);
12045                   if (opd != NULL)
12046                     {
12047                       bfd_vma dest;
12048
12049                       if (hash == NULL && opd->adjust != NULL)
12050                         {
12051                           long adjust = opd->adjust[sym_value / 8];
12052                           if (adjust == -1)
12053                             continue;
12054                           code_value += adjust;
12055                           sym_value += adjust;
12056                         }
12057                       dest = opd_entry_value (sym_sec, sym_value,
12058                                               &code_sec, &code_value, FALSE);
12059                       if (dest != (bfd_vma) -1)
12060                         {
12061                           destination = dest;
12062                           if (fdh != NULL)
12063                             {
12064                               /* Fixup old ABI sym to point at code
12065                                  entry.  */
12066                               hash->elf.root.type = bfd_link_hash_defweak;
12067                               hash->elf.root.u.def.section = code_sec;
12068                               hash->elf.root.u.def.value = code_value;
12069                             }
12070                         }
12071                     }
12072
12073                   /* Determine what (if any) linker stub is needed.  */
12074                   plt_ent = NULL;
12075                   stub_type = ppc_type_of_stub (section, irela, &hash,
12076                                                 &plt_ent, destination,
12077                                                 local_off);
12078
12079                   if (stub_type != ppc_stub_plt_call)
12080                     {
12081                       /* Check whether we need a TOC adjusting stub.
12082                          Since the linker pastes together pieces from
12083                          different object files when creating the
12084                          _init and _fini functions, it may be that a
12085                          call to what looks like a local sym is in
12086                          fact a call needing a TOC adjustment.  */
12087                       if (code_sec != NULL
12088                           && code_sec->output_section != NULL
12089                           && (htab->stub_group[code_sec->id].toc_off
12090                               != htab->stub_group[section->id].toc_off)
12091                           && (code_sec->has_toc_reloc
12092                               || code_sec->makes_toc_func_call))
12093                         stub_type = ppc_stub_long_branch_r2off;
12094                     }
12095
12096                   if (stub_type == ppc_stub_none)
12097                     continue;
12098
12099                   /* __tls_get_addr calls might be eliminated.  */
12100                   if (stub_type != ppc_stub_plt_call
12101                       && hash != NULL
12102                       && (hash == htab->tls_get_addr
12103                           || hash == htab->tls_get_addr_fd)
12104                       && section->has_tls_reloc
12105                       && irela != internal_relocs)
12106                     {
12107                       /* Get tls info.  */
12108                       unsigned char *tls_mask;
12109
12110                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12111                                          irela - 1, input_bfd))
12112                         goto error_ret_free_internal;
12113                       if (*tls_mask != 0)
12114                         continue;
12115                     }
12116
12117                   if (stub_type == ppc_stub_plt_call
12118                       && irela + 1 < irelaend
12119                       && irela[1].r_offset == irela->r_offset + 4
12120                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12121                     {
12122                       if (!tocsave_find (htab, INSERT,
12123                                          &local_syms, irela + 1, input_bfd))
12124                         goto error_ret_free_internal;
12125                     }
12126                   else if (stub_type == ppc_stub_plt_call)
12127                     stub_type = ppc_stub_plt_call_r2save;
12128
12129                   /* Support for grouping stub sections.  */
12130                   id_sec = htab->stub_group[section->id].link_sec;
12131
12132                   /* Get the name of this stub.  */
12133                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12134                   if (!stub_name)
12135                     goto error_ret_free_internal;
12136
12137                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12138                                                      stub_name, FALSE, FALSE);
12139                   if (stub_entry != NULL)
12140                     {
12141                       /* The proper stub has already been created.  */
12142                       free (stub_name);
12143                       if (stub_type == ppc_stub_plt_call_r2save)
12144                         stub_entry->stub_type = stub_type;
12145                       continue;
12146                     }
12147
12148                   stub_entry = ppc_add_stub (stub_name, section, info);
12149                   if (stub_entry == NULL)
12150                     {
12151                       free (stub_name);
12152                     error_ret_free_internal:
12153                       if (elf_section_data (section)->relocs == NULL)
12154                         free (internal_relocs);
12155                     error_ret_free_local:
12156                       if (local_syms != NULL
12157                           && (symtab_hdr->contents
12158                               != (unsigned char *) local_syms))
12159                         free (local_syms);
12160                       return FALSE;
12161                     }
12162
12163                   stub_entry->stub_type = stub_type;
12164                   if (stub_type != ppc_stub_plt_call
12165                       && stub_type != ppc_stub_plt_call_r2save)
12166                     {
12167                       stub_entry->target_value = code_value;
12168                       stub_entry->target_section = code_sec;
12169                     }
12170                   else
12171                     {
12172                       stub_entry->target_value = sym_value;
12173                       stub_entry->target_section = sym_sec;
12174                     }
12175                   stub_entry->h = hash;
12176                   stub_entry->plt_ent = plt_ent;
12177                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12178
12179                   if (stub_entry->h != NULL)
12180                     htab->stub_globals += 1;
12181                 }
12182
12183               /* We're done with the internal relocs, free them.  */
12184               if (elf_section_data (section)->relocs != internal_relocs)
12185                 free (internal_relocs);
12186             }
12187
12188           if (local_syms != NULL
12189               && symtab_hdr->contents != (unsigned char *) local_syms)
12190             {
12191               if (!info->keep_memory)
12192                 free (local_syms);
12193               else
12194                 symtab_hdr->contents = (unsigned char *) local_syms;
12195             }
12196         }
12197
12198       /* We may have added some stubs.  Find out the new size of the
12199          stub sections.  */
12200       for (stub_sec = htab->stub_bfd->sections;
12201            stub_sec != NULL;
12202            stub_sec = stub_sec->next)
12203         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12204           {
12205             stub_sec->rawsize = stub_sec->size;
12206             stub_sec->size = 0;
12207             stub_sec->reloc_count = 0;
12208             stub_sec->flags &= ~SEC_RELOC;
12209           }
12210
12211       htab->brlt->size = 0;
12212       htab->brlt->reloc_count = 0;
12213       htab->brlt->flags &= ~SEC_RELOC;
12214       if (htab->relbrlt != NULL)
12215         htab->relbrlt->size = 0;
12216
12217       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12218
12219       if (info->emitrelocations
12220           && htab->glink != NULL && htab->glink->size != 0)
12221         {
12222           htab->glink->reloc_count = 1;
12223           htab->glink->flags |= SEC_RELOC;
12224         }
12225
12226       if (htab->glink_eh_frame != NULL
12227           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12228           && htab->glink_eh_frame->output_section->size != 0)
12229         {
12230           size_t size = 0, align;
12231
12232           for (stub_sec = htab->stub_bfd->sections;
12233                stub_sec != NULL;
12234                stub_sec = stub_sec->next)
12235             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12236               size += 20;
12237           if (htab->glink != NULL && htab->glink->size != 0)
12238             size += 24;
12239           if (size != 0)
12240             size += sizeof (glink_eh_frame_cie);
12241           align = 1;
12242           align <<= htab->glink_eh_frame->output_section->alignment_power;
12243           align -= 1;
12244           size = (size + align) & ~align;
12245           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12246           htab->glink_eh_frame->size = size;
12247         }
12248
12249       if (htab->plt_stub_align != 0)
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             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12255                               & (-1 << htab->plt_stub_align));
12256
12257       for (stub_sec = htab->stub_bfd->sections;
12258            stub_sec != NULL;
12259            stub_sec = stub_sec->next)
12260         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12261             && stub_sec->rawsize != stub_sec->size)
12262           break;
12263
12264       /* Exit from this loop when no stubs have been added, and no stubs
12265          have changed size.  */
12266       if (stub_sec == NULL
12267           && (htab->glink_eh_frame == NULL
12268               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12269         break;
12270
12271       /* Ask the linker to do its stuff.  */
12272       (*htab->layout_sections_again) ();
12273     }
12274
12275   maybe_strip_output (info, htab->brlt);
12276   if (htab->glink_eh_frame != NULL)
12277     maybe_strip_output (info, htab->glink_eh_frame);
12278
12279   return TRUE;
12280 }
12281
12282 /* Called after we have determined section placement.  If sections
12283    move, we'll be called again.  Provide a value for TOCstart.  */
12284
12285 bfd_vma
12286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12287 {
12288   asection *s;
12289   bfd_vma TOCstart;
12290
12291   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12292      order.  The TOC starts where the first of these sections starts.  */
12293   s = bfd_get_section_by_name (obfd, ".got");
12294   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12295     s = bfd_get_section_by_name (obfd, ".toc");
12296   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12297     s = bfd_get_section_by_name (obfd, ".tocbss");
12298   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12299     s = bfd_get_section_by_name (obfd, ".plt");
12300   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12301     {
12302       /* This may happen for
12303          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12304          .toc directive
12305          o  bad linker script
12306          o --gc-sections and empty TOC sections
12307
12308          FIXME: Warn user?  */
12309
12310       /* Look for a likely section.  We probably won't even be
12311          using TOCstart.  */
12312       for (s = obfd->sections; s != NULL; s = s->next)
12313         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12314                          | SEC_EXCLUDE))
12315             == (SEC_ALLOC | SEC_SMALL_DATA))
12316           break;
12317       if (s == NULL)
12318         for (s = obfd->sections; s != NULL; s = s->next)
12319           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12320               == (SEC_ALLOC | SEC_SMALL_DATA))
12321             break;
12322       if (s == NULL)
12323         for (s = obfd->sections; s != NULL; s = s->next)
12324           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12325               == SEC_ALLOC)
12326             break;
12327       if (s == NULL)
12328         for (s = obfd->sections; s != NULL; s = s->next)
12329           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12330             break;
12331     }
12332
12333   TOCstart = 0;
12334   if (s != NULL)
12335     TOCstart = s->output_section->vma + s->output_offset;
12336
12337   _bfd_set_gp_value (obfd, TOCstart);
12338
12339   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12340     {
12341       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12342
12343       if (htab != NULL
12344           && htab->elf.hgot != NULL)
12345         {
12346           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12347           htab->elf.hgot->root.u.def.section = s;
12348         }
12349     }
12350   return TOCstart;
12351 }
12352
12353 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12354    write out any global entry stubs.  */
12355
12356 static bfd_boolean
12357 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12358 {
12359   struct bfd_link_info *info;
12360   struct ppc_link_hash_table *htab;
12361   struct plt_entry *pent;
12362   asection *s;
12363
12364   if (h->root.type == bfd_link_hash_indirect)
12365     return TRUE;
12366
12367   if (!h->pointer_equality_needed)
12368     return TRUE;
12369
12370   if (h->def_regular)
12371     return TRUE;
12372
12373   info = inf;
12374   htab = ppc_hash_table (info);
12375   if (htab == NULL)
12376     return FALSE;
12377
12378   s = htab->glink;
12379   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12380     if (pent->plt.offset != (bfd_vma) -1
12381         && pent->addend == 0)
12382       {
12383         bfd_byte *p;
12384         asection *plt;
12385         bfd_vma off;
12386
12387         p = s->contents + h->root.u.def.value;
12388         plt = htab->elf.splt;
12389         if (!htab->elf.dynamic_sections_created
12390             || h->dynindx == -1)
12391           plt = htab->elf.iplt;
12392         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12393         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12394
12395         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12396           {
12397             info->callbacks->einfo
12398               (_("%P: linkage table error against `%T'\n"),
12399                h->root.root.string);
12400             bfd_set_error (bfd_error_bad_value);
12401             htab->stub_error = TRUE;
12402           }
12403
12404         if (PPC_HA (off) != 0)
12405           {
12406             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12407             p += 4;
12408           }
12409         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12410         p += 4;
12411         bfd_put_32 (s->owner, MTCTR_R12, p);
12412         p += 4;
12413         bfd_put_32 (s->owner, BCTR, p);
12414         break;
12415       }
12416   return TRUE;
12417 }
12418
12419 /* Build all the stubs associated with the current output file.
12420    The stubs are kept in a hash table attached to the main linker
12421    hash table.  This function is called via gldelf64ppc_finish.  */
12422
12423 bfd_boolean
12424 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12425                        struct bfd_link_info *info,
12426                        char **stats)
12427 {
12428   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12429   asection *stub_sec;
12430   bfd_byte *p;
12431   int stub_sec_count = 0;
12432
12433   if (htab == NULL)
12434     return FALSE;
12435
12436   htab->emit_stub_syms = emit_stub_syms;
12437
12438   /* Allocate memory to hold the linker stubs.  */
12439   for (stub_sec = htab->stub_bfd->sections;
12440        stub_sec != NULL;
12441        stub_sec = stub_sec->next)
12442     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12443         && stub_sec->size != 0)
12444       {
12445         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12446         if (stub_sec->contents == NULL)
12447           return FALSE;
12448         /* We want to check that built size is the same as calculated
12449            size.  rawsize is a convenient location to use.  */
12450         stub_sec->rawsize = stub_sec->size;
12451         stub_sec->size = 0;
12452       }
12453
12454   if (htab->glink != NULL && htab->glink->size != 0)
12455     {
12456       unsigned int indx;
12457       bfd_vma plt0;
12458
12459       /* Build the .glink plt call stub.  */
12460       if (htab->emit_stub_syms)
12461         {
12462           struct elf_link_hash_entry *h;
12463           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12464                                     TRUE, FALSE, FALSE);
12465           if (h == NULL)
12466             return FALSE;
12467           if (h->root.type == bfd_link_hash_new)
12468             {
12469               h->root.type = bfd_link_hash_defined;
12470               h->root.u.def.section = htab->glink;
12471               h->root.u.def.value = 8;
12472               h->ref_regular = 1;
12473               h->def_regular = 1;
12474               h->ref_regular_nonweak = 1;
12475               h->forced_local = 1;
12476               h->non_elf = 0;
12477             }
12478         }
12479       plt0 = (htab->elf.splt->output_section->vma
12480               + htab->elf.splt->output_offset
12481               - 16);
12482       if (info->emitrelocations)
12483         {
12484           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12485           if (r == NULL)
12486             return FALSE;
12487           r->r_offset = (htab->glink->output_offset
12488                          + htab->glink->output_section->vma);
12489           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12490           r->r_addend = plt0;
12491         }
12492       p = htab->glink->contents;
12493       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12494       bfd_put_64 (htab->glink->owner, plt0, p);
12495       p += 8;
12496       if (htab->opd_abi)
12497         {
12498           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12499           p += 4;
12500           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12501           p += 4;
12502           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12503           p += 4;
12504           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12505           p += 4;
12506           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12507           p += 4;
12508           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12509           p += 4;
12510           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12511           p += 4;
12512           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12513           p += 4;
12514           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12515           p += 4;
12516           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12517           p += 4;
12518         }
12519       else
12520         {
12521           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12522           p += 4;
12523           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12524           p += 4;
12525           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12526           p += 4;
12527           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12528           p += 4;
12529           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12530           p += 4;
12531           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12532           p += 4;
12533           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12534           p += 4;
12535           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12536           p += 4;
12537           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12538           p += 4;
12539           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12540           p += 4;
12541           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12542           p += 4;
12543           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12544           p += 4;
12545         }
12546       bfd_put_32 (htab->glink->owner, BCTR, p);
12547       p += 4;
12548       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12549         {
12550           bfd_put_32 (htab->glink->owner, NOP, p);
12551           p += 4;
12552         }
12553
12554       /* Build the .glink lazy link call stubs.  */
12555       indx = 0;
12556       while (p < htab->glink->contents + htab->glink->rawsize)
12557         {
12558           if (htab->opd_abi)
12559             {
12560               if (indx < 0x8000)
12561                 {
12562                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12563                   p += 4;
12564                 }
12565               else
12566                 {
12567                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12568                   p += 4;
12569                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12570                               p);
12571                   p += 4;
12572                 }
12573             }
12574           bfd_put_32 (htab->glink->owner,
12575                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12576           indx++;
12577           p += 4;
12578         }
12579
12580       /* Build .glink global entry stubs.  */
12581       if (htab->glink->size > htab->glink->rawsize)
12582         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12583     }
12584
12585   if (htab->brlt->size != 0)
12586     {
12587       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12588                                          htab->brlt->size);
12589       if (htab->brlt->contents == NULL)
12590         return FALSE;
12591     }
12592   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12593     {
12594       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12595                                             htab->relbrlt->size);
12596       if (htab->relbrlt->contents == NULL)
12597         return FALSE;
12598     }
12599
12600   if (htab->glink_eh_frame != NULL
12601       && htab->glink_eh_frame->size != 0)
12602     {
12603       bfd_vma val;
12604       bfd_byte *last_fde;
12605       size_t last_fde_len, size, align, pad;
12606
12607       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12608       if (p == NULL)
12609         return FALSE;
12610       htab->glink_eh_frame->contents = p;
12611       last_fde = p;
12612
12613       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12614
12615       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12616       /* CIE length (rewrite in case little-endian).  */
12617       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12618       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12619       p += sizeof (glink_eh_frame_cie);
12620
12621       for (stub_sec = htab->stub_bfd->sections;
12622            stub_sec != NULL;
12623            stub_sec = stub_sec->next)
12624         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12625           {
12626             last_fde = p;
12627             last_fde_len = 16;
12628             /* FDE length.  */
12629             bfd_put_32 (htab->elf.dynobj, 16, p);
12630             p += 4;
12631             /* CIE pointer.  */
12632             val = p - htab->glink_eh_frame->contents;
12633             bfd_put_32 (htab->elf.dynobj, val, p);
12634             p += 4;
12635             /* Offset to stub section.  */
12636             val = (stub_sec->output_section->vma
12637                    + stub_sec->output_offset);
12638             val -= (htab->glink_eh_frame->output_section->vma
12639                     + htab->glink_eh_frame->output_offset);
12640             val -= p - htab->glink_eh_frame->contents;
12641             if (val + 0x80000000 > 0xffffffff)
12642               {
12643                 info->callbacks->einfo
12644                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12645                    stub_sec->name);
12646                 return FALSE;
12647               }
12648             bfd_put_32 (htab->elf.dynobj, val, p);
12649             p += 4;
12650             /* stub section size.  */
12651             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12652             p += 4;
12653             /* Augmentation.  */
12654             p += 1;
12655             /* Pad.  */
12656             p += 3;
12657           }
12658       if (htab->glink != NULL && htab->glink->size != 0)
12659         {
12660           last_fde = p;
12661           last_fde_len = 20;
12662           /* FDE length.  */
12663           bfd_put_32 (htab->elf.dynobj, 20, p);
12664           p += 4;
12665           /* CIE pointer.  */
12666           val = p - htab->glink_eh_frame->contents;
12667           bfd_put_32 (htab->elf.dynobj, val, p);
12668           p += 4;
12669           /* Offset to .glink.  */
12670           val = (htab->glink->output_section->vma
12671                  + htab->glink->output_offset
12672                  + 8);
12673           val -= (htab->glink_eh_frame->output_section->vma
12674                   + htab->glink_eh_frame->output_offset);
12675           val -= p - htab->glink_eh_frame->contents;
12676           if (val + 0x80000000 > 0xffffffff)
12677             {
12678               info->callbacks->einfo
12679                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12680                  htab->glink->name);
12681               return FALSE;
12682             }
12683           bfd_put_32 (htab->elf.dynobj, val, p);
12684           p += 4;
12685           /* .glink size.  */
12686           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12687           p += 4;
12688           /* Augmentation.  */
12689           p += 1;
12690
12691           *p++ = DW_CFA_advance_loc + 1;
12692           *p++ = DW_CFA_register;
12693           *p++ = 65;
12694           *p++ = 12;
12695           *p++ = DW_CFA_advance_loc + 4;
12696           *p++ = DW_CFA_restore_extended;
12697           *p++ = 65;
12698         }
12699       /* Subsume any padding into the last FDE if user .eh_frame
12700          sections are aligned more than glink_eh_frame.  Otherwise any
12701          zero padding will be seen as a terminator.  */
12702       size = p - htab->glink_eh_frame->contents;
12703       align = 1;
12704       align <<= htab->glink_eh_frame->output_section->alignment_power;
12705       align -= 1;
12706       pad = ((size + align) & ~align) - size;
12707       htab->glink_eh_frame->size = size + pad;
12708       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12709     }
12710
12711   /* Build the stubs as directed by the stub hash table.  */
12712   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12713
12714   if (htab->relbrlt != NULL)
12715     htab->relbrlt->reloc_count = 0;
12716
12717   if (htab->plt_stub_align != 0)
12718     for (stub_sec = htab->stub_bfd->sections;
12719          stub_sec != NULL;
12720          stub_sec = stub_sec->next)
12721       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12722         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12723                           & (-1 << htab->plt_stub_align));
12724
12725   for (stub_sec = htab->stub_bfd->sections;
12726        stub_sec != NULL;
12727        stub_sec = stub_sec->next)
12728     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12729       {
12730         stub_sec_count += 1;
12731         if (stub_sec->rawsize != stub_sec->size)
12732           break;
12733       }
12734
12735   if (stub_sec != NULL
12736       || (htab->glink_eh_frame != NULL
12737           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12738     {
12739       htab->stub_error = TRUE;
12740       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12741     }
12742
12743   if (htab->stub_error)
12744     return FALSE;
12745
12746   if (stats != NULL)
12747     {
12748       *stats = bfd_malloc (500);
12749       if (*stats == NULL)
12750         return FALSE;
12751
12752       sprintf (*stats, _("linker stubs in %u group%s\n"
12753                          "  branch       %lu\n"
12754                          "  toc adjust   %lu\n"
12755                          "  long branch  %lu\n"
12756                          "  long toc adj %lu\n"
12757                          "  plt call     %lu\n"
12758                          "  plt call toc %lu"),
12759                stub_sec_count,
12760                stub_sec_count == 1 ? "" : "s",
12761                htab->stub_count[ppc_stub_long_branch - 1],
12762                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12763                htab->stub_count[ppc_stub_plt_branch - 1],
12764                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12765                htab->stub_count[ppc_stub_plt_call - 1],
12766                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12767     }
12768   return TRUE;
12769 }
12770
12771 /* This function undoes the changes made by add_symbol_adjust.  */
12772
12773 static bfd_boolean
12774 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12775 {
12776   struct ppc_link_hash_entry *eh;
12777
12778   if (h->root.type == bfd_link_hash_indirect)
12779     return TRUE;
12780
12781   eh = (struct ppc_link_hash_entry *) h;
12782   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12783     return TRUE;
12784
12785   eh->elf.root.type = bfd_link_hash_undefined;
12786   return TRUE;
12787 }
12788
12789 void
12790 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12791 {
12792   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12793
12794   if (htab != NULL)
12795     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12796 }
12797
12798 /* What to do when ld finds relocations against symbols defined in
12799    discarded sections.  */
12800
12801 static unsigned int
12802 ppc64_elf_action_discarded (asection *sec)
12803 {
12804   if (strcmp (".opd", sec->name) == 0)
12805     return 0;
12806
12807   if (strcmp (".toc", sec->name) == 0)
12808     return 0;
12809
12810   if (strcmp (".toc1", sec->name) == 0)
12811     return 0;
12812
12813   return _bfd_elf_default_action_discarded (sec);
12814 }
12815
12816 /* The RELOCATE_SECTION function is called by the ELF backend linker
12817    to handle the relocations for a section.
12818
12819    The relocs are always passed as Rela structures; if the section
12820    actually uses Rel structures, the r_addend field will always be
12821    zero.
12822
12823    This function is responsible for adjust the section contents as
12824    necessary, and (if using Rela relocs and generating a
12825    relocatable output file) adjusting the reloc addend as
12826    necessary.
12827
12828    This function does not have to worry about setting the reloc
12829    address or the reloc symbol index.
12830
12831    LOCAL_SYMS is a pointer to the swapped in local symbols.
12832
12833    LOCAL_SECTIONS is an array giving the section in the input file
12834    corresponding to the st_shndx field of each local symbol.
12835
12836    The global hash table entry for the global symbols can be found
12837    via elf_sym_hashes (input_bfd).
12838
12839    When generating relocatable output, this function must handle
12840    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12841    going to be the section symbol corresponding to the output
12842    section, which means that the addend must be adjusted
12843    accordingly.  */
12844
12845 static bfd_boolean
12846 ppc64_elf_relocate_section (bfd *output_bfd,
12847                             struct bfd_link_info *info,
12848                             bfd *input_bfd,
12849                             asection *input_section,
12850                             bfd_byte *contents,
12851                             Elf_Internal_Rela *relocs,
12852                             Elf_Internal_Sym *local_syms,
12853                             asection **local_sections)
12854 {
12855   struct ppc_link_hash_table *htab;
12856   Elf_Internal_Shdr *symtab_hdr;
12857   struct elf_link_hash_entry **sym_hashes;
12858   Elf_Internal_Rela *rel;
12859   Elf_Internal_Rela *relend;
12860   Elf_Internal_Rela outrel;
12861   bfd_byte *loc;
12862   struct got_entry **local_got_ents;
12863   bfd_vma TOCstart;
12864   bfd_boolean ret = TRUE;
12865   bfd_boolean is_opd;
12866   /* Assume 'at' branch hints.  */
12867   bfd_boolean is_isa_v2 = TRUE;
12868   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12869
12870   /* Initialize howto table if needed.  */
12871   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12872     ppc_howto_init ();
12873
12874   htab = ppc_hash_table (info);
12875   if (htab == NULL)
12876     return FALSE;
12877
12878   /* Don't relocate stub sections.  */
12879   if (input_section->owner == htab->stub_bfd)
12880     return TRUE;
12881
12882   BFD_ASSERT (is_ppc64_elf (input_bfd));
12883
12884   local_got_ents = elf_local_got_ents (input_bfd);
12885   TOCstart = elf_gp (output_bfd);
12886   symtab_hdr = &elf_symtab_hdr (input_bfd);
12887   sym_hashes = elf_sym_hashes (input_bfd);
12888   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12889
12890   rel = relocs;
12891   relend = relocs + input_section->reloc_count;
12892   for (; rel < relend; rel++)
12893     {
12894       enum elf_ppc64_reloc_type r_type;
12895       bfd_vma addend;
12896       bfd_reloc_status_type r;
12897       Elf_Internal_Sym *sym;
12898       asection *sec;
12899       struct elf_link_hash_entry *h_elf;
12900       struct ppc_link_hash_entry *h;
12901       struct ppc_link_hash_entry *fdh;
12902       const char *sym_name;
12903       unsigned long r_symndx, toc_symndx;
12904       bfd_vma toc_addend;
12905       unsigned char tls_mask, tls_gd, tls_type;
12906       unsigned char sym_type;
12907       bfd_vma relocation;
12908       bfd_boolean unresolved_reloc;
12909       bfd_boolean warned;
12910       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12911       unsigned int insn;
12912       unsigned int mask;
12913       struct ppc_stub_hash_entry *stub_entry;
12914       bfd_vma max_br_offset;
12915       bfd_vma from;
12916       const Elf_Internal_Rela orig_rel = *rel;
12917
12918       r_type = ELF64_R_TYPE (rel->r_info);
12919       r_symndx = ELF64_R_SYM (rel->r_info);
12920
12921       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12922          symbol of the previous ADDR64 reloc.  The symbol gives us the
12923          proper TOC base to use.  */
12924       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12925           && rel != relocs
12926           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12927           && is_opd)
12928         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12929
12930       sym = NULL;
12931       sec = NULL;
12932       h_elf = NULL;
12933       sym_name = NULL;
12934       unresolved_reloc = FALSE;
12935       warned = FALSE;
12936
12937       if (r_symndx < symtab_hdr->sh_info)
12938         {
12939           /* It's a local symbol.  */
12940           struct _opd_sec_data *opd;
12941
12942           sym = local_syms + r_symndx;
12943           sec = local_sections[r_symndx];
12944           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12945           sym_type = ELF64_ST_TYPE (sym->st_info);
12946           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12947           opd = get_opd_info (sec);
12948           if (opd != NULL && opd->adjust != NULL)
12949             {
12950               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12951               if (adjust == -1)
12952                 relocation = 0;
12953               else
12954                 {
12955                   /* If this is a relocation against the opd section sym
12956                      and we have edited .opd, adjust the reloc addend so
12957                      that ld -r and ld --emit-relocs output is correct.
12958                      If it is a reloc against some other .opd symbol,
12959                      then the symbol value will be adjusted later.  */
12960                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12961                     rel->r_addend += adjust;
12962                   else
12963                     relocation += adjust;
12964                 }
12965             }
12966         }
12967       else
12968         {
12969           bfd_boolean ignored;
12970
12971           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12972                                    r_symndx, symtab_hdr, sym_hashes,
12973                                    h_elf, sec, relocation,
12974                                    unresolved_reloc, warned, ignored);
12975           sym_name = h_elf->root.root.string;
12976           sym_type = h_elf->type;
12977           if (sec != NULL
12978               && sec->owner == output_bfd
12979               && strcmp (sec->name, ".opd") == 0)
12980             {
12981               /* This is a symbol defined in a linker script.  All
12982                  such are defined in output sections, even those
12983                  defined by simple assignment from a symbol defined in
12984                  an input section.  Transfer the symbol to an
12985                  appropriate input .opd section, so that a branch to
12986                  this symbol will be mapped to the location specified
12987                  by the opd entry.  */
12988               struct bfd_link_order *lo;
12989               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12990                 if (lo->type == bfd_indirect_link_order)
12991                   {
12992                     asection *isec = lo->u.indirect.section;
12993                     if (h_elf->root.u.def.value >= isec->output_offset
12994                         && h_elf->root.u.def.value < (isec->output_offset
12995                                                       + isec->size))
12996                       {
12997                         h_elf->root.u.def.value -= isec->output_offset;
12998                         h_elf->root.u.def.section = isec;
12999                         sec = isec;
13000                         break;
13001                       }
13002                   }
13003             }
13004         }
13005       h = (struct ppc_link_hash_entry *) h_elf;
13006
13007       if (sec != NULL && discarded_section (sec))
13008         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13009                                          rel, 1, relend,
13010                                          ppc64_elf_howto_table[r_type], 0,
13011                                          contents);
13012
13013       if (info->relocatable)
13014         continue;
13015
13016       if (h != NULL && &h->elf == htab->elf.hgot)
13017         {
13018           relocation = (TOCstart
13019                         + htab->stub_group[input_section->id].toc_off);
13020           sec = bfd_abs_section_ptr;
13021           unresolved_reloc = FALSE;
13022         }
13023
13024       /* TLS optimizations.  Replace instruction sequences and relocs
13025          based on information we collected in tls_optimize.  We edit
13026          RELOCS so that --emit-relocs will output something sensible
13027          for the final instruction stream.  */
13028       tls_mask = 0;
13029       tls_gd = 0;
13030       toc_symndx = 0;
13031       if (h != NULL)
13032         tls_mask = h->tls_mask;
13033       else if (local_got_ents != NULL)
13034         {
13035           struct plt_entry **local_plt = (struct plt_entry **)
13036             (local_got_ents + symtab_hdr->sh_info);
13037           unsigned char *lgot_masks = (unsigned char *)
13038             (local_plt + symtab_hdr->sh_info);
13039           tls_mask = lgot_masks[r_symndx];
13040         }
13041       if (tls_mask == 0
13042           && (r_type == R_PPC64_TLS
13043               || r_type == R_PPC64_TLSGD
13044               || r_type == R_PPC64_TLSLD))
13045         {
13046           /* Check for toc tls entries.  */
13047           unsigned char *toc_tls;
13048
13049           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13050                              &local_syms, rel, input_bfd))
13051             return FALSE;
13052
13053           if (toc_tls)
13054             tls_mask = *toc_tls;
13055         }
13056
13057       /* Check that tls relocs are used with tls syms, and non-tls
13058          relocs are used with non-tls syms.  */
13059       if (r_symndx != STN_UNDEF
13060           && r_type != R_PPC64_NONE
13061           && (h == NULL
13062               || h->elf.root.type == bfd_link_hash_defined
13063               || h->elf.root.type == bfd_link_hash_defweak)
13064           && (IS_PPC64_TLS_RELOC (r_type)
13065               != (sym_type == STT_TLS
13066                   || (sym_type == STT_SECTION
13067                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13068         {
13069           if (tls_mask != 0
13070               && (r_type == R_PPC64_TLS
13071                   || r_type == R_PPC64_TLSGD
13072                   || r_type == R_PPC64_TLSLD))
13073             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13074             ;
13075           else
13076             info->callbacks->einfo
13077               (!IS_PPC64_TLS_RELOC (r_type)
13078                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13079                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13080                input_bfd, input_section, rel->r_offset,
13081                ppc64_elf_howto_table[r_type]->name,
13082                sym_name);
13083         }
13084
13085       /* Ensure reloc mapping code below stays sane.  */
13086       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13087           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13088           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13089           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13090           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13091           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13092           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13093           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13094           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13095           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13096         abort ();
13097
13098       switch (r_type)
13099         {
13100         default:
13101           break;
13102
13103         case R_PPC64_LO_DS_OPT:
13104           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13105           if ((insn & (0x3f << 26)) != 58u << 26)
13106             abort ();
13107           insn += (14u << 26) - (58u << 26);
13108           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13109           r_type = R_PPC64_TOC16_LO;
13110           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13111           break;
13112
13113         case R_PPC64_TOC16:
13114         case R_PPC64_TOC16_LO:
13115         case R_PPC64_TOC16_DS:
13116         case R_PPC64_TOC16_LO_DS:
13117           {
13118             /* Check for toc tls entries.  */
13119             unsigned char *toc_tls;
13120             int retval;
13121
13122             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13123                                    &local_syms, rel, input_bfd);
13124             if (retval == 0)
13125               return FALSE;
13126
13127             if (toc_tls)
13128               {
13129                 tls_mask = *toc_tls;
13130                 if (r_type == R_PPC64_TOC16_DS
13131                     || r_type == R_PPC64_TOC16_LO_DS)
13132                   {
13133                     if (tls_mask != 0
13134                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13135                       goto toctprel;
13136                   }
13137                 else
13138                   {
13139                     /* If we found a GD reloc pair, then we might be
13140                        doing a GD->IE transition.  */
13141                     if (retval == 2)
13142                       {
13143                         tls_gd = TLS_TPRELGD;
13144                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13145                           goto tls_ldgd_opt;
13146                       }
13147                     else if (retval == 3)
13148                       {
13149                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13150                           goto tls_ldgd_opt;
13151                       }
13152                   }
13153               }
13154           }
13155           break;
13156
13157         case R_PPC64_GOT_TPREL16_HI:
13158         case R_PPC64_GOT_TPREL16_HA:
13159           if (tls_mask != 0
13160               && (tls_mask & TLS_TPREL) == 0)
13161             {
13162               rel->r_offset -= d_offset;
13163               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13164               r_type = R_PPC64_NONE;
13165               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13166             }
13167           break;
13168
13169         case R_PPC64_GOT_TPREL16_DS:
13170         case R_PPC64_GOT_TPREL16_LO_DS:
13171           if (tls_mask != 0
13172               && (tls_mask & TLS_TPREL) == 0)
13173             {
13174             toctprel:
13175               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13176               insn &= 31 << 21;
13177               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13178               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13179               r_type = R_PPC64_TPREL16_HA;
13180               if (toc_symndx != 0)
13181                 {
13182                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13183                   rel->r_addend = toc_addend;
13184                   /* We changed the symbol.  Start over in order to
13185                      get h, sym, sec etc. right.  */
13186                   rel--;
13187                   continue;
13188                 }
13189               else
13190                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13191             }
13192           break;
13193
13194         case R_PPC64_TLS:
13195           if (tls_mask != 0
13196               && (tls_mask & TLS_TPREL) == 0)
13197             {
13198               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13199               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13200               if (insn == 0)
13201                 abort ();
13202               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13203               /* Was PPC64_TLS which sits on insn boundary, now
13204                  PPC64_TPREL16_LO which is at low-order half-word.  */
13205               rel->r_offset += d_offset;
13206               r_type = R_PPC64_TPREL16_LO;
13207               if (toc_symndx != 0)
13208                 {
13209                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13210                   rel->r_addend = toc_addend;
13211                   /* We changed the symbol.  Start over in order to
13212                      get h, sym, sec etc. right.  */
13213                   rel--;
13214                   continue;
13215                 }
13216               else
13217                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13218             }
13219           break;
13220
13221         case R_PPC64_GOT_TLSGD16_HI:
13222         case R_PPC64_GOT_TLSGD16_HA:
13223           tls_gd = TLS_TPRELGD;
13224           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13225             goto tls_gdld_hi;
13226           break;
13227
13228         case R_PPC64_GOT_TLSLD16_HI:
13229         case R_PPC64_GOT_TLSLD16_HA:
13230           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13231             {
13232             tls_gdld_hi:
13233               if ((tls_mask & tls_gd) != 0)
13234                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13235                           + R_PPC64_GOT_TPREL16_DS);
13236               else
13237                 {
13238                   rel->r_offset -= d_offset;
13239                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13240                   r_type = R_PPC64_NONE;
13241                 }
13242               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13243             }
13244           break;
13245
13246         case R_PPC64_GOT_TLSGD16:
13247         case R_PPC64_GOT_TLSGD16_LO:
13248           tls_gd = TLS_TPRELGD;
13249           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13250             goto tls_ldgd_opt;
13251           break;
13252
13253         case R_PPC64_GOT_TLSLD16:
13254         case R_PPC64_GOT_TLSLD16_LO:
13255           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13256             {
13257               unsigned int insn1, insn2, insn3;
13258               bfd_vma offset;
13259
13260             tls_ldgd_opt:
13261               offset = (bfd_vma) -1;
13262               /* If not using the newer R_PPC64_TLSGD/LD to mark
13263                  __tls_get_addr calls, we must trust that the call
13264                  stays with its arg setup insns, ie. that the next
13265                  reloc is the __tls_get_addr call associated with
13266                  the current reloc.  Edit both insns.  */
13267               if (input_section->has_tls_get_addr_call
13268                   && rel + 1 < relend
13269                   && branch_reloc_hash_match (input_bfd, rel + 1,
13270                                               htab->tls_get_addr,
13271                                               htab->tls_get_addr_fd))
13272                 offset = rel[1].r_offset;
13273               if ((tls_mask & tls_gd) != 0)
13274                 {
13275                   /* IE */
13276                   insn1 = bfd_get_32 (output_bfd,
13277                                       contents + rel->r_offset - d_offset);
13278                   insn1 &= (1 << 26) - (1 << 2);
13279                   insn1 |= 58 << 26;    /* ld */
13280                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13281                   if (offset != (bfd_vma) -1)
13282                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13283                   if ((tls_mask & TLS_EXPLICIT) == 0)
13284                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13285                               + R_PPC64_GOT_TPREL16_DS);
13286                   else
13287                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13288                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13289                 }
13290               else
13291                 {
13292                   /* LE */
13293                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13294                   insn2 = 0x38630000;   /* addi 3,3,0 */
13295                   if (tls_gd == 0)
13296                     {
13297                       /* Was an LD reloc.  */
13298                       if (toc_symndx)
13299                         sec = local_sections[toc_symndx];
13300                       for (r_symndx = 0;
13301                            r_symndx < symtab_hdr->sh_info;
13302                            r_symndx++)
13303                         if (local_sections[r_symndx] == sec)
13304                           break;
13305                       if (r_symndx >= symtab_hdr->sh_info)
13306                         r_symndx = STN_UNDEF;
13307                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13308                       if (r_symndx != STN_UNDEF)
13309                         rel->r_addend -= (local_syms[r_symndx].st_value
13310                                           + sec->output_offset
13311                                           + sec->output_section->vma);
13312                     }
13313                   else if (toc_symndx != 0)
13314                     {
13315                       r_symndx = toc_symndx;
13316                       rel->r_addend = toc_addend;
13317                     }
13318                   r_type = R_PPC64_TPREL16_HA;
13319                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13320                   if (offset != (bfd_vma) -1)
13321                     {
13322                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13323                                                     R_PPC64_TPREL16_LO);
13324                       rel[1].r_offset = offset + d_offset;
13325                       rel[1].r_addend = rel->r_addend;
13326                     }
13327                 }
13328               bfd_put_32 (output_bfd, insn1,
13329                           contents + rel->r_offset - d_offset);
13330               if (offset != (bfd_vma) -1)
13331                 {
13332                   insn3 = bfd_get_32 (output_bfd,
13333                                       contents + offset + 4);
13334                   if (insn3 == NOP
13335                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13336                     {
13337                       rel[1].r_offset += 4;
13338                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13339                       insn2 = NOP;
13340                     }
13341                   bfd_put_32 (output_bfd, insn2, contents + offset);
13342                 }
13343               if ((tls_mask & tls_gd) == 0
13344                   && (tls_gd == 0 || toc_symndx != 0))
13345                 {
13346                   /* We changed the symbol.  Start over in order
13347                      to get h, sym, sec etc. right.  */
13348                   rel--;
13349                   continue;
13350                 }
13351             }
13352           break;
13353
13354         case R_PPC64_TLSGD:
13355           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13356             {
13357               unsigned int insn2, insn3;
13358               bfd_vma offset = rel->r_offset;
13359
13360               if ((tls_mask & TLS_TPRELGD) != 0)
13361                 {
13362                   /* IE */
13363                   r_type = R_PPC64_NONE;
13364                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13365                 }
13366               else
13367                 {
13368                   /* LE */
13369                   if (toc_symndx != 0)
13370                     {
13371                       r_symndx = toc_symndx;
13372                       rel->r_addend = toc_addend;
13373                     }
13374                   r_type = R_PPC64_TPREL16_LO;
13375                   rel->r_offset = offset + d_offset;
13376                   insn2 = 0x38630000;   /* addi 3,3,0 */
13377                 }
13378               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379               /* Zap the reloc on the _tls_get_addr call too.  */
13380               BFD_ASSERT (offset == rel[1].r_offset);
13381               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13382               insn3 = bfd_get_32 (output_bfd,
13383                                   contents + offset + 4);
13384               if (insn3 == NOP
13385                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13386                 {
13387                   rel->r_offset += 4;
13388                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13389                   insn2 = NOP;
13390                 }
13391               bfd_put_32 (output_bfd, insn2, contents + offset);
13392               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13393                 {
13394                   rel--;
13395                   continue;
13396                 }
13397             }
13398           break;
13399
13400         case R_PPC64_TLSLD:
13401           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13402             {
13403               unsigned int insn2, insn3;
13404               bfd_vma offset = rel->r_offset;
13405
13406               if (toc_symndx)
13407                 sec = local_sections[toc_symndx];
13408               for (r_symndx = 0;
13409                    r_symndx < symtab_hdr->sh_info;
13410                    r_symndx++)
13411                 if (local_sections[r_symndx] == sec)
13412                   break;
13413               if (r_symndx >= symtab_hdr->sh_info)
13414                 r_symndx = STN_UNDEF;
13415               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13416               if (r_symndx != STN_UNDEF)
13417                 rel->r_addend -= (local_syms[r_symndx].st_value
13418                                   + sec->output_offset
13419                                   + sec->output_section->vma);
13420
13421               r_type = R_PPC64_TPREL16_LO;
13422               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13423               rel->r_offset = offset + d_offset;
13424               /* Zap the reloc on the _tls_get_addr call too.  */
13425               BFD_ASSERT (offset == rel[1].r_offset);
13426               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13427               insn2 = 0x38630000;       /* addi 3,3,0 */
13428               insn3 = bfd_get_32 (output_bfd,
13429                                   contents + offset + 4);
13430               if (insn3 == NOP
13431                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13432                 {
13433                   rel->r_offset += 4;
13434                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13435                   insn2 = NOP;
13436                 }
13437               bfd_put_32 (output_bfd, insn2, contents + offset);
13438               rel--;
13439               continue;
13440             }
13441           break;
13442
13443         case R_PPC64_DTPMOD64:
13444           if (rel + 1 < relend
13445               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13446               && rel[1].r_offset == rel->r_offset + 8)
13447             {
13448               if ((tls_mask & TLS_GD) == 0)
13449                 {
13450                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13451                   if ((tls_mask & TLS_TPRELGD) != 0)
13452                     r_type = R_PPC64_TPREL64;
13453                   else
13454                     {
13455                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13456                       r_type = R_PPC64_NONE;
13457                     }
13458                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13459                 }
13460             }
13461           else
13462             {
13463               if ((tls_mask & TLS_LD) == 0)
13464                 {
13465                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13466                   r_type = R_PPC64_NONE;
13467                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13468                 }
13469             }
13470           break;
13471
13472         case R_PPC64_TPREL64:
13473           if ((tls_mask & TLS_TPREL) == 0)
13474             {
13475               r_type = R_PPC64_NONE;
13476               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13477             }
13478           break;
13479
13480         case R_PPC64_REL16_HA:
13481           /* If we are generating a non-PIC executable, edit
13482              .  0:      addis 2,12,.TOC.-0b@ha
13483              .          addi 2,2,.TOC.-0b@l
13484              used by ELFv2 global entry points to set up r2, to
13485              .          lis 2,.TOC.@ha
13486              .          addi 2,2,.TOC.@l
13487              if .TOC. is in range.  */
13488           if (!info->shared
13489               && h != NULL && &h->elf == htab->elf.hgot
13490               && rel + 1 < relend
13491               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13492               && rel[1].r_offset == rel->r_offset + 4
13493               && rel[1].r_addend == rel->r_addend + 4
13494               && relocation + 0x80008000 <= 0xffffffff)
13495             {
13496               unsigned int insn1, insn2;
13497               bfd_vma offset = rel->r_offset - d_offset;
13498               insn1 = bfd_get_32 (output_bfd, contents + offset);
13499               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13500               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13501                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13502                 {
13503                   r_type = R_PPC64_ADDR16_HA;
13504                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13505                   rel->r_addend -= d_offset;
13506                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13507                   rel[1].r_addend -= d_offset + 4;
13508                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13509                 }
13510             }
13511           break;
13512         }
13513
13514       /* Handle other relocations that tweak non-addend part of insn.  */
13515       insn = 0;
13516       max_br_offset = 1 << 25;
13517       addend = rel->r_addend;
13518       reloc_dest = DEST_NORMAL;
13519       switch (r_type)
13520         {
13521         default:
13522           break;
13523
13524         case R_PPC64_TOCSAVE:
13525           if (relocation + addend == (rel->r_offset
13526                                       + input_section->output_offset
13527                                       + input_section->output_section->vma)
13528               && tocsave_find (htab, NO_INSERT,
13529                                &local_syms, rel, input_bfd))
13530             {
13531               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13532               if (insn == NOP
13533                   || insn == CROR_151515 || insn == CROR_313131)
13534                 bfd_put_32 (input_bfd,
13535                             STD_R2_0R1 + STK_TOC (htab),
13536                             contents + rel->r_offset);
13537             }
13538           break;
13539
13540           /* Branch taken prediction relocations.  */
13541         case R_PPC64_ADDR14_BRTAKEN:
13542         case R_PPC64_REL14_BRTAKEN:
13543           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13544           /* Fall thru.  */
13545
13546           /* Branch not taken prediction relocations.  */
13547         case R_PPC64_ADDR14_BRNTAKEN:
13548         case R_PPC64_REL14_BRNTAKEN:
13549           insn |= bfd_get_32 (output_bfd,
13550                               contents + rel->r_offset) & ~(0x01 << 21);
13551           /* Fall thru.  */
13552
13553         case R_PPC64_REL14:
13554           max_br_offset = 1 << 15;
13555           /* Fall thru.  */
13556
13557         case R_PPC64_REL24:
13558           /* Calls to functions with a different TOC, such as calls to
13559              shared objects, need to alter the TOC pointer.  This is
13560              done using a linkage stub.  A REL24 branching to these
13561              linkage stubs needs to be followed by a nop, as the nop
13562              will be replaced with an instruction to restore the TOC
13563              base pointer.  */
13564           fdh = h;
13565           if (h != NULL
13566               && h->oh != NULL
13567               && h->oh->is_func_descriptor)
13568             fdh = ppc_follow_link (h->oh);
13569           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13570                                            htab);
13571           if (stub_entry != NULL
13572               && (stub_entry->stub_type == ppc_stub_plt_call
13573                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13574                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13575                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13576             {
13577               bfd_boolean can_plt_call = FALSE;
13578
13579               /* All of these stubs will modify r2, so there must be a
13580                  branch and link followed by a nop.  The nop is
13581                  replaced by an insn to restore r2.  */
13582               if (rel->r_offset + 8 <= input_section->size)
13583                 {
13584                   unsigned long br;
13585
13586                   br = bfd_get_32 (input_bfd,
13587                                    contents + rel->r_offset);
13588                   if ((br & 1) != 0)
13589                     {
13590                       unsigned long nop;
13591
13592                       nop = bfd_get_32 (input_bfd,
13593                                         contents + rel->r_offset + 4);
13594                       if (nop == NOP
13595                           || nop == CROR_151515 || nop == CROR_313131)
13596                         {
13597                           if (h != NULL
13598                               && (h == htab->tls_get_addr_fd
13599                                   || h == htab->tls_get_addr)
13600                               && !htab->no_tls_get_addr_opt)
13601                             {
13602                               /* Special stub used, leave nop alone.  */
13603                             }
13604                           else
13605                             bfd_put_32 (input_bfd,
13606                                         LD_R2_0R1 + STK_TOC (htab),
13607                                         contents + rel->r_offset + 4);
13608                           can_plt_call = TRUE;
13609                         }
13610                     }
13611                 }
13612
13613               if (!can_plt_call && h != NULL)
13614                 {
13615                   const char *name = h->elf.root.root.string;
13616
13617                   if (*name == '.')
13618                     ++name;
13619
13620                   if (strncmp (name, "__libc_start_main", 17) == 0
13621                       && (name[17] == 0 || name[17] == '@'))
13622                     {
13623                       /* Allow crt1 branch to go via a toc adjusting
13624                          stub.  Other calls that never return could do
13625                          the same, if we could detect such.  */
13626                       can_plt_call = TRUE;
13627                     }
13628                 }
13629
13630               if (!can_plt_call)
13631                 {
13632                   /* g++ as of 20130507 emits self-calls without a
13633                      following nop.  This is arguably wrong since we
13634                      have conflicting information.  On the one hand a
13635                      global symbol and on the other a local call
13636                      sequence, but don't error for this special case.
13637                      It isn't possible to cheaply verify we have
13638                      exactly such a call.  Allow all calls to the same
13639                      section.  */
13640                   asection *code_sec = sec;
13641
13642                   if (get_opd_info (sec) != NULL)
13643                     {
13644                       bfd_vma off = (relocation + addend
13645                                      - sec->output_section->vma
13646                                      - sec->output_offset);
13647
13648                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13649                     }
13650                   if (code_sec == input_section)
13651                     can_plt_call = TRUE;
13652                 }
13653
13654               if (!can_plt_call)
13655                 {
13656                   info->callbacks->einfo
13657                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13658                        "recompile with -fPIC\n"),
13659                      input_bfd, input_section, rel->r_offset, sym_name);
13660
13661                   bfd_set_error (bfd_error_bad_value);
13662                   ret = FALSE;
13663                 }
13664
13665               if (can_plt_call
13666                   && (stub_entry->stub_type == ppc_stub_plt_call
13667                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13668                 unresolved_reloc = FALSE;
13669             }
13670
13671           if ((stub_entry == NULL
13672                || stub_entry->stub_type == ppc_stub_long_branch
13673                || stub_entry->stub_type == ppc_stub_plt_branch)
13674               && get_opd_info (sec) != NULL)
13675             {
13676               /* The branch destination is the value of the opd entry. */
13677               bfd_vma off = (relocation + addend
13678                              - sec->output_section->vma
13679                              - sec->output_offset);
13680               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13681               if (dest != (bfd_vma) -1)
13682                 {
13683                   relocation = dest;
13684                   addend = 0;
13685                   reloc_dest = DEST_OPD;
13686                 }
13687             }
13688
13689           /* If the branch is out of reach we ought to have a long
13690              branch stub.  */
13691           from = (rel->r_offset
13692                   + input_section->output_offset
13693                   + input_section->output_section->vma);
13694
13695           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13696                                                   ? fdh->elf.other
13697                                                   : sym->st_other);
13698
13699           if (stub_entry != NULL
13700               && (stub_entry->stub_type == ppc_stub_long_branch
13701                   || stub_entry->stub_type == ppc_stub_plt_branch)
13702               && (r_type == R_PPC64_ADDR14_BRTAKEN
13703                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13704                   || (relocation + addend - from + max_br_offset
13705                       < 2 * max_br_offset)))
13706             /* Don't use the stub if this branch is in range.  */
13707             stub_entry = NULL;
13708
13709           if (stub_entry != NULL)
13710             {
13711               /* Munge up the value and addend so that we call the stub
13712                  rather than the procedure directly.  */
13713               relocation = (stub_entry->stub_offset
13714                             + stub_entry->stub_sec->output_offset
13715                             + stub_entry->stub_sec->output_section->vma);
13716               addend = 0;
13717               reloc_dest = DEST_STUB;
13718
13719               if ((stub_entry->stub_type == ppc_stub_plt_call
13720                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13721                   && (ALWAYS_EMIT_R2SAVE
13722                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13723                   && rel + 1 < relend
13724                   && rel[1].r_offset == rel->r_offset + 4
13725                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13726                 relocation += 4;
13727             }
13728
13729           if (insn != 0)
13730             {
13731               if (is_isa_v2)
13732                 {
13733                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13734                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13735                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13736                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13737                     insn |= 0x02 << 21;
13738                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13739                     insn |= 0x08 << 21;
13740                   else
13741                     break;
13742                 }
13743               else
13744                 {
13745                   /* Invert 'y' bit if not the default.  */
13746                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13747                     insn ^= 0x01 << 21;
13748                 }
13749
13750               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13751             }
13752
13753           /* NOP out calls to undefined weak functions.
13754              We can thus call a weak function without first
13755              checking whether the function is defined.  */
13756           else if (h != NULL
13757                    && h->elf.root.type == bfd_link_hash_undefweak
13758                    && h->elf.dynindx == -1
13759                    && r_type == R_PPC64_REL24
13760                    && relocation == 0
13761                    && addend == 0)
13762             {
13763               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13764               continue;
13765             }
13766           break;
13767         }
13768
13769       /* Set `addend'.  */
13770       tls_type = 0;
13771       switch (r_type)
13772         {
13773         default:
13774           info->callbacks->einfo
13775             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13776              input_bfd, (int) r_type, sym_name);
13777
13778           bfd_set_error (bfd_error_bad_value);
13779           ret = FALSE;
13780           continue;
13781
13782         case R_PPC64_NONE:
13783         case R_PPC64_TLS:
13784         case R_PPC64_TLSGD:
13785         case R_PPC64_TLSLD:
13786         case R_PPC64_TOCSAVE:
13787         case R_PPC64_GNU_VTINHERIT:
13788         case R_PPC64_GNU_VTENTRY:
13789           continue;
13790
13791           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13792              address in the GOT as relocation value instead of the
13793              symbol's value itself.  Also, create a GOT entry for the
13794              symbol and put the symbol value there.  */
13795         case R_PPC64_GOT_TLSGD16:
13796         case R_PPC64_GOT_TLSGD16_LO:
13797         case R_PPC64_GOT_TLSGD16_HI:
13798         case R_PPC64_GOT_TLSGD16_HA:
13799           tls_type = TLS_TLS | TLS_GD;
13800           goto dogot;
13801
13802         case R_PPC64_GOT_TLSLD16:
13803         case R_PPC64_GOT_TLSLD16_LO:
13804         case R_PPC64_GOT_TLSLD16_HI:
13805         case R_PPC64_GOT_TLSLD16_HA:
13806           tls_type = TLS_TLS | TLS_LD;
13807           goto dogot;
13808
13809         case R_PPC64_GOT_TPREL16_DS:
13810         case R_PPC64_GOT_TPREL16_LO_DS:
13811         case R_PPC64_GOT_TPREL16_HI:
13812         case R_PPC64_GOT_TPREL16_HA:
13813           tls_type = TLS_TLS | TLS_TPREL;
13814           goto dogot;
13815
13816         case R_PPC64_GOT_DTPREL16_DS:
13817         case R_PPC64_GOT_DTPREL16_LO_DS:
13818         case R_PPC64_GOT_DTPREL16_HI:
13819         case R_PPC64_GOT_DTPREL16_HA:
13820           tls_type = TLS_TLS | TLS_DTPREL;
13821           goto dogot;
13822
13823         case R_PPC64_GOT16:
13824         case R_PPC64_GOT16_LO:
13825         case R_PPC64_GOT16_HI:
13826         case R_PPC64_GOT16_HA:
13827         case R_PPC64_GOT16_DS:
13828         case R_PPC64_GOT16_LO_DS:
13829         dogot:
13830           {
13831             /* Relocation is to the entry for this symbol in the global
13832                offset table.  */
13833             asection *got;
13834             bfd_vma *offp;
13835             bfd_vma off;
13836             unsigned long indx = 0;
13837             struct got_entry *ent;
13838
13839             if (tls_type == (TLS_TLS | TLS_LD)
13840                 && (h == NULL
13841                     || !h->elf.def_dynamic))
13842               ent = ppc64_tlsld_got (input_bfd);
13843             else
13844               {
13845
13846                 if (h != NULL)
13847                   {
13848                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13849                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13850                                                           &h->elf)
13851                         || (info->shared
13852                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13853                       /* This is actually a static link, or it is a
13854                          -Bsymbolic link and the symbol is defined
13855                          locally, or the symbol was forced to be local
13856                          because of a version file.  */
13857                       ;
13858                     else
13859                       {
13860                         BFD_ASSERT (h->elf.dynindx != -1);
13861                         indx = h->elf.dynindx;
13862                         unresolved_reloc = FALSE;
13863                       }
13864                     ent = h->elf.got.glist;
13865                   }
13866                 else
13867                   {
13868                     if (local_got_ents == NULL)
13869                       abort ();
13870                     ent = local_got_ents[r_symndx];
13871                   }
13872
13873                 for (; ent != NULL; ent = ent->next)
13874                   if (ent->addend == orig_rel.r_addend
13875                       && ent->owner == input_bfd
13876                       && ent->tls_type == tls_type)
13877                     break;
13878               }
13879
13880             if (ent == NULL)
13881               abort ();
13882             if (ent->is_indirect)
13883               ent = ent->got.ent;
13884             offp = &ent->got.offset;
13885             got = ppc64_elf_tdata (ent->owner)->got;
13886             if (got == NULL)
13887               abort ();
13888
13889             /* The offset must always be a multiple of 8.  We use the
13890                least significant bit to record whether we have already
13891                processed this entry.  */
13892             off = *offp;
13893             if ((off & 1) != 0)
13894               off &= ~1;
13895             else
13896               {
13897                 /* Generate relocs for the dynamic linker, except in
13898                    the case of TLSLD where we'll use one entry per
13899                    module.  */
13900                 asection *relgot;
13901                 bfd_boolean ifunc;
13902
13903                 *offp = off | 1;
13904                 relgot = NULL;
13905                 ifunc = (h != NULL
13906                          ? h->elf.type == STT_GNU_IFUNC
13907                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13908                 if (ifunc)
13909                   relgot = htab->elf.irelplt;
13910                 else if ((info->shared || indx != 0)
13911                          && (h == NULL
13912                              || (tls_type == (TLS_TLS | TLS_LD)
13913                                  && !h->elf.def_dynamic)
13914                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13915                              || h->elf.root.type != bfd_link_hash_undefweak))
13916                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13917                 if (relgot != NULL)
13918                   {
13919                     outrel.r_offset = (got->output_section->vma
13920                                        + got->output_offset
13921                                        + off);
13922                     outrel.r_addend = addend;
13923                     if (tls_type & (TLS_LD | TLS_GD))
13924                       {
13925                         outrel.r_addend = 0;
13926                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13927                         if (tls_type == (TLS_TLS | TLS_GD))
13928                           {
13929                             loc = relgot->contents;
13930                             loc += (relgot->reloc_count++
13931                                     * sizeof (Elf64_External_Rela));
13932                             bfd_elf64_swap_reloca_out (output_bfd,
13933                                                        &outrel, loc);
13934                             outrel.r_offset += 8;
13935                             outrel.r_addend = addend;
13936                             outrel.r_info
13937                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13938                           }
13939                       }
13940                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13941                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13942                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13943                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13944                     else if (indx != 0)
13945                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13946                     else
13947                       {
13948                         if (ifunc)
13949                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13950                         else
13951                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13952
13953                         /* Write the .got section contents for the sake
13954                            of prelink.  */
13955                         loc = got->contents + off;
13956                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13957                                     loc);
13958                       }
13959
13960                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13961                       {
13962                         outrel.r_addend += relocation;
13963                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13964                           outrel.r_addend -= htab->elf.tls_sec->vma;
13965                       }
13966                     loc = relgot->contents;
13967                     loc += (relgot->reloc_count++
13968                             * sizeof (Elf64_External_Rela));
13969                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13970                   }
13971
13972                 /* Init the .got section contents here if we're not
13973                    emitting a reloc.  */
13974                 else
13975                   {
13976                     relocation += addend;
13977                     if (tls_type == (TLS_TLS | TLS_LD))
13978                       relocation = 1;
13979                     else if (tls_type != 0)
13980                       {
13981                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13982                         if (tls_type == (TLS_TLS | TLS_TPREL))
13983                           relocation += DTP_OFFSET - TP_OFFSET;
13984
13985                         if (tls_type == (TLS_TLS | TLS_GD))
13986                           {
13987                             bfd_put_64 (output_bfd, relocation,
13988                                         got->contents + off + 8);
13989                             relocation = 1;
13990                           }
13991                       }
13992
13993                     bfd_put_64 (output_bfd, relocation,
13994                                 got->contents + off);
13995                   }
13996               }
13997
13998             if (off >= (bfd_vma) -2)
13999               abort ();
14000
14001             relocation = got->output_section->vma + got->output_offset + off;
14002             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14003           }
14004           break;
14005
14006         case R_PPC64_PLT16_HA:
14007         case R_PPC64_PLT16_HI:
14008         case R_PPC64_PLT16_LO:
14009         case R_PPC64_PLT32:
14010         case R_PPC64_PLT64:
14011           /* Relocation is to the entry for this symbol in the
14012              procedure linkage table.  */
14013
14014           /* Resolve a PLT reloc against a local symbol directly,
14015              without using the procedure linkage table.  */
14016           if (h == NULL)
14017             break;
14018
14019           /* It's possible that we didn't make a PLT entry for this
14020              symbol.  This happens when statically linking PIC code,
14021              or when using -Bsymbolic.  Go find a match if there is a
14022              PLT entry.  */
14023           if (htab->elf.splt != NULL)
14024             {
14025               struct plt_entry *ent;
14026               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14027                 if (ent->plt.offset != (bfd_vma) -1
14028                     && ent->addend == orig_rel.r_addend)
14029                   {
14030                     relocation = (htab->elf.splt->output_section->vma
14031                                   + htab->elf.splt->output_offset
14032                                   + ent->plt.offset);
14033                     unresolved_reloc = FALSE;
14034                     break;
14035                   }
14036             }
14037           break;
14038
14039         case R_PPC64_TOC:
14040           /* Relocation value is TOC base.  */
14041           relocation = TOCstart;
14042           if (r_symndx == STN_UNDEF)
14043             relocation += htab->stub_group[input_section->id].toc_off;
14044           else if (unresolved_reloc)
14045             ;
14046           else if (sec != NULL && sec->id <= htab->top_id)
14047             relocation += htab->stub_group[sec->id].toc_off;
14048           else
14049             unresolved_reloc = TRUE;
14050           goto dodyn;
14051
14052           /* TOC16 relocs.  We want the offset relative to the TOC base,
14053              which is the address of the start of the TOC plus 0x8000.
14054              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14055              in this order.  */
14056         case R_PPC64_TOC16:
14057         case R_PPC64_TOC16_LO:
14058         case R_PPC64_TOC16_HI:
14059         case R_PPC64_TOC16_DS:
14060         case R_PPC64_TOC16_LO_DS:
14061         case R_PPC64_TOC16_HA:
14062           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14063           break;
14064
14065           /* Relocate against the beginning of the section.  */
14066         case R_PPC64_SECTOFF:
14067         case R_PPC64_SECTOFF_LO:
14068         case R_PPC64_SECTOFF_HI:
14069         case R_PPC64_SECTOFF_DS:
14070         case R_PPC64_SECTOFF_LO_DS:
14071         case R_PPC64_SECTOFF_HA:
14072           if (sec != NULL)
14073             addend -= sec->output_section->vma;
14074           break;
14075
14076         case R_PPC64_REL16:
14077         case R_PPC64_REL16_LO:
14078         case R_PPC64_REL16_HI:
14079         case R_PPC64_REL16_HA:
14080           break;
14081
14082         case R_PPC64_REL14:
14083         case R_PPC64_REL14_BRNTAKEN:
14084         case R_PPC64_REL14_BRTAKEN:
14085         case R_PPC64_REL24:
14086           break;
14087
14088         case R_PPC64_TPREL16:
14089         case R_PPC64_TPREL16_LO:
14090         case R_PPC64_TPREL16_HI:
14091         case R_PPC64_TPREL16_HA:
14092         case R_PPC64_TPREL16_DS:
14093         case R_PPC64_TPREL16_LO_DS:
14094         case R_PPC64_TPREL16_HIGH:
14095         case R_PPC64_TPREL16_HIGHA:
14096         case R_PPC64_TPREL16_HIGHER:
14097         case R_PPC64_TPREL16_HIGHERA:
14098         case R_PPC64_TPREL16_HIGHEST:
14099         case R_PPC64_TPREL16_HIGHESTA:
14100           if (h != NULL
14101               && h->elf.root.type == bfd_link_hash_undefweak
14102               && h->elf.dynindx == -1)
14103             {
14104               /* Make this relocation against an undefined weak symbol
14105                  resolve to zero.  This is really just a tweak, since
14106                  code using weak externs ought to check that they are
14107                  defined before using them.  */
14108               bfd_byte *p = contents + rel->r_offset - d_offset;
14109
14110               insn = bfd_get_32 (output_bfd, p);
14111               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14112               if (insn != 0)
14113                 bfd_put_32 (output_bfd, insn, p);
14114               break;
14115             }
14116           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14117           if (info->shared)
14118             /* The TPREL16 relocs shouldn't really be used in shared
14119                libs as they will result in DT_TEXTREL being set, but
14120                support them anyway.  */
14121             goto dodyn;
14122           break;
14123
14124         case R_PPC64_DTPREL16:
14125         case R_PPC64_DTPREL16_LO:
14126         case R_PPC64_DTPREL16_HI:
14127         case R_PPC64_DTPREL16_HA:
14128         case R_PPC64_DTPREL16_DS:
14129         case R_PPC64_DTPREL16_LO_DS:
14130         case R_PPC64_DTPREL16_HIGH:
14131         case R_PPC64_DTPREL16_HIGHA:
14132         case R_PPC64_DTPREL16_HIGHER:
14133         case R_PPC64_DTPREL16_HIGHERA:
14134         case R_PPC64_DTPREL16_HIGHEST:
14135         case R_PPC64_DTPREL16_HIGHESTA:
14136           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14137           break;
14138
14139         case R_PPC64_DTPMOD64:
14140           relocation = 1;
14141           addend = 0;
14142           goto dodyn;
14143
14144         case R_PPC64_TPREL64:
14145           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146           goto dodyn;
14147
14148         case R_PPC64_DTPREL64:
14149           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14150           /* Fall thru */
14151
14152           /* Relocations that may need to be propagated if this is a
14153              dynamic object.  */
14154         case R_PPC64_REL30:
14155         case R_PPC64_REL32:
14156         case R_PPC64_REL64:
14157         case R_PPC64_ADDR14:
14158         case R_PPC64_ADDR14_BRNTAKEN:
14159         case R_PPC64_ADDR14_BRTAKEN:
14160         case R_PPC64_ADDR16:
14161         case R_PPC64_ADDR16_DS:
14162         case R_PPC64_ADDR16_HA:
14163         case R_PPC64_ADDR16_HI:
14164         case R_PPC64_ADDR16_HIGH:
14165         case R_PPC64_ADDR16_HIGHA:
14166         case R_PPC64_ADDR16_HIGHER:
14167         case R_PPC64_ADDR16_HIGHERA:
14168         case R_PPC64_ADDR16_HIGHEST:
14169         case R_PPC64_ADDR16_HIGHESTA:
14170         case R_PPC64_ADDR16_LO:
14171         case R_PPC64_ADDR16_LO_DS:
14172         case R_PPC64_ADDR24:
14173         case R_PPC64_ADDR32:
14174         case R_PPC64_ADDR64:
14175         case R_PPC64_UADDR16:
14176         case R_PPC64_UADDR32:
14177         case R_PPC64_UADDR64:
14178         dodyn:
14179           if ((input_section->flags & SEC_ALLOC) == 0)
14180             break;
14181
14182           if (NO_OPD_RELOCS && is_opd)
14183             break;
14184
14185           if ((info->shared
14186                && (h == NULL
14187                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14188                    || h->elf.root.type != bfd_link_hash_undefweak)
14189                && (must_be_dyn_reloc (info, r_type)
14190                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14191               || (ELIMINATE_COPY_RELOCS
14192                   && !info->shared
14193                   && h != NULL
14194                   && h->elf.dynindx != -1
14195                   && !h->elf.non_got_ref
14196                   && !h->elf.def_regular)
14197               || (!info->shared
14198                   && (h != NULL
14199                       ? h->elf.type == STT_GNU_IFUNC
14200                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14201             {
14202               bfd_boolean skip, relocate;
14203               asection *sreloc;
14204               bfd_vma out_off;
14205
14206               /* When generating a dynamic object, these relocations
14207                  are copied into the output file to be resolved at run
14208                  time.  */
14209
14210               skip = FALSE;
14211               relocate = FALSE;
14212
14213               out_off = _bfd_elf_section_offset (output_bfd, info,
14214                                                  input_section, rel->r_offset);
14215               if (out_off == (bfd_vma) -1)
14216                 skip = TRUE;
14217               else if (out_off == (bfd_vma) -2)
14218                 skip = TRUE, relocate = TRUE;
14219               out_off += (input_section->output_section->vma
14220                           + input_section->output_offset);
14221               outrel.r_offset = out_off;
14222               outrel.r_addend = rel->r_addend;
14223
14224               /* Optimize unaligned reloc use.  */
14225               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14226                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14227                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14228               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14229                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14230                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14231               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14232                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14233                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14234
14235               if (skip)
14236                 memset (&outrel, 0, sizeof outrel);
14237               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14238                        && !is_opd
14239                        && r_type != R_PPC64_TOC)
14240                 {
14241                   BFD_ASSERT (h->elf.dynindx != -1);
14242                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14243                 }
14244               else
14245                 {
14246                   /* This symbol is local, or marked to become local,
14247                      or this is an opd section reloc which must point
14248                      at a local function.  */
14249                   outrel.r_addend += relocation;
14250                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14251                     {
14252                       if (is_opd && h != NULL)
14253                         {
14254                           /* Lie about opd entries.  This case occurs
14255                              when building shared libraries and we
14256                              reference a function in another shared
14257                              lib.  The same thing happens for a weak
14258                              definition in an application that's
14259                              overridden by a strong definition in a
14260                              shared lib.  (I believe this is a generic
14261                              bug in binutils handling of weak syms.)
14262                              In these cases we won't use the opd
14263                              entry in this lib.  */
14264                           unresolved_reloc = FALSE;
14265                         }
14266                       if (!is_opd
14267                           && r_type == R_PPC64_ADDR64
14268                           && (h != NULL
14269                               ? h->elf.type == STT_GNU_IFUNC
14270                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14271                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14272                       else
14273                         {
14274                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14275
14276                           /* We need to relocate .opd contents for ld.so.
14277                              Prelink also wants simple and consistent rules
14278                              for relocs.  This make all RELATIVE relocs have
14279                              *r_offset equal to r_addend.  */
14280                           relocate = TRUE;
14281                         }
14282                     }
14283                   else
14284                     {
14285                       long indx = 0;
14286
14287                       if (h != NULL
14288                           ? h->elf.type == STT_GNU_IFUNC
14289                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14290                         {
14291                           info->callbacks->einfo
14292                             (_("%P: %H: %s for indirect "
14293                                "function `%T' unsupported\n"),
14294                              input_bfd, input_section, rel->r_offset,
14295                              ppc64_elf_howto_table[r_type]->name,
14296                              sym_name);
14297                           ret = FALSE;
14298                         }
14299                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14300                         ;
14301                       else if (sec == NULL || sec->owner == NULL)
14302                         {
14303                           bfd_set_error (bfd_error_bad_value);
14304                           return FALSE;
14305                         }
14306                       else
14307                         {
14308                           asection *osec;
14309
14310                           osec = sec->output_section;
14311                           indx = elf_section_data (osec)->dynindx;
14312
14313                           if (indx == 0)
14314                             {
14315                               if ((osec->flags & SEC_READONLY) == 0
14316                                   && htab->elf.data_index_section != NULL)
14317                                 osec = htab->elf.data_index_section;
14318                               else
14319                                 osec = htab->elf.text_index_section;
14320                               indx = elf_section_data (osec)->dynindx;
14321                             }
14322                           BFD_ASSERT (indx != 0);
14323
14324                           /* We are turning this relocation into one
14325                              against a section symbol, so subtract out
14326                              the output section's address but not the
14327                              offset of the input section in the output
14328                              section.  */
14329                           outrel.r_addend -= osec->vma;
14330                         }
14331
14332                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14333                     }
14334                 }
14335
14336               sreloc = elf_section_data (input_section)->sreloc;
14337               if (h != NULL
14338                   ? h->elf.type == STT_GNU_IFUNC
14339                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14340                 sreloc = htab->elf.irelplt;
14341               if (sreloc == NULL)
14342                 abort ();
14343
14344               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14345                   >= sreloc->size)
14346                 abort ();
14347               loc = sreloc->contents;
14348               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14349               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14350
14351               /* If this reloc is against an external symbol, it will
14352                  be computed at runtime, so there's no need to do
14353                  anything now.  However, for the sake of prelink ensure
14354                  that the section contents are a known value.  */
14355               if (! relocate)
14356                 {
14357                   unresolved_reloc = FALSE;
14358                   /* The value chosen here is quite arbitrary as ld.so
14359                      ignores section contents except for the special
14360                      case of .opd where the contents might be accessed
14361                      before relocation.  Choose zero, as that won't
14362                      cause reloc overflow.  */
14363                   relocation = 0;
14364                   addend = 0;
14365                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14366                      to improve backward compatibility with older
14367                      versions of ld.  */
14368                   if (r_type == R_PPC64_ADDR64)
14369                     addend = outrel.r_addend;
14370                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14371                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14372                     addend = (input_section->output_section->vma
14373                               + input_section->output_offset
14374                               + rel->r_offset);
14375                 }
14376             }
14377           break;
14378
14379         case R_PPC64_COPY:
14380         case R_PPC64_GLOB_DAT:
14381         case R_PPC64_JMP_SLOT:
14382         case R_PPC64_JMP_IREL:
14383         case R_PPC64_RELATIVE:
14384           /* We shouldn't ever see these dynamic relocs in relocatable
14385              files.  */
14386           /* Fall through.  */
14387
14388         case R_PPC64_PLTGOT16:
14389         case R_PPC64_PLTGOT16_DS:
14390         case R_PPC64_PLTGOT16_HA:
14391         case R_PPC64_PLTGOT16_HI:
14392         case R_PPC64_PLTGOT16_LO:
14393         case R_PPC64_PLTGOT16_LO_DS:
14394         case R_PPC64_PLTREL32:
14395         case R_PPC64_PLTREL64:
14396           /* These ones haven't been implemented yet.  */
14397
14398           info->callbacks->einfo
14399             (_("%P: %B: %s is not supported for `%T'\n"),
14400              input_bfd,
14401              ppc64_elf_howto_table[r_type]->name, sym_name);
14402
14403           bfd_set_error (bfd_error_invalid_operation);
14404           ret = FALSE;
14405           continue;
14406         }
14407
14408       /* Multi-instruction sequences that access the TOC can be
14409          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14410          to             nop;           addi rb,r2,x;  */
14411       switch (r_type)
14412         {
14413         default:
14414           break;
14415
14416         case R_PPC64_GOT_TLSLD16_HI:
14417         case R_PPC64_GOT_TLSGD16_HI:
14418         case R_PPC64_GOT_TPREL16_HI:
14419         case R_PPC64_GOT_DTPREL16_HI:
14420         case R_PPC64_GOT16_HI:
14421         case R_PPC64_TOC16_HI:
14422           /* These relocs would only be useful if building up an
14423              offset to later add to r2, perhaps in an indexed
14424              addressing mode instruction.  Don't try to optimize.
14425              Unfortunately, the possibility of someone building up an
14426              offset like this or even with the HA relocs, means that
14427              we need to check the high insn when optimizing the low
14428              insn.  */
14429           break;
14430
14431         case R_PPC64_GOT_TLSLD16_HA:
14432         case R_PPC64_GOT_TLSGD16_HA:
14433         case R_PPC64_GOT_TPREL16_HA:
14434         case R_PPC64_GOT_DTPREL16_HA:
14435         case R_PPC64_GOT16_HA:
14436         case R_PPC64_TOC16_HA:
14437           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14438               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14439             {
14440               bfd_byte *p = contents + (rel->r_offset & ~3);
14441               bfd_put_32 (input_bfd, NOP, p);
14442             }
14443           break;
14444
14445         case R_PPC64_GOT_TLSLD16_LO:
14446         case R_PPC64_GOT_TLSGD16_LO:
14447         case R_PPC64_GOT_TPREL16_LO_DS:
14448         case R_PPC64_GOT_DTPREL16_LO_DS:
14449         case R_PPC64_GOT16_LO:
14450         case R_PPC64_GOT16_LO_DS:
14451         case R_PPC64_TOC16_LO:
14452         case R_PPC64_TOC16_LO_DS:
14453           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14454               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14455             {
14456               bfd_byte *p = contents + (rel->r_offset & ~3);
14457               insn = bfd_get_32 (input_bfd, p);
14458               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14459                 {
14460                   /* Transform addic to addi when we change reg.  */
14461                   insn &= ~((0x3f << 26) | (0x1f << 16));
14462                   insn |= (14u << 26) | (2 << 16);
14463                 }
14464               else
14465                 {
14466                   insn &= ~(0x1f << 16);
14467                   insn |= 2 << 16;
14468                 }
14469               bfd_put_32 (input_bfd, insn, p);
14470             }
14471           break;
14472         }
14473
14474       /* Do any further special processing.  */
14475       switch (r_type)
14476         {
14477         default:
14478           break;
14479
14480         case R_PPC64_REL16_HA:
14481         case R_PPC64_ADDR16_HA:
14482         case R_PPC64_ADDR16_HIGHA:
14483         case R_PPC64_ADDR16_HIGHERA:
14484         case R_PPC64_ADDR16_HIGHESTA:
14485         case R_PPC64_TOC16_HA:
14486         case R_PPC64_SECTOFF_HA:
14487         case R_PPC64_TPREL16_HA:
14488         case R_PPC64_TPREL16_HIGHA:
14489         case R_PPC64_TPREL16_HIGHERA:
14490         case R_PPC64_TPREL16_HIGHESTA:
14491         case R_PPC64_DTPREL16_HA:
14492         case R_PPC64_DTPREL16_HIGHA:
14493         case R_PPC64_DTPREL16_HIGHERA:
14494         case R_PPC64_DTPREL16_HIGHESTA:
14495           /* It's just possible that this symbol is a weak symbol
14496              that's not actually defined anywhere. In that case,
14497              'sec' would be NULL, and we should leave the symbol
14498              alone (it will be set to zero elsewhere in the link).  */
14499           if (sec == NULL)
14500             break;
14501           /* Fall thru */
14502
14503         case R_PPC64_GOT16_HA:
14504         case R_PPC64_PLTGOT16_HA:
14505         case R_PPC64_PLT16_HA:
14506         case R_PPC64_GOT_TLSGD16_HA:
14507         case R_PPC64_GOT_TLSLD16_HA:
14508         case R_PPC64_GOT_TPREL16_HA:
14509         case R_PPC64_GOT_DTPREL16_HA:
14510           /* Add 0x10000 if sign bit in 0:15 is set.
14511              Bits 0:15 are not used.  */
14512           addend += 0x8000;
14513           break;
14514
14515         case R_PPC64_ADDR16_DS:
14516         case R_PPC64_ADDR16_LO_DS:
14517         case R_PPC64_GOT16_DS:
14518         case R_PPC64_GOT16_LO_DS:
14519         case R_PPC64_PLT16_LO_DS:
14520         case R_PPC64_SECTOFF_DS:
14521         case R_PPC64_SECTOFF_LO_DS:
14522         case R_PPC64_TOC16_DS:
14523         case R_PPC64_TOC16_LO_DS:
14524         case R_PPC64_PLTGOT16_DS:
14525         case R_PPC64_PLTGOT16_LO_DS:
14526         case R_PPC64_GOT_TPREL16_DS:
14527         case R_PPC64_GOT_TPREL16_LO_DS:
14528         case R_PPC64_GOT_DTPREL16_DS:
14529         case R_PPC64_GOT_DTPREL16_LO_DS:
14530         case R_PPC64_TPREL16_DS:
14531         case R_PPC64_TPREL16_LO_DS:
14532         case R_PPC64_DTPREL16_DS:
14533         case R_PPC64_DTPREL16_LO_DS:
14534           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14535           mask = 3;
14536           /* If this reloc is against an lq insn, then the value must be
14537              a multiple of 16.  This is somewhat of a hack, but the
14538              "correct" way to do this by defining _DQ forms of all the
14539              _DS relocs bloats all reloc switches in this file.  It
14540              doesn't seem to make much sense to use any of these relocs
14541              in data, so testing the insn should be safe.  */
14542           if ((insn & (0x3f << 26)) == (56u << 26))
14543             mask = 15;
14544           if (((relocation + addend) & mask) != 0)
14545             {
14546               info->callbacks->einfo
14547                 (_("%P: %H: error: %s not a multiple of %u\n"),
14548                  input_bfd, input_section, rel->r_offset,
14549                  ppc64_elf_howto_table[r_type]->name,
14550                  mask + 1);
14551               bfd_set_error (bfd_error_bad_value);
14552               ret = FALSE;
14553               continue;
14554             }
14555           break;
14556         }
14557
14558       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14559          because such sections are not SEC_ALLOC and thus ld.so will
14560          not process them.  */
14561       if (unresolved_reloc
14562           && !((input_section->flags & SEC_DEBUGGING) != 0
14563                && h->elf.def_dynamic)
14564           && _bfd_elf_section_offset (output_bfd, info, input_section,
14565                                       rel->r_offset) != (bfd_vma) -1)
14566         {
14567           info->callbacks->einfo
14568             (_("%P: %H: unresolvable %s against `%T'\n"),
14569              input_bfd, input_section, rel->r_offset,
14570              ppc64_elf_howto_table[(int) r_type]->name,
14571              h->elf.root.root.string);
14572           ret = FALSE;
14573         }
14574
14575       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14576                                     input_bfd,
14577                                     input_section,
14578                                     contents,
14579                                     rel->r_offset,
14580                                     relocation,
14581                                     addend);
14582
14583       if (r != bfd_reloc_ok)
14584         {
14585           char *more_info = NULL;
14586           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14587
14588           if (reloc_dest != DEST_NORMAL)
14589             {
14590               more_info = bfd_malloc (strlen (reloc_name) + 8);
14591               if (more_info != NULL)
14592                 {
14593                   strcpy (more_info, reloc_name);
14594                   strcat (more_info, (reloc_dest == DEST_OPD
14595                                       ? " (OPD)" : " (stub)"));
14596                   reloc_name = more_info;
14597                 }
14598             }
14599
14600           if (r == bfd_reloc_overflow)
14601             {
14602               if (warned)
14603                 continue;
14604               if (h != NULL
14605                   && h->elf.root.type == bfd_link_hash_undefweak
14606                   && ppc64_elf_howto_table[r_type]->pc_relative)
14607                 {
14608                   /* Assume this is a call protected by other code that
14609                      detects the symbol is undefined.  If this is the case,
14610                      we can safely ignore the overflow.  If not, the
14611                      program is hosed anyway, and a little warning isn't
14612                      going to help.  */
14613
14614                   continue;
14615                 }
14616
14617               if (!((*info->callbacks->reloc_overflow)
14618                     (info, &h->elf.root, sym_name,
14619                      reloc_name, orig_rel.r_addend,
14620                      input_bfd, input_section, rel->r_offset)))
14621                 return FALSE;
14622             }
14623           else
14624             {
14625               info->callbacks->einfo
14626                 (_("%P: %H: %s against `%T': error %d\n"),
14627                  input_bfd, input_section, rel->r_offset,
14628                  reloc_name, sym_name, (int) r);
14629               ret = FALSE;
14630             }
14631           if (more_info != NULL)
14632             free (more_info);
14633         }
14634     }
14635
14636   /* If we're emitting relocations, then shortly after this function
14637      returns, reloc offsets and addends for this section will be
14638      adjusted.  Worse, reloc symbol indices will be for the output
14639      file rather than the input.  Save a copy of the relocs for
14640      opd_entry_value.  */
14641   if (is_opd && (info->emitrelocations || info->relocatable))
14642     {
14643       bfd_size_type amt;
14644       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14645       rel = bfd_alloc (input_bfd, amt);
14646       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14647       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14648       if (rel == NULL)
14649         return FALSE;
14650       memcpy (rel, relocs, amt);
14651     }
14652   return ret;
14653 }
14654
14655 /* Adjust the value of any local symbols in opd sections.  */
14656
14657 static int
14658 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14659                               const char *name ATTRIBUTE_UNUSED,
14660                               Elf_Internal_Sym *elfsym,
14661                               asection *input_sec,
14662                               struct elf_link_hash_entry *h)
14663 {
14664   struct _opd_sec_data *opd;
14665   long adjust;
14666   bfd_vma value;
14667
14668   if (h != NULL)
14669     return 1;
14670
14671   opd = get_opd_info (input_sec);
14672   if (opd == NULL || opd->adjust == NULL)
14673     return 1;
14674
14675   value = elfsym->st_value - input_sec->output_offset;
14676   if (!info->relocatable)
14677     value -= input_sec->output_section->vma;
14678
14679   adjust = opd->adjust[value / 8];
14680   if (adjust == -1)
14681     return 2;
14682
14683   elfsym->st_value += adjust;
14684   return 1;
14685 }
14686
14687 /* Finish up dynamic symbol handling.  We set the contents of various
14688    dynamic sections here.  */
14689
14690 static bfd_boolean
14691 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14692                                  struct bfd_link_info *info,
14693                                  struct elf_link_hash_entry *h,
14694                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14695 {
14696   struct ppc_link_hash_table *htab;
14697   struct plt_entry *ent;
14698   Elf_Internal_Rela rela;
14699   bfd_byte *loc;
14700
14701   htab = ppc_hash_table (info);
14702   if (htab == NULL)
14703     return FALSE;
14704
14705   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14706     if (ent->plt.offset != (bfd_vma) -1)
14707       {
14708         /* This symbol has an entry in the procedure linkage
14709            table.  Set it up.  */
14710         if (!htab->elf.dynamic_sections_created
14711             || h->dynindx == -1)
14712           {
14713             BFD_ASSERT (h->type == STT_GNU_IFUNC
14714                         && h->def_regular
14715                         && (h->root.type == bfd_link_hash_defined
14716                             || h->root.type == bfd_link_hash_defweak));
14717             rela.r_offset = (htab->elf.iplt->output_section->vma
14718                              + htab->elf.iplt->output_offset
14719                              + ent->plt.offset);
14720             if (htab->opd_abi)
14721               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14722             else
14723               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14724             rela.r_addend = (h->root.u.def.value
14725                              + h->root.u.def.section->output_offset
14726                              + h->root.u.def.section->output_section->vma
14727                              + ent->addend);
14728             loc = (htab->elf.irelplt->contents
14729                    + (htab->elf.irelplt->reloc_count++
14730                       * sizeof (Elf64_External_Rela)));
14731           }
14732         else
14733           {
14734             rela.r_offset = (htab->elf.splt->output_section->vma
14735                              + htab->elf.splt->output_offset
14736                              + ent->plt.offset);
14737             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14738             rela.r_addend = ent->addend;
14739             loc = (htab->elf.srelplt->contents
14740                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14741                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14742           }
14743         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14744
14745         if (!htab->opd_abi)
14746           {
14747             if (!h->def_regular)
14748               {
14749                 /* Mark the symbol as undefined, rather than as
14750                    defined in glink.  Leave the value if there were
14751                    any relocations where pointer equality matters
14752                    (this is a clue for the dynamic linker, to make
14753                    function pointer comparisons work between an
14754                    application and shared library), otherwise set it
14755                    to zero.  */
14756                 sym->st_shndx = SHN_UNDEF;
14757                 if (!h->pointer_equality_needed)
14758                   sym->st_value = 0;
14759                 else if (!h->ref_regular_nonweak)
14760                   {
14761                     /* This breaks function pointer comparisons, but
14762                        that is better than breaking tests for a NULL
14763                        function pointer.  */
14764                     sym->st_value = 0;
14765                   }
14766               }
14767           }
14768       }
14769
14770   if (h->needs_copy)
14771     {
14772       /* This symbol needs a copy reloc.  Set it up.  */
14773
14774       if (h->dynindx == -1
14775           || (h->root.type != bfd_link_hash_defined
14776               && h->root.type != bfd_link_hash_defweak)
14777           || htab->relbss == NULL)
14778         abort ();
14779
14780       rela.r_offset = (h->root.u.def.value
14781                        + h->root.u.def.section->output_section->vma
14782                        + h->root.u.def.section->output_offset);
14783       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14784       rela.r_addend = 0;
14785       loc = htab->relbss->contents;
14786       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14787       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14788     }
14789
14790   return TRUE;
14791 }
14792
14793 /* Used to decide how to sort relocs in an optimal manner for the
14794    dynamic linker, before writing them out.  */
14795
14796 static enum elf_reloc_type_class
14797 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14798                             const asection *rel_sec,
14799                             const Elf_Internal_Rela *rela)
14800 {
14801   enum elf_ppc64_reloc_type r_type;
14802   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14803
14804   if (rel_sec == htab->elf.irelplt)
14805     return reloc_class_ifunc;
14806
14807   r_type = ELF64_R_TYPE (rela->r_info);
14808   switch (r_type)
14809     {
14810     case R_PPC64_RELATIVE:
14811       return reloc_class_relative;
14812     case R_PPC64_JMP_SLOT:
14813       return reloc_class_plt;
14814     case R_PPC64_COPY:
14815       return reloc_class_copy;
14816     default:
14817       return reloc_class_normal;
14818     }
14819 }
14820
14821 /* Finish up the dynamic sections.  */
14822
14823 static bfd_boolean
14824 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14825                                    struct bfd_link_info *info)
14826 {
14827   struct ppc_link_hash_table *htab;
14828   bfd *dynobj;
14829   asection *sdyn;
14830
14831   htab = ppc_hash_table (info);
14832   if (htab == NULL)
14833     return FALSE;
14834
14835   dynobj = htab->elf.dynobj;
14836   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14837
14838   if (htab->elf.dynamic_sections_created)
14839     {
14840       Elf64_External_Dyn *dyncon, *dynconend;
14841
14842       if (sdyn == NULL || htab->elf.sgot == NULL)
14843         abort ();
14844
14845       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14846       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14847       for (; dyncon < dynconend; dyncon++)
14848         {
14849           Elf_Internal_Dyn dyn;
14850           asection *s;
14851
14852           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14853
14854           switch (dyn.d_tag)
14855             {
14856             default:
14857               continue;
14858
14859             case DT_PPC64_GLINK:
14860               s = htab->glink;
14861               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14862               /* We stupidly defined DT_PPC64_GLINK to be the start
14863                  of glink rather than the first entry point, which is
14864                  what ld.so needs, and now have a bigger stub to
14865                  support automatic multiple TOCs.  */
14866               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14867               break;
14868
14869             case DT_PPC64_OPD:
14870               s = bfd_get_section_by_name (output_bfd, ".opd");
14871               if (s == NULL)
14872                 continue;
14873               dyn.d_un.d_ptr = s->vma;
14874               break;
14875
14876             case DT_PPC64_OPT:
14877               if (htab->do_multi_toc && htab->multi_toc_needed)
14878                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14879               break;
14880
14881             case DT_PPC64_OPDSZ:
14882               s = bfd_get_section_by_name (output_bfd, ".opd");
14883               if (s == NULL)
14884                 continue;
14885               dyn.d_un.d_val = s->size;
14886               break;
14887
14888             case DT_PLTGOT:
14889               s = htab->elf.splt;
14890               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14891               break;
14892
14893             case DT_JMPREL:
14894               s = htab->elf.srelplt;
14895               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14896               break;
14897
14898             case DT_PLTRELSZ:
14899               dyn.d_un.d_val = htab->elf.srelplt->size;
14900               break;
14901
14902             case DT_RELASZ:
14903               /* Don't count procedure linkage table relocs in the
14904                  overall reloc count.  */
14905               s = htab->elf.srelplt;
14906               if (s == NULL)
14907                 continue;
14908               dyn.d_un.d_val -= s->size;
14909               break;
14910
14911             case DT_RELA:
14912               /* We may not be using the standard ELF linker script.
14913                  If .rela.plt is the first .rela section, we adjust
14914                  DT_RELA to not include it.  */
14915               s = htab->elf.srelplt;
14916               if (s == NULL)
14917                 continue;
14918               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14919                 continue;
14920               dyn.d_un.d_ptr += s->size;
14921               break;
14922             }
14923
14924           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14925         }
14926     }
14927
14928   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14929     {
14930       /* Fill in the first entry in the global offset table.
14931          We use it to hold the link-time TOCbase.  */
14932       bfd_put_64 (output_bfd,
14933                   elf_gp (output_bfd) + TOC_BASE_OFF,
14934                   htab->elf.sgot->contents);
14935
14936       /* Set .got entry size.  */
14937       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14938     }
14939
14940   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14941     {
14942       /* Set .plt entry size.  */
14943       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14944         = PLT_ENTRY_SIZE (htab);
14945     }
14946
14947   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14948      brlt ourselves if emitrelocations.  */
14949   if (htab->brlt != NULL
14950       && htab->brlt->reloc_count != 0
14951       && !_bfd_elf_link_output_relocs (output_bfd,
14952                                        htab->brlt,
14953                                        elf_section_data (htab->brlt)->rela.hdr,
14954                                        elf_section_data (htab->brlt)->relocs,
14955                                        NULL))
14956     return FALSE;
14957
14958   if (htab->glink != NULL
14959       && htab->glink->reloc_count != 0
14960       && !_bfd_elf_link_output_relocs (output_bfd,
14961                                        htab->glink,
14962                                        elf_section_data (htab->glink)->rela.hdr,
14963                                        elf_section_data (htab->glink)->relocs,
14964                                        NULL))
14965     return FALSE;
14966
14967
14968   if (htab->glink_eh_frame != NULL
14969       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14970       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14971                                            htab->glink_eh_frame,
14972                                            htab->glink_eh_frame->contents))
14973     return FALSE;
14974
14975   /* We need to handle writing out multiple GOT sections ourselves,
14976      since we didn't add them to DYNOBJ.  We know dynobj is the first
14977      bfd.  */
14978   while ((dynobj = dynobj->link_next) != NULL)
14979     {
14980       asection *s;
14981
14982       if (!is_ppc64_elf (dynobj))
14983         continue;
14984
14985       s = ppc64_elf_tdata (dynobj)->got;
14986       if (s != NULL
14987           && s->size != 0
14988           && s->output_section != bfd_abs_section_ptr
14989           && !bfd_set_section_contents (output_bfd, s->output_section,
14990                                         s->contents, s->output_offset,
14991                                         s->size))
14992         return FALSE;
14993       s = ppc64_elf_tdata (dynobj)->relgot;
14994       if (s != NULL
14995           && s->size != 0
14996           && s->output_section != bfd_abs_section_ptr
14997           && !bfd_set_section_contents (output_bfd, s->output_section,
14998                                         s->contents, s->output_offset,
14999                                         s->size))
15000         return FALSE;
15001     }
15002
15003   return TRUE;
15004 }
15005
15006 #include "elf64-target.h"
15007
15008 /* FreeBSD support */
15009
15010 #undef  TARGET_LITTLE_SYM
15011 #undef  TARGET_LITTLE_NAME
15012
15013 #undef  TARGET_BIG_SYM
15014 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15015 #undef  TARGET_BIG_NAME
15016 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15017
15018 #undef  ELF_OSABI
15019 #define ELF_OSABI       ELFOSABI_FREEBSD
15020
15021 #undef  elf64_bed
15022 #define elf64_bed       elf64_powerpc_fbsd_bed
15023
15024 #include "elf64-target.h"
15025