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