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.  ABIv2 does not have a linker word, so use the
 137    CR save slot.  Used only by optimised __tls_get_addr call stub,
 138    relying on __tls_get_addr_opt not saving CR..  */
 139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 140
 141 /* TOC base pointers offset from start of TOC.  */
 142 #define TOC_BASE_OFF    0x8000
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176
 177 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 178 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 179
 180 /* glink call stub instructions.  We enter with the index in R0.  */
 181 #define GLINK_CALL_STUB_SIZE (16*4)
 182                                         /* 0:                           */
 183                                         /*  .quad plt0-1f               */
 184                                         /* __glink:                     */
 185 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 186 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 187                                         /* 1:                           */
 188 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 189                                         /*  ld %2,(0b-1b)(%11)          */
 190 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 191 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 192                                         /*  ld %12,0(%11)               */
 193                                         /*  ld %2,8(%11)                */
 194                                         /*  mtctr %12                   */
 195                                         /*  ld %11,16(%11)              */
 196                                         /*  bctr                        */
 197 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 198 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 199 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 200 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 201 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 202
 203 /* Pad with this.  */
 204 #define NOP             0x60000000
 205
 206 /* Some other nops.  */
 207 #define CROR_151515     0x4def7b82
 208 #define CROR_313131     0x4ffffb82
 209
 210 /* .glink entries for the first 32k functions are two instructions.  */
 211 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 212 #define B_DOT           0x48000000      /* b     .              */
 213
 214 /* After that, we need two instructions to load the index, followed by
 215    a branch.  */
 216 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 217 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 218
 219 /* Instructions used by the save and restore reg functions.  */
 220 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 221 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 222 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 223 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 224 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 225 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 226 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 227 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 228 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 229 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 230 #define BLR             0x4e800020      /* blr                  */
 231
 232 /* Since .opd is an array of descriptors and each entry will end up
 233    with identical R_PPC64_RELATIVE relocs, there is really no need to
 234    propagate .opd relocs;  The dynamic linker should be taught to
 235    relocate .opd without reloc entries.  */
 236 #ifndef NO_OPD_RELOCS
 237 #define NO_OPD_RELOCS 0
 238 #endif
 239 \f
 240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 241
 242 /* Relocation HOWTO's.  */
 243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 244
 245 static reloc_howto_type ppc64_elf_howto_raw[] = {
 246   /* This reloc does nothing.  */
 247   HOWTO (R_PPC64_NONE,          /* type */
 248          0,                     /* rightshift */
 249          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          32,                    /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_dont, /* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_PPC64_NONE",        /* name */
 256          FALSE,                 /* partial_inplace */
 257          0,                     /* src_mask */
 258          0,                     /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* A standard 32 bit relocation.  */
 262   HOWTO (R_PPC64_ADDR32,        /* type */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          32,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield, /* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_PPC64_ADDR32",      /* name */
 271          FALSE,                 /* partial_inplace */
 272          0,                     /* src_mask */
 273          0xffffffff,            /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* An absolute 26 bit branch; the lower two bits must be zero.
 277      FIXME: we don't check that, we just clear them.  */
 278   HOWTO (R_PPC64_ADDR24,        /* type */
 279          0,                     /* rightshift */
 280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          26,                    /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_bitfield, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_ADDR24",      /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0x03fffffc,            /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 16 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR16,        /* type */
 294          0,                     /* rightshift */
 295          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          16,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR16",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffff,                /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* A 16 bit relocation without overflow.  */
 308   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 309          0,                     /* rightshift */
 310          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          16,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_dont,/* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_PPC64_ADDR16_LO",   /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0xffff,                /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   /* Bits 16-31 of an address.  */
 323   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 324          16,                    /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_signed, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_PPC64_ADDR16_HI",   /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 338      bits, treated as a signed number, is negative.  */
 339   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 340          16,                    /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_signed, /* complain_on_overflow */
 346          ppc64_elf_ha_reloc,    /* special_function */
 347          "R_PPC64_ADDR16_HA",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* An absolute 16 bit branch; the lower two bits must be zero.
 354      FIXME: we don't check that, we just clear them.  */
 355   HOWTO (R_PPC64_ADDR14,        /* type */
 356          0,                     /* rightshift */
 357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          FALSE,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_bitfield, /* complain_on_overflow */
 362          ppc64_elf_branch_reloc, /* special_function */
 363          "R_PPC64_ADDR14",      /* name */
 364          FALSE,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0x0000fffc,            /* dst_mask */
 367          FALSE),                /* pcrel_offset */
 368
 369   /* An absolute 16 bit branch, for which bit 10 should be set to
 370      indicate that the branch is expected to be taken.  The lower two
 371      bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          16,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_bitfield, /* complain_on_overflow */
 379          ppc64_elf_brtaken_reloc, /* special_function */
 380          "R_PPC64_ADDR14_BRTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* An absolute 16 bit branch, for which bit 10 should be set to
 387      indicate that the branch is not expected to be taken.  The lower
 388      two bits must be zero.  */
 389   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 390          0,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          16,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_bitfield, /* complain_on_overflow */
 396          ppc64_elf_brtaken_reloc, /* special_function */
 397          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 398          FALSE,                 /* partial_inplace */
 399          0,                     /* src_mask */
 400          0x0000fffc,            /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403   /* A relative 26 bit branch; the lower two bits must be zero.  */
 404   HOWTO (R_PPC64_REL24,         /* type */
 405          0,                     /* rightshift */
 406          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          26,                    /* bitsize */
 408          TRUE,                  /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_signed, /* complain_on_overflow */
 411          ppc64_elf_branch_reloc, /* special_function */
 412          "R_PPC64_REL24",       /* name */
 413          FALSE,                 /* partial_inplace */
 414          0,                     /* src_mask */
 415          0x03fffffc,            /* dst_mask */
 416          TRUE),                 /* pcrel_offset */
 417
 418   /* A relative 16 bit branch; the lower two bits must be zero.  */
 419   HOWTO (R_PPC64_REL14,         /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          TRUE,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_branch_reloc, /* special_function */
 427          "R_PPC64_REL14",       /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          TRUE),                 /* pcrel_offset */
 432
 433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 434      the branch is expected to be taken.  The lower two bits must be
 435      zero.  */
 436   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          ppc64_elf_brtaken_reloc, /* special_function */
 444          "R_PPC64_REL14_BRTAKEN", /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 451      the branch is not expected to be taken.  The lower two bits must
 452      be zero.  */
 453   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          16,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          ppc64_elf_brtaken_reloc, /* special_function */
 461          "R_PPC64_REL14_BRNTAKEN",/* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0x0000fffc,            /* dst_mask */
 465          TRUE),                 /* pcrel_offset */
 466
 467   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 468      symbol.  */
 469   HOWTO (R_PPC64_GOT16,         /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_signed, /* complain_on_overflow */
 476          ppc64_elf_unhandled_reloc, /* special_function */
 477          "R_PPC64_GOT16",       /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0xffff,                /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 484      the symbol.  */
 485   HOWTO (R_PPC64_GOT16_LO,      /* type */
 486          0,                     /* rightshift */
 487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          ppc64_elf_unhandled_reloc, /* special_function */
 493          "R_PPC64_GOT16_LO",    /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 500      the symbol.  */
 501   HOWTO (R_PPC64_GOT16_HI,      /* type */
 502          16,                    /* rightshift */
 503          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_signed,/* complain_on_overflow */
 508          ppc64_elf_unhandled_reloc, /* special_function */
 509          "R_PPC64_GOT16_HI",    /* name */
 510          FALSE,                 /* partial_inplace */
 511          0,                     /* src_mask */
 512          0xffff,                /* dst_mask */
 513          FALSE),                /* pcrel_offset */
 514
 515   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 516      the symbol.  */
 517   HOWTO (R_PPC64_GOT16_HA,      /* type */
 518          16,                    /* rightshift */
 519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 520          16,                    /* bitsize */
 521          FALSE,                 /* pc_relative */
 522          0,                     /* bitpos */
 523          complain_overflow_signed,/* complain_on_overflow */
 524          ppc64_elf_unhandled_reloc, /* special_function */
 525          "R_PPC64_GOT16_HA",    /* name */
 526          FALSE,                 /* partial_inplace */
 527          0,                     /* src_mask */
 528          0xffff,                /* dst_mask */
 529          FALSE),                /* pcrel_offset */
 530
 531   /* This is used only by the dynamic linker.  The symbol should exist
 532      both in the object being run and in some shared library.  The
 533      dynamic linker copies the data addressed by the symbol from the
 534      shared library into the object, because the object being
 535      run has to have the data at some particular address.  */
 536   HOWTO (R_PPC64_COPY,          /* type */
 537          0,                     /* rightshift */
 538          0,                     /* this one is variable size */
 539          0,                     /* bitsize */
 540          FALSE,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont, /* complain_on_overflow */
 543          ppc64_elf_unhandled_reloc, /* special_function */
 544          "R_PPC64_COPY",        /* name */
 545          FALSE,                 /* partial_inplace */
 546          0,                     /* src_mask */
 547          0,                     /* dst_mask */
 548          FALSE),                /* pcrel_offset */
 549
 550   /* Like R_PPC64_ADDR64, but used when setting global offset table
 551      entries.  */
 552   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 553          0,                     /* rightshift */
 554          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 555          64,                    /* bitsize */
 556          FALSE,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          ppc64_elf_unhandled_reloc,  /* special_function */
 560          "R_PPC64_GLOB_DAT",    /* name */
 561          FALSE,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          ONES (64),             /* dst_mask */
 564          FALSE),                /* pcrel_offset */
 565
 566   /* Created by the link editor.  Marks a procedure linkage table
 567      entry for a symbol.  */
 568   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 569          0,                     /* rightshift */
 570          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          0,                     /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          ppc64_elf_unhandled_reloc, /* special_function */
 576          "R_PPC64_JMP_SLOT",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          0,                     /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Used only by the dynamic linker.  When the object is run, this
 583      doubleword64 is set to the load address of the object, plus the
 584      addend.  */
 585   HOWTO (R_PPC64_RELATIVE,      /* type */
 586          0,                     /* rightshift */
 587          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 588          64,                    /* bitsize */
 589          FALSE,                 /* pc_relative */
 590          0,                     /* bitpos */
 591          complain_overflow_dont, /* complain_on_overflow */
 592          bfd_elf_generic_reloc, /* special_function */
 593          "R_PPC64_RELATIVE",    /* name */
 594          FALSE,                 /* partial_inplace */
 595          0,                     /* src_mask */
 596          ONES (64),             /* dst_mask */
 597          FALSE),                /* pcrel_offset */
 598
 599   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 600   HOWTO (R_PPC64_UADDR32,       /* type */
 601          0,                     /* rightshift */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 603          32,                    /* bitsize */
 604          FALSE,                 /* pc_relative */
 605          0,                     /* bitpos */
 606          complain_overflow_bitfield, /* complain_on_overflow */
 607          bfd_elf_generic_reloc, /* special_function */
 608          "R_PPC64_UADDR32",     /* name */
 609          FALSE,                 /* partial_inplace */
 610          0,                     /* src_mask */
 611          0xffffffff,            /* dst_mask */
 612          FALSE),                /* pcrel_offset */
 613
 614   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 615   HOWTO (R_PPC64_UADDR16,       /* type */
 616          0,                     /* rightshift */
 617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 618          16,                    /* bitsize */
 619          FALSE,                 /* pc_relative */
 620          0,                     /* bitpos */
 621          complain_overflow_bitfield, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_UADDR16",     /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          0xffff,                /* dst_mask */
 627          FALSE),                /* pcrel_offset */
 628
 629   /* 32-bit PC relative.  */
 630   HOWTO (R_PPC64_REL32,         /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          TRUE,                  /* pc_relative */
 635          0,                     /* bitpos */
 636          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 637          complain_overflow_signed, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_REL32",       /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          TRUE),                 /* pcrel_offset */
 644
 645   /* 32-bit relocation to the symbol's procedure linkage table.  */
 646   HOWTO (R_PPC64_PLT32,         /* type */
 647          0,                     /* rightshift */
 648          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          32,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          ppc64_elf_unhandled_reloc, /* special_function */
 654          "R_PPC64_PLT32",       /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffffffff,            /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 661      FIXME: R_PPC64_PLTREL32 not supported.  */
 662   HOWTO (R_PPC64_PLTREL32,      /* type */
 663          0,                     /* rightshift */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          32,                    /* bitsize */
 666          TRUE,                  /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_signed, /* complain_on_overflow */
 669          bfd_elf_generic_reloc, /* special_function */
 670          "R_PPC64_PLTREL32",    /* name */
 671          FALSE,                 /* partial_inplace */
 672          0,                     /* src_mask */
 673          0xffffffff,            /* dst_mask */
 674          TRUE),                 /* pcrel_offset */
 675
 676   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 677      the symbol.  */
 678   HOWTO (R_PPC64_PLT16_LO,      /* type */
 679          0,                     /* rightshift */
 680          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          16,                    /* bitsize */
 682          FALSE,                 /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_dont, /* complain_on_overflow */
 685          ppc64_elf_unhandled_reloc, /* special_function */
 686          "R_PPC64_PLT16_LO",    /* name */
 687          FALSE,                 /* partial_inplace */
 688          0,                     /* src_mask */
 689          0xffff,                /* dst_mask */
 690          FALSE),                /* pcrel_offset */
 691
 692   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 693      the symbol.  */
 694   HOWTO (R_PPC64_PLT16_HI,      /* type */
 695          16,                    /* rightshift */
 696          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          16,                    /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_signed, /* complain_on_overflow */
 701          ppc64_elf_unhandled_reloc, /* special_function */
 702          "R_PPC64_PLT16_HI",    /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0xffff,                /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 709      the symbol.  */
 710   HOWTO (R_PPC64_PLT16_HA,      /* type */
 711          16,                    /* rightshift */
 712          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          16,                    /* bitsize */
 714          FALSE,                 /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_signed, /* complain_on_overflow */
 717          ppc64_elf_unhandled_reloc, /* special_function */
 718          "R_PPC64_PLT16_HA",    /* name */
 719          FALSE,                 /* partial_inplace */
 720          0,                     /* src_mask */
 721          0xffff,                /* dst_mask */
 722          FALSE),                /* pcrel_offset */
 723
 724   /* 16-bit section relative relocation.  */
 725   HOWTO (R_PPC64_SECTOFF,       /* type */
 726          0,                     /* rightshift */
 727          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 728          16,                    /* bitsize */
 729          FALSE,                 /* pc_relative */
 730          0,                     /* bitpos */
 731          complain_overflow_bitfield, /* complain_on_overflow */
 732          ppc64_elf_sectoff_reloc, /* special_function */
 733          "R_PPC64_SECTOFF",     /* name */
 734          FALSE,                 /* partial_inplace */
 735          0,                     /* src_mask */
 736          0xffff,                /* dst_mask */
 737          FALSE),                /* pcrel_offset */
 738
 739   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 740   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 741          0,                     /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_dont, /* complain_on_overflow */
 747          ppc64_elf_sectoff_reloc, /* special_function */
 748          "R_PPC64_SECTOFF_LO",  /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit upper half section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 756          16,                    /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF_HI",  /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* 16-bit upper half adjusted section relative relocation.  */
 770   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 771          16,                    /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_signed, /* complain_on_overflow */
 777          ppc64_elf_sectoff_ha_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_HA",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 785   HOWTO (R_PPC64_REL30,         /* type */
 786          2,                     /* rightshift */
 787          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          30,                    /* bitsize */
 789          TRUE,                  /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_PPC64_REL30",       /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xfffffffc,            /* dst_mask */
 797          TRUE),                 /* pcrel_offset */
 798
 799   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 800
 801   /* A standard 64-bit relocation.  */
 802   HOWTO (R_PPC64_ADDR64,        /* type */
 803          0,                     /* rightshift */
 804          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 805          64,                    /* bitsize */
 806          FALSE,                 /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_dont, /* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_PPC64_ADDR64",      /* name */
 811          FALSE,                 /* partial_inplace */
 812          0,                     /* src_mask */
 813          ONES (64),             /* dst_mask */
 814          FALSE),                /* pcrel_offset */
 815
 816   /* The bits 32-47 of an address.  */
 817   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 818          32,                    /* rightshift */
 819          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 820          16,                    /* bitsize */
 821          FALSE,                 /* pc_relative */
 822          0,                     /* bitpos */
 823          complain_overflow_dont, /* complain_on_overflow */
 824          bfd_elf_generic_reloc, /* special_function */
 825          "R_PPC64_ADDR16_HIGHER", /* name */
 826          FALSE,                 /* partial_inplace */
 827          0,                     /* src_mask */
 828          0xffff,                /* dst_mask */
 829          FALSE),                /* pcrel_offset */
 830
 831   /* The bits 32-47 of an address, plus 1 if the contents of the low
 832      16 bits, treated as a signed number, is negative.  */
 833   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 834          32,                    /* rightshift */
 835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 836          16,                    /* bitsize */
 837          FALSE,                 /* pc_relative */
 838          0,                     /* bitpos */
 839          complain_overflow_dont, /* complain_on_overflow */
 840          ppc64_elf_ha_reloc,    /* special_function */
 841          "R_PPC64_ADDR16_HIGHERA", /* name */
 842          FALSE,                 /* partial_inplace */
 843          0,                     /* src_mask */
 844          0xffff,                /* dst_mask */
 845          FALSE),                /* pcrel_offset */
 846
 847   /* The bits 48-63 of an address.  */
 848   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 849          48,                    /* rightshift */
 850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 851          16,                    /* bitsize */
 852          FALSE,                 /* pc_relative */
 853          0,                     /* bitpos */
 854          complain_overflow_dont, /* complain_on_overflow */
 855          bfd_elf_generic_reloc, /* special_function */
 856          "R_PPC64_ADDR16_HIGHEST", /* name */
 857          FALSE,                 /* partial_inplace */
 858          0,                     /* src_mask */
 859          0xffff,                /* dst_mask */
 860          FALSE),                /* pcrel_offset */
 861
 862   /* The bits 48-63 of an address, plus 1 if the contents of the low
 863      16 bits, treated as a signed number, is negative.  */
 864   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 865          48,                    /* rightshift */
 866          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          16,                    /* bitsize */
 868          FALSE,                 /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_dont, /* complain_on_overflow */
 871          ppc64_elf_ha_reloc,    /* special_function */
 872          "R_PPC64_ADDR16_HIGHESTA", /* name */
 873          FALSE,                 /* partial_inplace */
 874          0,                     /* src_mask */
 875          0xffff,                /* dst_mask */
 876          FALSE),                /* pcrel_offset */
 877
 878   /* Like ADDR64, but may be unaligned.  */
 879   HOWTO (R_PPC64_UADDR64,       /* type */
 880          0,                     /* rightshift */
 881          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 882          64,                    /* bitsize */
 883          FALSE,                 /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_dont, /* complain_on_overflow */
 886          bfd_elf_generic_reloc, /* special_function */
 887          "R_PPC64_UADDR64",     /* name */
 888          FALSE,                 /* partial_inplace */
 889          0,                     /* src_mask */
 890          ONES (64),             /* dst_mask */
 891          FALSE),                /* pcrel_offset */
 892
 893   /* 64-bit relative relocation.  */
 894   HOWTO (R_PPC64_REL64,         /* type */
 895          0,                     /* rightshift */
 896          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 897          64,                    /* bitsize */
 898          TRUE,                  /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          bfd_elf_generic_reloc, /* special_function */
 902          "R_PPC64_REL64",       /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          ONES (64),             /* dst_mask */
 906          TRUE),                 /* pcrel_offset */
 907
 908   /* 64-bit relocation to the symbol's procedure linkage table.  */
 909   HOWTO (R_PPC64_PLT64,         /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          ppc64_elf_unhandled_reloc, /* special_function */
 917          "R_PPC64_PLT64",       /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit PC relative relocation to the symbol's procedure linkage
 924      table.  */
 925   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 926   HOWTO (R_PPC64_PLTREL64,      /* type */
 927          0,                     /* rightshift */
 928          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 929          64,                    /* bitsize */
 930          TRUE,                  /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_dont, /* complain_on_overflow */
 933          ppc64_elf_unhandled_reloc, /* special_function */
 934          "R_PPC64_PLTREL64",    /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          ONES (64),             /* dst_mask */
 938          TRUE),                 /* pcrel_offset */
 939
 940   /* 16 bit TOC-relative relocation.  */
 941
 942   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 943   HOWTO (R_PPC64_TOC16,         /* type */
 944          0,                     /* rightshift */
 945          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 946          16,                    /* bitsize */
 947          FALSE,                 /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_signed, /* complain_on_overflow */
 950          ppc64_elf_toc_reloc,   /* special_function */
 951          "R_PPC64_TOC16",       /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          0xffff,                /* dst_mask */
 955          FALSE),                /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation without overflow.  */
 958
 959   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 960   HOWTO (R_PPC64_TOC16_LO,      /* type */
 961          0,                     /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_dont, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16_LO",    /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation, high 16 bits.  */
 975
 976   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 977   HOWTO (R_PPC64_TOC16_HI,      /* type */
 978          16,                    /* rightshift */
 979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          16,                    /* bitsize */
 981          FALSE,                 /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_signed, /* complain_on_overflow */
 984          ppc64_elf_toc_reloc,   /* special_function */
 985          "R_PPC64_TOC16_HI",    /* name */
 986          FALSE,                 /* partial_inplace */
 987          0,                     /* src_mask */
 988          0xffff,                /* dst_mask */
 989          FALSE),                /* pcrel_offset */
 990
 991   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 992      contents of the low 16 bits, treated as a signed number, is
 993      negative.  */
 994
 995   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 996   HOWTO (R_PPC64_TOC16_HA,      /* type */
 997          16,                    /* rightshift */
 998          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 999          16,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_signed, /* complain_on_overflow */
1003          ppc64_elf_toc_ha_reloc, /* special_function */
1004          "R_PPC64_TOC16_HA",    /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          0xffff,                /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1011
1012   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1013   HOWTO (R_PPC64_TOC,           /* type */
1014          0,                     /* rightshift */
1015          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1016          64,                    /* bitsize */
1017          FALSE,                 /* pc_relative */
1018          0,                     /* bitpos */
1019          complain_overflow_bitfield, /* complain_on_overflow */
1020          ppc64_elf_toc64_reloc, /* special_function */
1021          "R_PPC64_TOC",         /* name */
1022          FALSE,                 /* partial_inplace */
1023          0,                     /* src_mask */
1024          ONES (64),             /* dst_mask */
1025          FALSE),                /* pcrel_offset */
1026
1027   /* Like R_PPC64_GOT16, but also informs the link editor that the
1028      value to relocate may (!) refer to a PLT entry which the link
1029      editor (a) may replace with the symbol value.  If the link editor
1030      is unable to fully resolve the symbol, it may (b) create a PLT
1031      entry and store the address to the new PLT entry in the GOT.
1032      This permits lazy resolution of function symbols at run time.
1033      The link editor may also skip all of this and just (c) emit a
1034      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1035   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1036     HOWTO (R_PPC64_PLTGOT16,    /* type */
1037          0,                     /* rightshift */
1038          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1039          16,                    /* bitsize */
1040          FALSE,                 /* pc_relative */
1041          0,                     /* bitpos */
1042          complain_overflow_signed, /* complain_on_overflow */
1043          ppc64_elf_unhandled_reloc, /* special_function */
1044          "R_PPC64_PLTGOT16",    /* name */
1045          FALSE,                 /* partial_inplace */
1046          0,                     /* src_mask */
1047          0xffff,                /* dst_mask */
1048          FALSE),                /* pcrel_offset */
1049
1050   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1051   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1052   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1053          0,                     /* rightshift */
1054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1055          16,                    /* bitsize */
1056          FALSE,                 /* pc_relative */
1057          0,                     /* bitpos */
1058          complain_overflow_dont, /* complain_on_overflow */
1059          ppc64_elf_unhandled_reloc, /* special_function */
1060          "R_PPC64_PLTGOT16_LO", /* name */
1061          FALSE,                 /* partial_inplace */
1062          0,                     /* src_mask */
1063          0xffff,                /* dst_mask */
1064          FALSE),                /* pcrel_offset */
1065
1066   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1067   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1068   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1069          16,                    /* rightshift */
1070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1071          16,                    /* bitsize */
1072          FALSE,                 /* pc_relative */
1073          0,                     /* bitpos */
1074          complain_overflow_signed, /* complain_on_overflow */
1075          ppc64_elf_unhandled_reloc, /* special_function */
1076          "R_PPC64_PLTGOT16_HI", /* name */
1077          FALSE,                 /* partial_inplace */
1078          0,                     /* src_mask */
1079          0xffff,                /* dst_mask */
1080          FALSE),                /* pcrel_offset */
1081
1082   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083      1 if the contents of the low 16 bits, treated as a signed number,
1084      is negative.  */
1085   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1086   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1087          16,                    /* rightshift */
1088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1089          16,                    /* bitsize */
1090          FALSE,                 /* pc_relative */
1091          0,                     /* bitpos */
1092          complain_overflow_signed, /* complain_on_overflow */
1093          ppc64_elf_unhandled_reloc, /* special_function */
1094          "R_PPC64_PLTGOT16_HA", /* name */
1095          FALSE,                 /* partial_inplace */
1096          0,                     /* src_mask */
1097          0xffff,                /* dst_mask */
1098          FALSE),                /* pcrel_offset */
1099
1100   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1101   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1102          0,                     /* rightshift */
1103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1104          16,                    /* bitsize */
1105          FALSE,                 /* pc_relative */
1106          0,                     /* bitpos */
1107          complain_overflow_bitfield, /* complain_on_overflow */
1108          bfd_elf_generic_reloc, /* special_function */
1109          "R_PPC64_ADDR16_DS",   /* name */
1110          FALSE,                 /* partial_inplace */
1111          0,                     /* src_mask */
1112          0xfffc,                /* dst_mask */
1113          FALSE),                /* pcrel_offset */
1114
1115   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1116   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1117          0,                     /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_dont,/* complain_on_overflow */
1123          bfd_elf_generic_reloc, /* special_function */
1124          "R_PPC64_ADDR16_LO_DS",/* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xfffc,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_GOT16_DS,      /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          ppc64_elf_unhandled_reloc, /* special_function */
1139          "R_PPC64_GOT16_DS",    /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont, /* complain_on_overflow */
1153          ppc64_elf_unhandled_reloc, /* special_function */
1154          "R_PPC64_GOT16_LO_DS", /* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_PLT16_LO_DS", /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_bitfield, /* complain_on_overflow */
1183          ppc64_elf_sectoff_reloc, /* special_function */
1184          "R_PPC64_SECTOFF_DS",  /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_sectoff_reloc, /* special_function */
1199          "R_PPC64_SECTOFF_LO_DS",/* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_TOC16_DS,      /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_toc_reloc,   /* special_function */
1214          "R_PPC64_TOC16_DS",    /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_toc_reloc,   /* special_function */
1229          "R_PPC64_TOC16_LO_DS", /* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1236   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1237   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1238          0,                     /* rightshift */
1239          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1240          16,                    /* bitsize */
1241          FALSE,                 /* pc_relative */
1242          0,                     /* bitpos */
1243          complain_overflow_signed, /* complain_on_overflow */
1244          ppc64_elf_unhandled_reloc, /* special_function */
1245          "R_PPC64_PLTGOT16_DS", /* name */
1246          FALSE,                 /* partial_inplace */
1247          0,                     /* src_mask */
1248          0xfffc,                /* dst_mask */
1249          FALSE),                /* pcrel_offset */
1250
1251   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1252   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1253   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1254          0,                     /* rightshift */
1255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1256          16,                    /* bitsize */
1257          FALSE,                 /* pc_relative */
1258          0,                     /* bitpos */
1259          complain_overflow_dont, /* complain_on_overflow */
1260          ppc64_elf_unhandled_reloc, /* special_function */
1261          "R_PPC64_PLTGOT16_LO_DS",/* name */
1262          FALSE,                 /* partial_inplace */
1263          0,                     /* src_mask */
1264          0xfffc,                /* dst_mask */
1265          FALSE),                /* pcrel_offset */
1266
1267   /* Marker relocs for TLS.  */
1268   HOWTO (R_PPC64_TLS,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLS",         /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   HOWTO (R_PPC64_TLSGD,
1283          0,                     /* rightshift */
1284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1285          32,                    /* bitsize */
1286          FALSE,                 /* pc_relative */
1287          0,                     /* bitpos */
1288          complain_overflow_dont, /* complain_on_overflow */
1289          bfd_elf_generic_reloc, /* special_function */
1290          "R_PPC64_TLSGD",       /* name */
1291          FALSE,                 /* partial_inplace */
1292          0,                     /* src_mask */
1293          0,                     /* dst_mask */
1294          FALSE),                /* pcrel_offset */
1295
1296   HOWTO (R_PPC64_TLSLD,
1297          0,                     /* rightshift */
1298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1299          32,                    /* bitsize */
1300          FALSE,                 /* pc_relative */
1301          0,                     /* bitpos */
1302          complain_overflow_dont, /* complain_on_overflow */
1303          bfd_elf_generic_reloc, /* special_function */
1304          "R_PPC64_TLSLD",       /* name */
1305          FALSE,                 /* partial_inplace */
1306          0,                     /* src_mask */
1307          0,                     /* dst_mask */
1308          FALSE),                /* pcrel_offset */
1309
1310   HOWTO (R_PPC64_TOCSAVE,
1311          0,                     /* rightshift */
1312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1313          32,                    /* bitsize */
1314          FALSE,                 /* pc_relative */
1315          0,                     /* bitpos */
1316          complain_overflow_dont, /* complain_on_overflow */
1317          bfd_elf_generic_reloc, /* special_function */
1318          "R_PPC64_TOCSAVE",     /* name */
1319          FALSE,                 /* partial_inplace */
1320          0,                     /* src_mask */
1321          0,                     /* dst_mask */
1322          FALSE),                /* pcrel_offset */
1323
1324   /* Computes the load module index of the load module that contains the
1325      definition of its TLS sym.  */
1326   HOWTO (R_PPC64_DTPMOD64,
1327          0,                     /* rightshift */
1328          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          64,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          ppc64_elf_unhandled_reloc, /* special_function */
1334          "R_PPC64_DTPMOD64",    /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          ONES (64),             /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Computes a dtv-relative displacement, the difference between the value
1341      of sym+add and the base address of the thread-local storage block that
1342      contains the definition of sym, minus 0x8000.  */
1343   HOWTO (R_PPC64_DTPREL64,
1344          0,                     /* rightshift */
1345          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          64,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont, /* complain_on_overflow */
1350          ppc64_elf_unhandled_reloc, /* special_function */
1351          "R_PPC64_DTPREL64",    /* name */
1352          FALSE,                 /* partial_inplace */
1353          0,                     /* src_mask */
1354          ONES (64),             /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* A 16 bit dtprel reloc.  */
1358   HOWTO (R_PPC64_DTPREL16,
1359          0,                     /* rightshift */
1360          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1361          16,                    /* bitsize */
1362          FALSE,                 /* pc_relative */
1363          0,                     /* bitpos */
1364          complain_overflow_signed, /* complain_on_overflow */
1365          ppc64_elf_unhandled_reloc, /* special_function */
1366          "R_PPC64_DTPREL16",    /* name */
1367          FALSE,                 /* partial_inplace */
1368          0,                     /* src_mask */
1369          0xffff,                /* dst_mask */
1370          FALSE),                /* pcrel_offset */
1371
1372   /* Like DTPREL16, but no overflow.  */
1373   HOWTO (R_PPC64_DTPREL16_LO,
1374          0,                     /* rightshift */
1375          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1376          16,                    /* bitsize */
1377          FALSE,                 /* pc_relative */
1378          0,                     /* bitpos */
1379          complain_overflow_dont, /* complain_on_overflow */
1380          ppc64_elf_unhandled_reloc, /* special_function */
1381          "R_PPC64_DTPREL16_LO", /* name */
1382          FALSE,                 /* partial_inplace */
1383          0,                     /* src_mask */
1384          0xffff,                /* dst_mask */
1385          FALSE),                /* pcrel_offset */
1386
1387   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1388   HOWTO (R_PPC64_DTPREL16_HI,
1389          16,                    /* rightshift */
1390          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1391          16,                    /* bitsize */
1392          FALSE,                 /* pc_relative */
1393          0,                     /* bitpos */
1394          complain_overflow_signed, /* complain_on_overflow */
1395          ppc64_elf_unhandled_reloc, /* special_function */
1396          "R_PPC64_DTPREL16_HI", /* name */
1397          FALSE,                 /* partial_inplace */
1398          0,                     /* src_mask */
1399          0xffff,                /* dst_mask */
1400          FALSE),                /* pcrel_offset */
1401
1402   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1403   HOWTO (R_PPC64_DTPREL16_HA,
1404          16,                    /* rightshift */
1405          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1406          16,                    /* bitsize */
1407          FALSE,                 /* pc_relative */
1408          0,                     /* bitpos */
1409          complain_overflow_signed, /* complain_on_overflow */
1410          ppc64_elf_unhandled_reloc, /* special_function */
1411          "R_PPC64_DTPREL16_HA", /* name */
1412          FALSE,                 /* partial_inplace */
1413          0,                     /* src_mask */
1414          0xffff,                /* dst_mask */
1415          FALSE),                /* pcrel_offset */
1416
1417   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1418   HOWTO (R_PPC64_DTPREL16_HIGHER,
1419          32,                    /* rightshift */
1420          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1421          16,                    /* bitsize */
1422          FALSE,                 /* pc_relative */
1423          0,                     /* bitpos */
1424          complain_overflow_dont, /* complain_on_overflow */
1425          ppc64_elf_unhandled_reloc, /* special_function */
1426          "R_PPC64_DTPREL16_HIGHER", /* name */
1427          FALSE,                 /* partial_inplace */
1428          0,                     /* src_mask */
1429          0xffff,                /* dst_mask */
1430          FALSE),                /* pcrel_offset */
1431
1432   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1433   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434          32,                    /* rightshift */
1435          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1436          16,                    /* bitsize */
1437          FALSE,                 /* pc_relative */
1438          0,                     /* bitpos */
1439          complain_overflow_dont, /* complain_on_overflow */
1440          ppc64_elf_unhandled_reloc, /* special_function */
1441          "R_PPC64_DTPREL16_HIGHERA", /* name */
1442          FALSE,                 /* partial_inplace */
1443          0,                     /* src_mask */
1444          0xffff,                /* dst_mask */
1445          FALSE),                /* pcrel_offset */
1446
1447   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1448   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449          48,                    /* rightshift */
1450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          16,                    /* bitsize */
1452          FALSE,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_dont, /* complain_on_overflow */
1455          ppc64_elf_unhandled_reloc, /* special_function */
1456          "R_PPC64_DTPREL16_HIGHEST", /* name */
1457          FALSE,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0xffff,                /* dst_mask */
1460          FALSE),                /* pcrel_offset */
1461
1462   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1463   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464          48,                    /* rightshift */
1465          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1466          16,                    /* bitsize */
1467          FALSE,                 /* pc_relative */
1468          0,                     /* bitpos */
1469          complain_overflow_dont, /* complain_on_overflow */
1470          ppc64_elf_unhandled_reloc, /* special_function */
1471          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472          FALSE,                 /* partial_inplace */
1473          0,                     /* src_mask */
1474          0xffff,                /* dst_mask */
1475          FALSE),                /* pcrel_offset */
1476
1477   /* Like DTPREL16, but for insns with a DS field.  */
1478   HOWTO (R_PPC64_DTPREL16_DS,
1479          0,                     /* rightshift */
1480          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1481          16,                    /* bitsize */
1482          FALSE,                 /* pc_relative */
1483          0,                     /* bitpos */
1484          complain_overflow_signed, /* complain_on_overflow */
1485          ppc64_elf_unhandled_reloc, /* special_function */
1486          "R_PPC64_DTPREL16_DS", /* name */
1487          FALSE,                 /* partial_inplace */
1488          0,                     /* src_mask */
1489          0xfffc,                /* dst_mask */
1490          FALSE),                /* pcrel_offset */
1491
1492   /* Like DTPREL16_DS, but no overflow.  */
1493   HOWTO (R_PPC64_DTPREL16_LO_DS,
1494          0,                     /* rightshift */
1495          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          16,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont, /* complain_on_overflow */
1500          ppc64_elf_unhandled_reloc, /* special_function */
1501          "R_PPC64_DTPREL16_LO_DS", /* name */
1502          FALSE,                 /* partial_inplace */
1503          0,                     /* src_mask */
1504          0xfffc,                /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   /* Computes a tp-relative displacement, the difference between the value of
1508      sym+add and the value of the thread pointer (r13).  */
1509   HOWTO (R_PPC64_TPREL64,
1510          0,                     /* rightshift */
1511          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          64,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_TPREL64",     /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          ONES (64),             /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* A 16 bit tprel reloc.  */
1524   HOWTO (R_PPC64_TPREL16,
1525          0,                     /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_signed, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_TPREL16",     /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like TPREL16, but no overflow.  */
1539   HOWTO (R_PPC64_TPREL16_LO,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_dont, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_TPREL16_LO",  /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xffff,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1554   HOWTO (R_PPC64_TPREL16_HI,
1555          16,                    /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_signed, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_TPREL16_HI",  /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xffff,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1569   HOWTO (R_PPC64_TPREL16_HA,
1570          16,                    /* rightshift */
1571          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          16,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_signed, /* complain_on_overflow */
1576          ppc64_elf_unhandled_reloc, /* special_function */
1577          "R_PPC64_TPREL16_HA",  /* name */
1578          FALSE,                 /* partial_inplace */
1579          0,                     /* src_mask */
1580          0xffff,                /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582
1583   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1584   HOWTO (R_PPC64_TPREL16_HIGHER,
1585          32,                    /* rightshift */
1586          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          16,                    /* bitsize */
1588          FALSE,                 /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_dont, /* complain_on_overflow */
1591          ppc64_elf_unhandled_reloc, /* special_function */
1592          "R_PPC64_TPREL16_HIGHER",      /* name */
1593          FALSE,                 /* partial_inplace */
1594          0,                     /* src_mask */
1595          0xffff,                /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1599   HOWTO (R_PPC64_TPREL16_HIGHERA,
1600          32,                    /* rightshift */
1601          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1602          16,                    /* bitsize */
1603          FALSE,                 /* pc_relative */
1604          0,                     /* bitpos */
1605          complain_overflow_dont, /* complain_on_overflow */
1606          ppc64_elf_unhandled_reloc, /* special_function */
1607          "R_PPC64_TPREL16_HIGHERA", /* name */
1608          FALSE,                 /* partial_inplace */
1609          0,                     /* src_mask */
1610          0xffff,                /* dst_mask */
1611          FALSE),                /* pcrel_offset */
1612
1613   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1614   HOWTO (R_PPC64_TPREL16_HIGHEST,
1615          48,                    /* rightshift */
1616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          16,                    /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_dont, /* complain_on_overflow */
1621          ppc64_elf_unhandled_reloc, /* special_function */
1622          "R_PPC64_TPREL16_HIGHEST", /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0xffff,                /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1629   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630          48,                    /* rightshift */
1631          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1632          16,                    /* bitsize */
1633          FALSE,                 /* pc_relative */
1634          0,                     /* bitpos */
1635          complain_overflow_dont, /* complain_on_overflow */
1636          ppc64_elf_unhandled_reloc, /* special_function */
1637          "R_PPC64_TPREL16_HIGHESTA", /* name */
1638          FALSE,                 /* partial_inplace */
1639          0,                     /* src_mask */
1640          0xffff,                /* dst_mask */
1641          FALSE),                /* pcrel_offset */
1642
1643   /* Like TPREL16, but for insns with a DS field.  */
1644   HOWTO (R_PPC64_TPREL16_DS,
1645          0,                     /* rightshift */
1646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          16,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_signed, /* complain_on_overflow */
1651          ppc64_elf_unhandled_reloc, /* special_function */
1652          "R_PPC64_TPREL16_DS",  /* name */
1653          FALSE,                 /* partial_inplace */
1654          0,                     /* src_mask */
1655          0xfffc,                /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   /* Like TPREL16_DS, but no overflow.  */
1659   HOWTO (R_PPC64_TPREL16_LO_DS,
1660          0,                     /* rightshift */
1661          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1662          16,                    /* bitsize */
1663          FALSE,                 /* pc_relative */
1664          0,                     /* bitpos */
1665          complain_overflow_dont, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_TPREL16_LO_DS", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xfffc,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675      to the first entry relative to the TOC base (r2).  */
1676   HOWTO (R_PPC64_GOT_TLSGD16,
1677          0,                     /* rightshift */
1678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1679          16,                    /* bitsize */
1680          FALSE,                 /* pc_relative */
1681          0,                     /* bitpos */
1682          complain_overflow_signed, /* complain_on_overflow */
1683          ppc64_elf_unhandled_reloc, /* special_function */
1684          "R_PPC64_GOT_TLSGD16", /* name */
1685          FALSE,                 /* partial_inplace */
1686          0,                     /* src_mask */
1687          0xffff,                /* dst_mask */
1688          FALSE),                /* pcrel_offset */
1689
1690   /* Like GOT_TLSGD16, but no overflow.  */
1691   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1692          0,                     /* rightshift */
1693          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1694          16,                    /* bitsize */
1695          FALSE,                 /* pc_relative */
1696          0,                     /* bitpos */
1697          complain_overflow_dont, /* complain_on_overflow */
1698          ppc64_elf_unhandled_reloc, /* special_function */
1699          "R_PPC64_GOT_TLSGD16_LO", /* name */
1700          FALSE,                 /* partial_inplace */
1701          0,                     /* src_mask */
1702          0xffff,                /* dst_mask */
1703          FALSE),                /* pcrel_offset */
1704
1705   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1706   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707          16,                    /* rightshift */
1708          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1709          16,                    /* bitsize */
1710          FALSE,                 /* pc_relative */
1711          0,                     /* bitpos */
1712          complain_overflow_signed, /* complain_on_overflow */
1713          ppc64_elf_unhandled_reloc, /* special_function */
1714          "R_PPC64_GOT_TLSGD16_HI", /* name */
1715          FALSE,                 /* partial_inplace */
1716          0,                     /* src_mask */
1717          0xffff,                /* dst_mask */
1718          FALSE),                /* pcrel_offset */
1719
1720   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1721   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722          16,                    /* rightshift */
1723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1724          16,                    /* bitsize */
1725          FALSE,                 /* pc_relative */
1726          0,                     /* bitpos */
1727          complain_overflow_signed, /* complain_on_overflow */
1728          ppc64_elf_unhandled_reloc, /* special_function */
1729          "R_PPC64_GOT_TLSGD16_HA", /* name */
1730          FALSE,                 /* partial_inplace */
1731          0,                     /* src_mask */
1732          0xffff,                /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736      with values (sym+add)@dtpmod and zero, and computes the offset to the
1737      first entry relative to the TOC base (r2).  */
1738   HOWTO (R_PPC64_GOT_TLSLD16,
1739          0,                     /* rightshift */
1740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1741          16,                    /* bitsize */
1742          FALSE,                 /* pc_relative */
1743          0,                     /* bitpos */
1744          complain_overflow_signed, /* complain_on_overflow */
1745          ppc64_elf_unhandled_reloc, /* special_function */
1746          "R_PPC64_GOT_TLSLD16", /* name */
1747          FALSE,                 /* partial_inplace */
1748          0,                     /* src_mask */
1749          0xffff,                /* dst_mask */
1750          FALSE),                /* pcrel_offset */
1751
1752   /* Like GOT_TLSLD16, but no overflow.  */
1753   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1754          0,                     /* rightshift */
1755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1756          16,                    /* bitsize */
1757          FALSE,                 /* pc_relative */
1758          0,                     /* bitpos */
1759          complain_overflow_dont, /* complain_on_overflow */
1760          ppc64_elf_unhandled_reloc, /* special_function */
1761          "R_PPC64_GOT_TLSLD16_LO", /* name */
1762          FALSE,                 /* partial_inplace */
1763          0,                     /* src_mask */
1764          0xffff,                /* dst_mask */
1765          FALSE),                /* pcrel_offset */
1766
1767   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1768   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769          16,                    /* rightshift */
1770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1771          16,                    /* bitsize */
1772          FALSE,                 /* pc_relative */
1773          0,                     /* bitpos */
1774          complain_overflow_signed, /* complain_on_overflow */
1775          ppc64_elf_unhandled_reloc, /* special_function */
1776          "R_PPC64_GOT_TLSLD16_HI", /* name */
1777          FALSE,                 /* partial_inplace */
1778          0,                     /* src_mask */
1779          0xffff,                /* dst_mask */
1780          FALSE),                /* pcrel_offset */
1781
1782   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1783   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784          16,                    /* rightshift */
1785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1786          16,                    /* bitsize */
1787          FALSE,                 /* pc_relative */
1788          0,                     /* bitpos */
1789          complain_overflow_signed, /* complain_on_overflow */
1790          ppc64_elf_unhandled_reloc, /* special_function */
1791          "R_PPC64_GOT_TLSLD16_HA", /* name */
1792          FALSE,                 /* partial_inplace */
1793          0,                     /* src_mask */
1794          0xffff,                /* dst_mask */
1795          FALSE),                /* pcrel_offset */
1796
1797   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798      the offset to the entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_DTPREL16_DS", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xfffc,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_DTPREL16_DS, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xfffc,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_DTPREL16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_DTPREL16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859      offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_TPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_TPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_TPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_TPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_TPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_TPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_TPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   HOWTO (R_PPC64_JMP_IREL,      /* type */
1920          0,                     /* rightshift */
1921          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1922          0,                     /* bitsize */
1923          FALSE,                 /* pc_relative */
1924          0,                     /* bitpos */
1925          complain_overflow_dont, /* complain_on_overflow */
1926          ppc64_elf_unhandled_reloc, /* special_function */
1927          "R_PPC64_JMP_IREL",    /* name */
1928          FALSE,                 /* partial_inplace */
1929          0,                     /* src_mask */
1930          0,                     /* dst_mask */
1931          FALSE),                /* pcrel_offset */
1932
1933   HOWTO (R_PPC64_IRELATIVE,     /* type */
1934          0,                     /* rightshift */
1935          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1936          64,                    /* bitsize */
1937          FALSE,                 /* pc_relative */
1938          0,                     /* bitpos */
1939          complain_overflow_dont, /* complain_on_overflow */
1940          bfd_elf_generic_reloc, /* special_function */
1941          "R_PPC64_IRELATIVE",   /* name */
1942          FALSE,                 /* partial_inplace */
1943          0,                     /* src_mask */
1944          ONES (64),             /* dst_mask */
1945          FALSE),                /* pcrel_offset */
1946
1947   /* A 16 bit relative relocation.  */
1948   HOWTO (R_PPC64_REL16,         /* type */
1949          0,                     /* rightshift */
1950          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1951          16,                    /* bitsize */
1952          TRUE,                  /* pc_relative */
1953          0,                     /* bitpos */
1954          complain_overflow_bitfield, /* complain_on_overflow */
1955          bfd_elf_generic_reloc, /* special_function */
1956          "R_PPC64_REL16",       /* name */
1957          FALSE,                 /* partial_inplace */
1958          0,                     /* src_mask */
1959          0xffff,                /* dst_mask */
1960          TRUE),                 /* pcrel_offset */
1961
1962   /* A 16 bit relative relocation without overflow.  */
1963   HOWTO (R_PPC64_REL16_LO,      /* type */
1964          0,                     /* rightshift */
1965          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1966          16,                    /* bitsize */
1967          TRUE,                  /* pc_relative */
1968          0,                     /* bitpos */
1969          complain_overflow_dont,/* complain_on_overflow */
1970          bfd_elf_generic_reloc, /* special_function */
1971          "R_PPC64_REL16_LO",    /* name */
1972          FALSE,                 /* partial_inplace */
1973          0,                     /* src_mask */
1974          0xffff,                /* dst_mask */
1975          TRUE),                 /* pcrel_offset */
1976
1977   /* The high order 16 bits of a relative address.  */
1978   HOWTO (R_PPC64_REL16_HI,      /* type */
1979          16,                    /* rightshift */
1980          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1981          16,                    /* bitsize */
1982          TRUE,                  /* pc_relative */
1983          0,                     /* bitpos */
1984          complain_overflow_signed, /* complain_on_overflow */
1985          bfd_elf_generic_reloc, /* special_function */
1986          "R_PPC64_REL16_HI",    /* name */
1987          FALSE,                 /* partial_inplace */
1988          0,                     /* src_mask */
1989          0xffff,                /* dst_mask */
1990          TRUE),                 /* pcrel_offset */
1991
1992   /* The high order 16 bits of a relative address, plus 1 if the contents of
1993      the low 16 bits, treated as a signed number, is negative.  */
1994   HOWTO (R_PPC64_REL16_HA,      /* type */
1995          16,                    /* rightshift */
1996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1997          16,                    /* bitsize */
1998          TRUE,                  /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_signed, /* complain_on_overflow */
2001          ppc64_elf_ha_reloc,    /* special_function */
2002          "R_PPC64_REL16_HA",    /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          0xffff,                /* dst_mask */
2006          TRUE),                 /* pcrel_offset */
2007
2008   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2009   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2010          16,                    /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          FALSE,                 /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_dont, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_ADDR16_HIGH", /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          FALSE),                /* pcrel_offset */
2022
2023   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2024   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2025          16,                    /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          FALSE,                 /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont, /* complain_on_overflow */
2031          ppc64_elf_ha_reloc,    /* special_function */
2032          "R_PPC64_ADDR16_HIGHA",        /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          FALSE),                /* pcrel_offset */
2037
2038   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2039   HOWTO (R_PPC64_DTPREL16_HIGH,
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          FALSE,                 /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_dont, /* complain_on_overflow */
2046          ppc64_elf_unhandled_reloc, /* special_function */
2047          "R_PPC64_DTPREL16_HIGH", /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          FALSE),                /* pcrel_offset */
2052
2053   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2054   HOWTO (R_PPC64_DTPREL16_HIGHA,
2055          16,                    /* rightshift */
2056          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2057          16,                    /* bitsize */
2058          FALSE,                 /* pc_relative */
2059          0,                     /* bitpos */
2060          complain_overflow_dont, /* complain_on_overflow */
2061          ppc64_elf_unhandled_reloc, /* special_function */
2062          "R_PPC64_DTPREL16_HIGHA", /* name */
2063          FALSE,                 /* partial_inplace */
2064          0,                     /* src_mask */
2065          0xffff,                /* dst_mask */
2066          FALSE),                /* pcrel_offset */
2067
2068   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2069   HOWTO (R_PPC64_TPREL16_HIGH,
2070          16,                    /* rightshift */
2071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2072          16,                    /* bitsize */
2073          FALSE,                 /* pc_relative */
2074          0,                     /* bitpos */
2075          complain_overflow_dont, /* complain_on_overflow */
2076          ppc64_elf_unhandled_reloc, /* special_function */
2077          "R_PPC64_TPREL16_HIGH",        /* name */
2078          FALSE,                 /* partial_inplace */
2079          0,                     /* src_mask */
2080          0xffff,                /* dst_mask */
2081          FALSE),                /* pcrel_offset */
2082
2083   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2084   HOWTO (R_PPC64_TPREL16_HIGHA,
2085          16,                    /* rightshift */
2086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2087          16,                    /* bitsize */
2088          FALSE,                 /* pc_relative */
2089          0,                     /* bitpos */
2090          complain_overflow_dont, /* complain_on_overflow */
2091          ppc64_elf_unhandled_reloc, /* special_function */
2092          "R_PPC64_TPREL16_HIGHA",       /* name */
2093          FALSE,                 /* partial_inplace */
2094          0,                     /* src_mask */
2095          0xffff,                /* dst_mask */
2096          FALSE),                /* pcrel_offset */
2097
2098   /* GNU extension to record C++ vtable hierarchy.  */
2099   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2100          0,                     /* rightshift */
2101          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2102          0,                     /* bitsize */
2103          FALSE,                 /* pc_relative */
2104          0,                     /* bitpos */
2105          complain_overflow_dont, /* complain_on_overflow */
2106          NULL,                  /* special_function */
2107          "R_PPC64_GNU_VTINHERIT", /* name */
2108          FALSE,                 /* partial_inplace */
2109          0,                     /* src_mask */
2110          0,                     /* dst_mask */
2111          FALSE),                /* pcrel_offset */
2112
2113   /* GNU extension to record C++ vtable member usage.  */
2114   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2115          0,                     /* rightshift */
2116          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2117          0,                     /* bitsize */
2118          FALSE,                 /* pc_relative */
2119          0,                     /* bitpos */
2120          complain_overflow_dont, /* complain_on_overflow */
2121          NULL,                  /* special_function */
2122          "R_PPC64_GNU_VTENTRY", /* name */
2123          FALSE,                 /* partial_inplace */
2124          0,                     /* src_mask */
2125          0,                     /* dst_mask */
2126          FALSE),                /* pcrel_offset */
2127 };
2128
2129 \f
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2131    be done.  */
2132
2133 static void
2134 ppc_howto_init (void)
2135 {
2136   unsigned int i, type;
2137
2138   for (i = 0;
2139        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2140        i++)
2141     {
2142       type = ppc64_elf_howto_raw[i].type;
2143       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144                           / sizeof (ppc64_elf_howto_table[0])));
2145       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2146     }
2147 }
2148
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151                              bfd_reloc_code_real_type code)
2152 {
2153   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2154
2155   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156     /* Initialize howto table if needed.  */
2157     ppc_howto_init ();
2158
2159   switch (code)
2160     {
2161     default:
2162       return NULL;
2163
2164     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2165       break;
2166     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2167       break;
2168     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2169       break;
2170     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2171       break;
2172     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2173       break;
2174     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2175       break;
2176     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2177       break;
2178     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2179       break;
2180     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2181       break;
2182     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2183       break;
2184     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2185       break;
2186     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2187       break;
2188     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2189       break;
2190     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2191       break;
2192     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2193       break;
2194     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2195       break;
2196     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2197       break;
2198     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2199       break;
2200     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2201       break;
2202     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2203       break;
2204     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2205       break;
2206     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2207       break;
2208     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2209       break;
2210     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2211       break;
2212     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2213       break;
2214     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2215       break;
2216     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2217       break;
2218     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2219       break;
2220     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2221       break;
2222     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2223       break;
2224     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2225       break;
2226     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2227       break;
2228     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2229       break;
2230     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2231       break;
2232     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2233       break;
2234     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2235       break;
2236     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2237       break;
2238     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2239       break;
2240     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2241       break;
2242     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2243       break;
2244     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2245       break;
2246     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2247       break;
2248     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2249       break;
2250     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2251       break;
2252     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2253       break;
2254     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2255       break;
2256     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2257       break;
2258     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2259       break;
2260     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2261       break;
2262     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2263       break;
2264     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2265       break;
2266     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2267       break;
2268     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2269       break;
2270     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2271       break;
2272     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2273       break;
2274     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2275       break;
2276     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2287       break;
2288     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2289       break;
2290     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2291       break;
2292     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2293       break;
2294     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2295       break;
2296     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2297       break;
2298     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2299       break;
2300     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2301       break;
2302     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2303       break;
2304     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2305       break;
2306     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2307       break;
2308     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2309       break;
2310     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2321       break;
2322     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2323       break;
2324     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2325       break;
2326     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2327       break;
2328     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2329       break;
2330     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2331       break;
2332     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2333       break;
2334     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2345       break;
2346     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2347       break;
2348     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2351       break;
2352     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2353       break;
2354     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2355       break;
2356     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2357       break;
2358     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2359       break;
2360     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2361       break;
2362     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2363       break;
2364     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2365       break;
2366     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2367       break;
2368     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2371       break;
2372     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2373       break;
2374     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2375       break;
2376     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2377       break;
2378     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2379       break;
2380     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2381       break;
2382     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2383       break;
2384     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2385       break;
2386     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2387       break;
2388     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2389       break;
2390     }
2391
2392   return ppc64_elf_howto_table[r];
2393 };
2394
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2397                              const char *r_name)
2398 {
2399   unsigned int i;
2400
2401   for (i = 0;
2402        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2403        i++)
2404     if (ppc64_elf_howto_raw[i].name != NULL
2405         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406       return &ppc64_elf_howto_raw[i];
2407
2408   return NULL;
2409 }
2410
2411 /* Set the howto pointer for a PowerPC ELF reloc.  */
2412
2413 static void
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415                          Elf_Internal_Rela *dst)
2416 {
2417   unsigned int type;
2418
2419   /* Initialize howto table if needed.  */
2420   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2421     ppc_howto_init ();
2422
2423   type = ELF64_R_TYPE (dst->r_info);
2424   if (type >= (sizeof (ppc64_elf_howto_table)
2425                / sizeof (ppc64_elf_howto_table[0])))
2426     {
2427       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2428                              abfd, (int) type);
2429       type = R_PPC64_NONE;
2430     }
2431   cache_ptr->howto = ppc64_elf_howto_table[type];
2432 }
2433
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2435
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438                     void *data, asection *input_section,
2439                     bfd *output_bfd, char **error_message)
2440 {
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   /* Adjust the addend for sign extension of the low 16 bits.
2449      We won't actually be using the low 16 bits, so trashing them
2450      doesn't matter.  */
2451   reloc_entry->addend += 0x8000;
2452   return bfd_reloc_continue;
2453 }
2454
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457                         void *data, asection *input_section,
2458                         bfd *output_bfd, char **error_message)
2459 {
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462                                   input_section, output_bfd, error_message);
2463
2464   if (strcmp (symbol->section->name, ".opd") == 0
2465       && (symbol->section->owner->flags & DYNAMIC) == 0)
2466     {
2467       bfd_vma dest = opd_entry_value (symbol->section,
2468                                       symbol->value + reloc_entry->addend,
2469                                       NULL, NULL, FALSE);
2470       if (dest != (bfd_vma) -1)
2471         reloc_entry->addend = dest - (symbol->value
2472                                       + symbol->section->output_section->vma
2473                                       + symbol->section->output_offset);
2474     }
2475   return bfd_reloc_continue;
2476 }
2477
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480                          void *data, asection *input_section,
2481                          bfd *output_bfd, char **error_message)
2482 {
2483   long insn;
2484   enum elf_ppc64_reloc_type r_type;
2485   bfd_size_type octets;
2486   /* Assume 'at' branch hints.  */
2487   bfd_boolean is_isa_v2 = TRUE;
2488
2489   /* If this is a relocatable link (output_bfd test tells us), just
2490      call the generic function.  Any adjustment will be done at final
2491      link time.  */
2492   if (output_bfd != NULL)
2493     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494                                   input_section, output_bfd, error_message);
2495
2496   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498   insn &= ~(0x01 << 21);
2499   r_type = reloc_entry->howto->type;
2500   if (r_type == R_PPC64_ADDR14_BRTAKEN
2501       || r_type == R_PPC64_REL14_BRTAKEN)
2502     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2503
2504   if (is_isa_v2)
2505     {
2506       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2507          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2509       if ((insn & (0x14 << 21)) == (0x04 << 21))
2510         insn |= 0x02 << 21;
2511       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2512         insn |= 0x08 << 21;
2513       else
2514         goto out;
2515     }
2516   else
2517     {
2518       bfd_vma target = 0;
2519       bfd_vma from;
2520
2521       if (!bfd_is_com_section (symbol->section))
2522         target = symbol->value;
2523       target += symbol->section->output_section->vma;
2524       target += symbol->section->output_offset;
2525       target += reloc_entry->addend;
2526
2527       from = (reloc_entry->address
2528               + input_section->output_offset
2529               + input_section->output_section->vma);
2530
2531       /* Invert 'y' bit if not the default.  */
2532       if ((bfd_signed_vma) (target - from) < 0)
2533         insn ^= 0x01 << 21;
2534     }
2535   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2536  out:
2537   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538                                  input_section, output_bfd, error_message);
2539 }
2540
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543                          void *data, asection *input_section,
2544                          bfd *output_bfd, char **error_message)
2545 {
2546   /* If this is a relocatable link (output_bfd test tells us), just
2547      call the generic function.  Any adjustment will be done at final
2548      link time.  */
2549   if (output_bfd != NULL)
2550     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551                                   input_section, output_bfd, error_message);
2552
2553   /* Subtract the symbol section base address.  */
2554   reloc_entry->addend -= symbol->section->output_section->vma;
2555   return bfd_reloc_continue;
2556 }
2557
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560                             void *data, asection *input_section,
2561                             bfd *output_bfd, char **error_message)
2562 {
2563   /* If this is a relocatable link (output_bfd test tells us), just
2564      call the generic function.  Any adjustment will be done at final
2565      link time.  */
2566   if (output_bfd != NULL)
2567     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568                                   input_section, output_bfd, error_message);
2569
2570   /* Subtract the symbol section base address.  */
2571   reloc_entry->addend -= symbol->section->output_section->vma;
2572
2573   /* Adjust the addend for sign extension of the low 16 bits.  */
2574   reloc_entry->addend += 0x8000;
2575   return bfd_reloc_continue;
2576 }
2577
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580                      void *data, asection *input_section,
2581                      bfd *output_bfd, char **error_message)
2582 {
2583   bfd_vma TOCstart;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2593   if (TOCstart == 0)
2594     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2595
2596   /* Subtract the TOC base address.  */
2597   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598   return bfd_reloc_continue;
2599 }
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603                         void *data, asection *input_section,
2604                         bfd *output_bfd, char **error_message)
2605 {
2606   bfd_vma TOCstart;
2607
2608   /* If this is a relocatable link (output_bfd test tells us), just
2609      call the generic function.  Any adjustment will be done at final
2610      link time.  */
2611   if (output_bfd != NULL)
2612     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613                                   input_section, output_bfd, error_message);
2614
2615   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2616   if (TOCstart == 0)
2617     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2618
2619   /* Subtract the TOC base address.  */
2620   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2621
2622   /* Adjust the addend for sign extension of the low 16 bits.  */
2623   reloc_entry->addend += 0x8000;
2624   return bfd_reloc_continue;
2625 }
2626
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629                        void *data, asection *input_section,
2630                        bfd *output_bfd, char **error_message)
2631 {
2632   bfd_vma TOCstart;
2633   bfd_size_type octets;
2634
2635   /* If this is a relocatable link (output_bfd test tells us), just
2636      call the generic function.  Any adjustment will be done at final
2637      link time.  */
2638   if (output_bfd != NULL)
2639     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640                                   input_section, output_bfd, error_message);
2641
2642   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2643   if (TOCstart == 0)
2644     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2645
2646   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648   return bfd_reloc_ok;
2649 }
2650
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653                            void *data, asection *input_section,
2654                            bfd *output_bfd, char **error_message)
2655 {
2656   /* If this is a relocatable link (output_bfd test tells us), just
2657      call the generic function.  Any adjustment will be done at final
2658      link time.  */
2659   if (output_bfd != NULL)
2660     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661                                   input_section, output_bfd, error_message);
2662
2663   if (error_message != NULL)
2664     {
2665       static char buf[60];
2666       sprintf (buf, "generic linker can't handle %s",
2667                reloc_entry->howto->name);
2668       *error_message = buf;
2669     }
2670   return bfd_reloc_dangerous;
2671 }
2672
2673 /* Track GOT entries needed for a given symbol.  We might need more
2674    than one got entry per symbol.  */
2675 struct got_entry
2676 {
2677   struct got_entry *next;
2678
2679   /* The symbol addend that we'll be placing in the GOT.  */
2680   bfd_vma addend;
2681
2682   /* Unlike other ELF targets, we use separate GOT entries for the same
2683      symbol referenced from different input files.  This is to support
2684      automatic multiple TOC/GOT sections, where the TOC base can vary
2685      from one input file to another.  After partitioning into TOC groups
2686      we merge entries within the group.
2687
2688      Point to the BFD owning this GOT entry.  */
2689   bfd *owner;
2690
2691   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692      TLS_TPREL or TLS_DTPREL for tls entries.  */
2693   unsigned char tls_type;
2694
2695   /* Non-zero if got.ent points to real entry.  */
2696   unsigned char is_indirect;
2697
2698   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2699   union
2700     {
2701       bfd_signed_vma refcount;
2702       bfd_vma offset;
2703       struct got_entry *ent;
2704     } got;
2705 };
2706
2707 /* The same for PLT.  */
2708 struct plt_entry
2709 {
2710   struct plt_entry *next;
2711
2712   bfd_vma addend;
2713
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718     } plt;
2719 };
2720
2721 struct ppc64_elf_obj_tdata
2722 {
2723   struct elf_obj_tdata elf;
2724
2725   /* Shortcuts to dynamic linker sections.  */
2726   asection *got;
2727   asection *relgot;
2728
2729   /* Used during garbage collection.  We attach global symbols defined
2730      on removed .opd entries to this section so that the sym is removed.  */
2731   asection *deleted_section;
2732
2733   /* TLS local dynamic got entry handling.  Support for multiple GOT
2734      sections means we potentially need one of these for each input bfd.  */
2735   struct got_entry tlsld_got;
2736
2737   union {
2738     /* A copy of relocs before they are modified for --emit-relocs.  */
2739     Elf_Internal_Rela *relocs;
2740
2741     /* Section contents.  */
2742     bfd_byte *contents;
2743   } opd;
2744
2745   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746      the reloc to be in the range -32768 to 32767.  */
2747   unsigned int has_small_toc_reloc : 1;
2748
2749   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750      instruction not one we handle.  */
2751   unsigned int unexpected_toc_insn : 1;
2752 };
2753
2754 #define ppc64_elf_tdata(bfd) \
2755   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2756
2757 #define ppc64_tlsld_got(bfd) \
2758   (&ppc64_elf_tdata (bfd)->tlsld_got)
2759
2760 #define is_ppc64_elf(bfd) \
2761   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762    && elf_object_id (bfd) == PPC64_ELF_DATA)
2763
2764 /* Override the generic function because we store some extras.  */
2765
2766 static bfd_boolean
2767 ppc64_elf_mkobject (bfd *abfd)
2768 {
2769   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2770                                   PPC64_ELF_DATA);
2771 }
2772
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774    default is 32 bit.  */
2775
2776 static bfd_boolean
2777 ppc64_elf_object_p (bfd *abfd)
2778 {
2779   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2780     {
2781       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2782
2783       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2784         {
2785           /* Relies on arch after 32 bit default being 64 bit default.  */
2786           abfd->arch_info = abfd->arch_info->next;
2787           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2788         }
2789     }
2790   return TRUE;
2791 }
2792
2793 /* Support for core dump NOTE sections.  */
2794
2795 static bfd_boolean
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2797 {
2798   size_t offset, size;
2799
2800   if (note->descsz != 504)
2801     return FALSE;
2802
2803   /* pr_cursig */
2804   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2805
2806   /* pr_pid */
2807   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2808
2809   /* pr_reg */
2810   offset = 112;
2811   size = 384;
2812
2813   /* Make a ".reg/999" section.  */
2814   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815                                           size, note->descpos + offset);
2816 }
2817
2818 static bfd_boolean
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2820 {
2821   if (note->descsz != 136)
2822     return FALSE;
2823
2824   elf_tdata (abfd)->core->pid
2825     = bfd_get_32 (abfd, note->descdata + 24);
2826   elf_tdata (abfd)->core->program
2827     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828   elf_tdata (abfd)->core->command
2829     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2830
2831   return TRUE;
2832 }
2833
2834 static char *
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2836                            ...)
2837 {
2838   switch (note_type)
2839     {
2840     default:
2841       return NULL;
2842
2843     case NT_PRPSINFO:
2844       {
2845         char data[136];
2846         va_list ap;
2847
2848         va_start (ap, note_type);
2849         memset (data, 0, sizeof (data));
2850         strncpy (data + 40, va_arg (ap, const char *), 16);
2851         strncpy (data + 56, va_arg (ap, const char *), 80);
2852         va_end (ap);
2853         return elfcore_write_note (abfd, buf, bufsiz,
2854                                    "CORE", note_type, data, sizeof (data));
2855       }
2856
2857     case NT_PRSTATUS:
2858       {
2859         char data[504];
2860         va_list ap;
2861         long pid;
2862         int cursig;
2863         const void *greg;
2864
2865         va_start (ap, note_type);
2866         memset (data, 0, 112);
2867         pid = va_arg (ap, long);
2868         bfd_put_32 (abfd, pid, data + 32);
2869         cursig = va_arg (ap, int);
2870         bfd_put_16 (abfd, cursig, data + 12);
2871         greg = va_arg (ap, const void *);
2872         memcpy (data + 112, greg, 384);
2873         memset (data + 496, 0, 8);
2874         va_end (ap);
2875         return elfcore_write_note (abfd, buf, bufsiz,
2876                                    "CORE", note_type, data, sizeof (data));
2877       }
2878     }
2879 }
2880
2881 /* Add extra PPC sections.  */
2882
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2884 {
2885   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2886   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2887   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2891   { NULL,                     0,  0, 0,            0 }
2892 };
2893
2894 enum _ppc64_sec_type {
2895   sec_normal = 0,
2896   sec_opd = 1,
2897   sec_toc = 2
2898 };
2899
2900 struct _ppc64_elf_section_data
2901 {
2902   struct bfd_elf_section_data elf;
2903
2904   union
2905   {
2906     /* An array with one entry for each opd function descriptor.  */
2907     struct _opd_sec_data
2908     {
2909       /* Points to the function code section for local opd entries.  */
2910       asection **func_sec;
2911
2912       /* After editing .opd, adjust references to opd local syms.  */
2913       long *adjust;
2914     } opd;
2915
2916     /* An array for toc sections, indexed by offset/8.  */
2917     struct _toc_sec_data
2918     {
2919       /* Specifies the relocation symbol index used at a given toc offset.  */
2920       unsigned *symndx;
2921
2922       /* And the relocation addend.  */
2923       bfd_vma *add;
2924     } toc;
2925   } u;
2926
2927   enum _ppc64_sec_type sec_type:2;
2928
2929   /* Flag set when small branches are detected.  Used to
2930      select suitable defaults for the stub group size.  */
2931   unsigned int has_14bit_branch:1;
2932 };
2933
2934 #define ppc64_elf_section_data(sec) \
2935   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2936
2937 static bfd_boolean
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2939 {
2940   if (!sec->used_by_bfd)
2941     {
2942       struct _ppc64_elf_section_data *sdata;
2943       bfd_size_type amt = sizeof (*sdata);
2944
2945       sdata = bfd_zalloc (abfd, amt);
2946       if (sdata == NULL)
2947         return FALSE;
2948       sec->used_by_bfd = sdata;
2949     }
2950
2951   return _bfd_elf_new_section_hook (abfd, sec);
2952 }
2953
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2956 {
2957   if (sec != NULL
2958       && ppc64_elf_section_data (sec) != NULL
2959       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960     return &ppc64_elf_section_data (sec)->u.opd;
2961   return NULL;
2962 }
2963
2964 static inline int
2965 abiversion (bfd *abfd)
2966 {
2967   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2968 }
2969
2970 static inline void
2971 set_abiversion (bfd *abfd, int ver)
2972 {
2973   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2975 }
2976 \f
2977 /* Parameters for the qsort hook.  */
2978 static bfd_boolean synthetic_relocatable;
2979
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2981
2982 static int
2983 compare_symbols (const void *ap, const void *bp)
2984 {
2985   const asymbol *a = * (const asymbol **) ap;
2986   const asymbol *b = * (const asymbol **) bp;
2987
2988   /* Section symbols first.  */
2989   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2990     return -1;
2991   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2992     return 1;
2993
2994   /* then .opd symbols.  */
2995   if (strcmp (a->section->name, ".opd") == 0
2996       && strcmp (b->section->name, ".opd") != 0)
2997     return -1;
2998   if (strcmp (a->section->name, ".opd") != 0
2999       && strcmp (b->section->name, ".opd") == 0)
3000     return 1;
3001
3002   /* then other code symbols.  */
3003   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004       == (SEC_CODE | SEC_ALLOC)
3005       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006          != (SEC_CODE | SEC_ALLOC))
3007     return -1;
3008
3009   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010       != (SEC_CODE | SEC_ALLOC)
3011       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012          == (SEC_CODE | SEC_ALLOC))
3013     return 1;
3014
3015   if (synthetic_relocatable)
3016     {
3017       if (a->section->id < b->section->id)
3018         return -1;
3019
3020       if (a->section->id > b->section->id)
3021         return 1;
3022     }
3023
3024   if (a->value + a->section->vma < b->value + b->section->vma)
3025     return -1;
3026
3027   if (a->value + a->section->vma > b->value + b->section->vma)
3028     return 1;
3029
3030   /* For syms with the same value, prefer strong dynamic global function
3031      syms over other syms.  */
3032   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3033     return -1;
3034
3035   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3036     return 1;
3037
3038   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3039     return -1;
3040
3041   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3042     return 1;
3043
3044   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3045     return -1;
3046
3047   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3048     return 1;
3049
3050   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3051     return -1;
3052
3053   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3054     return 1;
3055
3056   return 0;
3057 }
3058
3059 /* Search SYMS for a symbol of the given VALUE.  */
3060
3061 static asymbol *
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3063 {
3064   long mid;
3065
3066   if (id == -1)
3067     {
3068       while (lo < hi)
3069         {
3070           mid = (lo + hi) >> 1;
3071           if (syms[mid]->value + syms[mid]->section->vma < value)
3072             lo = mid + 1;
3073           else if (syms[mid]->value + syms[mid]->section->vma > value)
3074             hi = mid;
3075           else
3076             return syms[mid];
3077         }
3078     }
3079   else
3080     {
3081       while (lo < hi)
3082         {
3083           mid = (lo + hi) >> 1;
3084           if (syms[mid]->section->id < id)
3085             lo = mid + 1;
3086           else if (syms[mid]->section->id > id)
3087             hi = mid;
3088           else if (syms[mid]->value < value)
3089             lo = mid + 1;
3090           else if (syms[mid]->value > value)
3091             hi = mid;
3092           else
3093             return syms[mid];
3094         }
3095     }
3096   return NULL;
3097 }
3098
3099 static bfd_boolean
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3101 {
3102   bfd_vma vma = *(bfd_vma *) ptr;
3103   return ((section->flags & SEC_ALLOC) != 0
3104           && section->vma <= vma
3105           && vma < section->vma + section->size);
3106 }
3107
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109    entry syms.  Also generate @plt symbols for the glink branch table.  */
3110
3111 static long
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113                                 long static_count, asymbol **static_syms,
3114                                 long dyn_count, asymbol **dyn_syms,
3115                                 asymbol **ret)
3116 {
3117   asymbol *s;
3118   long i;
3119   long count;
3120   char *names;
3121   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122   asection *opd = NULL;
3123   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3124   asymbol **syms;
3125   int abi = abiversion (abfd);
3126
3127   *ret = NULL;
3128
3129   if (abi < 2)
3130     {
3131       opd = bfd_get_section_by_name (abfd, ".opd");
3132       if (opd == NULL && abi == 1)
3133         return 0;
3134     }
3135
3136   symcount = static_count;
3137   if (!relocatable)
3138     symcount += dyn_count;
3139   if (symcount == 0)
3140     return 0;
3141
3142   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3143   if (syms == NULL)
3144     return -1;
3145
3146   if (!relocatable && static_count != 0 && dyn_count != 0)
3147     {
3148       /* Use both symbol tables.  */
3149       memcpy (syms, static_syms, static_count * sizeof (*syms));
3150       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3151     }
3152   else if (!relocatable && static_count == 0)
3153     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3154   else
3155     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3156
3157   synthetic_relocatable = relocatable;
3158   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3159
3160   if (!relocatable && symcount > 1)
3161     {
3162       long j;
3163       /* Trim duplicate syms, since we may have merged the normal and
3164          dynamic symbols.  Actually, we only care about syms that have
3165          different values, so trim any with the same value.  */
3166       for (i = 1, j = 1; i < symcount; ++i)
3167         if (syms[i - 1]->value + syms[i - 1]->section->vma
3168             != syms[i]->value + syms[i]->section->vma)
3169           syms[j++] = syms[i];
3170       symcount = j;
3171     }
3172
3173   i = 0;
3174   if (strcmp (syms[i]->section->name, ".opd") == 0)
3175     ++i;
3176   codesecsym = i;
3177
3178   for (; i < symcount; ++i)
3179     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180          != (SEC_CODE | SEC_ALLOC))
3181         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3182       break;
3183   codesecsymend = i;
3184
3185   for (; i < symcount; ++i)
3186     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3187       break;
3188   secsymend = i;
3189
3190   for (; i < symcount; ++i)
3191     if (strcmp (syms[i]->section->name, ".opd") != 0)
3192       break;
3193   opdsymend = i;
3194
3195   for (; i < symcount; ++i)
3196     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197         != (SEC_CODE | SEC_ALLOC))
3198       break;
3199   symcount = i;
3200
3201   count = 0;
3202
3203   if (relocatable)
3204     {
3205       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3206       arelent *r;
3207       size_t size;
3208       long relcount;
3209
3210       if (opdsymend == secsymend)
3211         goto done;
3212
3213       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3215       if (relcount == 0)
3216         goto done;
3217
3218       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3219         {
3220           count = -1;
3221           goto done;
3222         }
3223
3224       size = 0;
3225       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3226         {
3227           asymbol *sym;
3228
3229           while (r < opd->relocation + relcount
3230                  && r->address < syms[i]->value + opd->vma)
3231             ++r;
3232
3233           if (r == opd->relocation + relcount)
3234             break;
3235
3236           if (r->address != syms[i]->value + opd->vma)
3237             continue;
3238
3239           if (r->howto->type != R_PPC64_ADDR64)
3240             continue;
3241
3242           sym = *r->sym_ptr_ptr;
3243           if (!sym_exists_at (syms, opdsymend, symcount,
3244                               sym->section->id, sym->value + r->addend))
3245             {
3246               ++count;
3247               size += sizeof (asymbol);
3248               size += strlen (syms[i]->name) + 2;
3249             }
3250         }
3251
3252       s = *ret = bfd_malloc (size);
3253       if (s == NULL)
3254         {
3255           count = -1;
3256           goto done;
3257         }
3258
3259       names = (char *) (s + count);
3260
3261       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3262         {
3263           asymbol *sym;
3264
3265           while (r < opd->relocation + relcount
3266                  && r->address < syms[i]->value + opd->vma)
3267             ++r;
3268
3269           if (r == opd->relocation + relcount)
3270             break;
3271
3272           if (r->address != syms[i]->value + opd->vma)
3273             continue;
3274
3275           if (r->howto->type != R_PPC64_ADDR64)
3276             continue;
3277
3278           sym = *r->sym_ptr_ptr;
3279           if (!sym_exists_at (syms, opdsymend, symcount,
3280                               sym->section->id, sym->value + r->addend))
3281             {
3282               size_t len;
3283
3284               *s = *syms[i];
3285               s->flags |= BSF_SYNTHETIC;
3286               s->section = sym->section;
3287               s->value = sym->value + r->addend;
3288               s->name = names;
3289               *names++ = '.';
3290               len = strlen (syms[i]->name);
3291               memcpy (names, syms[i]->name, len + 1);
3292               names += len + 1;
3293               /* Have udata.p point back to the original symbol this
3294                  synthetic symbol was derived from.  */
3295               s->udata.p = syms[i];
3296               s++;
3297             }
3298         }
3299     }
3300   else
3301     {
3302       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303       bfd_byte *contents = NULL;
3304       size_t size;
3305       long plt_count = 0;
3306       bfd_vma glink_vma = 0, resolv_vma = 0;
3307       asection *dynamic, *glink = NULL, *relplt = NULL;
3308       arelent *p;
3309
3310       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3311         {
3312         free_contents_and_exit:
3313           if (contents)
3314             free (contents);
3315           count = -1;
3316           goto done;
3317         }
3318
3319       size = 0;
3320       for (i = secsymend; i < opdsymend; ++i)
3321         {
3322           bfd_vma ent;
3323
3324           /* Ignore bogus symbols.  */
3325           if (syms[i]->value > opd->size - 8)
3326             continue;
3327
3328           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3330             {
3331               ++count;
3332               size += sizeof (asymbol);
3333               size += strlen (syms[i]->name) + 2;
3334             }
3335         }
3336
3337       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3338       if (dyn_count != 0
3339           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3340         {
3341           bfd_byte *dynbuf, *extdyn, *extdynend;
3342           size_t extdynsize;
3343           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3344
3345           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346             goto free_contents_and_exit;
3347
3348           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3350
3351           extdyn = dynbuf;
3352           extdynend = extdyn + dynamic->size;
3353           for (; extdyn < extdynend; extdyn += extdynsize)
3354             {
3355               Elf_Internal_Dyn dyn;
3356               (*swap_dyn_in) (abfd, extdyn, &dyn);
3357
3358               if (dyn.d_tag == DT_NULL)
3359                 break;
3360
3361               if (dyn.d_tag == DT_PPC64_GLINK)
3362                 {
3363                   /* The first glink stub starts at offset 32; see
3364                      comment in ppc64_elf_finish_dynamic_sections. */
3365                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366                   /* The .glink section usually does not survive the final
3367                      link; search for the section (usually .text) where the
3368                      glink stubs now reside.  */
3369                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3370                                                 &glink_vma);
3371                   break;
3372                 }
3373             }
3374
3375           free (dynbuf);
3376         }
3377
3378       if (glink != NULL)
3379         {
3380           /* Determine __glink trampoline by reading the relative branch
3381              from the first glink stub.  */
3382           bfd_byte buf[4];
3383           unsigned int off = 0;
3384
3385           while (bfd_get_section_contents (abfd, glink, buf,
3386                                            glink_vma + off - glink->vma, 4))
3387             {
3388               unsigned int insn = bfd_get_32 (abfd, buf);
3389               insn ^= B_DOT;
3390               if ((insn & ~0x3fffffc) == 0)
3391                 {
3392                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3393                   break;
3394                 }
3395               off += 4;
3396               if (off > 4)
3397                 break;
3398             }
3399
3400           if (resolv_vma)
3401             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3402
3403           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3404           if (relplt != NULL)
3405             {
3406               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408                 goto free_contents_and_exit;
3409
3410               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411               size += plt_count * sizeof (asymbol);
3412
3413               p = relplt->relocation;
3414               for (i = 0; i < plt_count; i++, p++)
3415                 {
3416                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3417                   if (p->addend != 0)
3418                     size += sizeof ("+0x") - 1 + 16;
3419                 }
3420             }
3421         }
3422
3423       s = *ret = bfd_malloc (size);
3424       if (s == NULL)
3425         goto free_contents_and_exit;
3426
3427       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3428
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           if (syms[i]->value > opd->size - 8)
3434             continue;
3435
3436           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3438             {
3439               long lo, hi;
3440               size_t len;
3441               asection *sec = abfd->sections;
3442
3443               *s = *syms[i];
3444               lo = codesecsym;
3445               hi = codesecsymend;
3446               while (lo < hi)
3447                 {
3448                   long mid = (lo + hi) >> 1;
3449                   if (syms[mid]->section->vma < ent)
3450                     lo = mid + 1;
3451                   else if (syms[mid]->section->vma > ent)
3452                     hi = mid;
3453                   else
3454                     {
3455                       sec = syms[mid]->section;
3456                       break;
3457                     }
3458                 }
3459
3460               if (lo >= hi && lo > codesecsym)
3461                 sec = syms[lo - 1]->section;
3462
3463               for (; sec != NULL; sec = sec->next)
3464                 {
3465                   if (sec->vma > ent)
3466                     break;
3467                   /* SEC_LOAD may not be set if SEC is from a separate debug
3468                      info file.  */
3469                   if ((sec->flags & SEC_ALLOC) == 0)
3470                     break;
3471                   if ((sec->flags & SEC_CODE) != 0)
3472                     s->section = sec;
3473                 }
3474               s->flags |= BSF_SYNTHETIC;
3475               s->value = ent - s->section->vma;
3476               s->name = names;
3477               *names++ = '.';
3478               len = strlen (syms[i]->name);
3479               memcpy (names, syms[i]->name, len + 1);
3480               names += len + 1;
3481               /* Have udata.p point back to the original symbol this
3482                  synthetic symbol was derived from.  */
3483               s->udata.p = syms[i];
3484               s++;
3485             }
3486         }
3487       free (contents);
3488
3489       if (glink != NULL && relplt != NULL)
3490         {
3491           if (resolv_vma)
3492             {
3493               /* Add a symbol for the main glink trampoline.  */
3494               memset (s, 0, sizeof *s);
3495               s->the_bfd = abfd;
3496               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3497               s->section = glink;
3498               s->value = resolv_vma - glink->vma;
3499               s->name = names;
3500               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501               names += sizeof ("__glink_PLTresolve");
3502               s++;
3503               count++;
3504             }
3505
3506           /* FIXME: It would be very much nicer to put sym@plt on the
3507              stub rather than on the glink branch table entry.  The
3508              objdump disassembler would then use a sensible symbol
3509              name on plt calls.  The difficulty in doing so is
3510              a) finding the stubs, and,
3511              b) matching stubs against plt entries, and,
3512              c) there can be multiple stubs for a given plt entry.
3513
3514              Solving (a) could be done by code scanning, but older
3515              ppc64 binaries used different stubs to current code.
3516              (b) is the tricky one since you need to known the toc
3517              pointer for at least one function that uses a pic stub to
3518              be able to calculate the plt address referenced.
3519              (c) means gdb would need to set multiple breakpoints (or
3520              find the glink branch itself) when setting breakpoints
3521              for pending shared library loads.  */
3522           p = relplt->relocation;
3523           for (i = 0; i < plt_count; i++, p++)
3524             {
3525               size_t len;
3526
3527               *s = **p->sym_ptr_ptr;
3528               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3529                  we are defining a symbol, ensure one of them is set.  */
3530               if ((s->flags & BSF_LOCAL) == 0)
3531                 s->flags |= BSF_GLOBAL;
3532               s->flags |= BSF_SYNTHETIC;
3533               s->section = glink;
3534               s->value = glink_vma - glink->vma;
3535               s->name = names;
3536               s->udata.p = NULL;
3537               len = strlen ((*p->sym_ptr_ptr)->name);
3538               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3539               names += len;
3540               if (p->addend != 0)
3541                 {
3542                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3543                   names += sizeof ("+0x") - 1;
3544                   bfd_sprintf_vma (abfd, names, p->addend);
3545                   names += strlen (names);
3546                 }
3547               memcpy (names, "@plt", sizeof ("@plt"));
3548               names += sizeof ("@plt");
3549               s++;
3550               if (abi < 2)
3551                 {
3552                   glink_vma += 8;
3553                   if (i >= 0x8000)
3554                     glink_vma += 4;
3555                 }
3556               else
3557                 glink_vma += 4;
3558             }
3559           count += plt_count;
3560         }
3561     }
3562
3563  done:
3564   free (syms);
3565   return count;
3566 }
3567 \f
3568 /* The following functions are specific to the ELF linker, while
3569    functions above are used generally.  Those named ppc64_elf_* are
3570    called by the main ELF linker code.  They appear in this file more
3571    or less in the order in which they are called.  eg.
3572    ppc64_elf_check_relocs is called early in the link process,
3573    ppc64_elf_finish_dynamic_sections is one of the last functions
3574    called.
3575
3576    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577    functions have both a function code symbol and a function descriptor
3578    symbol.  A call to foo in a relocatable object file looks like:
3579
3580    .            .text
3581    .    x:
3582    .            bl      .foo
3583    .            nop
3584
3585    The function definition in another object file might be:
3586
3587    .            .section .opd
3588    .    foo:    .quad   .foo
3589    .            .quad   .TOC.@tocbase
3590    .            .quad   0
3591    .
3592    .            .text
3593    .    .foo:   blr
3594
3595    When the linker resolves the call during a static link, the branch
3596    unsurprisingly just goes to .foo and the .opd information is unused.
3597    If the function definition is in a shared library, things are a little
3598    different:  The call goes via a plt call stub, the opd information gets
3599    copied to the plt, and the linker patches the nop.
3600
3601    .    x:
3602    .            bl      .foo_stub
3603    .            ld      2,40(1)
3604    .
3605    .
3606    .    .foo_stub:
3607    .            std     2,40(1)                 # in practice, the call stub
3608    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3609    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3610    .            ld      12,0(11)
3611    .            ld      2,8(11)
3612    .            mtctr   12
3613    .            ld      11,16(11)
3614    .            bctr
3615    .
3616    .            .section .plt
3617    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3618
3619    The "reloc ()" notation is supposed to indicate that the linker emits
3620    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3621    copying.
3622
3623    What are the difficulties here?  Well, firstly, the relocations
3624    examined by the linker in check_relocs are against the function code
3625    sym .foo, while the dynamic relocation in the plt is emitted against
3626    the function descriptor symbol, foo.  Somewhere along the line, we need
3627    to carefully copy dynamic link information from one symbol to the other.
3628    Secondly, the generic part of the elf linker will make .foo a dynamic
3629    symbol as is normal for most other backends.  We need foo dynamic
3630    instead, at least for an application final link.  However, when
3631    creating a shared library containing foo, we need to have both symbols
3632    dynamic so that references to .foo are satisfied during the early
3633    stages of linking.  Otherwise the linker might decide to pull in a
3634    definition from some other object, eg. a static library.
3635
3636    Update: As of August 2004, we support a new convention.  Function
3637    calls may use the function descriptor symbol, ie. "bl foo".  This
3638    behaves exactly as "bl .foo".  */
3639
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641    selects those that must be copied when linking a shared library,
3642    even when the symbol is local.  */
3643
3644 static int
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646                    enum elf_ppc64_reloc_type r_type)
3647 {
3648   switch (r_type)
3649     {
3650     default:
3651       return 1;
3652
3653     case R_PPC64_REL32:
3654     case R_PPC64_REL64:
3655     case R_PPC64_REL30:
3656       return 0;
3657
3658     case R_PPC64_TPREL16:
3659     case R_PPC64_TPREL16_LO:
3660     case R_PPC64_TPREL16_HI:
3661     case R_PPC64_TPREL16_HA:
3662     case R_PPC64_TPREL16_DS:
3663     case R_PPC64_TPREL16_LO_DS:
3664     case R_PPC64_TPREL16_HIGH:
3665     case R_PPC64_TPREL16_HIGHA:
3666     case R_PPC64_TPREL16_HIGHER:
3667     case R_PPC64_TPREL16_HIGHERA:
3668     case R_PPC64_TPREL16_HIGHEST:
3669     case R_PPC64_TPREL16_HIGHESTA:
3670     case R_PPC64_TPREL64:
3671       return !info->executable;
3672     }
3673 }
3674
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676    copying dynamic variables from a shared lib into an app's dynbss
3677    section, and instead use a dynamic relocation to point into the
3678    shared lib.  With code that gcc generates, it's vital that this be
3679    enabled;  In the PowerPC64 ABI, the address of a function is actually
3680    the address of a function descriptor, which resides in the .opd
3681    section.  gcc uses the descriptor directly rather than going via the
3682    GOT as some other ABI's do, which means that initialized function
3683    pointers must reference the descriptor.  Thus, a function pointer
3684    initialized to the address of a function in a shared library will
3685    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3686    redefines the function descriptor symbol to point to the copy.  This
3687    presents a problem as a plt entry for that function is also
3688    initialized from the function descriptor symbol and the copy reloc
3689    may not be initialized first.  */
3690 #define ELIMINATE_COPY_RELOCS 1
3691
3692 /* Section name for stubs is the associated section name plus this
3693    string.  */
3694 #define STUB_SUFFIX ".stub"
3695
3696 /* Linker stubs.
3697    ppc_stub_long_branch:
3698    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699    destination, but a 24 bit branch in a stub section will reach.
3700    .    b       dest
3701
3702    ppc_stub_plt_branch:
3703    Similar to the above, but a 24 bit branch in the stub section won't
3704    reach its destination.
3705    .    addis   %r11,%r2,xxx@toc@ha
3706    .    ld      %r12,xxx@toc@l(%r11)
3707    .    mtctr   %r12
3708    .    bctr
3709
3710    ppc_stub_plt_call:
3711    Used to call a function in a shared library.  If it so happens that
3712    the plt entry referenced crosses a 64k boundary, then an extra
3713    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3714    .    std     %r2,40(%r1)
3715    .    addis   %r11,%r2,xxx@toc@ha
3716    .    ld      %r12,xxx+0@toc@l(%r11)
3717    .    mtctr   %r12
3718    .    ld      %r2,xxx+8@toc@l(%r11)
3719    .    ld      %r11,xxx+16@toc@l(%r11)
3720    .    bctr
3721
3722    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723    code to adjust the value and save r2 to support multiple toc sections.
3724    A ppc_stub_long_branch with an r2 offset looks like:
3725    .    std     %r2,40(%r1)
3726    .    addis   %r2,%r2,off@ha
3727    .    addi    %r2,%r2,off@l
3728    .    b       dest
3729
3730    A ppc_stub_plt_branch with an r2 offset looks like:
3731    .    std     %r2,40(%r1)
3732    .    addis   %r11,%r2,xxx@toc@ha
3733    .    ld      %r12,xxx@toc@l(%r11)
3734    .    addis   %r2,%r2,off@ha
3735    .    addi    %r2,%r2,off@l
3736    .    mtctr   %r12
3737    .    bctr
3738
3739    In cases where the "addis" instruction would add zero, the "addis" is
3740    omitted and following instructions modified slightly in some cases.
3741 */
3742
3743 enum ppc_stub_type {
3744   ppc_stub_none,
3745   ppc_stub_long_branch,
3746   ppc_stub_long_branch_r2off,
3747   ppc_stub_plt_branch,
3748   ppc_stub_plt_branch_r2off,
3749   ppc_stub_plt_call,
3750   ppc_stub_plt_call_r2save
3751 };
3752
3753 struct ppc_stub_hash_entry {
3754
3755   /* Base hash table entry structure.  */
3756   struct bfd_hash_entry root;
3757
3758   enum ppc_stub_type stub_type;
3759
3760   /* The stub section.  */
3761   asection *stub_sec;
3762
3763   /* Offset within stub_sec of the beginning of this stub.  */
3764   bfd_vma stub_offset;
3765
3766   /* Given the symbol's value and its section we can determine its final
3767      value when building the stubs (so the stub knows where to jump.  */
3768   bfd_vma target_value;
3769   asection *target_section;
3770
3771   /* The symbol table entry, if any, that this was derived from.  */
3772   struct ppc_link_hash_entry *h;
3773   struct plt_entry *plt_ent;
3774
3775   /* Where this stub is being called from, or, in the case of combined
3776      stub sections, the first input section in the group.  */
3777   asection *id_sec;
3778
3779   /* Symbol st_other.  */
3780   unsigned char other;
3781 };
3782
3783 struct ppc_branch_hash_entry {
3784
3785   /* Base hash table entry structure.  */
3786   struct bfd_hash_entry root;
3787
3788   /* Offset within branch lookup table.  */
3789   unsigned int offset;
3790
3791   /* Generation marker.  */
3792   unsigned int iter;
3793 };
3794
3795 /* Used to track dynamic relocations for local symbols.  */
3796 struct ppc_dyn_relocs
3797 {
3798   struct ppc_dyn_relocs *next;
3799
3800   /* The input section of the reloc.  */
3801   asection *sec;
3802
3803   /* Total number of relocs copied for the input section.  */
3804   unsigned int count : 31;
3805
3806   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3807   unsigned int ifunc : 1;
3808 };
3809
3810 struct ppc_link_hash_entry
3811 {
3812   struct elf_link_hash_entry elf;
3813
3814   union {
3815     /* A pointer to the most recently used stub hash entry against this
3816        symbol.  */
3817     struct ppc_stub_hash_entry *stub_cache;
3818
3819     /* A pointer to the next symbol starting with a '.'  */
3820     struct ppc_link_hash_entry *next_dot_sym;
3821   } u;
3822
3823   /* Track dynamic relocs copied for this symbol.  */
3824   struct elf_dyn_relocs *dyn_relocs;
3825
3826   /* Link between function code and descriptor symbols.  */
3827   struct ppc_link_hash_entry *oh;
3828
3829   /* Flag function code and descriptor symbols.  */
3830   unsigned int is_func:1;
3831   unsigned int is_func_descriptor:1;
3832   unsigned int fake:1;
3833
3834   /* Whether global opd/toc sym has been adjusted or not.
3835      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836      should be set for all globals defined in any opd/toc section.  */
3837   unsigned int adjust_done:1;
3838
3839   /* Set if we twiddled this symbol to weak at some stage.  */
3840   unsigned int was_undefined:1;
3841
3842   /* Contexts in which symbol is used in the GOT (or TOC).
3843      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844      corresponding relocs are encountered during check_relocs.
3845      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846      indicate the corresponding GOT entry type is not needed.
3847      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848      a TPREL one.  We use a separate flag rather than setting TPREL
3849      just for convenience in distinguishing the two cases.  */
3850 #define TLS_GD           1      /* GD reloc. */
3851 #define TLS_LD           2      /* LD reloc. */
3852 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3853 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3854 #define TLS_TLS         16      /* Any TLS reloc.  */
3855 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3858   unsigned char tls_mask;
3859 };
3860
3861 /* ppc64 ELF linker hash table.  */
3862
3863 struct ppc_link_hash_table
3864 {
3865   struct elf_link_hash_table elf;
3866
3867   /* The stub hash table.  */
3868   struct bfd_hash_table stub_hash_table;
3869
3870   /* Another hash table for plt_branch stubs.  */
3871   struct bfd_hash_table branch_hash_table;
3872
3873   /* Hash table for function prologue tocsave.  */
3874   htab_t tocsave_htab;
3875
3876   /* Linker stub bfd.  */
3877   bfd *stub_bfd;
3878
3879   /* Linker call-backs.  */
3880   asection * (*add_stub_section) (const char *, asection *);
3881   void (*layout_sections_again) (void);
3882
3883   /* Array to keep track of which stub sections have been created, and
3884      information on stub grouping.  */
3885   struct map_stub {
3886     /* This is the section to which stubs in the group will be attached.  */
3887     asection *link_sec;
3888     /* The stub section.  */
3889     asection *stub_sec;
3890     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3891     bfd_vma toc_off;
3892   } *stub_group;
3893
3894   /* Temp used when calculating TOC pointers.  */
3895   bfd_vma toc_curr;
3896   bfd *toc_bfd;
3897   asection *toc_first_sec;
3898
3899   /* Highest input section id.  */
3900   int top_id;
3901
3902   /* Highest output section index.  */
3903   int top_index;
3904
3905   /* Used when adding symbols.  */
3906   struct ppc_link_hash_entry *dot_syms;
3907
3908   /* List of input sections for each output section.  */
3909   asection **input_list;
3910
3911   /* Shortcuts to get to dynamic linker sections.  */
3912   asection *dynbss;
3913   asection *relbss;
3914   asection *glink;
3915   asection *sfpr;
3916   asection *brlt;
3917   asection *relbrlt;
3918   asection *glink_eh_frame;
3919
3920   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3921   struct ppc_link_hash_entry *tls_get_addr;
3922   struct ppc_link_hash_entry *tls_get_addr_fd;
3923
3924   /* The size of reliplt used by got entry relocs.  */
3925   bfd_size_type got_reli_size;
3926
3927   /* Statistics.  */
3928   unsigned long stub_count[ppc_stub_plt_call_r2save];
3929
3930   /* Number of stubs against global syms.  */
3931   unsigned long stub_globals;
3932
3933   /* Alignment of PLT call stubs.  */
3934   unsigned int plt_stub_align:4;
3935
3936   /* Set if we're linking code with function descriptors.  */
3937   unsigned int opd_abi:1;
3938
3939   /* Set if PLT call stubs should load r11.  */
3940   unsigned int plt_static_chain:1;
3941
3942   /* Set if PLT call stubs need a read-read barrier.  */
3943   unsigned int plt_thread_safe:1;
3944
3945   /* Set if we should emit symbols for stubs.  */
3946   unsigned int emit_stub_syms:1;
3947
3948   /* Set if __tls_get_addr optimization should not be done.  */
3949   unsigned int no_tls_get_addr_opt:1;
3950
3951   /* Support for multiple toc sections.  */
3952   unsigned int do_multi_toc:1;
3953   unsigned int multi_toc_needed:1;
3954   unsigned int second_toc_pass:1;
3955   unsigned int do_toc_opt:1;
3956
3957   /* Set on error.  */
3958   unsigned int stub_error:1;
3959
3960   /* Temp used by ppc64_elf_process_dot_syms.  */
3961   unsigned int twiddled_syms:1;
3962
3963   /* Incremented every time we size stubs.  */
3964   unsigned int stub_iteration;
3965
3966   /* Small local sym cache.  */
3967   struct sym_cache sym_cache;
3968 };
3969
3970 /* Rename some of the generic section flags to better document how they
3971    are used here.  */
3972
3973 /* Nonzero if this section has TLS related relocations.  */
3974 #define has_tls_reloc sec_flg0
3975
3976 /* Nonzero if this section has a call to __tls_get_addr.  */
3977 #define has_tls_get_addr_call sec_flg1
3978
3979 /* Nonzero if this section has any toc or got relocs.  */
3980 #define has_toc_reloc sec_flg2
3981
3982 /* Nonzero if this section has a call to another section that uses
3983    the toc or got.  */
3984 #define makes_toc_func_call sec_flg3
3985
3986 /* Recursion protection when determining above flag.  */
3987 #define call_check_in_progress sec_flg4
3988 #define call_check_done sec_flg5
3989
3990 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3991
3992 #define ppc_hash_table(p) \
3993   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3994   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3995
3996 #define ppc_stub_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_stub_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 #define ppc_branch_hash_lookup(table, string, create, copy) \
4001   ((struct ppc_branch_hash_entry *) \
4002    bfd_hash_lookup ((table), (string), (create), (copy)))
4003
4004 /* Create an entry in the stub hash table.  */
4005
4006 static struct bfd_hash_entry *
4007 stub_hash_newfunc (struct bfd_hash_entry *entry,
4008                    struct bfd_hash_table *table,
4009                    const char *string)
4010 {
4011   /* Allocate the structure if it has not already been allocated by a
4012      subclass.  */
4013   if (entry == NULL)
4014     {
4015       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016       if (entry == NULL)
4017         return entry;
4018     }
4019
4020   /* Call the allocation method of the superclass.  */
4021   entry = bfd_hash_newfunc (entry, table, string);
4022   if (entry != NULL)
4023     {
4024       struct ppc_stub_hash_entry *eh;
4025
4026       /* Initialize the local fields.  */
4027       eh = (struct ppc_stub_hash_entry *) entry;
4028       eh->stub_type = ppc_stub_none;
4029       eh->stub_sec = NULL;
4030       eh->stub_offset = 0;
4031       eh->target_value = 0;
4032       eh->target_section = NULL;
4033       eh->h = NULL;
4034       eh->plt_ent = NULL;
4035       eh->id_sec = NULL;
4036       eh->other = 0;
4037     }
4038
4039   return entry;
4040 }
4041
4042 /* Create an entry in the branch hash table.  */
4043
4044 static struct bfd_hash_entry *
4045 branch_hash_newfunc (struct bfd_hash_entry *entry,
4046                      struct bfd_hash_table *table,
4047                      const char *string)
4048 {
4049   /* Allocate the structure if it has not already been allocated by a
4050      subclass.  */
4051   if (entry == NULL)
4052     {
4053       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054       if (entry == NULL)
4055         return entry;
4056     }
4057
4058   /* Call the allocation method of the superclass.  */
4059   entry = bfd_hash_newfunc (entry, table, string);
4060   if (entry != NULL)
4061     {
4062       struct ppc_branch_hash_entry *eh;
4063
4064       /* Initialize the local fields.  */
4065       eh = (struct ppc_branch_hash_entry *) entry;
4066       eh->offset = 0;
4067       eh->iter = 0;
4068     }
4069
4070   return entry;
4071 }
4072
4073 /* Create an entry in a ppc64 ELF linker hash table.  */
4074
4075 static struct bfd_hash_entry *
4076 link_hash_newfunc (struct bfd_hash_entry *entry,
4077                    struct bfd_hash_table *table,
4078                    const char *string)
4079 {
4080   /* Allocate the structure if it has not already been allocated by a
4081      subclass.  */
4082   if (entry == NULL)
4083     {
4084       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085       if (entry == NULL)
4086         return entry;
4087     }
4088
4089   /* Call the allocation method of the superclass.  */
4090   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4091   if (entry != NULL)
4092     {
4093       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4094
4095       memset (&eh->u.stub_cache, 0,
4096               (sizeof (struct ppc_link_hash_entry)
4097                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4098
4099       /* When making function calls, old ABI code references function entry
4100          points (dot symbols), while new ABI code references the function
4101          descriptor symbol.  We need to make any combination of reference and
4102          definition work together, without breaking archive linking.
4103
4104          For a defined function "foo" and an undefined call to "bar":
4105          An old object defines "foo" and ".foo", references ".bar" (possibly
4106          "bar" too).
4107          A new object defines "foo" and references "bar".
4108
4109          A new object thus has no problem with its undefined symbols being
4110          satisfied by definitions in an old object.  On the other hand, the
4111          old object won't have ".bar" satisfied by a new object.
4112
4113          Keep a list of newly added dot-symbols.  */
4114
4115       if (string[0] == '.')
4116         {
4117           struct ppc_link_hash_table *htab;
4118
4119           htab = (struct ppc_link_hash_table *) table;
4120           eh->u.next_dot_sym = htab->dot_syms;
4121           htab->dot_syms = eh;
4122         }
4123     }
4124
4125   return entry;
4126 }
4127
4128 struct tocsave_entry {
4129   asection *sec;
4130   bfd_vma offset;
4131 };
4132
4133 static hashval_t
4134 tocsave_htab_hash (const void *p)
4135 {
4136   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4137   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4138 }
4139
4140 static int
4141 tocsave_htab_eq (const void *p1, const void *p2)
4142 {
4143   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4144   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4145   return e1->sec == e2->sec && e1->offset == e2->offset;
4146 }
4147
4148 /* Create a ppc64 ELF linker hash table.  */
4149
4150 static struct bfd_link_hash_table *
4151 ppc64_elf_link_hash_table_create (bfd *abfd)
4152 {
4153   struct ppc_link_hash_table *htab;
4154   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4155
4156   htab = bfd_zmalloc (amt);
4157   if (htab == NULL)
4158     return NULL;
4159
4160   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4161                                       sizeof (struct ppc_link_hash_entry),
4162                                       PPC64_ELF_DATA))
4163     {
4164       free (htab);
4165       return NULL;
4166     }
4167
4168   /* Init the stub hash table too.  */
4169   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4170                             sizeof (struct ppc_stub_hash_entry)))
4171     return NULL;
4172
4173   /* And the branch hash table.  */
4174   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175                             sizeof (struct ppc_branch_hash_entry)))
4176     return NULL;
4177
4178   htab->tocsave_htab = htab_try_create (1024,
4179                                         tocsave_htab_hash,
4180                                         tocsave_htab_eq,
4181                                         NULL);
4182   if (htab->tocsave_htab == NULL)
4183     return NULL;
4184
4185   /* Initializing two fields of the union is just cosmetic.  We really
4186      only care about glist, but when compiled on a 32-bit host the
4187      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4188      debugger inspection of these fields look nicer.  */
4189   htab->elf.init_got_refcount.refcount = 0;
4190   htab->elf.init_got_refcount.glist = NULL;
4191   htab->elf.init_plt_refcount.refcount = 0;
4192   htab->elf.init_plt_refcount.glist = NULL;
4193   htab->elf.init_got_offset.offset = 0;
4194   htab->elf.init_got_offset.glist = NULL;
4195   htab->elf.init_plt_offset.offset = 0;
4196   htab->elf.init_plt_offset.glist = NULL;
4197
4198   return &htab->elf.root;
4199 }
4200
4201 /* Free the derived linker hash table.  */
4202
4203 static void
4204 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4205 {
4206   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4207
4208   bfd_hash_table_free (&htab->stub_hash_table);
4209   bfd_hash_table_free (&htab->branch_hash_table);
4210   if (htab->tocsave_htab)
4211     htab_delete (htab->tocsave_htab);
4212   _bfd_elf_link_hash_table_free (hash);
4213 }
4214
4215 /* Create sections for linker generated code.  */
4216
4217 static bfd_boolean
4218 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4219 {
4220   struct ppc_link_hash_table *htab;
4221   flagword flags;
4222
4223   htab = ppc_hash_table (info);
4224
4225   /* Create .sfpr for code to save and restore fp regs.  */
4226   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4227            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4228   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4229                                                    flags);
4230   if (htab->sfpr == NULL
4231       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4232     return FALSE;
4233
4234   /* Create .glink for lazy dynamic linking support.  */
4235   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4236                                                     flags);
4237   if (htab->glink == NULL
4238       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4239     return FALSE;
4240
4241   if (!info->no_ld_generated_unwind_info)
4242     {
4243       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4244                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4246                                                                  ".eh_frame",
4247                                                                  flags);
4248       if (htab->glink_eh_frame == NULL
4249           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4250         return FALSE;
4251     }
4252
4253   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4254   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4255   if (htab->elf.iplt == NULL
4256       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4257     return FALSE;
4258
4259   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4260            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4261   htab->elf.irelplt
4262     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4263   if (htab->elf.irelplt == NULL
4264       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4265     return FALSE;
4266
4267   /* Create branch lookup table for plt_branch stubs.  */
4268   flags = (SEC_ALLOC | SEC_LOAD
4269            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4271                                                    flags);
4272   if (htab->brlt == NULL
4273       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4274     return FALSE;
4275
4276   if (!info->shared)
4277     return TRUE;
4278
4279   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4280            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4281   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4282                                                       ".rela.branch_lt",
4283                                                       flags);
4284   if (htab->relbrlt == NULL
4285       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4286     return FALSE;
4287
4288   return TRUE;
4289 }
4290
4291 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4292
4293 bfd_boolean
4294 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4295 {
4296   struct ppc_link_hash_table *htab;
4297
4298   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4299
4300 /* Always hook our dynamic sections into the first bfd, which is the
4301    linker created stub bfd.  This ensures that the GOT header is at
4302    the start of the output TOC section.  */
4303   htab = ppc_hash_table (info);
4304   if (htab == NULL)
4305     return FALSE;
4306   htab->stub_bfd = abfd;
4307   htab->elf.dynobj = abfd;
4308
4309   if (info->relocatable)
4310     return TRUE;
4311
4312   return create_linkage_sections (htab->elf.dynobj, info);
4313 }
4314
4315 /* Build a name for an entry in the stub hash table.  */
4316
4317 static char *
4318 ppc_stub_name (const asection *input_section,
4319                const asection *sym_sec,
4320                const struct ppc_link_hash_entry *h,
4321                const Elf_Internal_Rela *rel)
4322 {
4323   char *stub_name;
4324   ssize_t len;
4325
4326   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4327      offsets from a sym as a branch target?  In fact, we could
4328      probably assume the addend is always zero.  */
4329   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4330
4331   if (h)
4332     {
4333       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4334       stub_name = bfd_malloc (len);
4335       if (stub_name == NULL)
4336         return stub_name;
4337
4338       len = sprintf (stub_name, "%08x.%s+%x",
4339                      input_section->id & 0xffffffff,
4340                      h->elf.root.root.string,
4341                      (int) rel->r_addend & 0xffffffff);
4342     }
4343   else
4344     {
4345       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4346       stub_name = bfd_malloc (len);
4347       if (stub_name == NULL)
4348         return stub_name;
4349
4350       len = sprintf (stub_name, "%08x.%x:%x+%x",
4351                      input_section->id & 0xffffffff,
4352                      sym_sec->id & 0xffffffff,
4353                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4354                      (int) rel->r_addend & 0xffffffff);
4355     }
4356   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4357     stub_name[len - 2] = 0;
4358   return stub_name;
4359 }
4360
4361 /* Look up an entry in the stub hash.  Stub entries are cached because
4362    creating the stub name takes a bit of time.  */
4363
4364 static struct ppc_stub_hash_entry *
4365 ppc_get_stub_entry (const asection *input_section,
4366                     const asection *sym_sec,
4367                     struct ppc_link_hash_entry *h,
4368                     const Elf_Internal_Rela *rel,
4369                     struct ppc_link_hash_table *htab)
4370 {
4371   struct ppc_stub_hash_entry *stub_entry;
4372   const asection *id_sec;
4373
4374   /* If this input section is part of a group of sections sharing one
4375      stub section, then use the id of the first section in the group.
4376      Stub names need to include a section id, as there may well be
4377      more than one stub used to reach say, printf, and we need to
4378      distinguish between them.  */
4379   id_sec = htab->stub_group[input_section->id].link_sec;
4380
4381   if (h != NULL && h->u.stub_cache != NULL
4382       && h->u.stub_cache->h == h
4383       && h->u.stub_cache->id_sec == id_sec)
4384     {
4385       stub_entry = h->u.stub_cache;
4386     }
4387   else
4388     {
4389       char *stub_name;
4390
4391       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4392       if (stub_name == NULL)
4393         return NULL;
4394
4395       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4396                                          stub_name, FALSE, FALSE);
4397       if (h != NULL)
4398         h->u.stub_cache = stub_entry;
4399
4400       free (stub_name);
4401     }
4402
4403   return stub_entry;
4404 }
4405
4406 /* Add a new stub entry to the stub hash.  Not all fields of the new
4407    stub entry are initialised.  */
4408
4409 static struct ppc_stub_hash_entry *
4410 ppc_add_stub (const char *stub_name,
4411               asection *section,
4412               struct bfd_link_info *info)
4413 {
4414   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4415   asection *link_sec;
4416   asection *stub_sec;
4417   struct ppc_stub_hash_entry *stub_entry;
4418
4419   link_sec = htab->stub_group[section->id].link_sec;
4420   stub_sec = htab->stub_group[section->id].stub_sec;
4421   if (stub_sec == NULL)
4422     {
4423       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4424       if (stub_sec == NULL)
4425         {
4426           size_t namelen;
4427           bfd_size_type len;
4428           char *s_name;
4429
4430           namelen = strlen (link_sec->name);
4431           len = namelen + sizeof (STUB_SUFFIX);
4432           s_name = bfd_alloc (htab->stub_bfd, len);
4433           if (s_name == NULL)
4434             return NULL;
4435
4436           memcpy (s_name, link_sec->name, namelen);
4437           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4438           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4439           if (stub_sec == NULL)
4440             return NULL;
4441           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4442         }
4443       htab->stub_group[section->id].stub_sec = stub_sec;
4444     }
4445
4446   /* Enter this entry into the linker stub hash table.  */
4447   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4448                                      TRUE, FALSE);
4449   if (stub_entry == NULL)
4450     {
4451       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4452                               section->owner, stub_name);
4453       return NULL;
4454     }
4455
4456   stub_entry->stub_sec = stub_sec;
4457   stub_entry->stub_offset = 0;
4458   stub_entry->id_sec = link_sec;
4459   return stub_entry;
4460 }
4461
4462 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4463    not already done.  */
4464
4465 static bfd_boolean
4466 create_got_section (bfd *abfd, struct bfd_link_info *info)
4467 {
4468   asection *got, *relgot;
4469   flagword flags;
4470   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4471
4472   if (!is_ppc64_elf (abfd))
4473     return FALSE;
4474   if (htab == NULL)
4475     return FALSE;
4476
4477   if (!htab->elf.sgot
4478       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4479     return FALSE;
4480
4481   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4482            | SEC_LINKER_CREATED);
4483
4484   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4485   if (!got
4486       || !bfd_set_section_alignment (abfd, got, 3))
4487     return FALSE;
4488
4489   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4490                                                flags | SEC_READONLY);
4491   if (!relgot
4492       || ! bfd_set_section_alignment (abfd, relgot, 3))
4493     return FALSE;
4494
4495   ppc64_elf_tdata (abfd)->got = got;
4496   ppc64_elf_tdata (abfd)->relgot = relgot;
4497   return TRUE;
4498 }
4499
4500 /* Create the dynamic sections, and set up shortcuts.  */
4501
4502 static bfd_boolean
4503 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4504 {
4505   struct ppc_link_hash_table *htab;
4506
4507   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4508     return FALSE;
4509
4510   htab = ppc_hash_table (info);
4511   if (htab == NULL)
4512     return FALSE;
4513
4514   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4515   if (!info->shared)
4516     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4517
4518   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4519       || (!info->shared && !htab->relbss))
4520     abort ();
4521
4522   return TRUE;
4523 }
4524
4525 /* Follow indirect and warning symbol links.  */
4526
4527 static inline struct bfd_link_hash_entry *
4528 follow_link (struct bfd_link_hash_entry *h)
4529 {
4530   while (h->type == bfd_link_hash_indirect
4531          || h->type == bfd_link_hash_warning)
4532     h = h->u.i.link;
4533   return h;
4534 }
4535
4536 static inline struct elf_link_hash_entry *
4537 elf_follow_link (struct elf_link_hash_entry *h)
4538 {
4539   return (struct elf_link_hash_entry *) follow_link (&h->root);
4540 }
4541
4542 static inline struct ppc_link_hash_entry *
4543 ppc_follow_link (struct ppc_link_hash_entry *h)
4544 {
4545   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4546 }
4547
4548 /* Merge PLT info on FROM with that on TO.  */
4549
4550 static void
4551 move_plt_plist (struct ppc_link_hash_entry *from,
4552                 struct ppc_link_hash_entry *to)
4553 {
4554   if (from->elf.plt.plist != NULL)
4555     {
4556       if (to->elf.plt.plist != NULL)
4557         {
4558           struct plt_entry **entp;
4559           struct plt_entry *ent;
4560
4561           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4562             {
4563               struct plt_entry *dent;
4564
4565               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4566                 if (dent->addend == ent->addend)
4567                   {
4568                     dent->plt.refcount += ent->plt.refcount;
4569                     *entp = ent->next;
4570                     break;
4571                   }
4572               if (dent == NULL)
4573                 entp = &ent->next;
4574             }
4575           *entp = to->elf.plt.plist;
4576         }
4577
4578       to->elf.plt.plist = from->elf.plt.plist;
4579       from->elf.plt.plist = NULL;
4580     }
4581 }
4582
4583 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4584
4585 static void
4586 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4587                                 struct elf_link_hash_entry *dir,
4588                                 struct elf_link_hash_entry *ind)
4589 {
4590   struct ppc_link_hash_entry *edir, *eind;
4591
4592   edir = (struct ppc_link_hash_entry *) dir;
4593   eind = (struct ppc_link_hash_entry *) ind;
4594
4595   edir->is_func |= eind->is_func;
4596   edir->is_func_descriptor |= eind->is_func_descriptor;
4597   edir->tls_mask |= eind->tls_mask;
4598   if (eind->oh != NULL)
4599     edir->oh = ppc_follow_link (eind->oh);
4600
4601   /* If called to transfer flags for a weakdef during processing
4602      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4603      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4604   if (!(ELIMINATE_COPY_RELOCS
4605         && eind->elf.root.type != bfd_link_hash_indirect
4606         && edir->elf.dynamic_adjusted))
4607     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4608
4609   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4610   edir->elf.ref_regular |= eind->elf.ref_regular;
4611   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4612   edir->elf.needs_plt |= eind->elf.needs_plt;
4613   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4614
4615   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4616   if (eind->dyn_relocs != NULL)
4617     {
4618       if (edir->dyn_relocs != NULL)
4619         {
4620           struct elf_dyn_relocs **pp;
4621           struct elf_dyn_relocs *p;
4622
4623           /* Add reloc counts against the indirect sym to the direct sym
4624              list.  Merge any entries against the same section.  */
4625           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4626             {
4627               struct elf_dyn_relocs *q;
4628
4629               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4630                 if (q->sec == p->sec)
4631                   {
4632                     q->pc_count += p->pc_count;
4633                     q->count += p->count;
4634                     *pp = p->next;
4635                     break;
4636                   }
4637               if (q == NULL)
4638                 pp = &p->next;
4639             }
4640           *pp = edir->dyn_relocs;
4641         }
4642
4643       edir->dyn_relocs = eind->dyn_relocs;
4644       eind->dyn_relocs = NULL;
4645     }
4646
4647   /* If we were called to copy over info for a weak sym, that's all.
4648      You might think dyn_relocs need not be copied over;  After all,
4649      both syms will be dynamic or both non-dynamic so we're just
4650      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4651      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4652      dyn_relocs in read-only sections, and it does so on what is the
4653      DIR sym here.  */
4654   if (eind->elf.root.type != bfd_link_hash_indirect)
4655     return;
4656
4657   /* Copy over got entries that we may have already seen to the
4658      symbol which just became indirect.  */
4659   if (eind->elf.got.glist != NULL)
4660     {
4661       if (edir->elf.got.glist != NULL)
4662         {
4663           struct got_entry **entp;
4664           struct got_entry *ent;
4665
4666           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4667             {
4668               struct got_entry *dent;
4669
4670               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4671                 if (dent->addend == ent->addend
4672                     && dent->owner == ent->owner
4673                     && dent->tls_type == ent->tls_type)
4674                   {
4675                     dent->got.refcount += ent->got.refcount;
4676                     *entp = ent->next;
4677                     break;
4678                   }
4679               if (dent == NULL)
4680                 entp = &ent->next;
4681             }
4682           *entp = edir->elf.got.glist;
4683         }
4684
4685       edir->elf.got.glist = eind->elf.got.glist;
4686       eind->elf.got.glist = NULL;
4687     }
4688
4689   /* And plt entries.  */
4690   move_plt_plist (eind, edir);
4691
4692   if (eind->elf.dynindx != -1)
4693     {
4694       if (edir->elf.dynindx != -1)
4695         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4696                                 edir->elf.dynstr_index);
4697       edir->elf.dynindx = eind->elf.dynindx;
4698       edir->elf.dynstr_index = eind->elf.dynstr_index;
4699       eind->elf.dynindx = -1;
4700       eind->elf.dynstr_index = 0;
4701     }
4702 }
4703
4704 /* Find the function descriptor hash entry from the given function code
4705    hash entry FH.  Link the entries via their OH fields.  */
4706
4707 static struct ppc_link_hash_entry *
4708 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4709 {
4710   struct ppc_link_hash_entry *fdh = fh->oh;
4711
4712   if (fdh == NULL)
4713     {
4714       const char *fd_name = fh->elf.root.root.string + 1;
4715
4716       fdh = (struct ppc_link_hash_entry *)
4717         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4718       if (fdh == NULL)
4719         return fdh;
4720
4721       fdh->is_func_descriptor = 1;
4722       fdh->oh = fh;
4723       fh->is_func = 1;
4724       fh->oh = fdh;
4725     }
4726
4727   return ppc_follow_link (fdh);
4728 }
4729
4730 /* Make a fake function descriptor sym for the code sym FH.  */
4731
4732 static struct ppc_link_hash_entry *
4733 make_fdh (struct bfd_link_info *info,
4734           struct ppc_link_hash_entry *fh)
4735 {
4736   bfd *abfd;
4737   asymbol *newsym;
4738   struct bfd_link_hash_entry *bh;
4739   struct ppc_link_hash_entry *fdh;
4740
4741   abfd = fh->elf.root.u.undef.abfd;
4742   newsym = bfd_make_empty_symbol (abfd);
4743   newsym->name = fh->elf.root.root.string + 1;
4744   newsym->section = bfd_und_section_ptr;
4745   newsym->value = 0;
4746   newsym->flags = BSF_WEAK;
4747
4748   bh = NULL;
4749   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4750                                          newsym->flags, newsym->section,
4751                                          newsym->value, NULL, FALSE, FALSE,
4752                                          &bh))
4753     return NULL;
4754
4755   fdh = (struct ppc_link_hash_entry *) bh;
4756   fdh->elf.non_elf = 0;
4757   fdh->fake = 1;
4758   fdh->is_func_descriptor = 1;
4759   fdh->oh = fh;
4760   fh->is_func = 1;
4761   fh->oh = fdh;
4762   return fdh;
4763 }
4764
4765 /* Fix function descriptor symbols defined in .opd sections to be
4766    function type.  */
4767
4768 static bfd_boolean
4769 ppc64_elf_add_symbol_hook (bfd *ibfd,
4770                            struct bfd_link_info *info,
4771                            Elf_Internal_Sym *isym,
4772                            const char **name,
4773                            flagword *flags ATTRIBUTE_UNUSED,
4774                            asection **sec,
4775                            bfd_vma *value ATTRIBUTE_UNUSED)
4776 {
4777   if ((ibfd->flags & DYNAMIC) == 0
4778       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4779     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4780
4781   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4782     {
4783       if ((ibfd->flags & DYNAMIC) == 0)
4784         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4785     }
4786   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4787     ;
4788   else if (*sec != NULL
4789            && strcmp ((*sec)->name, ".opd") == 0)
4790     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4791
4792   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4793     {
4794       if (abiversion (ibfd) == 0)
4795         set_abiversion (ibfd, 2);
4796       else if (abiversion (ibfd) == 1)
4797         {
4798           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4799                                     " for ABI version 1\n"), name);
4800           bfd_set_error (bfd_error_bad_value);
4801           return FALSE;
4802         }
4803     }
4804
4805   return TRUE;
4806 }
4807
4808 /* Merge non-visibility st_other attributes: local entry point.  */
4809
4810 static void
4811 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4812                                   const Elf_Internal_Sym *isym,
4813                                   bfd_boolean definition,
4814                                   bfd_boolean dynamic)
4815 {
4816   if (definition && !dynamic)
4817     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4818                 | ELF_ST_VISIBILITY (h->other));
4819 }
4820
4821 /* This function makes an old ABI object reference to ".bar" cause the
4822    inclusion of a new ABI object archive that defines "bar".
4823    NAME is a symbol defined in an archive.  Return a symbol in the hash
4824    table that might be satisfied by the archive symbols.  */
4825
4826 static struct elf_link_hash_entry *
4827 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4828                                  struct bfd_link_info *info,
4829                                  const char *name)
4830 {
4831   struct elf_link_hash_entry *h;
4832   char *dot_name;
4833   size_t len;
4834
4835   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4836   if (h != NULL
4837       /* Don't return this sym if it is a fake function descriptor
4838          created by add_symbol_adjust.  */
4839       && !(h->root.type == bfd_link_hash_undefweak
4840            && ((struct ppc_link_hash_entry *) h)->fake))
4841     return h;
4842
4843   if (name[0] == '.')
4844     return h;
4845
4846   len = strlen (name);
4847   dot_name = bfd_alloc (abfd, len + 2);
4848   if (dot_name == NULL)
4849     return (struct elf_link_hash_entry *) 0 - 1;
4850   dot_name[0] = '.';
4851   memcpy (dot_name + 1, name, len + 1);
4852   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4853   bfd_release (abfd, dot_name);
4854   return h;
4855 }
4856
4857 /* This function satisfies all old ABI object references to ".bar" if a
4858    new ABI object defines "bar".  Well, at least, undefined dot symbols
4859    are made weak.  This stops later archive searches from including an
4860    object if we already have a function descriptor definition.  It also
4861    prevents the linker complaining about undefined symbols.
4862    We also check and correct mismatched symbol visibility here.  The
4863    most restrictive visibility of the function descriptor and the
4864    function entry symbol is used.  */
4865
4866 static bfd_boolean
4867 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4868 {
4869   struct ppc_link_hash_table *htab;
4870   struct ppc_link_hash_entry *fdh;
4871
4872   if (eh->elf.root.type == bfd_link_hash_indirect)
4873     return TRUE;
4874
4875   if (eh->elf.root.type == bfd_link_hash_warning)
4876     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4877
4878   if (eh->elf.root.root.string[0] != '.')
4879     abort ();
4880
4881   htab = ppc_hash_table (info);
4882   if (htab == NULL)
4883     return FALSE;
4884
4885   fdh = lookup_fdh (eh, htab);
4886   if (fdh == NULL)
4887     {
4888       if (!info->relocatable
4889           && (eh->elf.root.type == bfd_link_hash_undefined
4890               || eh->elf.root.type == bfd_link_hash_undefweak)
4891           && eh->elf.ref_regular)
4892         {
4893           /* Make an undefweak function descriptor sym, which is enough to
4894              pull in an --as-needed shared lib, but won't cause link
4895              errors.  Archives are handled elsewhere.  */
4896           fdh = make_fdh (info, eh);
4897           if (fdh == NULL)
4898             return FALSE;
4899           fdh->elf.ref_regular = 1;
4900         }
4901     }
4902   else
4903     {
4904       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4905       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4906       if (entry_vis < descr_vis)
4907         fdh->elf.other += entry_vis - descr_vis;
4908       else if (entry_vis > descr_vis)
4909         eh->elf.other += descr_vis - entry_vis;
4910
4911       if ((fdh->elf.root.type == bfd_link_hash_defined
4912            || fdh->elf.root.type == bfd_link_hash_defweak)
4913           && eh->elf.root.type == bfd_link_hash_undefined)
4914         {
4915           eh->elf.root.type = bfd_link_hash_undefweak;
4916           eh->was_undefined = 1;
4917           htab->twiddled_syms = 1;
4918         }
4919     }
4920
4921   return TRUE;
4922 }
4923
4924 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4925
4926 static bfd_boolean
4927 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4928 {
4929   struct ppc_link_hash_table *htab;
4930   struct ppc_link_hash_entry **p, *eh;
4931
4932   if (!is_ppc64_elf (info->output_bfd))
4933     return TRUE;
4934   htab = ppc_hash_table (info);
4935   if (htab == NULL)
4936     return FALSE;
4937
4938   if (is_ppc64_elf (ibfd))
4939     {
4940       p = &htab->dot_syms;
4941       while ((eh = *p) != NULL)
4942         {
4943           *p = NULL;
4944           if (&eh->elf == htab->elf.hgot)
4945             ;
4946           else if (htab->elf.hgot == NULL
4947                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4948             htab->elf.hgot = &eh->elf;
4949           else if (!add_symbol_adjust (eh, info))
4950             return FALSE;
4951           p = &eh->u.next_dot_sym;
4952         }
4953     }
4954
4955   /* Clear the list for non-ppc64 input files.  */
4956   p = &htab->dot_syms;
4957   while ((eh = *p) != NULL)
4958     {
4959       *p = NULL;
4960       p = &eh->u.next_dot_sym;
4961     }
4962
4963   /* We need to fix the undefs list for any syms we have twiddled to
4964      undef_weak.  */
4965   if (htab->twiddled_syms)
4966     {
4967       bfd_link_repair_undef_list (&htab->elf.root);
4968       htab->twiddled_syms = 0;
4969     }
4970   return TRUE;
4971 }
4972
4973 /* Undo hash table changes when an --as-needed input file is determined
4974    not to be needed.  */
4975
4976 static bfd_boolean
4977 ppc64_elf_notice_as_needed (bfd *ibfd,
4978                             struct bfd_link_info *info,
4979                             enum notice_asneeded_action act)
4980 {
4981   if (act == notice_not_needed)
4982     {
4983       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4984
4985       if (htab == NULL)
4986         return FALSE;
4987
4988       htab->dot_syms = NULL;
4989     }
4990   return _bfd_elf_notice_as_needed (ibfd, info, act);
4991 }
4992
4993 /* If --just-symbols against a final linked binary, then assume we need
4994    toc adjusting stubs when calling functions defined there.  */
4995
4996 static void
4997 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4998 {
4999   if ((sec->flags & SEC_CODE) != 0
5000       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5001       && is_ppc64_elf (sec->owner))
5002     {
5003       if (abiversion (sec->owner) >= 2
5004           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5005         sec->has_toc_reloc = 1;
5006     }
5007   _bfd_elf_link_just_syms (sec, info);
5008 }
5009
5010 static struct plt_entry **
5011 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5012                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5013 {
5014   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5015   struct plt_entry **local_plt;
5016   unsigned char *local_got_tls_masks;
5017
5018   if (local_got_ents == NULL)
5019     {
5020       bfd_size_type size = symtab_hdr->sh_info;
5021
5022       size *= (sizeof (*local_got_ents)
5023                + sizeof (*local_plt)
5024                + sizeof (*local_got_tls_masks));
5025       local_got_ents = bfd_zalloc (abfd, size);
5026       if (local_got_ents == NULL)
5027         return NULL;
5028       elf_local_got_ents (abfd) = local_got_ents;
5029     }
5030
5031   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5032     {
5033       struct got_entry *ent;
5034
5035       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5036         if (ent->addend == r_addend
5037             && ent->owner == abfd
5038             && ent->tls_type == tls_type)
5039           break;
5040       if (ent == NULL)
5041         {
5042           bfd_size_type amt = sizeof (*ent);
5043           ent = bfd_alloc (abfd, amt);
5044           if (ent == NULL)
5045             return FALSE;
5046           ent->next = local_got_ents[r_symndx];
5047           ent->addend = r_addend;
5048           ent->owner = abfd;
5049           ent->tls_type = tls_type;
5050           ent->is_indirect = FALSE;
5051           ent->got.refcount = 0;
5052           local_got_ents[r_symndx] = ent;
5053         }
5054       ent->got.refcount += 1;
5055     }
5056
5057   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5058   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5059   local_got_tls_masks[r_symndx] |= tls_type;
5060
5061   return local_plt + r_symndx;
5062 }
5063
5064 static bfd_boolean
5065 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5066 {
5067   struct plt_entry *ent;
5068
5069   for (ent = *plist; ent != NULL; ent = ent->next)
5070     if (ent->addend == addend)
5071       break;
5072   if (ent == NULL)
5073     {
5074       bfd_size_type amt = sizeof (*ent);
5075       ent = bfd_alloc (abfd, amt);
5076       if (ent == NULL)
5077         return FALSE;
5078       ent->next = *plist;
5079       ent->addend = addend;
5080       ent->plt.refcount = 0;
5081       *plist = ent;
5082     }
5083   ent->plt.refcount += 1;
5084   return TRUE;
5085 }
5086
5087 static bfd_boolean
5088 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5089 {
5090   return (r_type == R_PPC64_REL24
5091           || r_type == R_PPC64_REL14
5092           || r_type == R_PPC64_REL14_BRTAKEN
5093           || r_type == R_PPC64_REL14_BRNTAKEN
5094           || r_type == R_PPC64_ADDR24
5095           || r_type == R_PPC64_ADDR14
5096           || r_type == R_PPC64_ADDR14_BRTAKEN
5097           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5098 }
5099
5100 /* Look through the relocs for a section during the first phase, and
5101    calculate needed space in the global offset table, procedure
5102    linkage table, and dynamic reloc sections.  */
5103
5104 static bfd_boolean
5105 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5106                         asection *sec, const Elf_Internal_Rela *relocs)
5107 {
5108   struct ppc_link_hash_table *htab;
5109   Elf_Internal_Shdr *symtab_hdr;
5110   struct elf_link_hash_entry **sym_hashes;
5111   const Elf_Internal_Rela *rel;
5112   const Elf_Internal_Rela *rel_end;
5113   asection *sreloc;
5114   asection **opd_sym_map;
5115   struct elf_link_hash_entry *tga, *dottga;
5116
5117   if (info->relocatable)
5118     return TRUE;
5119
5120   /* Don't do anything special with non-loaded, non-alloced sections.
5121      In particular, any relocs in such sections should not affect GOT
5122      and PLT reference counting (ie. we don't allow them to create GOT
5123      or PLT entries), there's no possibility or desire to optimize TLS
5124      relocs, and there's not much point in propagating relocs to shared
5125      libs that the dynamic linker won't relocate.  */
5126   if ((sec->flags & SEC_ALLOC) == 0)
5127     return TRUE;
5128
5129   BFD_ASSERT (is_ppc64_elf (abfd));
5130
5131   htab = ppc_hash_table (info);
5132   if (htab == NULL)
5133     return FALSE;
5134
5135   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5136                               FALSE, FALSE, TRUE);
5137   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5138                                  FALSE, FALSE, TRUE);
5139   symtab_hdr = &elf_symtab_hdr (abfd);
5140   sym_hashes = elf_sym_hashes (abfd);
5141   sreloc = NULL;
5142   opd_sym_map = NULL;
5143   if (strcmp (sec->name, ".opd") == 0)
5144     {
5145       /* Garbage collection needs some extra help with .opd sections.
5146          We don't want to necessarily keep everything referenced by
5147          relocs in .opd, as that would keep all functions.  Instead,
5148          if we reference an .opd symbol (a function descriptor), we
5149          want to keep the function code symbol's section.  This is
5150          easy for global symbols, but for local syms we need to keep
5151          information about the associated function section.  */
5152       bfd_size_type amt;
5153
5154       if (abiversion (abfd) == 0)
5155         set_abiversion (abfd, 1);
5156       else if (abiversion (abfd) == 2)
5157         {
5158           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5159                                   abiversion (abfd));
5160           bfd_set_error (bfd_error_bad_value);
5161           return FALSE;
5162         }
5163       amt = sec->size * sizeof (*opd_sym_map) / 8;
5164       opd_sym_map = bfd_zalloc (abfd, amt);
5165       if (opd_sym_map == NULL)
5166         return FALSE;
5167       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5168       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5169       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5170     }
5171
5172   rel_end = relocs + sec->reloc_count;
5173   for (rel = relocs; rel < rel_end; rel++)
5174     {
5175       unsigned long r_symndx;
5176       struct elf_link_hash_entry *h;
5177       enum elf_ppc64_reloc_type r_type;
5178       int tls_type;
5179       struct _ppc64_elf_section_data *ppc64_sec;
5180       struct plt_entry **ifunc;
5181
5182       r_symndx = ELF64_R_SYM (rel->r_info);
5183       if (r_symndx < symtab_hdr->sh_info)
5184         h = NULL;
5185       else
5186         {
5187           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5188           h = elf_follow_link (h);
5189
5190           /* PR15323, ref flags aren't set for references in the same
5191              object.  */
5192           h->root.non_ir_ref = 1;
5193
5194           if (h == htab->elf.hgot)
5195             sec->has_toc_reloc = 1;
5196         }
5197
5198       tls_type = 0;
5199       ifunc = NULL;
5200       if (h != NULL)
5201         {
5202           if (h->type == STT_GNU_IFUNC)
5203             {
5204               h->needs_plt = 1;
5205               ifunc = &h->plt.plist;
5206             }
5207         }
5208       else
5209         {
5210           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5211                                                           abfd, r_symndx);
5212           if (isym == NULL)
5213             return FALSE;
5214
5215           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5216             {
5217               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5218                                              rel->r_addend, PLT_IFUNC);
5219               if (ifunc == NULL)
5220                 return FALSE;
5221             }
5222         }
5223       r_type = ELF64_R_TYPE (rel->r_info);
5224       if (is_branch_reloc (r_type))
5225         {
5226           if (h != NULL && (h == tga || h == dottga))
5227             {
5228               if (rel != relocs
5229                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5230                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5231                 /* We have a new-style __tls_get_addr call with a marker
5232                    reloc.  */
5233                 ;
5234               else
5235                 /* Mark this section as having an old-style call.  */
5236                 sec->has_tls_get_addr_call = 1;
5237             }
5238
5239           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5240           if (ifunc != NULL
5241               && !update_plt_info (abfd, ifunc, rel->r_addend))
5242             return FALSE;
5243         }
5244
5245       switch (r_type)
5246         {
5247         case R_PPC64_TLSGD:
5248         case R_PPC64_TLSLD:
5249           /* These special tls relocs tie a call to __tls_get_addr with
5250              its parameter symbol.  */
5251           break;
5252
5253         case R_PPC64_GOT_TLSLD16:
5254         case R_PPC64_GOT_TLSLD16_LO:
5255         case R_PPC64_GOT_TLSLD16_HI:
5256         case R_PPC64_GOT_TLSLD16_HA:
5257           tls_type = TLS_TLS | TLS_LD;
5258           goto dogottls;
5259
5260         case R_PPC64_GOT_TLSGD16:
5261         case R_PPC64_GOT_TLSGD16_LO:
5262         case R_PPC64_GOT_TLSGD16_HI:
5263         case R_PPC64_GOT_TLSGD16_HA:
5264           tls_type = TLS_TLS | TLS_GD;
5265           goto dogottls;
5266
5267         case R_PPC64_GOT_TPREL16_DS:
5268         case R_PPC64_GOT_TPREL16_LO_DS:
5269         case R_PPC64_GOT_TPREL16_HI:
5270         case R_PPC64_GOT_TPREL16_HA:
5271           if (!info->executable)
5272             info->flags |= DF_STATIC_TLS;
5273           tls_type = TLS_TLS | TLS_TPREL;
5274           goto dogottls;
5275
5276         case R_PPC64_GOT_DTPREL16_DS:
5277         case R_PPC64_GOT_DTPREL16_LO_DS:
5278         case R_PPC64_GOT_DTPREL16_HI:
5279         case R_PPC64_GOT_DTPREL16_HA:
5280           tls_type = TLS_TLS | TLS_DTPREL;
5281         dogottls:
5282           sec->has_tls_reloc = 1;
5283           /* Fall thru */
5284
5285         case R_PPC64_GOT16:
5286         case R_PPC64_GOT16_DS:
5287         case R_PPC64_GOT16_HA:
5288         case R_PPC64_GOT16_HI:
5289         case R_PPC64_GOT16_LO:
5290         case R_PPC64_GOT16_LO_DS:
5291           /* This symbol requires a global offset table entry.  */
5292           sec->has_toc_reloc = 1;
5293           if (r_type == R_PPC64_GOT_TLSLD16
5294               || r_type == R_PPC64_GOT_TLSGD16
5295               || r_type == R_PPC64_GOT_TPREL16_DS
5296               || r_type == R_PPC64_GOT_DTPREL16_DS
5297               || r_type == R_PPC64_GOT16
5298               || r_type == R_PPC64_GOT16_DS)
5299             {
5300               htab->do_multi_toc = 1;
5301               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5302             }
5303
5304           if (ppc64_elf_tdata (abfd)->got == NULL
5305               && !create_got_section (abfd, info))
5306             return FALSE;
5307
5308           if (h != NULL)
5309             {
5310               struct ppc_link_hash_entry *eh;
5311               struct got_entry *ent;
5312
5313               eh = (struct ppc_link_hash_entry *) h;
5314               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5315                 if (ent->addend == rel->r_addend
5316                     && ent->owner == abfd
5317                     && ent->tls_type == tls_type)
5318                   break;
5319               if (ent == NULL)
5320                 {
5321                   bfd_size_type amt = sizeof (*ent);
5322                   ent = bfd_alloc (abfd, amt);
5323                   if (ent == NULL)
5324                     return FALSE;
5325                   ent->next = eh->elf.got.glist;
5326                   ent->addend = rel->r_addend;
5327                   ent->owner = abfd;
5328                   ent->tls_type = tls_type;
5329                   ent->is_indirect = FALSE;
5330                   ent->got.refcount = 0;
5331                   eh->elf.got.glist = ent;
5332                 }
5333               ent->got.refcount += 1;
5334               eh->tls_mask |= tls_type;
5335             }
5336           else
5337             /* This is a global offset table entry for a local symbol.  */
5338             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5339                                         rel->r_addend, tls_type))
5340               return FALSE;
5341
5342           /* We may also need a plt entry if the symbol turns out to be
5343              an ifunc.  */
5344           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5345             {
5346               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5347                 return FALSE;
5348             }
5349           break;
5350
5351         case R_PPC64_PLT16_HA:
5352         case R_PPC64_PLT16_HI:
5353         case R_PPC64_PLT16_LO:
5354         case R_PPC64_PLT32:
5355         case R_PPC64_PLT64:
5356           /* This symbol requires a procedure linkage table entry.  We
5357              actually build the entry in adjust_dynamic_symbol,
5358              because this might be a case of linking PIC code without
5359              linking in any dynamic objects, in which case we don't
5360              need to generate a procedure linkage table after all.  */
5361           if (h == NULL)
5362             {
5363               /* It does not make sense to have a procedure linkage
5364                  table entry for a local symbol.  */
5365               bfd_set_error (bfd_error_bad_value);
5366               return FALSE;
5367             }
5368           else
5369             {
5370               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5371                 return FALSE;
5372               h->needs_plt = 1;
5373               if (h->root.root.string[0] == '.'
5374                   && h->root.root.string[1] != '\0')
5375                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5376             }
5377           break;
5378
5379           /* The following relocations don't need to propagate the
5380              relocation if linking a shared object since they are
5381              section relative.  */
5382         case R_PPC64_SECTOFF:
5383         case R_PPC64_SECTOFF_LO:
5384         case R_PPC64_SECTOFF_HI:
5385         case R_PPC64_SECTOFF_HA:
5386         case R_PPC64_SECTOFF_DS:
5387         case R_PPC64_SECTOFF_LO_DS:
5388         case R_PPC64_DTPREL16:
5389         case R_PPC64_DTPREL16_LO:
5390         case R_PPC64_DTPREL16_HI:
5391         case R_PPC64_DTPREL16_HA:
5392         case R_PPC64_DTPREL16_DS:
5393         case R_PPC64_DTPREL16_LO_DS:
5394         case R_PPC64_DTPREL16_HIGH:
5395         case R_PPC64_DTPREL16_HIGHA:
5396         case R_PPC64_DTPREL16_HIGHER:
5397         case R_PPC64_DTPREL16_HIGHERA:
5398         case R_PPC64_DTPREL16_HIGHEST:
5399         case R_PPC64_DTPREL16_HIGHESTA:
5400           break;
5401
5402           /* Nor do these.  */
5403         case R_PPC64_REL16:
5404         case R_PPC64_REL16_LO:
5405         case R_PPC64_REL16_HI:
5406         case R_PPC64_REL16_HA:
5407           break;
5408
5409         case R_PPC64_TOC16:
5410         case R_PPC64_TOC16_DS:
5411           htab->do_multi_toc = 1;
5412           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5413         case R_PPC64_TOC16_LO:
5414         case R_PPC64_TOC16_HI:
5415         case R_PPC64_TOC16_HA:
5416         case R_PPC64_TOC16_LO_DS:
5417           sec->has_toc_reloc = 1;
5418           break;
5419
5420           /* This relocation describes the C++ object vtable hierarchy.
5421              Reconstruct it for later use during GC.  */
5422         case R_PPC64_GNU_VTINHERIT:
5423           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5424             return FALSE;
5425           break;
5426
5427           /* This relocation describes which C++ vtable entries are actually
5428              used.  Record for later use during GC.  */
5429         case R_PPC64_GNU_VTENTRY:
5430           BFD_ASSERT (h != NULL);
5431           if (h != NULL
5432               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5433             return FALSE;
5434           break;
5435
5436         case R_PPC64_REL14:
5437         case R_PPC64_REL14_BRTAKEN:
5438         case R_PPC64_REL14_BRNTAKEN:
5439           {
5440             asection *dest = NULL;
5441
5442             /* Heuristic: If jumping outside our section, chances are
5443                we are going to need a stub.  */
5444             if (h != NULL)
5445               {
5446                 /* If the sym is weak it may be overridden later, so
5447                    don't assume we know where a weak sym lives.  */
5448                 if (h->root.type == bfd_link_hash_defined)
5449                   dest = h->root.u.def.section;
5450               }
5451             else
5452               {
5453                 Elf_Internal_Sym *isym;
5454
5455                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5456                                               abfd, r_symndx);
5457                 if (isym == NULL)
5458                   return FALSE;
5459
5460                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5461               }
5462
5463             if (dest != sec)
5464               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5465           }
5466           /* Fall through.  */
5467
5468         case R_PPC64_REL24:
5469           if (h != NULL && ifunc == NULL)
5470             {
5471               /* We may need a .plt entry if the function this reloc
5472                  refers to is in a shared lib.  */
5473               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5474                 return FALSE;
5475               h->needs_plt = 1;
5476               if (h->root.root.string[0] == '.'
5477                   && h->root.root.string[1] != '\0')
5478                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5479               if (h == tga || h == dottga)
5480                 sec->has_tls_reloc = 1;
5481             }
5482           break;
5483
5484         case R_PPC64_TPREL64:
5485           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5486           if (!info->executable)
5487             info->flags |= DF_STATIC_TLS;
5488           goto dotlstoc;
5489
5490         case R_PPC64_DTPMOD64:
5491           if (rel + 1 < rel_end
5492               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5493               && rel[1].r_offset == rel->r_offset + 8)
5494             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5495           else
5496             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5497           goto dotlstoc;
5498
5499         case R_PPC64_DTPREL64:
5500           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5501           if (rel != relocs
5502               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5503               && rel[-1].r_offset == rel->r_offset - 8)
5504             /* This is the second reloc of a dtpmod, dtprel pair.
5505                Don't mark with TLS_DTPREL.  */
5506             goto dodyn;
5507
5508         dotlstoc:
5509           sec->has_tls_reloc = 1;
5510           if (h != NULL)
5511             {
5512               struct ppc_link_hash_entry *eh;
5513               eh = (struct ppc_link_hash_entry *) h;
5514               eh->tls_mask |= tls_type;
5515             }
5516           else
5517             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5518                                         rel->r_addend, tls_type))
5519               return FALSE;
5520
5521           ppc64_sec = ppc64_elf_section_data (sec);
5522           if (ppc64_sec->sec_type != sec_toc)
5523             {
5524               bfd_size_type amt;
5525
5526               /* One extra to simplify get_tls_mask.  */
5527               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5528               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5529               if (ppc64_sec->u.toc.symndx == NULL)
5530                 return FALSE;
5531               amt = sec->size * sizeof (bfd_vma) / 8;
5532               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5533               if (ppc64_sec->u.toc.add == NULL)
5534                 return FALSE;
5535               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5536               ppc64_sec->sec_type = sec_toc;
5537             }
5538           BFD_ASSERT (rel->r_offset % 8 == 0);
5539           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5540           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5541
5542           /* Mark the second slot of a GD or LD entry.
5543              -1 to indicate GD and -2 to indicate LD.  */
5544           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5545             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5546           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5547             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5548           goto dodyn;
5549
5550         case R_PPC64_TPREL16:
5551         case R_PPC64_TPREL16_LO:
5552         case R_PPC64_TPREL16_HI:
5553         case R_PPC64_TPREL16_HA:
5554         case R_PPC64_TPREL16_DS:
5555         case R_PPC64_TPREL16_LO_DS:
5556         case R_PPC64_TPREL16_HIGH:
5557         case R_PPC64_TPREL16_HIGHA:
5558         case R_PPC64_TPREL16_HIGHER:
5559         case R_PPC64_TPREL16_HIGHERA:
5560         case R_PPC64_TPREL16_HIGHEST:
5561         case R_PPC64_TPREL16_HIGHESTA:
5562           if (info->shared)
5563             {
5564               if (!info->executable)
5565                 info->flags |= DF_STATIC_TLS;
5566               goto dodyn;
5567             }
5568           break;
5569
5570         case R_PPC64_ADDR64:
5571           if (opd_sym_map != NULL
5572               && rel + 1 < rel_end
5573               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5574             {
5575               if (h != NULL)
5576                 {
5577                   if (h->root.root.string[0] == '.'
5578                       && h->root.root.string[1] != 0
5579                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5580                     ;
5581                   else
5582                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5583                 }
5584               else
5585                 {
5586                   asection *s;
5587                   Elf_Internal_Sym *isym;
5588
5589                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5590                                                 abfd, r_symndx);
5591                   if (isym == NULL)
5592                     return FALSE;
5593
5594                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5595                   if (s != NULL && s != sec)
5596                     opd_sym_map[rel->r_offset / 8] = s;
5597                 }
5598             }
5599           /* Fall through.  */
5600
5601         case R_PPC64_ADDR16:
5602         case R_PPC64_ADDR16_DS:
5603         case R_PPC64_ADDR16_HA:
5604         case R_PPC64_ADDR16_HI:
5605         case R_PPC64_ADDR16_HIGH:
5606         case R_PPC64_ADDR16_HIGHA:
5607         case R_PPC64_ADDR16_HIGHER:
5608         case R_PPC64_ADDR16_HIGHERA:
5609         case R_PPC64_ADDR16_HIGHEST:
5610         case R_PPC64_ADDR16_HIGHESTA:
5611         case R_PPC64_ADDR16_LO:
5612         case R_PPC64_ADDR16_LO_DS:
5613           if (h != NULL && !info->shared && abiversion (abfd) == 2
5614               && rel->r_addend == 0)
5615             {
5616               /* We may need a .plt entry if this reloc refers to a
5617                  function in a shared lib.  */
5618               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5619                 return FALSE;
5620               h->pointer_equality_needed = 1;
5621             }
5622           /* Fall through.  */
5623
5624         case R_PPC64_REL30:
5625         case R_PPC64_REL32:
5626         case R_PPC64_REL64:
5627         case R_PPC64_ADDR14:
5628         case R_PPC64_ADDR14_BRNTAKEN:
5629         case R_PPC64_ADDR14_BRTAKEN:
5630         case R_PPC64_ADDR24:
5631         case R_PPC64_ADDR32:
5632         case R_PPC64_UADDR16:
5633         case R_PPC64_UADDR32:
5634         case R_PPC64_UADDR64:
5635         case R_PPC64_TOC:
5636           if (h != NULL && !info->shared)
5637             /* We may need a copy reloc.  */
5638             h->non_got_ref = 1;
5639
5640           /* Don't propagate .opd relocs.  */
5641           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5642             break;
5643
5644           /* If we are creating a shared library, and this is a reloc
5645              against a global symbol, or a non PC relative reloc
5646              against a local symbol, then we need to copy the reloc
5647              into the shared library.  However, if we are linking with
5648              -Bsymbolic, we do not need to copy a reloc against a
5649              global symbol which is defined in an object we are
5650              including in the link (i.e., DEF_REGULAR is set).  At
5651              this point we have not seen all the input files, so it is
5652              possible that DEF_REGULAR is not set now but will be set
5653              later (it is never cleared).  In case of a weak definition,
5654              DEF_REGULAR may be cleared later by a strong definition in
5655              a shared library.  We account for that possibility below by
5656              storing information in the dyn_relocs field of the hash
5657              table entry.  A similar situation occurs when creating
5658              shared libraries and symbol visibility changes render the
5659              symbol local.
5660
5661              If on the other hand, we are creating an executable, we
5662              may need to keep relocations for symbols satisfied by a
5663              dynamic library if we manage to avoid copy relocs for the
5664              symbol.  */
5665         dodyn:
5666           if ((info->shared
5667                && (must_be_dyn_reloc (info, r_type)
5668                    || (h != NULL
5669                        && (!SYMBOLIC_BIND (info, h)
5670                            || h->root.type == bfd_link_hash_defweak
5671                            || !h->def_regular))))
5672               || (ELIMINATE_COPY_RELOCS
5673                   && !info->shared
5674                   && h != NULL
5675                   && (h->root.type == bfd_link_hash_defweak
5676                       || !h->def_regular))
5677               || (!info->shared
5678                   && ifunc != NULL))
5679             {
5680               /* We must copy these reloc types into the output file.
5681                  Create a reloc section in dynobj and make room for
5682                  this reloc.  */
5683               if (sreloc == NULL)
5684                 {
5685                   sreloc = _bfd_elf_make_dynamic_reloc_section
5686                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5687
5688                   if (sreloc == NULL)
5689                     return FALSE;
5690                 }
5691
5692               /* If this is a global symbol, we count the number of
5693                  relocations we need for this symbol.  */
5694               if (h != NULL)
5695                 {
5696                   struct elf_dyn_relocs *p;
5697                   struct elf_dyn_relocs **head;
5698
5699                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5700                   p = *head;
5701                   if (p == NULL || p->sec != sec)
5702                     {
5703                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5704                       if (p == NULL)
5705                         return FALSE;
5706                       p->next = *head;
5707                       *head = p;
5708                       p->sec = sec;
5709                       p->count = 0;
5710                       p->pc_count = 0;
5711                     }
5712                   p->count += 1;
5713                   if (!must_be_dyn_reloc (info, r_type))
5714                     p->pc_count += 1;
5715                 }
5716               else
5717                 {
5718                   /* Track dynamic relocs needed for local syms too.
5719                      We really need local syms available to do this
5720                      easily.  Oh well.  */
5721                   struct ppc_dyn_relocs *p;
5722                   struct ppc_dyn_relocs **head;
5723                   bfd_boolean is_ifunc;
5724                   asection *s;
5725                   void *vpp;
5726                   Elf_Internal_Sym *isym;
5727
5728                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5729                                                 abfd, r_symndx);
5730                   if (isym == NULL)
5731                     return FALSE;
5732
5733                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5734                   if (s == NULL)
5735                     s = sec;
5736
5737                   vpp = &elf_section_data (s)->local_dynrel;
5738                   head = (struct ppc_dyn_relocs **) vpp;
5739                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5740                   p = *head;
5741                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5742                     p = p->next;
5743                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5744                     {
5745                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5746                       if (p == NULL)
5747                         return FALSE;
5748                       p->next = *head;
5749                       *head = p;
5750                       p->sec = sec;
5751                       p->ifunc = is_ifunc;
5752                       p->count = 0;
5753                     }
5754                   p->count += 1;
5755                 }
5756             }
5757           break;
5758
5759         default:
5760           break;
5761         }
5762     }
5763
5764   return TRUE;
5765 }
5766
5767 /* Merge backend specific data from an object file to the output
5768    object file when linking.  */
5769
5770 static bfd_boolean
5771 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5772 {
5773   unsigned long iflags, oflags;
5774
5775   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5776     return TRUE;
5777
5778   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5779     return TRUE;
5780
5781   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5782     return FALSE;
5783
5784   iflags = elf_elfheader (ibfd)->e_flags;
5785   oflags = elf_elfheader (obfd)->e_flags;
5786
5787   if (!elf_flags_init (obfd) || oflags == 0)
5788     {
5789       elf_flags_init (obfd) = TRUE;
5790       elf_elfheader (obfd)->e_flags = iflags;
5791     }
5792   else if (iflags == oflags || iflags == 0)
5793     ;
5794   else if (iflags & ~EF_PPC64_ABI)
5795     {
5796       (*_bfd_error_handler)
5797         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5798       bfd_set_error (bfd_error_bad_value);
5799       return FALSE;
5800     }
5801   else
5802     {
5803       (*_bfd_error_handler)
5804         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5805          ibfd, iflags, oflags);
5806       bfd_set_error (bfd_error_bad_value);
5807       return FALSE;
5808     }
5809
5810   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5811   _bfd_elf_merge_object_attributes (ibfd, obfd);
5812
5813   return TRUE;
5814 }
5815
5816 static bfd_boolean
5817 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5818 {
5819   /* Print normal ELF private data.  */
5820   _bfd_elf_print_private_bfd_data (abfd, ptr);
5821
5822   if (elf_elfheader (abfd)->e_flags != 0)
5823     {
5824       FILE *file = ptr;
5825
5826       /* xgettext:c-format */
5827       fprintf (file, _("private flags = 0x%lx:"),
5828                elf_elfheader (abfd)->e_flags);
5829
5830       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5831         fprintf (file, _(" [abiv%ld]"),
5832                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5833       fputc ('\n', file);
5834     }
5835
5836   return TRUE;
5837 }
5838
5839 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5840    of the code entry point, and its section.  */
5841
5842 static bfd_vma
5843 opd_entry_value (asection *opd_sec,
5844                  bfd_vma offset,
5845                  asection **code_sec,
5846                  bfd_vma *code_off,
5847                  bfd_boolean in_code_sec)
5848 {
5849   bfd *opd_bfd = opd_sec->owner;
5850   Elf_Internal_Rela *relocs;
5851   Elf_Internal_Rela *lo, *hi, *look;
5852   bfd_vma val;
5853
5854   /* No relocs implies we are linking a --just-symbols object, or looking
5855      at a final linked executable with addr2line or somesuch.  */
5856   if (opd_sec->reloc_count == 0)
5857     {
5858       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5859
5860       if (contents == NULL)
5861         {
5862           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5863             return (bfd_vma) -1;
5864           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5865         }
5866
5867       val = bfd_get_64 (opd_bfd, contents + offset);
5868       if (code_sec != NULL)
5869         {
5870           asection *sec, *likely = NULL;
5871
5872           if (in_code_sec)
5873             {
5874               sec = *code_sec;
5875               if (sec->vma <= val
5876                   && val < sec->vma + sec->size)
5877                 likely = sec;
5878               else
5879                 val = -1;
5880             }
5881           else
5882             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5883               if (sec->vma <= val
5884                   && (sec->flags & SEC_LOAD) != 0
5885                   && (sec->flags & SEC_ALLOC) != 0)
5886                 likely = sec;
5887           if (likely != NULL)
5888             {
5889               *code_sec = likely;
5890               if (code_off != NULL)
5891                 *code_off = val - likely->vma;
5892             }
5893         }
5894       return val;
5895     }
5896
5897   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5898
5899   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5900   if (relocs == NULL)
5901     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5902
5903   /* Go find the opd reloc at the sym address.  */
5904   lo = relocs;
5905   BFD_ASSERT (lo != NULL);
5906   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5907   val = (bfd_vma) -1;
5908   while (lo < hi)
5909     {
5910       look = lo + (hi - lo) / 2;
5911       if (look->r_offset < offset)
5912         lo = look + 1;
5913       else if (look->r_offset > offset)
5914         hi = look;
5915       else
5916         {
5917           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5918
5919           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5920               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5921             {
5922               unsigned long symndx = ELF64_R_SYM (look->r_info);
5923               asection *sec;
5924
5925               if (symndx < symtab_hdr->sh_info
5926                   || elf_sym_hashes (opd_bfd) == NULL)
5927                 {
5928                   Elf_Internal_Sym *sym;
5929
5930                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5931                   if (sym == NULL)
5932                     {
5933                       size_t symcnt = symtab_hdr->sh_info;
5934                       if (elf_sym_hashes (opd_bfd) == NULL)
5935                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5936                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5937                                                   0, NULL, NULL, NULL);
5938                       if (sym == NULL)
5939                         break;
5940                       symtab_hdr->contents = (bfd_byte *) sym;
5941                     }
5942
5943                   sym += symndx;
5944                   val = sym->st_value;
5945                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5946                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5947                 }
5948               else
5949                 {
5950                   struct elf_link_hash_entry **sym_hashes;
5951                   struct elf_link_hash_entry *rh;
5952
5953                   sym_hashes = elf_sym_hashes (opd_bfd);
5954                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5955                   if (rh != NULL)
5956                     {
5957                       rh = elf_follow_link (rh);
5958                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5959                                   || rh->root.type == bfd_link_hash_defweak);
5960                       val = rh->root.u.def.value;
5961                       sec = rh->root.u.def.section;
5962                     }
5963                   else
5964                     {
5965                       /* Handle the odd case where we can be called
5966                          during bfd_elf_link_add_symbols before the
5967                          symbol hashes have been fully populated.  */
5968                       Elf_Internal_Sym *sym;
5969
5970                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5971                                                   symndx, NULL, NULL, NULL);
5972                       if (sym == NULL)
5973                         break;
5974
5975                       val = sym->st_value;
5976                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5977                       free (sym);
5978                     }
5979                 }
5980               val += look->r_addend;
5981               if (code_off != NULL)
5982                 *code_off = val;
5983               if (code_sec != NULL)
5984                 {
5985                   if (in_code_sec && *code_sec != sec)
5986                     return -1;
5987                   else
5988                     *code_sec = sec;
5989                 }
5990               if (sec != NULL && sec->output_section != NULL)
5991                 val += sec->output_section->vma + sec->output_offset;
5992             }
5993           break;
5994         }
5995     }
5996
5997   return val;
5998 }
5999
6000 /* If the ELF symbol SYM might be a function in SEC, return the
6001    function size and set *CODE_OFF to the function's entry point,
6002    otherwise return zero.  */
6003
6004 static bfd_size_type
6005 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6006                               bfd_vma *code_off)
6007 {
6008   bfd_size_type size;
6009
6010   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6011                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6012     return 0;
6013
6014   size = 0;
6015   if (!(sym->flags & BSF_SYNTHETIC))
6016     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6017
6018   if (strcmp (sym->section->name, ".opd") == 0)
6019     {
6020       if (opd_entry_value (sym->section, sym->value,
6021                            &sec, code_off, TRUE) == (bfd_vma) -1)
6022         return 0;
6023       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6024          symbol.  This size has nothing to do with the code size of the
6025          function, which is what we're supposed to return, but the
6026          code size isn't available without looking up the dot-sym.
6027          However, doing that would be a waste of time particularly
6028          since elf_find_function will look at the dot-sym anyway.
6029          Now, elf_find_function will keep the largest size of any
6030          function sym found at the code address of interest, so return
6031          1 here to avoid it incorrectly caching a larger function size
6032          for a small function.  This does mean we return the wrong
6033          size for a new-ABI function of size 24, but all that does is
6034          disable caching for such functions.  */
6035       if (size == 24)
6036         size = 1;
6037     }
6038   else
6039     {
6040       if (sym->section != sec)
6041         return 0;
6042       *code_off = sym->value;
6043     }
6044   if (size == 0)
6045     size = 1;
6046   return size;
6047 }
6048
6049 /* Return true if symbol is defined in a regular object file.  */
6050
6051 static bfd_boolean
6052 is_static_defined (struct elf_link_hash_entry *h)
6053 {
6054   return ((h->root.type == bfd_link_hash_defined
6055            || h->root.type == bfd_link_hash_defweak)
6056           && h->root.u.def.section != NULL
6057           && h->root.u.def.section->output_section != NULL);
6058 }
6059
6060 /* If FDH is a function descriptor symbol, return the associated code
6061    entry symbol if it is defined.  Return NULL otherwise.  */
6062
6063 static struct ppc_link_hash_entry *
6064 defined_code_entry (struct ppc_link_hash_entry *fdh)
6065 {
6066   if (fdh->is_func_descriptor)
6067     {
6068       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6069       if (fh->elf.root.type == bfd_link_hash_defined
6070           || fh->elf.root.type == bfd_link_hash_defweak)
6071         return fh;
6072     }
6073   return NULL;
6074 }
6075
6076 /* If FH is a function code entry symbol, return the associated
6077    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6078
6079 static struct ppc_link_hash_entry *
6080 defined_func_desc (struct ppc_link_hash_entry *fh)
6081 {
6082   if (fh->oh != NULL
6083       && fh->oh->is_func_descriptor)
6084     {
6085       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6086       if (fdh->elf.root.type == bfd_link_hash_defined
6087           || fdh->elf.root.type == bfd_link_hash_defweak)
6088         return fdh;
6089     }
6090   return NULL;
6091 }
6092
6093 /* Mark all our entry sym sections, both opd and code section.  */
6094
6095 static void
6096 ppc64_elf_gc_keep (struct bfd_link_info *info)
6097 {
6098   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6099   struct bfd_sym_chain *sym;
6100
6101   if (htab == NULL)
6102     return;
6103
6104   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6105     {
6106       struct ppc_link_hash_entry *eh, *fh;
6107       asection *sec;
6108
6109       eh = (struct ppc_link_hash_entry *)
6110         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6111       if (eh == NULL)
6112         continue;
6113       if (eh->elf.root.type != bfd_link_hash_defined
6114           && eh->elf.root.type != bfd_link_hash_defweak)
6115         continue;
6116
6117       fh = defined_code_entry (eh);
6118       if (fh != NULL)
6119         {
6120           sec = fh->elf.root.u.def.section;
6121           sec->flags |= SEC_KEEP;
6122         }
6123       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6124                && opd_entry_value (eh->elf.root.u.def.section,
6125                                    eh->elf.root.u.def.value,
6126                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6127         sec->flags |= SEC_KEEP;
6128
6129       sec = eh->elf.root.u.def.section;
6130       sec->flags |= SEC_KEEP;
6131     }
6132 }
6133
6134 /* Mark sections containing dynamically referenced symbols.  When
6135    building shared libraries, we must assume that any visible symbol is
6136    referenced.  */
6137
6138 static bfd_boolean
6139 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6140 {
6141   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6142   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6143   struct ppc_link_hash_entry *fdh;
6144
6145   /* Dynamic linking info is on the func descriptor sym.  */
6146   fdh = defined_func_desc (eh);
6147   if (fdh != NULL)
6148     eh = fdh;
6149
6150   if ((eh->elf.root.type == bfd_link_hash_defined
6151        || eh->elf.root.type == bfd_link_hash_defweak)
6152       && (eh->elf.ref_dynamic
6153           || (!info->executable
6154               && eh->elf.def_regular
6155               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6156               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6157               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6158                   || !bfd_hide_sym_by_version (info->version_info,
6159                                                eh->elf.root.root.string)))))
6160     {
6161       asection *code_sec;
6162       struct ppc_link_hash_entry *fh;
6163
6164       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6165
6166       /* Function descriptor syms cause the associated
6167          function code sym section to be marked.  */
6168       fh = defined_code_entry (eh);
6169       if (fh != NULL)
6170         {
6171           code_sec = fh->elf.root.u.def.section;
6172           code_sec->flags |= SEC_KEEP;
6173         }
6174       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6175                && opd_entry_value (eh->elf.root.u.def.section,
6176                                    eh->elf.root.u.def.value,
6177                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6178         code_sec->flags |= SEC_KEEP;
6179     }
6180
6181   return TRUE;
6182 }
6183
6184 /* Return the section that should be marked against GC for a given
6185    relocation.  */
6186
6187 static asection *
6188 ppc64_elf_gc_mark_hook (asection *sec,
6189                         struct bfd_link_info *info,
6190                         Elf_Internal_Rela *rel,
6191                         struct elf_link_hash_entry *h,
6192                         Elf_Internal_Sym *sym)
6193 {
6194   asection *rsec;
6195
6196   /* Syms return NULL if we're marking .opd, so we avoid marking all
6197      function sections, as all functions are referenced in .opd.  */
6198   rsec = NULL;
6199   if (get_opd_info (sec) != NULL)
6200     return rsec;
6201
6202   if (h != NULL)
6203     {
6204       enum elf_ppc64_reloc_type r_type;
6205       struct ppc_link_hash_entry *eh, *fh, *fdh;
6206
6207       r_type = ELF64_R_TYPE (rel->r_info);
6208       switch (r_type)
6209         {
6210         case R_PPC64_GNU_VTINHERIT:
6211         case R_PPC64_GNU_VTENTRY:
6212           break;
6213
6214         default:
6215           switch (h->root.type)
6216             {
6217             case bfd_link_hash_defined:
6218             case bfd_link_hash_defweak:
6219               eh = (struct ppc_link_hash_entry *) h;
6220               fdh = defined_func_desc (eh);
6221               if (fdh != NULL)
6222                 eh = fdh;
6223
6224               /* Function descriptor syms cause the associated
6225                  function code sym section to be marked.  */
6226               fh = defined_code_entry (eh);
6227               if (fh != NULL)
6228                 {
6229                   /* They also mark their opd section.  */
6230                   eh->elf.root.u.def.section->gc_mark = 1;
6231
6232                   rsec = fh->elf.root.u.def.section;
6233                 }
6234               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6235                        && opd_entry_value (eh->elf.root.u.def.section,
6236                                            eh->elf.root.u.def.value,
6237                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6238                 eh->elf.root.u.def.section->gc_mark = 1;
6239               else
6240                 rsec = h->root.u.def.section;
6241               break;
6242
6243             case bfd_link_hash_common:
6244               rsec = h->root.u.c.p->section;
6245               break;
6246
6247             default:
6248               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6249             }
6250         }
6251     }
6252   else
6253     {
6254       struct _opd_sec_data *opd;
6255
6256       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6257       opd = get_opd_info (rsec);
6258       if (opd != NULL && opd->func_sec != NULL)
6259         {
6260           rsec->gc_mark = 1;
6261
6262           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6263         }
6264     }
6265
6266   return rsec;
6267 }
6268
6269 /* Update the .got, .plt. and dynamic reloc reference counts for the
6270    section being removed.  */
6271
6272 static bfd_boolean
6273 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6274                          asection *sec, const Elf_Internal_Rela *relocs)
6275 {
6276   struct ppc_link_hash_table *htab;
6277   Elf_Internal_Shdr *symtab_hdr;
6278   struct elf_link_hash_entry **sym_hashes;
6279   struct got_entry **local_got_ents;
6280   const Elf_Internal_Rela *rel, *relend;
6281
6282   if (info->relocatable)
6283     return TRUE;
6284
6285   if ((sec->flags & SEC_ALLOC) == 0)
6286     return TRUE;
6287
6288   elf_section_data (sec)->local_dynrel = NULL;
6289
6290   htab = ppc_hash_table (info);
6291   if (htab == NULL)
6292     return FALSE;
6293
6294   symtab_hdr = &elf_symtab_hdr (abfd);
6295   sym_hashes = elf_sym_hashes (abfd);
6296   local_got_ents = elf_local_got_ents (abfd);
6297
6298   relend = relocs + sec->reloc_count;
6299   for (rel = relocs; rel < relend; rel++)
6300     {
6301       unsigned long r_symndx;
6302       enum elf_ppc64_reloc_type r_type;
6303       struct elf_link_hash_entry *h = NULL;
6304       unsigned char tls_type = 0;
6305
6306       r_symndx = ELF64_R_SYM (rel->r_info);
6307       r_type = ELF64_R_TYPE (rel->r_info);
6308       if (r_symndx >= symtab_hdr->sh_info)
6309         {
6310           struct ppc_link_hash_entry *eh;
6311           struct elf_dyn_relocs **pp;
6312           struct elf_dyn_relocs *p;
6313
6314           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6315           h = elf_follow_link (h);
6316           eh = (struct ppc_link_hash_entry *) h;
6317
6318           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6319             if (p->sec == sec)
6320               {
6321                 /* Everything must go for SEC.  */
6322                 *pp = p->next;
6323                 break;
6324               }
6325         }
6326
6327       if (is_branch_reloc (r_type))
6328         {
6329           struct plt_entry **ifunc = NULL;
6330           if (h != NULL)
6331             {
6332               if (h->type == STT_GNU_IFUNC)
6333                 ifunc = &h->plt.plist;
6334             }
6335           else if (local_got_ents != NULL)
6336             {
6337               struct plt_entry **local_plt = (struct plt_entry **)
6338                 (local_got_ents + symtab_hdr->sh_info);
6339               unsigned char *local_got_tls_masks = (unsigned char *)
6340                 (local_plt + symtab_hdr->sh_info);
6341               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6342                 ifunc = local_plt + r_symndx;
6343             }
6344           if (ifunc != NULL)
6345             {
6346               struct plt_entry *ent;
6347
6348               for (ent = *ifunc; ent != NULL; ent = ent->next)
6349                 if (ent->addend == rel->r_addend)
6350                   break;
6351               if (ent == NULL)
6352                 abort ();
6353               if (ent->plt.refcount > 0)
6354                 ent->plt.refcount -= 1;
6355               continue;
6356             }
6357         }
6358
6359       switch (r_type)
6360         {
6361         case R_PPC64_GOT_TLSLD16:
6362         case R_PPC64_GOT_TLSLD16_LO:
6363         case R_PPC64_GOT_TLSLD16_HI:
6364         case R_PPC64_GOT_TLSLD16_HA:
6365           tls_type = TLS_TLS | TLS_LD;
6366           goto dogot;
6367
6368         case R_PPC64_GOT_TLSGD16:
6369         case R_PPC64_GOT_TLSGD16_LO:
6370         case R_PPC64_GOT_TLSGD16_HI:
6371         case R_PPC64_GOT_TLSGD16_HA:
6372           tls_type = TLS_TLS | TLS_GD;
6373           goto dogot;
6374
6375         case R_PPC64_GOT_TPREL16_DS:
6376         case R_PPC64_GOT_TPREL16_LO_DS:
6377         case R_PPC64_GOT_TPREL16_HI:
6378         case R_PPC64_GOT_TPREL16_HA:
6379           tls_type = TLS_TLS | TLS_TPREL;
6380           goto dogot;
6381
6382         case R_PPC64_GOT_DTPREL16_DS:
6383         case R_PPC64_GOT_DTPREL16_LO_DS:
6384         case R_PPC64_GOT_DTPREL16_HI:
6385         case R_PPC64_GOT_DTPREL16_HA:
6386           tls_type = TLS_TLS | TLS_DTPREL;
6387           goto dogot;
6388
6389         case R_PPC64_GOT16:
6390         case R_PPC64_GOT16_DS:
6391         case R_PPC64_GOT16_HA:
6392         case R_PPC64_GOT16_HI:
6393         case R_PPC64_GOT16_LO:
6394         case R_PPC64_GOT16_LO_DS:
6395         dogot:
6396           {
6397             struct got_entry *ent;
6398
6399             if (h != NULL)
6400               ent = h->got.glist;
6401             else
6402               ent = local_got_ents[r_symndx];
6403
6404             for (; ent != NULL; ent = ent->next)
6405               if (ent->addend == rel->r_addend
6406                   && ent->owner == abfd
6407                   && ent->tls_type == tls_type)
6408                 break;
6409             if (ent == NULL)
6410               abort ();
6411             if (ent->got.refcount > 0)
6412               ent->got.refcount -= 1;
6413           }
6414           break;
6415
6416         case R_PPC64_PLT16_HA:
6417         case R_PPC64_PLT16_HI:
6418         case R_PPC64_PLT16_LO:
6419         case R_PPC64_PLT32:
6420         case R_PPC64_PLT64:
6421         case R_PPC64_REL14:
6422         case R_PPC64_REL14_BRNTAKEN:
6423         case R_PPC64_REL14_BRTAKEN:
6424         case R_PPC64_REL24:
6425           if (h != NULL)
6426             {
6427               struct plt_entry *ent;
6428
6429               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6430                 if (ent->addend == rel->r_addend)
6431                   break;
6432               if (ent != NULL && ent->plt.refcount > 0)
6433                 ent->plt.refcount -= 1;
6434             }
6435           break;
6436
6437         default:
6438           break;
6439         }
6440     }
6441   return TRUE;
6442 }
6443
6444 /* The maximum size of .sfpr.  */
6445 #define SFPR_MAX (218*4)
6446
6447 struct sfpr_def_parms
6448 {
6449   const char name[12];
6450   unsigned char lo, hi;
6451   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6452   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6453 };
6454
6455 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6456
6457 static bfd_boolean
6458 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6459 {
6460   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6461   unsigned int i;
6462   size_t len = strlen (parm->name);
6463   bfd_boolean writing = FALSE;
6464   char sym[16];
6465
6466   if (htab == NULL)
6467     return FALSE;
6468
6469   memcpy (sym, parm->name, len);
6470   sym[len + 2] = 0;
6471
6472   for (i = parm->lo; i <= parm->hi; i++)
6473     {
6474       struct elf_link_hash_entry *h;
6475
6476       sym[len + 0] = i / 10 + '0';
6477       sym[len + 1] = i % 10 + '0';
6478       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6479       if (h != NULL
6480           && !h->def_regular)
6481         {
6482           h->root.type = bfd_link_hash_defined;
6483           h->root.u.def.section = htab->sfpr;
6484           h->root.u.def.value = htab->sfpr->size;
6485           h->type = STT_FUNC;
6486           h->def_regular = 1;
6487           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6488           writing = TRUE;
6489           if (htab->sfpr->contents == NULL)
6490             {
6491               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6492               if (htab->sfpr->contents == NULL)
6493                 return FALSE;
6494             }
6495         }
6496       if (writing)
6497         {
6498           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6499           if (i != parm->hi)
6500             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6501           else
6502             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6503           htab->sfpr->size = p - htab->sfpr->contents;
6504         }
6505     }
6506
6507   return TRUE;
6508 }
6509
6510 static bfd_byte *
6511 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6512 {
6513   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6514   return p + 4;
6515 }
6516
6517 static bfd_byte *
6518 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6519 {
6520   p = savegpr0 (abfd, p, r);
6521   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6522   p = p + 4;
6523   bfd_put_32 (abfd, BLR, p);
6524   return p + 4;
6525 }
6526
6527 static bfd_byte *
6528 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6529 {
6530   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6531   return p + 4;
6532 }
6533
6534 static bfd_byte *
6535 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 {
6537   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6538   p = p + 4;
6539   p = restgpr0 (abfd, p, r);
6540   bfd_put_32 (abfd, MTLR_R0, p);
6541   p = p + 4;
6542   if (r == 29)
6543     {
6544       p = restgpr0 (abfd, p, 30);
6545       p = restgpr0 (abfd, p, 31);
6546     }
6547   bfd_put_32 (abfd, BLR, p);
6548   return p + 4;
6549 }
6550
6551 static bfd_byte *
6552 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6553 {
6554   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6555   return p + 4;
6556 }
6557
6558 static bfd_byte *
6559 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6560 {
6561   p = savegpr1 (abfd, p, r);
6562   bfd_put_32 (abfd, BLR, p);
6563   return p + 4;
6564 }
6565
6566 static bfd_byte *
6567 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6568 {
6569   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6570   return p + 4;
6571 }
6572
6573 static bfd_byte *
6574 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6575 {
6576   p = restgpr1 (abfd, p, r);
6577   bfd_put_32 (abfd, BLR, p);
6578   return p + 4;
6579 }
6580
6581 static bfd_byte *
6582 savefpr (bfd *abfd, bfd_byte *p, int r)
6583 {
6584   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585   return p + 4;
6586 }
6587
6588 static bfd_byte *
6589 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591   p = savefpr (abfd, p, r);
6592   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6593   p = p + 4;
6594   bfd_put_32 (abfd, BLR, p);
6595   return p + 4;
6596 }
6597
6598 static bfd_byte *
6599 restfpr (bfd *abfd, bfd_byte *p, int r)
6600 {
6601   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6602   return p + 4;
6603 }
6604
6605 static bfd_byte *
6606 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 {
6608   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6609   p = p + 4;
6610   p = restfpr (abfd, p, r);
6611   bfd_put_32 (abfd, MTLR_R0, p);
6612   p = p + 4;
6613   if (r == 29)
6614     {
6615       p = restfpr (abfd, p, 30);
6616       p = restfpr (abfd, p, 31);
6617     }
6618   bfd_put_32 (abfd, BLR, p);
6619   return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   p = savefpr (abfd, p, r);
6626   bfd_put_32 (abfd, BLR, p);
6627   return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633   p = restfpr (abfd, p, r);
6634   bfd_put_32 (abfd, BLR, p);
6635   return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 savevr (bfd *abfd, bfd_byte *p, int r)
6640 {
6641   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6642   p = p + 4;
6643   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6644   return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   p = savevr (abfd, p, r);
6651   bfd_put_32 (abfd, BLR, p);
6652   return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 restvr (bfd *abfd, bfd_byte *p, int r)
6657 {
6658   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6659   p = p + 4;
6660   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6661   return p + 4;
6662 }
6663
6664 static bfd_byte *
6665 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6666 {
6667   p = restvr (abfd, p, r);
6668   bfd_put_32 (abfd, BLR, p);
6669   return p + 4;
6670 }
6671
6672 /* Called via elf_link_hash_traverse to transfer dynamic linking
6673    information on function code symbol entries to their corresponding
6674    function descriptor symbol entries.  */
6675
6676 static bfd_boolean
6677 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6678 {
6679   struct bfd_link_info *info;
6680   struct ppc_link_hash_table *htab;
6681   struct plt_entry *ent;
6682   struct ppc_link_hash_entry *fh;
6683   struct ppc_link_hash_entry *fdh;
6684   bfd_boolean force_local;
6685
6686   fh = (struct ppc_link_hash_entry *) h;
6687   if (fh->elf.root.type == bfd_link_hash_indirect)
6688     return TRUE;
6689
6690   info = inf;
6691   htab = ppc_hash_table (info);
6692   if (htab == NULL)
6693     return FALSE;
6694
6695   /* Resolve undefined references to dot-symbols as the value
6696      in the function descriptor, if we have one in a regular object.
6697      This is to satisfy cases like ".quad .foo".  Calls to functions
6698      in dynamic objects are handled elsewhere.  */
6699   if (fh->elf.root.type == bfd_link_hash_undefweak
6700       && fh->was_undefined
6701       && (fdh = defined_func_desc (fh)) != NULL
6702       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6703       && opd_entry_value (fdh->elf.root.u.def.section,
6704                           fdh->elf.root.u.def.value,
6705                           &fh->elf.root.u.def.section,
6706                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6707     {
6708       fh->elf.root.type = fdh->elf.root.type;
6709       fh->elf.forced_local = 1;
6710       fh->elf.def_regular = fdh->elf.def_regular;
6711       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6712     }
6713
6714   /* If this is a function code symbol, transfer dynamic linking
6715      information to the function descriptor symbol.  */
6716   if (!fh->is_func)
6717     return TRUE;
6718
6719   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6720     if (ent->plt.refcount > 0)
6721       break;
6722   if (ent == NULL
6723       || fh->elf.root.root.string[0] != '.'
6724       || fh->elf.root.root.string[1] == '\0')
6725     return TRUE;
6726
6727   /* Find the corresponding function descriptor symbol.  Create it
6728      as undefined if necessary.  */
6729
6730   fdh = lookup_fdh (fh, htab);
6731   if (fdh == NULL
6732       && !info->executable
6733       && (fh->elf.root.type == bfd_link_hash_undefined
6734           || fh->elf.root.type == bfd_link_hash_undefweak))
6735     {
6736       fdh = make_fdh (info, fh);
6737       if (fdh == NULL)
6738         return FALSE;
6739     }
6740
6741   /* Fake function descriptors are made undefweak.  If the function
6742      code symbol is strong undefined, make the fake sym the same.
6743      If the function code symbol is defined, then force the fake
6744      descriptor local;  We can't support overriding of symbols in a
6745      shared library on a fake descriptor.  */
6746
6747   if (fdh != NULL
6748       && fdh->fake
6749       && fdh->elf.root.type == bfd_link_hash_undefweak)
6750     {
6751       if (fh->elf.root.type == bfd_link_hash_undefined)
6752         {
6753           fdh->elf.root.type = bfd_link_hash_undefined;
6754           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6755         }
6756       else if (fh->elf.root.type == bfd_link_hash_defined
6757                || fh->elf.root.type == bfd_link_hash_defweak)
6758         {
6759           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6760         }
6761     }
6762
6763   if (fdh != NULL
6764       && !fdh->elf.forced_local
6765       && (!info->executable
6766           || fdh->elf.def_dynamic
6767           || fdh->elf.ref_dynamic
6768           || (fdh->elf.root.type == bfd_link_hash_undefweak
6769               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6770     {
6771       if (fdh->elf.dynindx == -1)
6772         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6773           return FALSE;
6774       fdh->elf.ref_regular |= fh->elf.ref_regular;
6775       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6776       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6777       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6778       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6779         {
6780           move_plt_plist (fh, fdh);
6781           fdh->elf.needs_plt = 1;
6782         }
6783       fdh->is_func_descriptor = 1;
6784       fdh->oh = fh;
6785       fh->oh = fdh;
6786     }
6787
6788   /* Now that the info is on the function descriptor, clear the
6789      function code sym info.  Any function code syms for which we
6790      don't have a definition in a regular file, we force local.
6791      This prevents a shared library from exporting syms that have
6792      been imported from another library.  Function code syms that
6793      are really in the library we must leave global to prevent the
6794      linker dragging in a definition from a static library.  */
6795   force_local = (!fh->elf.def_regular
6796                  || fdh == NULL
6797                  || !fdh->elf.def_regular
6798                  || fdh->elf.forced_local);
6799   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6800
6801   return TRUE;
6802 }
6803
6804 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6805    this hook to a) provide some gcc support functions, and b) transfer
6806    dynamic linking information gathered so far on function code symbol
6807    entries, to their corresponding function descriptor symbol entries.  */
6808
6809 static bfd_boolean
6810 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6811                             struct bfd_link_info *info)
6812 {
6813   struct ppc_link_hash_table *htab;
6814   unsigned int i;
6815   static const struct sfpr_def_parms funcs[] =
6816     {
6817       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6818       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6819       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6820       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6821       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6822       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6823       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6824       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6825       { "._savef", 14, 31, savefpr, savefpr1_tail },
6826       { "._restf", 14, 31, restfpr, restfpr1_tail },
6827       { "_savevr_", 20, 31, savevr, savevr_tail },
6828       { "_restvr_", 20, 31, restvr, restvr_tail }
6829     };
6830
6831   htab = ppc_hash_table (info);
6832   if (htab == NULL)
6833     return FALSE;
6834
6835   if (!info->relocatable
6836       && htab->elf.hgot != NULL)
6837     {
6838       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6839       /* Make .TOC. defined so as to prevent it being made dynamic.
6840          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6841       htab->elf.hgot->type = STT_OBJECT;
6842       htab->elf.hgot->root.type = bfd_link_hash_defined;
6843       htab->elf.hgot->root.u.def.value = 0;
6844       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6845       htab->elf.hgot->def_regular = 1;
6846       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6847                                | STV_HIDDEN);
6848     }
6849
6850   if (htab->sfpr == NULL)
6851     /* We don't have any relocs.  */
6852     return TRUE;
6853
6854   /* Provide any missing _save* and _rest* functions.  */
6855   htab->sfpr->size = 0;
6856   if (!info->relocatable)
6857     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6858       if (!sfpr_define (info, &funcs[i]))
6859         return FALSE;
6860
6861   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6862
6863   if (htab->sfpr->size == 0)
6864     htab->sfpr->flags |= SEC_EXCLUDE;
6865
6866   return TRUE;
6867 }
6868
6869 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6870
6871 static bfd_boolean
6872 readonly_dynrelocs (struct elf_link_hash_entry *h)
6873 {
6874   struct ppc_link_hash_entry *eh;
6875   struct elf_dyn_relocs *p;
6876
6877   eh = (struct ppc_link_hash_entry *) h;
6878   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6879     {
6880       asection *s = p->sec->output_section;
6881
6882       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6883         return TRUE;
6884     }
6885   return FALSE;
6886 }
6887
6888 /* Adjust a symbol defined by a dynamic object and referenced by a
6889    regular object.  The current definition is in some section of the
6890    dynamic object, but we're not including those sections.  We have to
6891    change the definition to something the rest of the link can
6892    understand.  */
6893
6894 static bfd_boolean
6895 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6896                                  struct elf_link_hash_entry *h)
6897 {
6898   struct ppc_link_hash_table *htab;
6899   asection *s;
6900
6901   htab = ppc_hash_table (info);
6902   if (htab == NULL)
6903     return FALSE;
6904
6905   /* Deal with function syms.  */
6906   if (h->type == STT_FUNC
6907       || h->type == STT_GNU_IFUNC
6908       || h->needs_plt)
6909     {
6910       /* Clear procedure linkage table information for any symbol that
6911          won't need a .plt entry.  */
6912       struct plt_entry *ent;
6913       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6914         if (ent->plt.refcount > 0)
6915           break;
6916       if (ent == NULL
6917           || (h->type != STT_GNU_IFUNC
6918               && (SYMBOL_CALLS_LOCAL (info, h)
6919                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6920                       && h->root.type == bfd_link_hash_undefweak))))
6921         {
6922           h->plt.plist = NULL;
6923           h->needs_plt = 0;
6924         }
6925       else if (abiversion (info->output_bfd) == 2)
6926         {
6927           /* After adjust_dynamic_symbol, non_got_ref set in the
6928              non-shared case means that we have allocated space in
6929              .dynbss for the symbol and thus dyn_relocs for this
6930              symbol should be discarded.
6931              If we get here we know we are making a PLT entry for this
6932              symbol, and in an executable we'd normally resolve
6933              relocations against this symbol to the PLT entry.  Allow
6934              dynamic relocs if the reference is weak, and the dynamic
6935              relocs will not cause text relocation.  */
6936           if (!h->ref_regular_nonweak
6937               && h->non_got_ref
6938               && h->type != STT_GNU_IFUNC
6939               && !readonly_dynrelocs (h))
6940             h->non_got_ref = 0;
6941
6942           /* If making a plt entry, then we don't need copy relocs.  */
6943           return TRUE;
6944         }
6945     }
6946   else
6947     h->plt.plist = NULL;
6948
6949   /* If this is a weak symbol, and there is a real definition, the
6950      processor independent code will have arranged for us to see the
6951      real definition first, and we can just use the same value.  */
6952   if (h->u.weakdef != NULL)
6953     {
6954       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6955                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6956       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6957       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6958       if (ELIMINATE_COPY_RELOCS)
6959         h->non_got_ref = h->u.weakdef->non_got_ref;
6960       return TRUE;
6961     }
6962
6963   /* If we are creating a shared library, we must presume that the
6964      only references to the symbol are via the global offset table.
6965      For such cases we need not do anything here; the relocations will
6966      be handled correctly by relocate_section.  */
6967   if (info->shared)
6968     return TRUE;
6969
6970   /* If there are no references to this symbol that do not use the
6971      GOT, we don't need to generate a copy reloc.  */
6972   if (!h->non_got_ref)
6973     return TRUE;
6974
6975   /* Don't generate a copy reloc for symbols defined in the executable.  */
6976   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6977     return TRUE;
6978
6979   /* If we didn't find any dynamic relocs in read-only sections, then
6980      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6981   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6982     {
6983       h->non_got_ref = 0;
6984       return TRUE;
6985     }
6986
6987   if (h->plt.plist != NULL)
6988     {
6989       /* We should never get here, but unfortunately there are versions
6990          of gcc out there that improperly (for this ABI) put initialized
6991          function pointers, vtable refs and suchlike in read-only
6992          sections.  Allow them to proceed, but warn that this might
6993          break at runtime.  */
6994       info->callbacks->einfo
6995         (_("%P: copy reloc against `%T' requires lazy plt linking; "
6996            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6997          h->root.root.string);
6998     }
6999
7000   /* This is a reference to a symbol defined by a dynamic object which
7001      is not a function.  */
7002
7003   /* We must allocate the symbol in our .dynbss section, which will
7004      become part of the .bss section of the executable.  There will be
7005      an entry for this symbol in the .dynsym section.  The dynamic
7006      object will contain position independent code, so all references
7007      from the dynamic object to this symbol will go through the global
7008      offset table.  The dynamic linker will use the .dynsym entry to
7009      determine the address it must put in the global offset table, so
7010      both the dynamic object and the regular object will refer to the
7011      same memory location for the variable.  */
7012
7013   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7014      to copy the initial value out of the dynamic object and into the
7015      runtime process image.  We need to remember the offset into the
7016      .rela.bss section we are going to use.  */
7017   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7018     {
7019       htab->relbss->size += sizeof (Elf64_External_Rela);
7020       h->needs_copy = 1;
7021     }
7022
7023   s = htab->dynbss;
7024
7025   return _bfd_elf_adjust_dynamic_copy (h, s);
7026 }
7027
7028 /* If given a function descriptor symbol, hide both the function code
7029    sym and the descriptor.  */
7030 static void
7031 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7032                        struct elf_link_hash_entry *h,
7033                        bfd_boolean force_local)
7034 {
7035   struct ppc_link_hash_entry *eh;
7036   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7037
7038   eh = (struct ppc_link_hash_entry *) h;
7039   if (eh->is_func_descriptor)
7040     {
7041       struct ppc_link_hash_entry *fh = eh->oh;
7042
7043       if (fh == NULL)
7044         {
7045           const char *p, *q;
7046           struct ppc_link_hash_table *htab;
7047           char save;
7048
7049           /* We aren't supposed to use alloca in BFD because on
7050              systems which do not have alloca the version in libiberty
7051              calls xmalloc, which might cause the program to crash
7052              when it runs out of memory.  This function doesn't have a
7053              return status, so there's no way to gracefully return an
7054              error.  So cheat.  We know that string[-1] can be safely
7055              accessed;  It's either a string in an ELF string table,
7056              or allocated in an objalloc structure.  */
7057
7058           p = eh->elf.root.root.string - 1;
7059           save = *p;
7060           *(char *) p = '.';
7061           htab = ppc_hash_table (info);
7062           if (htab == NULL)
7063             return;
7064
7065           fh = (struct ppc_link_hash_entry *)
7066             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7067           *(char *) p = save;
7068
7069           /* Unfortunately, if it so happens that the string we were
7070              looking for was allocated immediately before this string,
7071              then we overwrote the string terminator.  That's the only
7072              reason the lookup should fail.  */
7073           if (fh == NULL)
7074             {
7075               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7076               while (q >= eh->elf.root.root.string && *q == *p)
7077                 --q, --p;
7078               if (q < eh->elf.root.root.string && *p == '.')
7079                 fh = (struct ppc_link_hash_entry *)
7080                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7081             }
7082           if (fh != NULL)
7083             {
7084               eh->oh = fh;
7085               fh->oh = eh;
7086             }
7087         }
7088       if (fh != NULL)
7089         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7090     }
7091 }
7092
7093 static bfd_boolean
7094 get_sym_h (struct elf_link_hash_entry **hp,
7095            Elf_Internal_Sym **symp,
7096            asection **symsecp,
7097            unsigned char **tls_maskp,
7098            Elf_Internal_Sym **locsymsp,
7099            unsigned long r_symndx,
7100            bfd *ibfd)
7101 {
7102   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7103
7104   if (r_symndx >= symtab_hdr->sh_info)
7105     {
7106       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7107       struct elf_link_hash_entry *h;
7108
7109       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7110       h = elf_follow_link (h);
7111
7112       if (hp != NULL)
7113         *hp = h;
7114
7115       if (symp != NULL)
7116         *symp = NULL;
7117
7118       if (symsecp != NULL)
7119         {
7120           asection *symsec = NULL;
7121           if (h->root.type == bfd_link_hash_defined
7122               || h->root.type == bfd_link_hash_defweak)
7123             symsec = h->root.u.def.section;
7124           *symsecp = symsec;
7125         }
7126
7127       if (tls_maskp != NULL)
7128         {
7129           struct ppc_link_hash_entry *eh;
7130
7131           eh = (struct ppc_link_hash_entry *) h;
7132           *tls_maskp = &eh->tls_mask;
7133         }
7134     }
7135   else
7136     {
7137       Elf_Internal_Sym *sym;
7138       Elf_Internal_Sym *locsyms = *locsymsp;
7139
7140       if (locsyms == NULL)
7141         {
7142           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7143           if (locsyms == NULL)
7144             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7145                                             symtab_hdr->sh_info,
7146                                             0, NULL, NULL, NULL);
7147           if (locsyms == NULL)
7148             return FALSE;
7149           *locsymsp = locsyms;
7150         }
7151       sym = locsyms + r_symndx;
7152
7153       if (hp != NULL)
7154         *hp = NULL;
7155
7156       if (symp != NULL)
7157         *symp = sym;
7158
7159       if (symsecp != NULL)
7160         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7161
7162       if (tls_maskp != NULL)
7163         {
7164           struct got_entry **lgot_ents;
7165           unsigned char *tls_mask;
7166
7167           tls_mask = NULL;
7168           lgot_ents = elf_local_got_ents (ibfd);
7169           if (lgot_ents != NULL)
7170             {
7171               struct plt_entry **local_plt = (struct plt_entry **)
7172                 (lgot_ents + symtab_hdr->sh_info);
7173               unsigned char *lgot_masks = (unsigned char *)
7174                 (local_plt + symtab_hdr->sh_info);
7175               tls_mask = &lgot_masks[r_symndx];
7176             }
7177           *tls_maskp = tls_mask;
7178         }
7179     }
7180   return TRUE;
7181 }
7182
7183 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7184    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7185    type suitable for optimization, and 1 otherwise.  */
7186
7187 static int
7188 get_tls_mask (unsigned char **tls_maskp,
7189               unsigned long *toc_symndx,
7190               bfd_vma *toc_addend,
7191               Elf_Internal_Sym **locsymsp,
7192               const Elf_Internal_Rela *rel,
7193               bfd *ibfd)
7194 {
7195   unsigned long r_symndx;
7196   int next_r;
7197   struct elf_link_hash_entry *h;
7198   Elf_Internal_Sym *sym;
7199   asection *sec;
7200   bfd_vma off;
7201
7202   r_symndx = ELF64_R_SYM (rel->r_info);
7203   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7204     return 0;
7205
7206   if ((*tls_maskp != NULL && **tls_maskp != 0)
7207       || sec == NULL
7208       || ppc64_elf_section_data (sec) == NULL
7209       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7210     return 1;
7211
7212   /* Look inside a TOC section too.  */
7213   if (h != NULL)
7214     {
7215       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7216       off = h->root.u.def.value;
7217     }
7218   else
7219     off = sym->st_value;
7220   off += rel->r_addend;
7221   BFD_ASSERT (off % 8 == 0);
7222   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7223   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7224   if (toc_symndx != NULL)
7225     *toc_symndx = r_symndx;
7226   if (toc_addend != NULL)
7227     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7228   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7229     return 0;
7230   if ((h == NULL || is_static_defined (h))
7231       && (next_r == -1 || next_r == -2))
7232     return 1 - next_r;
7233   return 1;
7234 }
7235
7236 /* Find (or create) an entry in the tocsave hash table.  */
7237
7238 static struct tocsave_entry *
7239 tocsave_find (struct ppc_link_hash_table *htab,
7240               enum insert_option insert,
7241               Elf_Internal_Sym **local_syms,
7242               const Elf_Internal_Rela *irela,
7243               bfd *ibfd)
7244 {
7245   unsigned long r_indx;
7246   struct elf_link_hash_entry *h;
7247   Elf_Internal_Sym *sym;
7248   struct tocsave_entry ent, *p;
7249   hashval_t hash;
7250   struct tocsave_entry **slot;
7251
7252   r_indx = ELF64_R_SYM (irela->r_info);
7253   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7254     return NULL;
7255   if (ent.sec == NULL || ent.sec->output_section == NULL)
7256     {
7257       (*_bfd_error_handler)
7258         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7259       return NULL;
7260     }
7261
7262   if (h != NULL)
7263     ent.offset = h->root.u.def.value;
7264   else
7265     ent.offset = sym->st_value;
7266   ent.offset += irela->r_addend;
7267
7268   hash = tocsave_htab_hash (&ent);
7269   slot = ((struct tocsave_entry **)
7270           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7271   if (slot == NULL)
7272     return NULL;
7273
7274   if (*slot == NULL)
7275     {
7276       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7277       if (p == NULL)
7278         return NULL;
7279       *p = ent;
7280       *slot = p;
7281     }
7282   return *slot;
7283 }
7284
7285 /* Adjust all global syms defined in opd sections.  In gcc generated
7286    code for the old ABI, these will already have been done.  */
7287
7288 static bfd_boolean
7289 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7290 {
7291   struct ppc_link_hash_entry *eh;
7292   asection *sym_sec;
7293   struct _opd_sec_data *opd;
7294
7295   if (h->root.type == bfd_link_hash_indirect)
7296     return TRUE;
7297
7298   if (h->root.type != bfd_link_hash_defined
7299       && h->root.type != bfd_link_hash_defweak)
7300     return TRUE;
7301
7302   eh = (struct ppc_link_hash_entry *) h;
7303   if (eh->adjust_done)
7304     return TRUE;
7305
7306   sym_sec = eh->elf.root.u.def.section;
7307   opd = get_opd_info (sym_sec);
7308   if (opd != NULL && opd->adjust != NULL)
7309     {
7310       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7311       if (adjust == -1)
7312         {
7313           /* This entry has been deleted.  */
7314           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7315           if (dsec == NULL)
7316             {
7317               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7318                 if (discarded_section (dsec))
7319                   {
7320                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7321                     break;
7322                   }
7323             }
7324           eh->elf.root.u.def.value = 0;
7325           eh->elf.root.u.def.section = dsec;
7326         }
7327       else
7328         eh->elf.root.u.def.value += adjust;
7329       eh->adjust_done = 1;
7330     }
7331   return TRUE;
7332 }
7333
7334 /* Handles decrementing dynamic reloc counts for the reloc specified by
7335    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7336    have already been determined.  */
7337
7338 static bfd_boolean
7339 dec_dynrel_count (bfd_vma r_info,
7340                   asection *sec,
7341                   struct bfd_link_info *info,
7342                   Elf_Internal_Sym **local_syms,
7343                   struct elf_link_hash_entry *h,
7344                   Elf_Internal_Sym *sym)
7345 {
7346   enum elf_ppc64_reloc_type r_type;
7347   asection *sym_sec = NULL;
7348
7349   /* Can this reloc be dynamic?  This switch, and later tests here
7350      should be kept in sync with the code in check_relocs.  */
7351   r_type = ELF64_R_TYPE (r_info);
7352   switch (r_type)
7353     {
7354     default:
7355       return TRUE;
7356
7357     case R_PPC64_TPREL16:
7358     case R_PPC64_TPREL16_LO:
7359     case R_PPC64_TPREL16_HI:
7360     case R_PPC64_TPREL16_HA:
7361     case R_PPC64_TPREL16_DS:
7362     case R_PPC64_TPREL16_LO_DS:
7363     case R_PPC64_TPREL16_HIGH:
7364     case R_PPC64_TPREL16_HIGHA:
7365     case R_PPC64_TPREL16_HIGHER:
7366     case R_PPC64_TPREL16_HIGHERA:
7367     case R_PPC64_TPREL16_HIGHEST:
7368     case R_PPC64_TPREL16_HIGHESTA:
7369       if (!info->shared)
7370         return TRUE;
7371
7372     case R_PPC64_TPREL64:
7373     case R_PPC64_DTPMOD64:
7374     case R_PPC64_DTPREL64:
7375     case R_PPC64_ADDR64:
7376     case R_PPC64_REL30:
7377     case R_PPC64_REL32:
7378     case R_PPC64_REL64:
7379     case R_PPC64_ADDR14:
7380     case R_PPC64_ADDR14_BRNTAKEN:
7381     case R_PPC64_ADDR14_BRTAKEN:
7382     case R_PPC64_ADDR16:
7383     case R_PPC64_ADDR16_DS:
7384     case R_PPC64_ADDR16_HA:
7385     case R_PPC64_ADDR16_HI:
7386     case R_PPC64_ADDR16_HIGH:
7387     case R_PPC64_ADDR16_HIGHA:
7388     case R_PPC64_ADDR16_HIGHER:
7389     case R_PPC64_ADDR16_HIGHERA:
7390     case R_PPC64_ADDR16_HIGHEST:
7391     case R_PPC64_ADDR16_HIGHESTA:
7392     case R_PPC64_ADDR16_LO:
7393     case R_PPC64_ADDR16_LO_DS:
7394     case R_PPC64_ADDR24:
7395     case R_PPC64_ADDR32:
7396     case R_PPC64_UADDR16:
7397     case R_PPC64_UADDR32:
7398     case R_PPC64_UADDR64:
7399     case R_PPC64_TOC:
7400       break;
7401     }
7402
7403   if (local_syms != NULL)
7404     {
7405       unsigned long r_symndx;
7406       bfd *ibfd = sec->owner;
7407
7408       r_symndx = ELF64_R_SYM (r_info);
7409       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7410         return FALSE;
7411     }
7412
7413   if ((info->shared
7414        && (must_be_dyn_reloc (info, r_type)
7415            || (h != NULL
7416                && (!SYMBOLIC_BIND (info, h)
7417                    || h->root.type == bfd_link_hash_defweak
7418                    || !h->def_regular))))
7419       || (ELIMINATE_COPY_RELOCS
7420           && !info->shared
7421           && h != NULL
7422           && (h->root.type == bfd_link_hash_defweak
7423               || !h->def_regular)))
7424     ;
7425   else
7426     return TRUE;
7427
7428   if (h != NULL)
7429     {
7430       struct elf_dyn_relocs *p;
7431       struct elf_dyn_relocs **pp;
7432       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7433
7434       /* elf_gc_sweep may have already removed all dyn relocs associated
7435          with local syms for a given section.  Also, symbol flags are
7436          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7437          report a dynreloc miscount.  */
7438       if (*pp == NULL && info->gc_sections)
7439         return TRUE;
7440
7441       while ((p = *pp) != NULL)
7442         {
7443           if (p->sec == sec)
7444             {
7445               if (!must_be_dyn_reloc (info, r_type))
7446                 p->pc_count -= 1;
7447               p->count -= 1;
7448               if (p->count == 0)
7449                 *pp = p->next;
7450               return TRUE;
7451             }
7452           pp = &p->next;
7453         }
7454     }
7455   else
7456     {
7457       struct ppc_dyn_relocs *p;
7458       struct ppc_dyn_relocs **pp;
7459       void *vpp;
7460       bfd_boolean is_ifunc;
7461
7462       if (local_syms == NULL)
7463         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7464       if (sym_sec == NULL)
7465         sym_sec = sec;
7466
7467       vpp = &elf_section_data (sym_sec)->local_dynrel;
7468       pp = (struct ppc_dyn_relocs **) vpp;
7469
7470       if (*pp == NULL && info->gc_sections)
7471         return TRUE;
7472
7473       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7474       while ((p = *pp) != NULL)
7475         {
7476           if (p->sec == sec && p->ifunc == is_ifunc)
7477             {
7478               p->count -= 1;
7479               if (p->count == 0)
7480                 *pp = p->next;
7481               return TRUE;
7482             }
7483           pp = &p->next;
7484         }
7485     }
7486
7487   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7488                           sec->owner, sec);
7489   bfd_set_error (bfd_error_bad_value);
7490   return FALSE;
7491 }
7492
7493 /* Remove unused Official Procedure Descriptor entries.  Currently we
7494    only remove those associated with functions in discarded link-once
7495    sections, or weakly defined functions that have been overridden.  It
7496    would be possible to remove many more entries for statically linked
7497    applications.  */
7498
7499 bfd_boolean
7500 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7501 {
7502   bfd *ibfd;
7503   bfd_boolean some_edited = FALSE;
7504   asection *need_pad = NULL;
7505
7506   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7507     {
7508       asection *sec;
7509       Elf_Internal_Rela *relstart, *rel, *relend;
7510       Elf_Internal_Shdr *symtab_hdr;
7511       Elf_Internal_Sym *local_syms;
7512       bfd_vma offset;
7513       struct _opd_sec_data *opd;
7514       bfd_boolean need_edit, add_aux_fields;
7515       bfd_size_type cnt_16b = 0;
7516
7517       if (!is_ppc64_elf (ibfd))
7518         continue;
7519
7520       sec = bfd_get_section_by_name (ibfd, ".opd");
7521       if (sec == NULL || sec->size == 0)
7522         continue;
7523
7524       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7525         continue;
7526
7527       if (sec->output_section == bfd_abs_section_ptr)
7528         continue;
7529
7530       /* Look through the section relocs.  */
7531       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7532         continue;
7533
7534       local_syms = NULL;
7535       symtab_hdr = &elf_symtab_hdr (ibfd);
7536
7537       /* Read the relocations.  */
7538       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7539                                             info->keep_memory);
7540       if (relstart == NULL)
7541         return FALSE;
7542
7543       /* First run through the relocs to check they are sane, and to
7544          determine whether we need to edit this opd section.  */
7545       need_edit = FALSE;
7546       need_pad = sec;
7547       offset = 0;
7548       relend = relstart + sec->reloc_count;
7549       for (rel = relstart; rel < relend; )
7550         {
7551           enum elf_ppc64_reloc_type r_type;
7552           unsigned long r_symndx;
7553           asection *sym_sec;
7554           struct elf_link_hash_entry *h;
7555           Elf_Internal_Sym *sym;
7556
7557           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7558              only interested in the reloc pointing to a function entry
7559              point.  */
7560           if (rel->r_offset != offset
7561               || rel + 1 >= relend
7562               || (rel + 1)->r_offset != offset + 8)
7563             {
7564               /* If someone messes with .opd alignment then after a
7565                  "ld -r" we might have padding in the middle of .opd.
7566                  Also, there's nothing to prevent someone putting
7567                  something silly in .opd with the assembler.  No .opd
7568                  optimization for them!  */
7569             broken_opd:
7570               (*_bfd_error_handler)
7571                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7572               need_edit = FALSE;
7573               break;
7574             }
7575
7576           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7577               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7578             {
7579               (*_bfd_error_handler)
7580                 (_("%B: unexpected reloc type %u in .opd section"),
7581                  ibfd, r_type);
7582               need_edit = FALSE;
7583               break;
7584             }
7585
7586           r_symndx = ELF64_R_SYM (rel->r_info);
7587           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7588                           r_symndx, ibfd))
7589             goto error_ret;
7590
7591           if (sym_sec == NULL || sym_sec->owner == NULL)
7592             {
7593               const char *sym_name;
7594               if (h != NULL)
7595                 sym_name = h->root.root.string;
7596               else
7597                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7598                                              sym_sec);
7599
7600               (*_bfd_error_handler)
7601                 (_("%B: undefined sym `%s' in .opd section"),
7602                  ibfd, sym_name);
7603               need_edit = FALSE;
7604               break;
7605             }
7606
7607           /* opd entries are always for functions defined in the
7608              current input bfd.  If the symbol isn't defined in the
7609              input bfd, then we won't be using the function in this
7610              bfd;  It must be defined in a linkonce section in another
7611              bfd, or is weak.  It's also possible that we are
7612              discarding the function due to a linker script /DISCARD/,
7613              which we test for via the output_section.  */
7614           if (sym_sec->owner != ibfd
7615               || sym_sec->output_section == bfd_abs_section_ptr)
7616             need_edit = TRUE;
7617
7618           rel += 2;
7619           if (rel == relend
7620               || (rel + 1 == relend && rel->r_offset == offset + 16))
7621             {
7622               if (sec->size == offset + 24)
7623                 {
7624                   need_pad = NULL;
7625                   break;
7626                 }
7627               if (rel == relend && sec->size == offset + 16)
7628                 {
7629                   cnt_16b++;
7630                   break;
7631                 }
7632               goto broken_opd;
7633             }
7634
7635           if (rel->r_offset == offset + 24)
7636             offset += 24;
7637           else if (rel->r_offset != offset + 16)
7638             goto broken_opd;
7639           else if (rel + 1 < relend
7640                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7641                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7642             {
7643               offset += 16;
7644               cnt_16b++;
7645             }
7646           else if (rel + 2 < relend
7647                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7648                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7649             {
7650               offset += 24;
7651               rel += 1;
7652             }
7653           else
7654             goto broken_opd;
7655         }
7656
7657       add_aux_fields = non_overlapping && cnt_16b > 0;
7658
7659       if (need_edit || add_aux_fields)
7660         {
7661           Elf_Internal_Rela *write_rel;
7662           Elf_Internal_Shdr *rel_hdr;
7663           bfd_byte *rptr, *wptr;
7664           bfd_byte *new_contents;
7665           bfd_boolean skip;
7666           long opd_ent_size;
7667           bfd_size_type amt;
7668
7669           new_contents = NULL;
7670           amt = sec->size * sizeof (long) / 8;
7671           opd = &ppc64_elf_section_data (sec)->u.opd;
7672           opd->adjust = bfd_zalloc (sec->owner, amt);
7673           if (opd->adjust == NULL)
7674             return FALSE;
7675           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7676
7677           /* This seems a waste of time as input .opd sections are all
7678              zeros as generated by gcc, but I suppose there's no reason
7679              this will always be so.  We might start putting something in
7680              the third word of .opd entries.  */
7681           if ((sec->flags & SEC_IN_MEMORY) == 0)
7682             {
7683               bfd_byte *loc;
7684               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7685                 {
7686                   if (loc != NULL)
7687                     free (loc);
7688                 error_ret:
7689                   if (local_syms != NULL
7690                       && symtab_hdr->contents != (unsigned char *) local_syms)
7691                     free (local_syms);
7692                   if (elf_section_data (sec)->relocs != relstart)
7693                     free (relstart);
7694                   return FALSE;
7695                 }
7696               sec->contents = loc;
7697               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7698             }
7699
7700           elf_section_data (sec)->relocs = relstart;
7701
7702           new_contents = sec->contents;
7703           if (add_aux_fields)
7704             {
7705               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7706               if (new_contents == NULL)
7707                 return FALSE;
7708               need_pad = FALSE;
7709             }
7710           wptr = new_contents;
7711           rptr = sec->contents;
7712
7713           write_rel = relstart;
7714           skip = FALSE;
7715           offset = 0;
7716           opd_ent_size = 0;
7717           for (rel = relstart; rel < relend; rel++)
7718             {
7719               unsigned long r_symndx;
7720               asection *sym_sec;
7721               struct elf_link_hash_entry *h;
7722               Elf_Internal_Sym *sym;
7723
7724               r_symndx = ELF64_R_SYM (rel->r_info);
7725               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7726                               r_symndx, ibfd))
7727                 goto error_ret;
7728
7729               if (rel->r_offset == offset)
7730                 {
7731                   struct ppc_link_hash_entry *fdh = NULL;
7732
7733                   /* See if the .opd entry is full 24 byte or
7734                      16 byte (with fd_aux entry overlapped with next
7735                      fd_func).  */
7736                   opd_ent_size = 24;
7737                   if ((rel + 2 == relend && sec->size == offset + 16)
7738                       || (rel + 3 < relend
7739                           && rel[2].r_offset == offset + 16
7740                           && rel[3].r_offset == offset + 24
7741                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7742                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7743                     opd_ent_size = 16;
7744
7745                   if (h != NULL
7746                       && h->root.root.string[0] == '.')
7747                     {
7748                       struct ppc_link_hash_table *htab;
7749
7750                       htab = ppc_hash_table (info);
7751                       if (htab != NULL)
7752                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7753                                           htab);
7754                       if (fdh != NULL
7755                           && fdh->elf.root.type != bfd_link_hash_defined
7756                           && fdh->elf.root.type != bfd_link_hash_defweak)
7757                         fdh = NULL;
7758                     }
7759
7760                   skip = (sym_sec->owner != ibfd
7761                           || sym_sec->output_section == bfd_abs_section_ptr);
7762                   if (skip)
7763                     {
7764                       if (fdh != NULL && sym_sec->owner == ibfd)
7765                         {
7766                           /* Arrange for the function descriptor sym
7767                              to be dropped.  */
7768                           fdh->elf.root.u.def.value = 0;
7769                           fdh->elf.root.u.def.section = sym_sec;
7770                         }
7771                       opd->adjust[rel->r_offset / 8] = -1;
7772                     }
7773                   else
7774                     {
7775                       /* We'll be keeping this opd entry.  */
7776
7777                       if (fdh != NULL)
7778                         {
7779                           /* Redefine the function descriptor symbol to
7780                              this location in the opd section.  It is
7781                              necessary to update the value here rather
7782                              than using an array of adjustments as we do
7783                              for local symbols, because various places
7784                              in the generic ELF code use the value
7785                              stored in u.def.value.  */
7786                           fdh->elf.root.u.def.value = wptr - new_contents;
7787                           fdh->adjust_done = 1;
7788                         }
7789
7790                       /* Local syms are a bit tricky.  We could
7791                          tweak them as they can be cached, but
7792                          we'd need to look through the local syms
7793                          for the function descriptor sym which we
7794                          don't have at the moment.  So keep an
7795                          array of adjustments.  */
7796                       opd->adjust[rel->r_offset / 8]
7797                         = (wptr - new_contents) - (rptr - sec->contents);
7798
7799                       if (wptr != rptr)
7800                         memcpy (wptr, rptr, opd_ent_size);
7801                       wptr += opd_ent_size;
7802                       if (add_aux_fields && opd_ent_size == 16)
7803                         {
7804                           memset (wptr, '\0', 8);
7805                           wptr += 8;
7806                         }
7807                     }
7808                   rptr += opd_ent_size;
7809                   offset += opd_ent_size;
7810                 }
7811
7812               if (skip)
7813                 {
7814                   if (!NO_OPD_RELOCS
7815                       && !info->relocatable
7816                       && !dec_dynrel_count (rel->r_info, sec, info,
7817                                             NULL, h, sym))
7818                     goto error_ret;
7819                 }
7820               else
7821                 {
7822                   /* We need to adjust any reloc offsets to point to the
7823                      new opd entries.  While we're at it, we may as well
7824                      remove redundant relocs.  */
7825                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7826                   if (write_rel != rel)
7827                     memcpy (write_rel, rel, sizeof (*rel));
7828                   ++write_rel;
7829                 }
7830             }
7831
7832           sec->size = wptr - new_contents;
7833           sec->reloc_count = write_rel - relstart;
7834           if (add_aux_fields)
7835             {
7836               free (sec->contents);
7837               sec->contents = new_contents;
7838             }
7839
7840           /* Fudge the header size too, as this is used later in
7841              elf_bfd_final_link if we are emitting relocs.  */
7842           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7843           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7844           some_edited = TRUE;
7845         }
7846       else if (elf_section_data (sec)->relocs != relstart)
7847         free (relstart);
7848
7849       if (local_syms != NULL
7850           && symtab_hdr->contents != (unsigned char *) local_syms)
7851         {
7852           if (!info->keep_memory)
7853             free (local_syms);
7854           else
7855             symtab_hdr->contents = (unsigned char *) local_syms;
7856         }
7857     }
7858
7859   if (some_edited)
7860     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7861
7862   /* If we are doing a final link and the last .opd entry is just 16 byte
7863      long, add a 8 byte padding after it.  */
7864   if (need_pad != NULL && !info->relocatable)
7865     {
7866       bfd_byte *p;
7867
7868       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7869         {
7870           BFD_ASSERT (need_pad->size > 0);
7871
7872           p = bfd_malloc (need_pad->size + 8);
7873           if (p == NULL)
7874             return FALSE;
7875
7876           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7877                                           p, 0, need_pad->size))
7878             return FALSE;
7879
7880           need_pad->contents = p;
7881           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7882         }
7883       else
7884         {
7885           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7886           if (p == NULL)
7887             return FALSE;
7888
7889           need_pad->contents = p;
7890         }
7891
7892       memset (need_pad->contents + need_pad->size, 0, 8);
7893       need_pad->size += 8;
7894     }
7895
7896   return TRUE;
7897 }
7898
7899 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7900
7901 asection *
7902 ppc64_elf_tls_setup (struct bfd_link_info *info,
7903                      int no_tls_get_addr_opt,
7904                      int *no_multi_toc)
7905 {
7906   struct ppc_link_hash_table *htab;
7907
7908   htab = ppc_hash_table (info);
7909   if (htab == NULL)
7910     return NULL;
7911
7912   if (abiversion (info->output_bfd) == 1)
7913     htab->opd_abi = 1;
7914
7915   if (*no_multi_toc)
7916     htab->do_multi_toc = 0;
7917   else if (!htab->do_multi_toc)
7918     *no_multi_toc = 1;
7919
7920   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7921                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7922                                               FALSE, FALSE, TRUE));
7923   /* Move dynamic linking info to the function descriptor sym.  */
7924   if (htab->tls_get_addr != NULL)
7925     func_desc_adjust (&htab->tls_get_addr->elf, info);
7926   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7927                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7928                                                  FALSE, FALSE, TRUE));
7929   if (!no_tls_get_addr_opt)
7930     {
7931       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7932
7933       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7934                                   FALSE, FALSE, TRUE);
7935       if (opt != NULL)
7936         func_desc_adjust (opt, info);
7937       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7938                                      FALSE, FALSE, TRUE);
7939       if (opt_fd != NULL
7940           && (opt_fd->root.type == bfd_link_hash_defined
7941               || opt_fd->root.type == bfd_link_hash_defweak))
7942         {
7943           /* If glibc supports an optimized __tls_get_addr call stub,
7944              signalled by the presence of __tls_get_addr_opt, and we'll
7945              be calling __tls_get_addr via a plt call stub, then
7946              make __tls_get_addr point to __tls_get_addr_opt.  */
7947           tga_fd = &htab->tls_get_addr_fd->elf;
7948           if (htab->elf.dynamic_sections_created
7949               && tga_fd != NULL
7950               && (tga_fd->type == STT_FUNC
7951                   || tga_fd->needs_plt)
7952               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7953                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7954                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7955             {
7956               struct plt_entry *ent;
7957
7958               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7959                 if (ent->plt.refcount > 0)
7960                   break;
7961               if (ent != NULL)
7962                 {
7963                   tga_fd->root.type = bfd_link_hash_indirect;
7964                   tga_fd->root.u.i.link = &opt_fd->root;
7965                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7966                   if (opt_fd->dynindx != -1)
7967                     {
7968                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7969                       opt_fd->dynindx = -1;
7970                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7971                                               opt_fd->dynstr_index);
7972                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7973                         return NULL;
7974                     }
7975                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7976                   tga = &htab->tls_get_addr->elf;
7977                   if (opt != NULL && tga != NULL)
7978                     {
7979                       tga->root.type = bfd_link_hash_indirect;
7980                       tga->root.u.i.link = &opt->root;
7981                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7982                       _bfd_elf_link_hash_hide_symbol (info, opt,
7983                                                       tga->forced_local);
7984                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7985                     }
7986                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7987                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7988                   if (htab->tls_get_addr != NULL)
7989                     {
7990                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7991                       htab->tls_get_addr->is_func = 1;
7992                     }
7993                 }
7994             }
7995         }
7996       else
7997         no_tls_get_addr_opt = TRUE;
7998     }
7999   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8000   return _bfd_elf_tls_setup (info->output_bfd, info);
8001 }
8002
8003 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8004    HASH1 or HASH2.  */
8005
8006 static bfd_boolean
8007 branch_reloc_hash_match (const bfd *ibfd,
8008                          const Elf_Internal_Rela *rel,
8009                          const struct ppc_link_hash_entry *hash1,
8010                          const struct ppc_link_hash_entry *hash2)
8011 {
8012   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8013   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8014   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8015
8016   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8017     {
8018       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8019       struct elf_link_hash_entry *h;
8020
8021       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8022       h = elf_follow_link (h);
8023       if (h == &hash1->elf || h == &hash2->elf)
8024         return TRUE;
8025     }
8026   return FALSE;
8027 }
8028
8029 /* Run through all the TLS relocs looking for optimization
8030    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8031    a preliminary section layout so that we know the TLS segment
8032    offsets.  We can't optimize earlier because some optimizations need
8033    to know the tp offset, and we need to optimize before allocating
8034    dynamic relocations.  */
8035
8036 bfd_boolean
8037 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8038 {
8039   bfd *ibfd;
8040   asection *sec;
8041   struct ppc_link_hash_table *htab;
8042   unsigned char *toc_ref;
8043   int pass;
8044
8045   if (info->relocatable || !info->executable)
8046     return TRUE;
8047
8048   htab = ppc_hash_table (info);
8049   if (htab == NULL)
8050     return FALSE;
8051
8052   /* Make two passes over the relocs.  On the first pass, mark toc
8053      entries involved with tls relocs, and check that tls relocs
8054      involved in setting up a tls_get_addr call are indeed followed by
8055      such a call.  If they are not, we can't do any tls optimization.
8056      On the second pass twiddle tls_mask flags to notify
8057      relocate_section that optimization can be done, and adjust got
8058      and plt refcounts.  */
8059   toc_ref = NULL;
8060   for (pass = 0; pass < 2; ++pass)
8061     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8062       {
8063         Elf_Internal_Sym *locsyms = NULL;
8064         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8065
8066         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8067           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8068             {
8069               Elf_Internal_Rela *relstart, *rel, *relend;
8070               bfd_boolean found_tls_get_addr_arg = 0;
8071
8072               /* Read the relocations.  */
8073               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8074                                                     info->keep_memory);
8075               if (relstart == NULL)
8076                 return FALSE;
8077
8078               relend = relstart + sec->reloc_count;
8079               for (rel = relstart; rel < relend; rel++)
8080                 {
8081                   enum elf_ppc64_reloc_type r_type;
8082                   unsigned long r_symndx;
8083                   struct elf_link_hash_entry *h;
8084                   Elf_Internal_Sym *sym;
8085                   asection *sym_sec;
8086                   unsigned char *tls_mask;
8087                   unsigned char tls_set, tls_clear, tls_type = 0;
8088                   bfd_vma value;
8089                   bfd_boolean ok_tprel, is_local;
8090                   long toc_ref_index = 0;
8091                   int expecting_tls_get_addr = 0;
8092                   bfd_boolean ret = FALSE;
8093
8094                   r_symndx = ELF64_R_SYM (rel->r_info);
8095                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8096                                   r_symndx, ibfd))
8097                     {
8098                     err_free_rel:
8099                       if (elf_section_data (sec)->relocs != relstart)
8100                         free (relstart);
8101                       if (toc_ref != NULL)
8102                         free (toc_ref);
8103                       if (locsyms != NULL
8104                           && (elf_symtab_hdr (ibfd).contents
8105                               != (unsigned char *) locsyms))
8106                         free (locsyms);
8107                       return ret;
8108                     }
8109
8110                   if (h != NULL)
8111                     {
8112                       if (h->root.type == bfd_link_hash_defined
8113                           || h->root.type == bfd_link_hash_defweak)
8114                         value = h->root.u.def.value;
8115                       else if (h->root.type == bfd_link_hash_undefweak)
8116                         value = 0;
8117                       else
8118                         {
8119                           found_tls_get_addr_arg = 0;
8120                           continue;
8121                         }
8122                     }
8123                   else
8124                     /* Symbols referenced by TLS relocs must be of type
8125                        STT_TLS.  So no need for .opd local sym adjust.  */
8126                     value = sym->st_value;
8127
8128                   ok_tprel = FALSE;
8129                   is_local = FALSE;
8130                   if (h == NULL
8131                       || !h->def_dynamic)
8132                     {
8133                       is_local = TRUE;
8134                       if (h != NULL
8135                           && h->root.type == bfd_link_hash_undefweak)
8136                         ok_tprel = TRUE;
8137                       else
8138                         {
8139                           value += sym_sec->output_offset;
8140                           value += sym_sec->output_section->vma;
8141                           value -= htab->elf.tls_sec->vma;
8142                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8143                                       < (bfd_vma) 1 << 32);
8144                         }
8145                     }
8146
8147                   r_type = ELF64_R_TYPE (rel->r_info);
8148                   /* If this section has old-style __tls_get_addr calls
8149                      without marker relocs, then check that each
8150                      __tls_get_addr call reloc is preceded by a reloc
8151                      that conceivably belongs to the __tls_get_addr arg
8152                      setup insn.  If we don't find matching arg setup
8153                      relocs, don't do any tls optimization.  */
8154                   if (pass == 0
8155                       && sec->has_tls_get_addr_call
8156                       && h != NULL
8157                       && (h == &htab->tls_get_addr->elf
8158                           || h == &htab->tls_get_addr_fd->elf)
8159                       && !found_tls_get_addr_arg
8160                       && is_branch_reloc (r_type))
8161                     {
8162                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8163                                                 "TLS optimization disabled\n"),
8164                                               ibfd, sec, rel->r_offset);
8165                       ret = TRUE;
8166                       goto err_free_rel;
8167                     }
8168
8169                   found_tls_get_addr_arg = 0;
8170                   switch (r_type)
8171                     {
8172                     case R_PPC64_GOT_TLSLD16:
8173                     case R_PPC64_GOT_TLSLD16_LO:
8174                       expecting_tls_get_addr = 1;
8175                       found_tls_get_addr_arg = 1;
8176                       /* Fall thru */
8177
8178                     case R_PPC64_GOT_TLSLD16_HI:
8179                     case R_PPC64_GOT_TLSLD16_HA:
8180                       /* These relocs should never be against a symbol
8181                          defined in a shared lib.  Leave them alone if
8182                          that turns out to be the case.  */
8183                       if (!is_local)
8184                         continue;
8185
8186                       /* LD -> LE */
8187                       tls_set = 0;
8188                       tls_clear = TLS_LD;
8189                       tls_type = TLS_TLS | TLS_LD;
8190                       break;
8191
8192                     case R_PPC64_GOT_TLSGD16:
8193                     case R_PPC64_GOT_TLSGD16_LO:
8194                       expecting_tls_get_addr = 1;
8195                       found_tls_get_addr_arg = 1;
8196                       /* Fall thru */
8197
8198                     case R_PPC64_GOT_TLSGD16_HI:
8199                     case R_PPC64_GOT_TLSGD16_HA:
8200                       if (ok_tprel)
8201                         /* GD -> LE */
8202                         tls_set = 0;
8203                       else
8204                         /* GD -> IE */
8205                         tls_set = TLS_TLS | TLS_TPRELGD;
8206                       tls_clear = TLS_GD;
8207                       tls_type = TLS_TLS | TLS_GD;
8208                       break;
8209
8210                     case R_PPC64_GOT_TPREL16_DS:
8211                     case R_PPC64_GOT_TPREL16_LO_DS:
8212                     case R_PPC64_GOT_TPREL16_HI:
8213                     case R_PPC64_GOT_TPREL16_HA:
8214                       if (ok_tprel)
8215                         {
8216                           /* IE -> LE */
8217                           tls_set = 0;
8218                           tls_clear = TLS_TPREL;
8219                           tls_type = TLS_TLS | TLS_TPREL;
8220                           break;
8221                         }
8222                       continue;
8223
8224                     case R_PPC64_TLSGD:
8225                     case R_PPC64_TLSLD:
8226                       found_tls_get_addr_arg = 1;
8227                       /* Fall thru */
8228
8229                     case R_PPC64_TLS:
8230                     case R_PPC64_TOC16:
8231                     case R_PPC64_TOC16_LO:
8232                       if (sym_sec == NULL || sym_sec != toc)
8233                         continue;
8234
8235                       /* Mark this toc entry as referenced by a TLS
8236                          code sequence.  We can do that now in the
8237                          case of R_PPC64_TLS, and after checking for
8238                          tls_get_addr for the TOC16 relocs.  */
8239                       if (toc_ref == NULL)
8240                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8241                       if (toc_ref == NULL)
8242                         goto err_free_rel;
8243
8244                       if (h != NULL)
8245                         value = h->root.u.def.value;
8246                       else
8247                         value = sym->st_value;
8248                       value += rel->r_addend;
8249                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8250                       toc_ref_index = (value + toc->output_offset) / 8;
8251                       if (r_type == R_PPC64_TLS
8252                           || r_type == R_PPC64_TLSGD
8253                           || r_type == R_PPC64_TLSLD)
8254                         {
8255                           toc_ref[toc_ref_index] = 1;
8256                           continue;
8257                         }
8258
8259                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8260                         continue;
8261
8262                       tls_set = 0;
8263                       tls_clear = 0;
8264                       expecting_tls_get_addr = 2;
8265                       break;
8266
8267                     case R_PPC64_TPREL64:
8268                       if (pass == 0
8269                           || sec != toc
8270                           || toc_ref == NULL
8271                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8272                         continue;
8273                       if (ok_tprel)
8274                         {
8275                           /* IE -> LE */
8276                           tls_set = TLS_EXPLICIT;
8277                           tls_clear = TLS_TPREL;
8278                           break;
8279                         }
8280                       continue;
8281
8282                     case R_PPC64_DTPMOD64:
8283                       if (pass == 0
8284                           || sec != toc
8285                           || toc_ref == NULL
8286                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8287                         continue;
8288                       if (rel + 1 < relend
8289                           && (rel[1].r_info
8290                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8291                           && rel[1].r_offset == rel->r_offset + 8)
8292                         {
8293                           if (ok_tprel)
8294                             /* GD -> LE */
8295                             tls_set = TLS_EXPLICIT | TLS_GD;
8296                           else
8297                             /* GD -> IE */
8298                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8299                           tls_clear = TLS_GD;
8300                         }
8301                       else
8302                         {
8303                           if (!is_local)
8304                             continue;
8305
8306                           /* LD -> LE */
8307                           tls_set = TLS_EXPLICIT;
8308                           tls_clear = TLS_LD;
8309                         }
8310                       break;
8311
8312                     default:
8313                       continue;
8314                     }
8315
8316                   if (pass == 0)
8317                     {
8318                       if (!expecting_tls_get_addr
8319                           || !sec->has_tls_get_addr_call)
8320                         continue;
8321
8322                       if (rel + 1 < relend
8323                           && branch_reloc_hash_match (ibfd, rel + 1,
8324                                                       htab->tls_get_addr,
8325                                                       htab->tls_get_addr_fd))
8326                         {
8327                           if (expecting_tls_get_addr == 2)
8328                             {
8329                               /* Check for toc tls entries.  */
8330                               unsigned char *toc_tls;
8331                               int retval;
8332
8333                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8334                                                      &locsyms,
8335                                                      rel, ibfd);
8336                               if (retval == 0)
8337                                 goto err_free_rel;
8338                               if (toc_tls != NULL)
8339                                 {
8340                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8341                                     found_tls_get_addr_arg = 1;
8342                                   if (retval > 1)
8343                                     toc_ref[toc_ref_index] = 1;
8344                                 }
8345                             }
8346                           continue;
8347                         }
8348
8349                       if (expecting_tls_get_addr != 1)
8350                         continue;
8351
8352                       /* Uh oh, we didn't find the expected call.  We
8353                          could just mark this symbol to exclude it
8354                          from tls optimization but it's safer to skip
8355                          the entire optimization.  */
8356                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8357                                                 "TLS optimization disabled\n"),
8358                                               ibfd, sec, rel->r_offset);
8359                       ret = TRUE;
8360                       goto err_free_rel;
8361                     }
8362
8363                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8364                     {
8365                       struct plt_entry *ent;
8366                       for (ent = htab->tls_get_addr->elf.plt.plist;
8367                            ent != NULL;
8368                            ent = ent->next)
8369                         if (ent->addend == 0)
8370                           {
8371                             if (ent->plt.refcount > 0)
8372                               {
8373                                 ent->plt.refcount -= 1;
8374                                 expecting_tls_get_addr = 0;
8375                               }
8376                             break;
8377                           }
8378                     }
8379
8380                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8381                     {
8382                       struct plt_entry *ent;
8383                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8384                            ent != NULL;
8385                            ent = ent->next)
8386                         if (ent->addend == 0)
8387                           {
8388                             if (ent->plt.refcount > 0)
8389                               ent->plt.refcount -= 1;
8390                             break;
8391                           }
8392                     }
8393
8394                   if (tls_clear == 0)
8395                     continue;
8396
8397                   if ((tls_set & TLS_EXPLICIT) == 0)
8398                     {
8399                       struct got_entry *ent;
8400
8401                       /* Adjust got entry for this reloc.  */
8402                       if (h != NULL)
8403                         ent = h->got.glist;
8404                       else
8405                         ent = elf_local_got_ents (ibfd)[r_symndx];
8406
8407                       for (; ent != NULL; ent = ent->next)
8408                         if (ent->addend == rel->r_addend
8409                             && ent->owner == ibfd
8410                             && ent->tls_type == tls_type)
8411                           break;
8412                       if (ent == NULL)
8413                         abort ();
8414
8415                       if (tls_set == 0)
8416                         {
8417                           /* We managed to get rid of a got entry.  */
8418                           if (ent->got.refcount > 0)
8419                             ent->got.refcount -= 1;
8420                         }
8421                     }
8422                   else
8423                     {
8424                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8425                          we'll lose one or two dyn relocs.  */
8426                       if (!dec_dynrel_count (rel->r_info, sec, info,
8427                                              NULL, h, sym))
8428                         return FALSE;
8429
8430                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8431                         {
8432                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8433                                                  NULL, h, sym))
8434                             return FALSE;
8435                         }
8436                     }
8437
8438                   *tls_mask |= tls_set;
8439                   *tls_mask &= ~tls_clear;
8440                 }
8441
8442               if (elf_section_data (sec)->relocs != relstart)
8443                 free (relstart);
8444             }
8445
8446         if (locsyms != NULL
8447             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8448           {
8449             if (!info->keep_memory)
8450               free (locsyms);
8451             else
8452               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8453           }
8454       }
8455
8456   if (toc_ref != NULL)
8457     free (toc_ref);
8458   return TRUE;
8459 }
8460
8461 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8462    the values of any global symbols in a toc section that has been
8463    edited.  Globals in toc sections should be a rarity, so this function
8464    sets a flag if any are found in toc sections other than the one just
8465    edited, so that futher hash table traversals can be avoided.  */
8466
8467 struct adjust_toc_info
8468 {
8469   asection *toc;
8470   unsigned long *skip;
8471   bfd_boolean global_toc_syms;
8472 };
8473
8474 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8475
8476 static bfd_boolean
8477 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8478 {
8479   struct ppc_link_hash_entry *eh;
8480   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8481   unsigned long i;
8482
8483   if (h->root.type != bfd_link_hash_defined
8484       && h->root.type != bfd_link_hash_defweak)
8485     return TRUE;
8486
8487   eh = (struct ppc_link_hash_entry *) h;
8488   if (eh->adjust_done)
8489     return TRUE;
8490
8491   if (eh->elf.root.u.def.section == toc_inf->toc)
8492     {
8493       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8494         i = toc_inf->toc->rawsize >> 3;
8495       else
8496         i = eh->elf.root.u.def.value >> 3;
8497
8498       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8499         {
8500           (*_bfd_error_handler)
8501             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8502           do
8503             ++i;
8504           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8505           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8506         }
8507
8508       eh->elf.root.u.def.value -= toc_inf->skip[i];
8509       eh->adjust_done = 1;
8510     }
8511   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8512     toc_inf->global_toc_syms = TRUE;
8513
8514   return TRUE;
8515 }
8516
8517 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8518
8519 static bfd_boolean
8520 ok_lo_toc_insn (unsigned int insn)
8521 {
8522   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8523           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8524           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8525           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8526           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8527           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8528           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8529           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8530           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8531           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8532           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8533           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8534           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8535           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8536           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8537               && (insn & 3) != 1)
8538           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8539               && ((insn & 3) == 0 || (insn & 3) == 3))
8540           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8541 }
8542
8543 /* Examine all relocs referencing .toc sections in order to remove
8544    unused .toc entries.  */
8545
8546 bfd_boolean
8547 ppc64_elf_edit_toc (struct bfd_link_info *info)
8548 {
8549   bfd *ibfd;
8550   struct adjust_toc_info toc_inf;
8551   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552
8553   htab->do_toc_opt = 1;
8554   toc_inf.global_toc_syms = TRUE;
8555   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8556     {
8557       asection *toc, *sec;
8558       Elf_Internal_Shdr *symtab_hdr;
8559       Elf_Internal_Sym *local_syms;
8560       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8561       unsigned long *skip, *drop;
8562       unsigned char *used;
8563       unsigned char *keep, last, some_unused;
8564
8565       if (!is_ppc64_elf (ibfd))
8566         continue;
8567
8568       toc = bfd_get_section_by_name (ibfd, ".toc");
8569       if (toc == NULL
8570           || toc->size == 0
8571           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8572           || discarded_section (toc))
8573         continue;
8574
8575       toc_relocs = NULL;
8576       local_syms = NULL;
8577       symtab_hdr = &elf_symtab_hdr (ibfd);
8578
8579       /* Look at sections dropped from the final link.  */
8580       skip = NULL;
8581       relstart = NULL;
8582       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8583         {
8584           if (sec->reloc_count == 0
8585               || !discarded_section (sec)
8586               || get_opd_info (sec)
8587               || (sec->flags & SEC_ALLOC) == 0
8588               || (sec->flags & SEC_DEBUGGING) != 0)
8589             continue;
8590
8591           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8592           if (relstart == NULL)
8593             goto error_ret;
8594
8595           /* Run through the relocs to see which toc entries might be
8596              unused.  */
8597           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8598             {
8599               enum elf_ppc64_reloc_type r_type;
8600               unsigned long r_symndx;
8601               asection *sym_sec;
8602               struct elf_link_hash_entry *h;
8603               Elf_Internal_Sym *sym;
8604               bfd_vma val;
8605
8606               r_type = ELF64_R_TYPE (rel->r_info);
8607               switch (r_type)
8608                 {
8609                 default:
8610                   continue;
8611
8612                 case R_PPC64_TOC16:
8613                 case R_PPC64_TOC16_LO:
8614                 case R_PPC64_TOC16_HI:
8615                 case R_PPC64_TOC16_HA:
8616                 case R_PPC64_TOC16_DS:
8617                 case R_PPC64_TOC16_LO_DS:
8618                   break;
8619                 }
8620
8621               r_symndx = ELF64_R_SYM (rel->r_info);
8622               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8623                               r_symndx, ibfd))
8624                 goto error_ret;
8625
8626               if (sym_sec != toc)
8627                 continue;
8628
8629               if (h != NULL)
8630                 val = h->root.u.def.value;
8631               else
8632                 val = sym->st_value;
8633               val += rel->r_addend;
8634
8635               if (val >= toc->size)
8636                 continue;
8637
8638               /* Anything in the toc ought to be aligned to 8 bytes.
8639                  If not, don't mark as unused.  */
8640               if (val & 7)
8641                 continue;
8642
8643               if (skip == NULL)
8644                 {
8645                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8646                   if (skip == NULL)
8647                     goto error_ret;
8648                 }
8649
8650               skip[val >> 3] = ref_from_discarded;
8651             }
8652
8653           if (elf_section_data (sec)->relocs != relstart)
8654             free (relstart);
8655         }
8656
8657       /* For largetoc loads of address constants, we can convert
8658          .  addis rx,2,addr@got@ha
8659          .  ld ry,addr@got@l(rx)
8660          to
8661          .  addis rx,2,addr@toc@ha
8662          .  addi ry,rx,addr@toc@l
8663          when addr is within 2G of the toc pointer.  This then means
8664          that the word storing "addr" in the toc is no longer needed.  */
8665
8666       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8667           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8668           && toc->reloc_count != 0)
8669         {
8670           /* Read toc relocs.  */
8671           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8672                                                   info->keep_memory);
8673           if (toc_relocs == NULL)
8674             goto error_ret;
8675
8676           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8677             {
8678               enum elf_ppc64_reloc_type r_type;
8679               unsigned long r_symndx;
8680               asection *sym_sec;
8681               struct elf_link_hash_entry *h;
8682               Elf_Internal_Sym *sym;
8683               bfd_vma val, addr;
8684
8685               r_type = ELF64_R_TYPE (rel->r_info);
8686               if (r_type != R_PPC64_ADDR64)
8687                 continue;
8688
8689               r_symndx = ELF64_R_SYM (rel->r_info);
8690               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8691                               r_symndx, ibfd))
8692                 goto error_ret;
8693
8694               if (sym_sec == NULL
8695                   || discarded_section (sym_sec))
8696                 continue;
8697
8698               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8699                 continue;
8700
8701               if (h != NULL)
8702                 {
8703                   if (h->type == STT_GNU_IFUNC)
8704                     continue;
8705                   val = h->root.u.def.value;
8706                 }
8707               else
8708                 {
8709                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8710                     continue;
8711                   val = sym->st_value;
8712                 }
8713               val += rel->r_addend;
8714               val += sym_sec->output_section->vma + sym_sec->output_offset;
8715
8716               /* We don't yet know the exact toc pointer value, but we
8717                  know it will be somewhere in the toc section.  Don't
8718                  optimize if the difference from any possible toc
8719                  pointer is outside [ff..f80008000, 7fff7fff].  */
8720               addr = toc->output_section->vma + TOC_BASE_OFF;
8721               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8722                 continue;
8723
8724               addr = toc->output_section->vma + toc->output_section->rawsize;
8725               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8726                 continue;
8727
8728               if (skip == NULL)
8729                 {
8730                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8731                   if (skip == NULL)
8732                     goto error_ret;
8733                 }
8734
8735               skip[rel->r_offset >> 3]
8736                 |= can_optimize | ((rel - toc_relocs) << 2);
8737             }
8738         }
8739
8740       if (skip == NULL)
8741         continue;
8742
8743       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8744       if (used == NULL)
8745         {
8746         error_ret:
8747           if (local_syms != NULL
8748               && symtab_hdr->contents != (unsigned char *) local_syms)
8749             free (local_syms);
8750           if (sec != NULL
8751               && relstart != NULL
8752               && elf_section_data (sec)->relocs != relstart)
8753             free (relstart);
8754           if (toc_relocs != NULL
8755               && elf_section_data (toc)->relocs != toc_relocs)
8756             free (toc_relocs);
8757           if (skip != NULL)
8758             free (skip);
8759           return FALSE;
8760         }
8761
8762       /* Now check all kept sections that might reference the toc.
8763          Check the toc itself last.  */
8764       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8765                   : ibfd->sections);
8766            sec != NULL;
8767            sec = (sec == toc ? NULL
8768                   : sec->next == NULL ? toc
8769                   : sec->next == toc && toc->next ? toc->next
8770                   : sec->next))
8771         {
8772           int repeat;
8773
8774           if (sec->reloc_count == 0
8775               || discarded_section (sec)
8776               || get_opd_info (sec)
8777               || (sec->flags & SEC_ALLOC) == 0
8778               || (sec->flags & SEC_DEBUGGING) != 0)
8779             continue;
8780
8781           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8782                                                 info->keep_memory);
8783           if (relstart == NULL)
8784             goto error_ret;
8785
8786           /* Mark toc entries referenced as used.  */
8787           do
8788             {
8789               repeat = 0;
8790               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8791                 {
8792                   enum elf_ppc64_reloc_type r_type;
8793                   unsigned long r_symndx;
8794                   asection *sym_sec;
8795                   struct elf_link_hash_entry *h;
8796                   Elf_Internal_Sym *sym;
8797                   bfd_vma val;
8798                   enum {no_check, check_lo, check_ha} insn_check;
8799
8800                   r_type = ELF64_R_TYPE (rel->r_info);
8801                   switch (r_type)
8802                     {
8803                     default:
8804                       insn_check = no_check;
8805                       break;
8806
8807                     case R_PPC64_GOT_TLSLD16_HA:
8808                     case R_PPC64_GOT_TLSGD16_HA:
8809                     case R_PPC64_GOT_TPREL16_HA:
8810                     case R_PPC64_GOT_DTPREL16_HA:
8811                     case R_PPC64_GOT16_HA:
8812                     case R_PPC64_TOC16_HA:
8813                       insn_check = check_ha;
8814                       break;
8815
8816                     case R_PPC64_GOT_TLSLD16_LO:
8817                     case R_PPC64_GOT_TLSGD16_LO:
8818                     case R_PPC64_GOT_TPREL16_LO_DS:
8819                     case R_PPC64_GOT_DTPREL16_LO_DS:
8820                     case R_PPC64_GOT16_LO:
8821                     case R_PPC64_GOT16_LO_DS:
8822                     case R_PPC64_TOC16_LO:
8823                     case R_PPC64_TOC16_LO_DS:
8824                       insn_check = check_lo;
8825                       break;
8826                     }
8827
8828                   if (insn_check != no_check)
8829                     {
8830                       bfd_vma off = rel->r_offset & ~3;
8831                       unsigned char buf[4];
8832                       unsigned int insn;
8833
8834                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8835                         {
8836                           free (used);
8837                           goto error_ret;
8838                         }
8839                       insn = bfd_get_32 (ibfd, buf);
8840                       if (insn_check == check_lo
8841                           ? !ok_lo_toc_insn (insn)
8842                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8843                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8844                         {
8845                           char str[12];
8846
8847                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8848                           sprintf (str, "%#08x", insn);
8849                           info->callbacks->einfo
8850                             (_("%P: %H: toc optimization is not supported for"
8851                                " %s instruction.\n"),
8852                              ibfd, sec, rel->r_offset & ~3, str);
8853                         }
8854                     }
8855
8856                   switch (r_type)
8857                     {
8858                     case R_PPC64_TOC16:
8859                     case R_PPC64_TOC16_LO:
8860                     case R_PPC64_TOC16_HI:
8861                     case R_PPC64_TOC16_HA:
8862                     case R_PPC64_TOC16_DS:
8863                     case R_PPC64_TOC16_LO_DS:
8864                       /* In case we're taking addresses of toc entries.  */
8865                     case R_PPC64_ADDR64:
8866                       break;
8867
8868                     default:
8869                       continue;
8870                     }
8871
8872                   r_symndx = ELF64_R_SYM (rel->r_info);
8873                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8874                                   r_symndx, ibfd))
8875                     {
8876                       free (used);
8877                       goto error_ret;
8878                     }
8879
8880                   if (sym_sec != toc)
8881                     continue;
8882
8883                   if (h != NULL)
8884                     val = h->root.u.def.value;
8885                   else
8886                     val = sym->st_value;
8887                   val += rel->r_addend;
8888
8889                   if (val >= toc->size)
8890                     continue;
8891
8892                   if ((skip[val >> 3] & can_optimize) != 0)
8893                     {
8894                       bfd_vma off;
8895                       unsigned char opc;
8896
8897                       switch (r_type)
8898                         {
8899                         case R_PPC64_TOC16_HA:
8900                           break;
8901
8902                         case R_PPC64_TOC16_LO_DS:
8903                           off = rel->r_offset;
8904                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8905                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8906                                                          off, 1))
8907                             {
8908                               free (used);
8909                               goto error_ret;
8910                             }
8911                           if ((opc & (0x3f << 2)) == (58u << 2))
8912                             break;
8913                           /* Fall thru */
8914
8915                         default:
8916                           /* Wrong sort of reloc, or not a ld.  We may
8917                              as well clear ref_from_discarded too.  */
8918                           skip[val >> 3] = 0;
8919                         }
8920                     }
8921
8922                   if (sec != toc)
8923                     used[val >> 3] = 1;
8924                   /* For the toc section, we only mark as used if this
8925                      entry itself isn't unused.  */
8926                   else if ((used[rel->r_offset >> 3]
8927                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8928                            && !used[val >> 3])
8929                     {
8930                       /* Do all the relocs again, to catch reference
8931                          chains.  */
8932                       repeat = 1;
8933                       used[val >> 3] = 1;
8934                     }
8935                 }
8936             }
8937           while (repeat);
8938
8939           if (elf_section_data (sec)->relocs != relstart)
8940             free (relstart);
8941         }
8942
8943       /* Merge the used and skip arrays.  Assume that TOC
8944          doublewords not appearing as either used or unused belong
8945          to to an entry more than one doubleword in size.  */
8946       for (drop = skip, keep = used, last = 0, some_unused = 0;
8947            drop < skip + (toc->size + 7) / 8;
8948            ++drop, ++keep)
8949         {
8950           if (*keep)
8951             {
8952               *drop &= ~ref_from_discarded;
8953               if ((*drop & can_optimize) != 0)
8954                 some_unused = 1;
8955               last = 0;
8956             }
8957           else if ((*drop & ref_from_discarded) != 0)
8958             {
8959               some_unused = 1;
8960               last = ref_from_discarded;
8961             }
8962           else
8963             *drop = last;
8964         }
8965
8966       free (used);
8967
8968       if (some_unused)
8969         {
8970           bfd_byte *contents, *src;
8971           unsigned long off;
8972           Elf_Internal_Sym *sym;
8973           bfd_boolean local_toc_syms = FALSE;
8974
8975           /* Shuffle the toc contents, and at the same time convert the
8976              skip array from booleans into offsets.  */
8977           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8978             goto error_ret;
8979
8980           elf_section_data (toc)->this_hdr.contents = contents;
8981
8982           for (src = contents, off = 0, drop = skip;
8983                src < contents + toc->size;
8984                src += 8, ++drop)
8985             {
8986               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8987                 off += 8;
8988               else if (off != 0)
8989                 {
8990                   *drop = off;
8991                   memcpy (src - off, src, 8);
8992                 }
8993             }
8994           *drop = off;
8995           toc->rawsize = toc->size;
8996           toc->size = src - contents - off;
8997
8998           /* Adjust addends for relocs against the toc section sym,
8999              and optimize any accesses we can.  */
9000           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9001             {
9002               if (sec->reloc_count == 0
9003                   || discarded_section (sec))
9004                 continue;
9005
9006               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9007                                                     info->keep_memory);
9008               if (relstart == NULL)
9009                 goto error_ret;
9010
9011               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9012                 {
9013                   enum elf_ppc64_reloc_type r_type;
9014                   unsigned long r_symndx;
9015                   asection *sym_sec;
9016                   struct elf_link_hash_entry *h;
9017                   bfd_vma val;
9018
9019                   r_type = ELF64_R_TYPE (rel->r_info);
9020                   switch (r_type)
9021                     {
9022                     default:
9023                       continue;
9024
9025                     case R_PPC64_TOC16:
9026                     case R_PPC64_TOC16_LO:
9027                     case R_PPC64_TOC16_HI:
9028                     case R_PPC64_TOC16_HA:
9029                     case R_PPC64_TOC16_DS:
9030                     case R_PPC64_TOC16_LO_DS:
9031                     case R_PPC64_ADDR64:
9032                       break;
9033                     }
9034
9035                   r_symndx = ELF64_R_SYM (rel->r_info);
9036                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9037                                   r_symndx, ibfd))
9038                     goto error_ret;
9039
9040                   if (sym_sec != toc)
9041                     continue;
9042
9043                   if (h != NULL)
9044                     val = h->root.u.def.value;
9045                   else
9046                     {
9047                       val = sym->st_value;
9048                       if (val != 0)
9049                         local_toc_syms = TRUE;
9050                     }
9051
9052                   val += rel->r_addend;
9053
9054                   if (val > toc->rawsize)
9055                     val = toc->rawsize;
9056                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9057                     continue;
9058                   else if ((skip[val >> 3] & can_optimize) != 0)
9059                     {
9060                       Elf_Internal_Rela *tocrel
9061                         = toc_relocs + (skip[val >> 3] >> 2);
9062                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9063
9064                       switch (r_type)
9065                         {
9066                         case R_PPC64_TOC16_HA:
9067                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9068                           break;
9069
9070                         case R_PPC64_TOC16_LO_DS:
9071                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9072                           break;
9073
9074                         default:
9075                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9076                             ppc_howto_init ();
9077                           info->callbacks->einfo
9078                             (_("%P: %H: %s references "
9079                                "optimized away TOC entry\n"),
9080                              ibfd, sec, rel->r_offset,
9081                              ppc64_elf_howto_table[r_type]->name);
9082                           bfd_set_error (bfd_error_bad_value);
9083                           goto error_ret;
9084                         }
9085                       rel->r_addend = tocrel->r_addend;
9086                       elf_section_data (sec)->relocs = relstart;
9087                       continue;
9088                     }
9089
9090                   if (h != NULL || sym->st_value != 0)
9091                     continue;
9092
9093                   rel->r_addend -= skip[val >> 3];
9094                   elf_section_data (sec)->relocs = relstart;
9095                 }
9096
9097               if (elf_section_data (sec)->relocs != relstart)
9098                 free (relstart);
9099             }
9100
9101           /* We shouldn't have local or global symbols defined in the TOC,
9102              but handle them anyway.  */
9103           if (local_syms != NULL)
9104             for (sym = local_syms;
9105                  sym < local_syms + symtab_hdr->sh_info;
9106                  ++sym)
9107               if (sym->st_value != 0
9108                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9109                 {
9110                   unsigned long i;
9111
9112                   if (sym->st_value > toc->rawsize)
9113                     i = toc->rawsize >> 3;
9114                   else
9115                     i = sym->st_value >> 3;
9116
9117                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9118                     {
9119                       if (local_toc_syms)
9120                         (*_bfd_error_handler)
9121                           (_("%s defined on removed toc entry"),
9122                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9123                       do
9124                         ++i;
9125                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9126                       sym->st_value = (bfd_vma) i << 3;
9127                     }
9128
9129                   sym->st_value -= skip[i];
9130                   symtab_hdr->contents = (unsigned char *) local_syms;
9131                 }
9132
9133           /* Adjust any global syms defined in this toc input section.  */
9134           if (toc_inf.global_toc_syms)
9135             {
9136               toc_inf.toc = toc;
9137               toc_inf.skip = skip;
9138               toc_inf.global_toc_syms = FALSE;
9139               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9140                                       &toc_inf);
9141             }
9142
9143           if (toc->reloc_count != 0)
9144             {
9145               Elf_Internal_Shdr *rel_hdr;
9146               Elf_Internal_Rela *wrel;
9147               bfd_size_type sz;
9148
9149               /* Remove unused toc relocs, and adjust those we keep.  */
9150               if (toc_relocs == NULL)
9151                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9152                                                         info->keep_memory);
9153               if (toc_relocs == NULL)
9154                 goto error_ret;
9155
9156               wrel = toc_relocs;
9157               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9158                 if ((skip[rel->r_offset >> 3]
9159                      & (ref_from_discarded | can_optimize)) == 0)
9160                   {
9161                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9162                     wrel->r_info = rel->r_info;
9163                     wrel->r_addend = rel->r_addend;
9164                     ++wrel;
9165                   }
9166                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9167                                             &local_syms, NULL, NULL))
9168                   goto error_ret;
9169
9170               elf_section_data (toc)->relocs = toc_relocs;
9171               toc->reloc_count = wrel - toc_relocs;
9172               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9173               sz = rel_hdr->sh_entsize;
9174               rel_hdr->sh_size = toc->reloc_count * sz;
9175             }
9176         }
9177       else if (toc_relocs != NULL
9178                && elf_section_data (toc)->relocs != toc_relocs)
9179         free (toc_relocs);
9180
9181       if (local_syms != NULL
9182           && symtab_hdr->contents != (unsigned char *) local_syms)
9183         {
9184           if (!info->keep_memory)
9185             free (local_syms);
9186           else
9187             symtab_hdr->contents = (unsigned char *) local_syms;
9188         }
9189       free (skip);
9190     }
9191
9192   return TRUE;
9193 }
9194
9195 /* Return true iff input section I references the TOC using
9196    instructions limited to +/-32k offsets.  */
9197
9198 bfd_boolean
9199 ppc64_elf_has_small_toc_reloc (asection *i)
9200 {
9201   return (is_ppc64_elf (i->owner)
9202           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9203 }
9204
9205 /* Allocate space for one GOT entry.  */
9206
9207 static void
9208 allocate_got (struct elf_link_hash_entry *h,
9209               struct bfd_link_info *info,
9210               struct got_entry *gent)
9211 {
9212   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9213   bfd_boolean dyn;
9214   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9215   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9216                  ? 16 : 8);
9217   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9218                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9219   asection *got = ppc64_elf_tdata (gent->owner)->got;
9220
9221   gent->got.offset = got->size;
9222   got->size += entsize;
9223
9224   dyn = htab->elf.dynamic_sections_created;
9225   if (h->type == STT_GNU_IFUNC)
9226     {
9227       htab->elf.irelplt->size += rentsize;
9228       htab->got_reli_size += rentsize;
9229     }
9230   else if ((info->shared
9231             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9232            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9233                || h->root.type != bfd_link_hash_undefweak))
9234     {
9235       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9236       relgot->size += rentsize;
9237     }
9238 }
9239
9240 /* This function merges got entries in the same toc group.  */
9241
9242 static void
9243 merge_got_entries (struct got_entry **pent)
9244 {
9245   struct got_entry *ent, *ent2;
9246
9247   for (ent = *pent; ent != NULL; ent = ent->next)
9248     if (!ent->is_indirect)
9249       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9250         if (!ent2->is_indirect
9251             && ent2->addend == ent->addend
9252             && ent2->tls_type == ent->tls_type
9253             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9254           {
9255             ent2->is_indirect = TRUE;
9256             ent2->got.ent = ent;
9257           }
9258 }
9259
9260 /* Allocate space in .plt, .got and associated reloc sections for
9261    dynamic relocs.  */
9262
9263 static bfd_boolean
9264 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9265 {
9266   struct bfd_link_info *info;
9267   struct ppc_link_hash_table *htab;
9268   asection *s;
9269   struct ppc_link_hash_entry *eh;
9270   struct elf_dyn_relocs *p;
9271   struct got_entry **pgent, *gent;
9272
9273   if (h->root.type == bfd_link_hash_indirect)
9274     return TRUE;
9275
9276   info = (struct bfd_link_info *) inf;
9277   htab = ppc_hash_table (info);
9278   if (htab == NULL)
9279     return FALSE;
9280
9281   if ((htab->elf.dynamic_sections_created
9282        && h->dynindx != -1
9283        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9284       || h->type == STT_GNU_IFUNC)
9285     {
9286       struct plt_entry *pent;
9287       bfd_boolean doneone = FALSE;
9288       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9289         if (pent->plt.refcount > 0)
9290           {
9291             if (!htab->elf.dynamic_sections_created
9292                 || h->dynindx == -1)
9293               {
9294                 s = htab->elf.iplt;
9295                 pent->plt.offset = s->size;
9296                 s->size += PLT_ENTRY_SIZE (htab);
9297                 s = htab->elf.irelplt;
9298               }
9299             else
9300               {
9301                 /* If this is the first .plt entry, make room for the special
9302                    first entry.  */
9303                 s = htab->elf.splt;
9304                 if (s->size == 0)
9305                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9306
9307                 pent->plt.offset = s->size;
9308
9309                 /* Make room for this entry.  */
9310                 s->size += PLT_ENTRY_SIZE (htab);
9311
9312                 /* Make room for the .glink code.  */
9313                 s = htab->glink;
9314                 if (s->size == 0)
9315                   s->size += GLINK_CALL_STUB_SIZE;
9316                 if (htab->opd_abi)
9317                   {
9318                     /* We need bigger stubs past index 32767.  */
9319                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9320                       s->size += 4;
9321                     s->size += 2*4;
9322                   }
9323                 else
9324                   s->size += 4;
9325
9326                 /* We also need to make an entry in the .rela.plt section.  */
9327                 s = htab->elf.srelplt;
9328               }
9329             s->size += sizeof (Elf64_External_Rela);
9330             doneone = TRUE;
9331           }
9332         else
9333           pent->plt.offset = (bfd_vma) -1;
9334       if (!doneone)
9335         {
9336           h->plt.plist = NULL;
9337           h->needs_plt = 0;
9338         }
9339     }
9340   else
9341     {
9342       h->plt.plist = NULL;
9343       h->needs_plt = 0;
9344     }
9345
9346   eh = (struct ppc_link_hash_entry *) h;
9347   /* Run through the TLS GD got entries first if we're changing them
9348      to TPREL.  */
9349   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9350     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9351       if (gent->got.refcount > 0
9352           && (gent->tls_type & TLS_GD) != 0)
9353         {
9354           /* This was a GD entry that has been converted to TPREL.  If
9355              there happens to be a TPREL entry we can use that one.  */
9356           struct got_entry *ent;
9357           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9358             if (ent->got.refcount > 0
9359                 && (ent->tls_type & TLS_TPREL) != 0
9360                 && ent->addend == gent->addend
9361                 && ent->owner == gent->owner)
9362               {
9363                 gent->got.refcount = 0;
9364                 break;
9365               }
9366
9367           /* If not, then we'll be using our own TPREL entry.  */
9368           if (gent->got.refcount != 0)
9369             gent->tls_type = TLS_TLS | TLS_TPREL;
9370         }
9371
9372   /* Remove any list entry that won't generate a word in the GOT before
9373      we call merge_got_entries.  Otherwise we risk merging to empty
9374      entries.  */
9375   pgent = &h->got.glist;
9376   while ((gent = *pgent) != NULL)
9377     if (gent->got.refcount > 0)
9378       {
9379         if ((gent->tls_type & TLS_LD) != 0
9380             && !h->def_dynamic)
9381           {
9382             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9383             *pgent = gent->next;
9384           }
9385         else
9386           pgent = &gent->next;
9387       }
9388     else
9389       *pgent = gent->next;
9390
9391   if (!htab->do_multi_toc)
9392     merge_got_entries (&h->got.glist);
9393
9394   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9395     if (!gent->is_indirect)
9396       {
9397         /* Make sure this symbol is output as a dynamic symbol.
9398            Undefined weak syms won't yet be marked as dynamic,
9399            nor will all TLS symbols.  */
9400         if (h->dynindx == -1
9401             && !h->forced_local
9402             && h->type != STT_GNU_IFUNC
9403             && htab->elf.dynamic_sections_created)
9404           {
9405             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9406               return FALSE;
9407           }
9408
9409         if (!is_ppc64_elf (gent->owner))
9410           abort ();
9411
9412         allocate_got (h, info, gent);
9413       }
9414
9415   if (eh->dyn_relocs == NULL
9416       || (!htab->elf.dynamic_sections_created
9417           && h->type != STT_GNU_IFUNC))
9418     return TRUE;
9419
9420   /* In the shared -Bsymbolic case, discard space allocated for
9421      dynamic pc-relative relocs against symbols which turn out to be
9422      defined in regular objects.  For the normal shared case, discard
9423      space for relocs that have become local due to symbol visibility
9424      changes.  */
9425
9426   if (info->shared)
9427     {
9428       /* Relocs that use pc_count are those that appear on a call insn,
9429          or certain REL relocs (see must_be_dyn_reloc) that can be
9430          generated via assembly.  We want calls to protected symbols to
9431          resolve directly to the function rather than going via the plt.
9432          If people want function pointer comparisons to work as expected
9433          then they should avoid writing weird assembly.  */
9434       if (SYMBOL_CALLS_LOCAL (info, h))
9435         {
9436           struct elf_dyn_relocs **pp;
9437
9438           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9439             {
9440               p->count -= p->pc_count;
9441               p->pc_count = 0;
9442               if (p->count == 0)
9443                 *pp = p->next;
9444               else
9445                 pp = &p->next;
9446             }
9447         }
9448
9449       /* Also discard relocs on undefined weak syms with non-default
9450          visibility.  */
9451       if (eh->dyn_relocs != NULL
9452           && h->root.type == bfd_link_hash_undefweak)
9453         {
9454           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9455             eh->dyn_relocs = NULL;
9456
9457           /* Make sure this symbol is output as a dynamic symbol.
9458              Undefined weak syms won't yet be marked as dynamic.  */
9459           else if (h->dynindx == -1
9460                    && !h->forced_local)
9461             {
9462               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9463                 return FALSE;
9464             }
9465         }
9466     }
9467   else if (h->type == STT_GNU_IFUNC)
9468     {
9469       if (!h->non_got_ref)
9470         eh->dyn_relocs = NULL;
9471     }
9472   else if (ELIMINATE_COPY_RELOCS)
9473     {
9474       /* For the non-shared case, discard space for relocs against
9475          symbols which turn out to need copy relocs or are not
9476          dynamic.  */
9477
9478       if (!h->non_got_ref
9479           && !h->def_regular)
9480         {
9481           /* Make sure this symbol is output as a dynamic symbol.
9482              Undefined weak syms won't yet be marked as dynamic.  */
9483           if (h->dynindx == -1
9484               && !h->forced_local)
9485             {
9486               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9487                 return FALSE;
9488             }
9489
9490           /* If that succeeded, we know we'll be keeping all the
9491              relocs.  */
9492           if (h->dynindx != -1)
9493             goto keep;
9494         }
9495
9496       eh->dyn_relocs = NULL;
9497
9498     keep: ;
9499     }
9500
9501   /* Finally, allocate space.  */
9502   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9503     {
9504       asection *sreloc = elf_section_data (p->sec)->sreloc;
9505       if (eh->elf.type == STT_GNU_IFUNC)
9506         sreloc = htab->elf.irelplt;
9507       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9508     }
9509
9510   return TRUE;
9511 }
9512
9513 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9514    to set up space for global entry stubs.  These are put in glink,
9515    after the branch table.  */
9516
9517 static bfd_boolean
9518 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9519 {
9520   struct bfd_link_info *info;
9521   struct ppc_link_hash_table *htab;
9522   struct plt_entry *pent;
9523   asection *s;
9524
9525   if (h->root.type == bfd_link_hash_indirect)
9526     return TRUE;
9527
9528   if (!h->pointer_equality_needed)
9529     return TRUE;
9530
9531   if (h->def_regular)
9532     return TRUE;
9533
9534   info = inf;
9535   htab = ppc_hash_table (info);
9536   if (htab == NULL)
9537     return FALSE;
9538
9539   s = htab->glink;
9540   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9541     if (pent->plt.offset != (bfd_vma) -1
9542         && pent->addend == 0)
9543       {
9544         /* For ELFv2, if this symbol is not defined in a regular file
9545            and we are not generating a shared library or pie, then we
9546            need to define the symbol in the executable on a call stub.
9547            This is to avoid text relocations.  */
9548         s->size = (s->size + 15) & -16;
9549         h->root.u.def.section = s;
9550         h->root.u.def.value = s->size;
9551         s->size += 16;
9552         break;
9553       }
9554   return TRUE;
9555 }
9556
9557 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9558    read-only sections.  */
9559
9560 static bfd_boolean
9561 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9562 {
9563   if (h->root.type == bfd_link_hash_indirect)
9564     return TRUE;
9565
9566   if (readonly_dynrelocs (h))
9567     {
9568       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9569
9570       /* Not an error, just cut short the traversal.  */
9571       return FALSE;
9572     }
9573   return TRUE;
9574 }
9575
9576 /* Set the sizes of the dynamic sections.  */
9577
9578 static bfd_boolean
9579 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9580                                  struct bfd_link_info *info)
9581 {
9582   struct ppc_link_hash_table *htab;
9583   bfd *dynobj;
9584   asection *s;
9585   bfd_boolean relocs;
9586   bfd *ibfd;
9587   struct got_entry *first_tlsld;
9588
9589   htab = ppc_hash_table (info);
9590   if (htab == NULL)
9591     return FALSE;
9592
9593   dynobj = htab->elf.dynobj;
9594   if (dynobj == NULL)
9595     abort ();
9596
9597   if (htab->elf.dynamic_sections_created)
9598     {
9599       /* Set the contents of the .interp section to the interpreter.  */
9600       if (info->executable)
9601         {
9602           s = bfd_get_linker_section (dynobj, ".interp");
9603           if (s == NULL)
9604             abort ();
9605           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9606           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9607         }
9608     }
9609
9610   /* Set up .got offsets for local syms, and space for local dynamic
9611      relocs.  */
9612   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9613     {
9614       struct got_entry **lgot_ents;
9615       struct got_entry **end_lgot_ents;
9616       struct plt_entry **local_plt;
9617       struct plt_entry **end_local_plt;
9618       unsigned char *lgot_masks;
9619       bfd_size_type locsymcount;
9620       Elf_Internal_Shdr *symtab_hdr;
9621
9622       if (!is_ppc64_elf (ibfd))
9623         continue;
9624
9625       for (s = ibfd->sections; s != NULL; s = s->next)
9626         {
9627           struct ppc_dyn_relocs *p;
9628
9629           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9630             {
9631               if (!bfd_is_abs_section (p->sec)
9632                   && bfd_is_abs_section (p->sec->output_section))
9633                 {
9634                   /* Input section has been discarded, either because
9635                      it is a copy of a linkonce section or due to
9636                      linker script /DISCARD/, so we'll be discarding
9637                      the relocs too.  */
9638                 }
9639               else if (p->count != 0)
9640                 {
9641                   asection *srel = elf_section_data (p->sec)->sreloc;
9642                   if (p->ifunc)
9643                     srel = htab->elf.irelplt;
9644                   srel->size += p->count * sizeof (Elf64_External_Rela);
9645                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9646                     info->flags |= DF_TEXTREL;
9647                 }
9648             }
9649         }
9650
9651       lgot_ents = elf_local_got_ents (ibfd);
9652       if (!lgot_ents)
9653         continue;
9654
9655       symtab_hdr = &elf_symtab_hdr (ibfd);
9656       locsymcount = symtab_hdr->sh_info;
9657       end_lgot_ents = lgot_ents + locsymcount;
9658       local_plt = (struct plt_entry **) end_lgot_ents;
9659       end_local_plt = local_plt + locsymcount;
9660       lgot_masks = (unsigned char *) end_local_plt;
9661       s = ppc64_elf_tdata (ibfd)->got;
9662       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9663         {
9664           struct got_entry **pent, *ent;
9665
9666           pent = lgot_ents;
9667           while ((ent = *pent) != NULL)
9668             if (ent->got.refcount > 0)
9669               {
9670                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9671                   {
9672                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9673                     *pent = ent->next;
9674                   }
9675                 else
9676                   {
9677                     unsigned int ent_size = 8;
9678                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9679
9680                     ent->got.offset = s->size;
9681                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9682                       {
9683                         ent_size *= 2;
9684                         rel_size *= 2;
9685                       }
9686                     s->size += ent_size;
9687                     if ((*lgot_masks & PLT_IFUNC) != 0)
9688                       {
9689                         htab->elf.irelplt->size += rel_size;
9690                         htab->got_reli_size += rel_size;
9691                       }
9692                     else if (info->shared)
9693                       {
9694                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9695                         srel->size += rel_size;
9696                       }
9697                     pent = &ent->next;
9698                   }
9699               }
9700             else
9701               *pent = ent->next;
9702         }
9703
9704       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9705       for (; local_plt < end_local_plt; ++local_plt)
9706         {
9707           struct plt_entry *ent;
9708
9709           for (ent = *local_plt; ent != NULL; ent = ent->next)
9710             if (ent->plt.refcount > 0)
9711               {
9712                 s = htab->elf.iplt;
9713                 ent->plt.offset = s->size;
9714                 s->size += PLT_ENTRY_SIZE (htab);
9715
9716                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9717               }
9718             else
9719               ent->plt.offset = (bfd_vma) -1;
9720         }
9721     }
9722
9723   /* Allocate global sym .plt and .got entries, and space for global
9724      sym dynamic relocs.  */
9725   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9726   /* Stash the end of glink branch table.  */
9727   if (htab->glink != NULL)
9728     htab->glink->rawsize = htab->glink->size;
9729
9730   if (!htab->opd_abi && !info->shared)
9731     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9732
9733   first_tlsld = NULL;
9734   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9735     {
9736       struct got_entry *ent;
9737
9738       if (!is_ppc64_elf (ibfd))
9739         continue;
9740
9741       ent = ppc64_tlsld_got (ibfd);
9742       if (ent->got.refcount > 0)
9743         {
9744           if (!htab->do_multi_toc && first_tlsld != NULL)
9745             {
9746               ent->is_indirect = TRUE;
9747               ent->got.ent = first_tlsld;
9748             }
9749           else
9750             {
9751               if (first_tlsld == NULL)
9752                 first_tlsld = ent;
9753               s = ppc64_elf_tdata (ibfd)->got;
9754               ent->got.offset = s->size;
9755               ent->owner = ibfd;
9756               s->size += 16;
9757               if (info->shared)
9758                 {
9759                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9760                   srel->size += sizeof (Elf64_External_Rela);
9761                 }
9762             }
9763         }
9764       else
9765         ent->got.offset = (bfd_vma) -1;
9766     }
9767
9768   /* We now have determined the sizes of the various dynamic sections.
9769      Allocate memory for them.  */
9770   relocs = FALSE;
9771   for (s = dynobj->sections; s != NULL; s = s->next)
9772     {
9773       if ((s->flags & SEC_LINKER_CREATED) == 0)
9774         continue;
9775
9776       if (s == htab->brlt || s == htab->relbrlt)
9777         /* These haven't been allocated yet;  don't strip.  */
9778         continue;
9779       else if (s == htab->elf.sgot
9780                || s == htab->elf.splt
9781                || s == htab->elf.iplt
9782                || s == htab->glink
9783                || s == htab->dynbss)
9784         {
9785           /* Strip this section if we don't need it; see the
9786              comment below.  */
9787         }
9788       else if (s == htab->glink_eh_frame)
9789         {
9790           if (!bfd_is_abs_section (s->output_section))
9791             /* Not sized yet.  */
9792             continue;
9793         }
9794       else if (CONST_STRNEQ (s->name, ".rela"))
9795         {
9796           if (s->size != 0)
9797             {
9798               if (s != htab->elf.srelplt)
9799                 relocs = TRUE;
9800
9801               /* We use the reloc_count field as a counter if we need
9802                  to copy relocs into the output file.  */
9803               s->reloc_count = 0;
9804             }
9805         }
9806       else
9807         {
9808           /* It's not one of our sections, so don't allocate space.  */
9809           continue;
9810         }
9811
9812       if (s->size == 0)
9813         {
9814           /* If we don't need this section, strip it from the
9815              output file.  This is mostly to handle .rela.bss and
9816              .rela.plt.  We must create both sections in
9817              create_dynamic_sections, because they must be created
9818              before the linker maps input sections to output
9819              sections.  The linker does that before
9820              adjust_dynamic_symbol is called, and it is that
9821              function which decides whether anything needs to go
9822              into these sections.  */
9823           s->flags |= SEC_EXCLUDE;
9824           continue;
9825         }
9826
9827       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9828         continue;
9829
9830       /* Allocate memory for the section contents.  We use bfd_zalloc
9831          here in case unused entries are not reclaimed before the
9832          section's contents are written out.  This should not happen,
9833          but this way if it does we get a R_PPC64_NONE reloc in .rela
9834          sections instead of garbage.
9835          We also rely on the section contents being zero when writing
9836          the GOT.  */
9837       s->contents = bfd_zalloc (dynobj, s->size);
9838       if (s->contents == NULL)
9839         return FALSE;
9840     }
9841
9842   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9843     {
9844       if (!is_ppc64_elf (ibfd))
9845         continue;
9846
9847       s = ppc64_elf_tdata (ibfd)->got;
9848       if (s != NULL && s != htab->elf.sgot)
9849         {
9850           if (s->size == 0)
9851             s->flags |= SEC_EXCLUDE;
9852           else
9853             {
9854               s->contents = bfd_zalloc (ibfd, s->size);
9855               if (s->contents == NULL)
9856                 return FALSE;
9857             }
9858         }
9859       s = ppc64_elf_tdata (ibfd)->relgot;
9860       if (s != NULL)
9861         {
9862           if (s->size == 0)
9863             s->flags |= SEC_EXCLUDE;
9864           else
9865             {
9866               s->contents = bfd_zalloc (ibfd, s->size);
9867               if (s->contents == NULL)
9868                 return FALSE;
9869               relocs = TRUE;
9870               s->reloc_count = 0;
9871             }
9872         }
9873     }
9874
9875   if (htab->elf.dynamic_sections_created)
9876     {
9877       bfd_boolean tls_opt;
9878
9879       /* Add some entries to the .dynamic section.  We fill in the
9880          values later, in ppc64_elf_finish_dynamic_sections, but we
9881          must add the entries now so that we get the correct size for
9882          the .dynamic section.  The DT_DEBUG entry is filled in by the
9883          dynamic linker and used by the debugger.  */
9884 #define add_dynamic_entry(TAG, VAL) \
9885   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9886
9887       if (info->executable)
9888         {
9889           if (!add_dynamic_entry (DT_DEBUG, 0))
9890             return FALSE;
9891         }
9892
9893       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9894         {
9895           if (!add_dynamic_entry (DT_PLTGOT, 0)
9896               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9897               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9898               || !add_dynamic_entry (DT_JMPREL, 0)
9899               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9900             return FALSE;
9901         }
9902
9903       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9904         {
9905           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9906               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9907             return FALSE;
9908         }
9909
9910       tls_opt = (!htab->no_tls_get_addr_opt
9911                  && htab->tls_get_addr_fd != NULL
9912                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9913       if (tls_opt || !htab->opd_abi)
9914         {
9915           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9916             return FALSE;
9917         }
9918
9919       if (relocs)
9920         {
9921           if (!add_dynamic_entry (DT_RELA, 0)
9922               || !add_dynamic_entry (DT_RELASZ, 0)
9923               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9924             return FALSE;
9925
9926           /* If any dynamic relocs apply to a read-only section,
9927              then we need a DT_TEXTREL entry.  */
9928           if ((info->flags & DF_TEXTREL) == 0)
9929             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9930
9931           if ((info->flags & DF_TEXTREL) != 0)
9932             {
9933               if (!add_dynamic_entry (DT_TEXTREL, 0))
9934                 return FALSE;
9935             }
9936         }
9937     }
9938 #undef add_dynamic_entry
9939
9940   return TRUE;
9941 }
9942
9943 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9944
9945 static bfd_boolean
9946 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9947 {
9948   if (h->plt.plist != NULL
9949       && !h->def_regular
9950       && !h->pointer_equality_needed)
9951     return FALSE;
9952
9953   return _bfd_elf_hash_symbol (h);
9954 }
9955
9956 /* Determine the type of stub needed, if any, for a call.  */
9957
9958 static inline enum ppc_stub_type
9959 ppc_type_of_stub (asection *input_sec,
9960                   const Elf_Internal_Rela *rel,
9961                   struct ppc_link_hash_entry **hash,
9962                   struct plt_entry **plt_ent,
9963                   bfd_vma destination,
9964                   unsigned long local_off)
9965 {
9966   struct ppc_link_hash_entry *h = *hash;
9967   bfd_vma location;
9968   bfd_vma branch_offset;
9969   bfd_vma max_branch_offset;
9970   enum elf_ppc64_reloc_type r_type;
9971
9972   if (h != NULL)
9973     {
9974       struct plt_entry *ent;
9975       struct ppc_link_hash_entry *fdh = h;
9976       if (h->oh != NULL
9977           && h->oh->is_func_descriptor)
9978         {
9979           fdh = ppc_follow_link (h->oh);
9980           *hash = fdh;
9981         }
9982
9983       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9984         if (ent->addend == rel->r_addend
9985             && ent->plt.offset != (bfd_vma) -1)
9986           {
9987             *plt_ent = ent;
9988             return ppc_stub_plt_call;
9989           }
9990
9991       /* Here, we know we don't have a plt entry.  If we don't have a
9992          either a defined function descriptor or a defined entry symbol
9993          in a regular object file, then it is pointless trying to make
9994          any other type of stub.  */
9995       if (!is_static_defined (&fdh->elf)
9996           && !is_static_defined (&h->elf))
9997         return ppc_stub_none;
9998     }
9999   else if (elf_local_got_ents (input_sec->owner) != NULL)
10000     {
10001       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10002       struct plt_entry **local_plt = (struct plt_entry **)
10003         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10004       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10005
10006       if (local_plt[r_symndx] != NULL)
10007         {
10008           struct plt_entry *ent;
10009
10010           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10011             if (ent->addend == rel->r_addend
10012                 && ent->plt.offset != (bfd_vma) -1)
10013               {
10014                 *plt_ent = ent;
10015                 return ppc_stub_plt_call;
10016               }
10017         }
10018     }
10019
10020   /* Determine where the call point is.  */
10021   location = (input_sec->output_offset
10022               + input_sec->output_section->vma
10023               + rel->r_offset);
10024
10025   branch_offset = destination - location;
10026   r_type = ELF64_R_TYPE (rel->r_info);
10027
10028   /* Determine if a long branch stub is needed.  */
10029   max_branch_offset = 1 << 25;
10030   if (r_type != R_PPC64_REL24)
10031     max_branch_offset = 1 << 15;
10032
10033   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10034     /* We need a stub.  Figure out whether a long_branch or plt_branch
10035        is needed later.  */
10036     return ppc_stub_long_branch;
10037
10038   return ppc_stub_none;
10039 }
10040
10041 /* With power7 weakly ordered memory model, it is possible for ld.so
10042    to update a plt entry in one thread and have another thread see a
10043    stale zero toc entry.  To avoid this we need some sort of acquire
10044    barrier in the call stub.  One solution is to make the load of the
10045    toc word seem to appear to depend on the load of the function entry
10046    word.  Another solution is to test for r2 being zero, and branch to
10047    the appropriate glink entry if so.
10048
10049    .    fake dep barrier        compare
10050    .    ld 12,xxx(2)            ld 12,xxx(2)
10051    .    mtctr 12                mtctr 12
10052    .    xor 11,12,12            ld 2,xxx+8(2)
10053    .    add 2,2,11              cmpldi 2,0
10054    .    ld 2,xxx+8(2)           bnectr+
10055    .    bctr                    b <glink_entry>
10056
10057    The solution involving the compare turns out to be faster, so
10058    that's what we use unless the branch won't reach.  */
10059
10060 #define ALWAYS_USE_FAKE_DEP 0
10061 #define ALWAYS_EMIT_R2SAVE 0
10062
10063 #define PPC_LO(v) ((v) & 0xffff)
10064 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10065 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10066
10067 static inline unsigned int
10068 plt_stub_size (struct ppc_link_hash_table *htab,
10069                struct ppc_stub_hash_entry *stub_entry,
10070                bfd_vma off)
10071 {
10072   unsigned size = 12;
10073
10074   if (ALWAYS_EMIT_R2SAVE
10075       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10076     size += 4;
10077   if (PPC_HA (off) != 0)
10078     size += 4;
10079   if (htab->opd_abi)
10080     {
10081       size += 4;
10082       if (htab->plt_static_chain)
10083         size += 4;
10084       if (htab->plt_thread_safe)
10085         size += 8;
10086       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10087         size += 4;
10088     }
10089   if (stub_entry->h != NULL
10090       && (stub_entry->h == htab->tls_get_addr_fd
10091           || stub_entry->h == htab->tls_get_addr)
10092       && !htab->no_tls_get_addr_opt)
10093     size += 13 * 4;
10094   return size;
10095 }
10096
10097 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10098    then return the padding needed to do so.  */
10099 static inline unsigned int
10100 plt_stub_pad (struct ppc_link_hash_table *htab,
10101               struct ppc_stub_hash_entry *stub_entry,
10102               bfd_vma plt_off)
10103 {
10104   int stub_align = 1 << htab->plt_stub_align;
10105   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10106   bfd_vma stub_off = stub_entry->stub_sec->size;
10107
10108   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10109       > (stub_size & -stub_align))
10110     return stub_align - (stub_off & (stub_align - 1));
10111   return 0;
10112 }
10113
10114 /* Build a .plt call stub.  */
10115
10116 static inline bfd_byte *
10117 build_plt_stub (struct ppc_link_hash_table *htab,
10118                 struct ppc_stub_hash_entry *stub_entry,
10119                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10120 {
10121   bfd *obfd = htab->stub_bfd;
10122   bfd_boolean plt_load_toc = htab->opd_abi;
10123   bfd_boolean plt_static_chain = htab->plt_static_chain;
10124   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10125   bfd_boolean use_fake_dep = plt_thread_safe;
10126   bfd_vma cmp_branch_off = 0;
10127
10128   if (!ALWAYS_USE_FAKE_DEP
10129       && plt_load_toc
10130       && plt_thread_safe
10131       && !(stub_entry->h != NULL
10132            && (stub_entry->h == htab->tls_get_addr_fd
10133                || stub_entry->h == htab->tls_get_addr)
10134            && !htab->no_tls_get_addr_opt))
10135     {
10136       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10137       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10138                           / PLT_ENTRY_SIZE (htab));
10139       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10140       bfd_vma to, from;
10141
10142       if (pltindex > 32768)
10143         glinkoff += (pltindex - 32768) * 4;
10144       to = (glinkoff
10145             + htab->glink->output_offset
10146             + htab->glink->output_section->vma);
10147       from = (p - stub_entry->stub_sec->contents
10148               + 4 * (ALWAYS_EMIT_R2SAVE
10149                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10150               + 4 * (PPC_HA (offset) != 0)
10151               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10152                      != PPC_HA (offset))
10153               + 4 * (plt_static_chain != 0)
10154               + 20
10155               + stub_entry->stub_sec->output_offset
10156               + stub_entry->stub_sec->output_section->vma);
10157       cmp_branch_off = to - from;
10158       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10159     }
10160
10161   if (PPC_HA (offset) != 0)
10162     {
10163       if (r != NULL)
10164         {
10165           if (ALWAYS_EMIT_R2SAVE
10166               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10167             r[0].r_offset += 4;
10168           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10169           r[1].r_offset = r[0].r_offset + 4;
10170           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10171           r[1].r_addend = r[0].r_addend;
10172           if (plt_load_toc)
10173             {
10174               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10175                 {
10176                   r[2].r_offset = r[1].r_offset + 4;
10177                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10178                   r[2].r_addend = r[0].r_addend;
10179                 }
10180               else
10181                 {
10182                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10183                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10184                   r[2].r_addend = r[0].r_addend + 8;
10185                   if (plt_static_chain)
10186                     {
10187                       r[3].r_offset = r[2].r_offset + 4;
10188                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10189                       r[3].r_addend = r[0].r_addend + 16;
10190                     }
10191                 }
10192             }
10193         }
10194       if (ALWAYS_EMIT_R2SAVE
10195           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10196         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10197       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10198       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10199       if (plt_load_toc
10200           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10201         {
10202           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10203           offset = 0;
10204         }
10205       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10206       if (plt_load_toc)
10207         {
10208           if (use_fake_dep)
10209             {
10210               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10211               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10212             }
10213           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10214           if (plt_static_chain)
10215             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10216         }
10217     }
10218   else
10219     {
10220       if (r != NULL)
10221         {
10222           if (ALWAYS_EMIT_R2SAVE
10223               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10224             r[0].r_offset += 4;
10225           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10226           if (plt_load_toc)
10227             {
10228               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10229                 {
10230                   r[1].r_offset = r[0].r_offset + 4;
10231                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10232                   r[1].r_addend = r[0].r_addend;
10233                 }
10234               else
10235                 {
10236                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10237                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10238                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10239                   if (plt_static_chain)
10240                     {
10241                       r[2].r_offset = r[1].r_offset + 4;
10242                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10243                       r[2].r_addend = r[0].r_addend + 8;
10244                     }
10245                 }
10246             }
10247         }
10248       if (ALWAYS_EMIT_R2SAVE
10249           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10250         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10251       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10252       if (plt_load_toc
10253           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10254         {
10255           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10256           offset = 0;
10257         }
10258       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10259       if (plt_load_toc)
10260         {
10261           if (use_fake_dep)
10262             {
10263               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10264               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10265             }
10266           if (plt_static_chain)
10267             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10268           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10269         }
10270     }
10271   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10272     {
10273       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10274       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10275       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10276     }
10277   else
10278     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10279   return p;
10280 }
10281
10282 /* Build a special .plt call stub for __tls_get_addr.  */
10283
10284 #define LD_R11_0R3      0xe9630000
10285 #define LD_R12_0R3      0xe9830000
10286 #define MR_R0_R3        0x7c601b78
10287 #define CMPDI_R11_0     0x2c2b0000
10288 #define ADD_R3_R12_R13  0x7c6c6a14
10289 #define BEQLR           0x4d820020
10290 #define MR_R3_R0        0x7c030378
10291 #define STD_R11_0R1     0xf9610000
10292 #define BCTRL           0x4e800421
10293 #define LD_R11_0R1      0xe9610000
10294 #define MTLR_R11        0x7d6803a6
10295
10296 static inline bfd_byte *
10297 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10298                          struct ppc_stub_hash_entry *stub_entry,
10299                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10300 {
10301   bfd *obfd = htab->stub_bfd;
10302
10303   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10304   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10305   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10306   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10307   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10308   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10309   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10310   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10311   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10312
10313   if (r != NULL)
10314     r[0].r_offset += 9 * 4;
10315   p = build_plt_stub (htab, stub_entry, p, offset, r);
10316   bfd_put_32 (obfd, BCTRL, p - 4);
10317
10318   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10319   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10320   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10321   bfd_put_32 (obfd, BLR, p),                    p += 4;
10322
10323   return p;
10324 }
10325
10326 static Elf_Internal_Rela *
10327 get_relocs (asection *sec, int count)
10328 {
10329   Elf_Internal_Rela *relocs;
10330   struct bfd_elf_section_data *elfsec_data;
10331
10332   elfsec_data = elf_section_data (sec);
10333   relocs = elfsec_data->relocs;
10334   if (relocs == NULL)
10335     {
10336       bfd_size_type relsize;
10337       relsize = sec->reloc_count * sizeof (*relocs);
10338       relocs = bfd_alloc (sec->owner, relsize);
10339       if (relocs == NULL)
10340         return NULL;
10341       elfsec_data->relocs = relocs;
10342       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10343                                           sizeof (Elf_Internal_Shdr));
10344       if (elfsec_data->rela.hdr == NULL)
10345         return NULL;
10346       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10347                                         * sizeof (Elf64_External_Rela));
10348       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10349       sec->reloc_count = 0;
10350     }
10351   relocs += sec->reloc_count;
10352   sec->reloc_count += count;
10353   return relocs;
10354 }
10355
10356 static bfd_vma
10357 get_r2off (struct bfd_link_info *info,
10358            struct ppc_stub_hash_entry *stub_entry)
10359 {
10360   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10361   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10362
10363   if (r2off == 0)
10364     {
10365       /* Support linking -R objects.  Get the toc pointer from the
10366          opd entry.  */
10367       char buf[8];
10368       if (!htab->opd_abi)
10369         return r2off;
10370       asection *opd = stub_entry->h->elf.root.u.def.section;
10371       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10372
10373       if (strcmp (opd->name, ".opd") != 0
10374           || opd->reloc_count != 0)
10375         {
10376           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10377                                   stub_entry->h->elf.root.root.string);
10378           bfd_set_error (bfd_error_bad_value);
10379           return 0;
10380         }
10381       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10382         return 0;
10383       r2off = bfd_get_64 (opd->owner, buf);
10384       r2off -= elf_gp (info->output_bfd);
10385     }
10386   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10387   return r2off;
10388 }
10389
10390 static bfd_boolean
10391 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10392 {
10393   struct ppc_stub_hash_entry *stub_entry;
10394   struct ppc_branch_hash_entry *br_entry;
10395   struct bfd_link_info *info;
10396   struct ppc_link_hash_table *htab;
10397   bfd_byte *loc;
10398   bfd_byte *p;
10399   bfd_vma dest, off;
10400   int size;
10401   Elf_Internal_Rela *r;
10402   asection *plt;
10403
10404   /* Massage our args to the form they really have.  */
10405   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10406   info = in_arg;
10407
10408   htab = ppc_hash_table (info);
10409   if (htab == NULL)
10410     return FALSE;
10411
10412   /* Make a note of the offset within the stubs for this entry.  */
10413   stub_entry->stub_offset = stub_entry->stub_sec->size;
10414   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10415
10416   htab->stub_count[stub_entry->stub_type - 1] += 1;
10417   switch (stub_entry->stub_type)
10418     {
10419     case ppc_stub_long_branch:
10420     case ppc_stub_long_branch_r2off:
10421       /* Branches are relative.  This is where we are going to.  */
10422       dest = (stub_entry->target_value
10423               + stub_entry->target_section->output_offset
10424               + stub_entry->target_section->output_section->vma);
10425       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10426       off = dest;
10427
10428       /* And this is where we are coming from.  */
10429       off -= (stub_entry->stub_offset
10430               + stub_entry->stub_sec->output_offset
10431               + stub_entry->stub_sec->output_section->vma);
10432
10433       size = 4;
10434       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10435         {
10436           bfd_vma r2off = get_r2off (info, stub_entry);
10437
10438           if (r2off == 0)
10439             {
10440               htab->stub_error = TRUE;
10441               return FALSE;
10442             }
10443           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10444           loc += 4;
10445           size = 12;
10446           if (PPC_HA (r2off) != 0)
10447             {
10448               size = 16;
10449               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10450               loc += 4;
10451             }
10452           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10453           loc += 4;
10454           off -= size - 4;
10455         }
10456       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10457
10458       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10459         {
10460           info->callbacks->einfo
10461             (_("%P: long branch stub `%s' offset overflow\n"),
10462              stub_entry->root.string);
10463           htab->stub_error = TRUE;
10464           return FALSE;
10465         }
10466
10467       if (info->emitrelocations)
10468         {
10469           r = get_relocs (stub_entry->stub_sec, 1);
10470           if (r == NULL)
10471             return FALSE;
10472           r->r_offset = loc - stub_entry->stub_sec->contents;
10473           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10474           r->r_addend = dest;
10475           if (stub_entry->h != NULL)
10476             {
10477               struct elf_link_hash_entry **hashes;
10478               unsigned long symndx;
10479               struct ppc_link_hash_entry *h;
10480
10481               hashes = elf_sym_hashes (htab->stub_bfd);
10482               if (hashes == NULL)
10483                 {
10484                   bfd_size_type hsize;
10485
10486                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10487                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10488                   if (hashes == NULL)
10489                     return FALSE;
10490                   elf_sym_hashes (htab->stub_bfd) = hashes;
10491                   htab->stub_globals = 1;
10492                 }
10493               symndx = htab->stub_globals++;
10494               h = stub_entry->h;
10495               hashes[symndx] = &h->elf;
10496               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10497               if (h->oh != NULL && h->oh->is_func)
10498                 h = ppc_follow_link (h->oh);
10499               if (h->elf.root.u.def.section != stub_entry->target_section)
10500                 /* H is an opd symbol.  The addend must be zero.  */
10501                 r->r_addend = 0;
10502               else
10503                 {
10504                   off = (h->elf.root.u.def.value
10505                          + h->elf.root.u.def.section->output_offset
10506                          + h->elf.root.u.def.section->output_section->vma);
10507                   r->r_addend -= off;
10508                 }
10509             }
10510         }
10511       break;
10512
10513     case ppc_stub_plt_branch:
10514     case ppc_stub_plt_branch_r2off:
10515       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10516                                          stub_entry->root.string + 9,
10517                                          FALSE, FALSE);
10518       if (br_entry == NULL)
10519         {
10520           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10521                                   stub_entry->root.string);
10522           htab->stub_error = TRUE;
10523           return FALSE;
10524         }
10525
10526       dest = (stub_entry->target_value
10527               + stub_entry->target_section->output_offset
10528               + stub_entry->target_section->output_section->vma);
10529       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10530         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10531
10532       bfd_put_64 (htab->brlt->owner, dest,
10533                   htab->brlt->contents + br_entry->offset);
10534
10535       if (br_entry->iter == htab->stub_iteration)
10536         {
10537           br_entry->iter = 0;
10538
10539           if (htab->relbrlt != NULL)
10540             {
10541               /* Create a reloc for the branch lookup table entry.  */
10542               Elf_Internal_Rela rela;
10543               bfd_byte *rl;
10544
10545               rela.r_offset = (br_entry->offset
10546                                + htab->brlt->output_offset
10547                                + htab->brlt->output_section->vma);
10548               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10549               rela.r_addend = dest;
10550
10551               rl = htab->relbrlt->contents;
10552               rl += (htab->relbrlt->reloc_count++
10553                      * sizeof (Elf64_External_Rela));
10554               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10555             }
10556           else if (info->emitrelocations)
10557             {
10558               r = get_relocs (htab->brlt, 1);
10559               if (r == NULL)
10560                 return FALSE;
10561               /* brlt, being SEC_LINKER_CREATED does not go through the
10562                  normal reloc processing.  Symbols and offsets are not
10563                  translated from input file to output file form, so
10564                  set up the offset per the output file.  */
10565               r->r_offset = (br_entry->offset
10566                              + htab->brlt->output_offset
10567                              + htab->brlt->output_section->vma);
10568               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10569               r->r_addend = dest;
10570             }
10571         }
10572
10573       dest = (br_entry->offset
10574               + htab->brlt->output_offset
10575               + htab->brlt->output_section->vma);
10576
10577       off = (dest
10578              - elf_gp (htab->brlt->output_section->owner)
10579              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10580
10581       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10582         {
10583           info->callbacks->einfo
10584             (_("%P: linkage table error against `%T'\n"),
10585              stub_entry->root.string);
10586           bfd_set_error (bfd_error_bad_value);
10587           htab->stub_error = TRUE;
10588           return FALSE;
10589         }
10590
10591       if (info->emitrelocations)
10592         {
10593           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10594           if (r == NULL)
10595             return FALSE;
10596           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10597           if (bfd_big_endian (info->output_bfd))
10598             r[0].r_offset += 2;
10599           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10600             r[0].r_offset += 4;
10601           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10602           r[0].r_addend = dest;
10603           if (PPC_HA (off) != 0)
10604             {
10605               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10606               r[1].r_offset = r[0].r_offset + 4;
10607               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10608               r[1].r_addend = r[0].r_addend;
10609             }
10610         }
10611
10612       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10613         {
10614           if (PPC_HA (off) != 0)
10615             {
10616               size = 16;
10617               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10618               loc += 4;
10619               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10620             }
10621           else
10622             {
10623               size = 12;
10624               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10625             }
10626         }
10627       else
10628         {
10629           bfd_vma r2off = get_r2off (info, stub_entry);
10630
10631           if (r2off == 0 && htab->opd_abi)
10632             {
10633               htab->stub_error = TRUE;
10634               return FALSE;
10635             }
10636
10637           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10638           loc += 4;
10639           size = 16;
10640           if (PPC_HA (off) != 0)
10641             {
10642               size += 4;
10643               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10644               loc += 4;
10645               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10646             }
10647           else
10648             bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10649
10650           if (PPC_HA (r2off) != 0)
10651             {
10652               size += 4;
10653               loc += 4;
10654               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10655             }
10656           if (PPC_LO (r2off) != 0)
10657             {
10658               size += 4;
10659               loc += 4;
10660               bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10661             }
10662         }
10663       loc += 4;
10664       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10665       loc += 4;
10666       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10667       break;
10668
10669     case ppc_stub_plt_call:
10670     case ppc_stub_plt_call_r2save:
10671       if (stub_entry->h != NULL
10672           && stub_entry->h->is_func_descriptor
10673           && stub_entry->h->oh != NULL)
10674         {
10675           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10676
10677           /* If the old-ABI "dot-symbol" is undefined make it weak so
10678              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10679              FIXME: We used to define the symbol on one of the call
10680              stubs instead, which is why we test symbol section id
10681              against htab->top_id in various places.  Likely all
10682              these checks could now disappear.  */
10683           if (fh->elf.root.type == bfd_link_hash_undefined)
10684             fh->elf.root.type = bfd_link_hash_undefweak;
10685           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10686           fh->was_undefined = 0;
10687         }
10688
10689       /* Now build the stub.  */
10690       dest = stub_entry->plt_ent->plt.offset & ~1;
10691       if (dest >= (bfd_vma) -2)
10692         abort ();
10693
10694       plt = htab->elf.splt;
10695       if (!htab->elf.dynamic_sections_created
10696           || stub_entry->h == NULL
10697           || stub_entry->h->elf.dynindx == -1)
10698         plt = htab->elf.iplt;
10699
10700       dest += plt->output_offset + plt->output_section->vma;
10701
10702       if (stub_entry->h == NULL
10703           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10704         {
10705           Elf_Internal_Rela rela;
10706           bfd_byte *rl;
10707
10708           rela.r_offset = dest;
10709           if (htab->opd_abi)
10710             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10711           else
10712             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10713           rela.r_addend = (stub_entry->target_value
10714                            + stub_entry->target_section->output_offset
10715                            + stub_entry->target_section->output_section->vma);
10716
10717           rl = (htab->elf.irelplt->contents
10718                 + (htab->elf.irelplt->reloc_count++
10719                    * sizeof (Elf64_External_Rela)));
10720           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10721           stub_entry->plt_ent->plt.offset |= 1;
10722         }
10723
10724       off = (dest
10725              - elf_gp (plt->output_section->owner)
10726              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10727
10728       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10729         {
10730           info->callbacks->einfo
10731             (_("%P: linkage table error against `%T'\n"),
10732              stub_entry->h != NULL
10733              ? stub_entry->h->elf.root.root.string
10734              : "<local sym>");
10735           bfd_set_error (bfd_error_bad_value);
10736           htab->stub_error = TRUE;
10737           return FALSE;
10738         }
10739
10740       if (htab->plt_stub_align != 0)
10741         {
10742           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10743
10744           stub_entry->stub_sec->size += pad;
10745           stub_entry->stub_offset = stub_entry->stub_sec->size;
10746           loc += pad;
10747         }
10748
10749       r = NULL;
10750       if (info->emitrelocations)
10751         {
10752           r = get_relocs (stub_entry->stub_sec,
10753                           (2
10754                            + (PPC_HA (off) != 0)
10755                            + (htab->plt_static_chain
10756                               && PPC_HA (off + 16) == PPC_HA (off))));
10757           if (r == NULL)
10758             return FALSE;
10759           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10760           if (bfd_big_endian (info->output_bfd))
10761             r[0].r_offset += 2;
10762           r[0].r_addend = dest;
10763         }
10764       if (stub_entry->h != NULL
10765           && (stub_entry->h == htab->tls_get_addr_fd
10766               || stub_entry->h == htab->tls_get_addr)
10767           && !htab->no_tls_get_addr_opt)
10768         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10769       else
10770         p = build_plt_stub (htab, stub_entry, loc, off, r);
10771       size = p - loc;
10772       break;
10773
10774     default:
10775       BFD_FAIL ();
10776       return FALSE;
10777     }
10778
10779   stub_entry->stub_sec->size += size;
10780
10781   if (htab->emit_stub_syms)
10782     {
10783       struct elf_link_hash_entry *h;
10784       size_t len1, len2;
10785       char *name;
10786       const char *const stub_str[] = { "long_branch",
10787                                        "long_branch_r2off",
10788                                        "plt_branch",
10789                                        "plt_branch_r2off",
10790                                        "plt_call",
10791                                        "plt_call" };
10792
10793       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10794       len2 = strlen (stub_entry->root.string);
10795       name = bfd_malloc (len1 + len2 + 2);
10796       if (name == NULL)
10797         return FALSE;
10798       memcpy (name, stub_entry->root.string, 9);
10799       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10800       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10801       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10802       if (h == NULL)
10803         return FALSE;
10804       if (h->root.type == bfd_link_hash_new)
10805         {
10806           h->root.type = bfd_link_hash_defined;
10807           h->root.u.def.section = stub_entry->stub_sec;
10808           h->root.u.def.value = stub_entry->stub_offset;
10809           h->ref_regular = 1;
10810           h->def_regular = 1;
10811           h->ref_regular_nonweak = 1;
10812           h->forced_local = 1;
10813           h->non_elf = 0;
10814         }
10815     }
10816
10817   return TRUE;
10818 }
10819
10820 /* As above, but don't actually build the stub.  Just bump offset so
10821    we know stub section sizes, and select plt_branch stubs where
10822    long_branch stubs won't do.  */
10823
10824 static bfd_boolean
10825 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10826 {
10827   struct ppc_stub_hash_entry *stub_entry;
10828   struct bfd_link_info *info;
10829   struct ppc_link_hash_table *htab;
10830   bfd_vma off;
10831   int size;
10832
10833   /* Massage our args to the form they really have.  */
10834   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10835   info = in_arg;
10836
10837   htab = ppc_hash_table (info);
10838   if (htab == NULL)
10839     return FALSE;
10840
10841   if (stub_entry->stub_type == ppc_stub_plt_call
10842       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10843     {
10844       asection *plt;
10845       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10846       if (off >= (bfd_vma) -2)
10847         abort ();
10848       plt = htab->elf.splt;
10849       if (!htab->elf.dynamic_sections_created
10850           || stub_entry->h == NULL
10851           || stub_entry->h->elf.dynindx == -1)
10852         plt = htab->elf.iplt;
10853       off += (plt->output_offset
10854               + plt->output_section->vma
10855               - elf_gp (plt->output_section->owner)
10856               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10857
10858       size = plt_stub_size (htab, stub_entry, off);
10859       if (htab->plt_stub_align)
10860         size += plt_stub_pad (htab, stub_entry, off);
10861       if (info->emitrelocations)
10862         {
10863           stub_entry->stub_sec->reloc_count
10864             += ((PPC_HA (off) != 0)
10865                 + (htab->opd_abi
10866                    ? 2 + (htab->plt_static_chain
10867                           && PPC_HA (off + 16) == PPC_HA (off))
10868                    : 1));
10869           stub_entry->stub_sec->flags |= SEC_RELOC;
10870         }
10871     }
10872   else
10873     {
10874       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10875          variants.  */
10876       bfd_vma r2off = 0;
10877       bfd_vma local_off = 0;
10878
10879       off = (stub_entry->target_value
10880              + stub_entry->target_section->output_offset
10881              + stub_entry->target_section->output_section->vma);
10882       off -= (stub_entry->stub_sec->size
10883               + stub_entry->stub_sec->output_offset
10884               + stub_entry->stub_sec->output_section->vma);
10885
10886       /* Reset the stub type from the plt variant in case we now
10887          can reach with a shorter stub.  */
10888       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10889         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10890
10891       size = 4;
10892       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10893         {
10894           r2off = get_r2off (info, stub_entry);
10895           if (r2off == 0 && htab->opd_abi)
10896             {
10897               htab->stub_error = TRUE;
10898               return FALSE;
10899             }
10900           size = 12;
10901           if (PPC_HA (r2off) != 0)
10902             size = 16;
10903           off -= size - 4;
10904         }
10905
10906       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10907
10908       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10909          Do the same for -R objects without function descriptors.  */
10910       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10911           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10912               && r2off == 0))
10913         {
10914           struct ppc_branch_hash_entry *br_entry;
10915
10916           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10917                                              stub_entry->root.string + 9,
10918                                              TRUE, FALSE);
10919           if (br_entry == NULL)
10920             {
10921               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10922                                       stub_entry->root.string);
10923               htab->stub_error = TRUE;
10924               return FALSE;
10925             }
10926
10927           if (br_entry->iter != htab->stub_iteration)
10928             {
10929               br_entry->iter = htab->stub_iteration;
10930               br_entry->offset = htab->brlt->size;
10931               htab->brlt->size += 8;
10932
10933               if (htab->relbrlt != NULL)
10934                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10935               else if (info->emitrelocations)
10936                 {
10937                   htab->brlt->reloc_count += 1;
10938                   htab->brlt->flags |= SEC_RELOC;
10939                 }
10940             }
10941
10942           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10943           off = (br_entry->offset
10944                  + htab->brlt->output_offset
10945                  + htab->brlt->output_section->vma
10946                  - elf_gp (htab->brlt->output_section->owner)
10947                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10948
10949           if (info->emitrelocations)
10950             {
10951               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10952               stub_entry->stub_sec->flags |= SEC_RELOC;
10953             }
10954
10955           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10956             {
10957               size = 12;
10958               if (PPC_HA (off) != 0)
10959                 size = 16;
10960             }
10961           else
10962             {
10963               size = 16;
10964               if (PPC_HA (off) != 0)
10965                 size += 4;
10966
10967               if (PPC_HA (r2off) != 0)
10968                 size += 4;
10969               if (PPC_LO (r2off) != 0)
10970                 size += 4;
10971             }
10972         }
10973       else if (info->emitrelocations)
10974         {
10975           stub_entry->stub_sec->reloc_count += 1;
10976           stub_entry->stub_sec->flags |= SEC_RELOC;
10977         }
10978     }
10979
10980   stub_entry->stub_sec->size += size;
10981   return TRUE;
10982 }
10983
10984 /* Set up various things so that we can make a list of input sections
10985    for each output section included in the link.  Returns -1 on error,
10986    0 when no stubs will be needed, and 1 on success.  */
10987
10988 int
10989 ppc64_elf_setup_section_lists
10990   (struct bfd_link_info *info,
10991    asection *(*add_stub_section) (const char *, asection *),
10992    void (*layout_sections_again) (void))
10993 {
10994   bfd *input_bfd;
10995   int top_id, top_index, id;
10996   asection *section;
10997   asection **input_list;
10998   bfd_size_type amt;
10999   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11000
11001   if (htab == NULL)
11002     return -1;
11003   /* Stash our params away.  */
11004   htab->add_stub_section = add_stub_section;
11005   htab->layout_sections_again = layout_sections_again;
11006
11007   /* Find the top input section id.  */
11008   for (input_bfd = info->input_bfds, top_id = 3;
11009        input_bfd != NULL;
11010        input_bfd = input_bfd->link_next)
11011     {
11012       for (section = input_bfd->sections;
11013            section != NULL;
11014            section = section->next)
11015         {
11016           if (top_id < section->id)
11017             top_id = section->id;
11018         }
11019     }
11020
11021   htab->top_id = top_id;
11022   amt = sizeof (struct map_stub) * (top_id + 1);
11023   htab->stub_group = bfd_zmalloc (amt);
11024   if (htab->stub_group == NULL)
11025     return -1;
11026
11027   /* Set toc_off for com, und, abs and ind sections.  */
11028   for (id = 0; id < 3; id++)
11029     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11030
11031   /* We can't use output_bfd->section_count here to find the top output
11032      section index as some sections may have been removed, and
11033      strip_excluded_output_sections doesn't renumber the indices.  */
11034   for (section = info->output_bfd->sections, top_index = 0;
11035        section != NULL;
11036        section = section->next)
11037     {
11038       if (top_index < section->index)
11039         top_index = section->index;
11040     }
11041
11042   htab->top_index = top_index;
11043   amt = sizeof (asection *) * (top_index + 1);
11044   input_list = bfd_zmalloc (amt);
11045   htab->input_list = input_list;
11046   if (input_list == NULL)
11047     return -1;
11048
11049   return 1;
11050 }
11051
11052 /* Set up for first pass at multitoc partitioning.  */
11053
11054 void
11055 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11056 {
11057   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11058
11059   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11060   htab->toc_bfd = NULL;
11061   htab->toc_first_sec = NULL;
11062 }
11063
11064 /* The linker repeatedly calls this function for each TOC input section
11065    and linker generated GOT section.  Group input bfds such that the toc
11066    within a group is less than 64k in size.  */
11067
11068 bfd_boolean
11069 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11070 {
11071   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11072   bfd_vma addr, off, limit;
11073
11074   if (htab == NULL)
11075     return FALSE;
11076
11077   if (!htab->second_toc_pass)
11078     {
11079       /* Keep track of the first .toc or .got section for this input bfd.  */
11080       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11081
11082       if (new_bfd)
11083         {
11084           htab->toc_bfd = isec->owner;
11085           htab->toc_first_sec = isec;
11086         }
11087
11088       addr = isec->output_offset + isec->output_section->vma;
11089       off = addr - htab->toc_curr;
11090       limit = 0x80008000;
11091       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11092         limit = 0x10000;
11093       if (off + isec->size > limit)
11094         {
11095           addr = (htab->toc_first_sec->output_offset
11096                   + htab->toc_first_sec->output_section->vma);
11097           htab->toc_curr = addr;
11098         }
11099
11100       /* toc_curr is the base address of this toc group.  Set elf_gp
11101          for the input section to be the offset relative to the
11102          output toc base plus 0x8000.  Making the input elf_gp an
11103          offset allows us to move the toc as a whole without
11104          recalculating input elf_gp.  */
11105       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11106       off += TOC_BASE_OFF;
11107
11108       /* Die if someone uses a linker script that doesn't keep input
11109          file .toc and .got together.  */
11110       if (new_bfd
11111           && elf_gp (isec->owner) != 0
11112           && elf_gp (isec->owner) != off)
11113         return FALSE;
11114
11115       elf_gp (isec->owner) = off;
11116       return TRUE;
11117     }
11118
11119   /* During the second pass toc_first_sec points to the start of
11120      a toc group, and toc_curr is used to track the old elf_gp.
11121      We use toc_bfd to ensure we only look at each bfd once.  */
11122   if (htab->toc_bfd == isec->owner)
11123     return TRUE;
11124   htab->toc_bfd = isec->owner;
11125
11126   if (htab->toc_first_sec == NULL
11127       || htab->toc_curr != elf_gp (isec->owner))
11128     {
11129       htab->toc_curr = elf_gp (isec->owner);
11130       htab->toc_first_sec = isec;
11131     }
11132   addr = (htab->toc_first_sec->output_offset
11133           + htab->toc_first_sec->output_section->vma);
11134   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11135   elf_gp (isec->owner) = off;
11136
11137   return TRUE;
11138 }
11139
11140 /* Called via elf_link_hash_traverse to merge GOT entries for global
11141    symbol H.  */
11142
11143 static bfd_boolean
11144 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11145 {
11146   if (h->root.type == bfd_link_hash_indirect)
11147     return TRUE;
11148
11149   merge_got_entries (&h->got.glist);
11150
11151   return TRUE;
11152 }
11153
11154 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11155    symbol H.  */
11156
11157 static bfd_boolean
11158 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11159 {
11160   struct got_entry *gent;
11161
11162   if (h->root.type == bfd_link_hash_indirect)
11163     return TRUE;
11164
11165   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11166     if (!gent->is_indirect)
11167       allocate_got (h, (struct bfd_link_info *) inf, gent);
11168   return TRUE;
11169 }
11170
11171 /* Called on the first multitoc pass after the last call to
11172    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11173    entries.  */
11174
11175 bfd_boolean
11176 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11177 {
11178   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11179   struct bfd *ibfd, *ibfd2;
11180   bfd_boolean done_something;
11181
11182   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11183
11184   if (!htab->do_multi_toc)
11185     return FALSE;
11186
11187   /* Merge global sym got entries within a toc group.  */
11188   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11189
11190   /* And tlsld_got.  */
11191   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11192     {
11193       struct got_entry *ent, *ent2;
11194
11195       if (!is_ppc64_elf (ibfd))
11196         continue;
11197
11198       ent = ppc64_tlsld_got (ibfd);
11199       if (!ent->is_indirect
11200           && ent->got.offset != (bfd_vma) -1)
11201         {
11202           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11203             {
11204               if (!is_ppc64_elf (ibfd2))
11205                 continue;
11206
11207               ent2 = ppc64_tlsld_got (ibfd2);
11208               if (!ent2->is_indirect
11209                   && ent2->got.offset != (bfd_vma) -1
11210                   && elf_gp (ibfd2) == elf_gp (ibfd))
11211                 {
11212                   ent2->is_indirect = TRUE;
11213                   ent2->got.ent = ent;
11214                 }
11215             }
11216         }
11217     }
11218
11219   /* Zap sizes of got sections.  */
11220   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11221   htab->elf.irelplt->size -= htab->got_reli_size;
11222   htab->got_reli_size = 0;
11223
11224   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11225     {
11226       asection *got, *relgot;
11227
11228       if (!is_ppc64_elf (ibfd))
11229         continue;
11230
11231       got = ppc64_elf_tdata (ibfd)->got;
11232       if (got != NULL)
11233         {
11234           got->rawsize = got->size;
11235           got->size = 0;
11236           relgot = ppc64_elf_tdata (ibfd)->relgot;
11237           relgot->rawsize = relgot->size;
11238           relgot->size = 0;
11239         }
11240     }
11241
11242   /* Now reallocate the got, local syms first.  We don't need to
11243      allocate section contents again since we never increase size.  */
11244   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11245     {
11246       struct got_entry **lgot_ents;
11247       struct got_entry **end_lgot_ents;
11248       struct plt_entry **local_plt;
11249       struct plt_entry **end_local_plt;
11250       unsigned char *lgot_masks;
11251       bfd_size_type locsymcount;
11252       Elf_Internal_Shdr *symtab_hdr;
11253       asection *s;
11254
11255       if (!is_ppc64_elf (ibfd))
11256         continue;
11257
11258       lgot_ents = elf_local_got_ents (ibfd);
11259       if (!lgot_ents)
11260         continue;
11261
11262       symtab_hdr = &elf_symtab_hdr (ibfd);
11263       locsymcount = symtab_hdr->sh_info;
11264       end_lgot_ents = lgot_ents + locsymcount;
11265       local_plt = (struct plt_entry **) end_lgot_ents;
11266       end_local_plt = local_plt + locsymcount;
11267       lgot_masks = (unsigned char *) end_local_plt;
11268       s = ppc64_elf_tdata (ibfd)->got;
11269       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11270         {
11271           struct got_entry *ent;
11272
11273           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11274             {
11275               unsigned int ent_size = 8;
11276               unsigned int rel_size = sizeof (Elf64_External_Rela);
11277
11278               ent->got.offset = s->size;
11279               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11280                 {
11281                   ent_size *= 2;
11282                   rel_size *= 2;
11283                 }
11284               s->size += ent_size;
11285               if ((*lgot_masks & PLT_IFUNC) != 0)
11286                 {
11287                   htab->elf.irelplt->size += rel_size;
11288                   htab->got_reli_size += rel_size;
11289                 }
11290               else if (info->shared)
11291                 {
11292                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11293                   srel->size += rel_size;
11294                 }
11295             }
11296         }
11297     }
11298
11299   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11300
11301   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11302     {
11303       struct got_entry *ent;
11304
11305       if (!is_ppc64_elf (ibfd))
11306         continue;
11307
11308       ent = ppc64_tlsld_got (ibfd);
11309       if (!ent->is_indirect
11310           && ent->got.offset != (bfd_vma) -1)
11311         {
11312           asection *s = ppc64_elf_tdata (ibfd)->got;
11313           ent->got.offset = s->size;
11314           s->size += 16;
11315           if (info->shared)
11316             {
11317               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11318               srel->size += sizeof (Elf64_External_Rela);
11319             }
11320         }
11321     }
11322
11323   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11324   if (!done_something)
11325     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11326       {
11327         asection *got;
11328
11329         if (!is_ppc64_elf (ibfd))
11330           continue;
11331
11332         got = ppc64_elf_tdata (ibfd)->got;
11333         if (got != NULL)
11334           {
11335             done_something = got->rawsize != got->size;
11336             if (done_something)
11337               break;
11338           }
11339       }
11340
11341   if (done_something)
11342     (*htab->layout_sections_again) ();
11343
11344   /* Set up for second pass over toc sections to recalculate elf_gp
11345      on input sections.  */
11346   htab->toc_bfd = NULL;
11347   htab->toc_first_sec = NULL;
11348   htab->second_toc_pass = TRUE;
11349   return done_something;
11350 }
11351
11352 /* Called after second pass of multitoc partitioning.  */
11353
11354 void
11355 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11356 {
11357   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11358
11359   /* After the second pass, toc_curr tracks the TOC offset used
11360      for code sections below in ppc64_elf_next_input_section.  */
11361   htab->toc_curr = TOC_BASE_OFF;
11362 }
11363
11364 /* No toc references were found in ISEC.  If the code in ISEC makes no
11365    calls, then there's no need to use toc adjusting stubs when branching
11366    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11367    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11368    needed, and 2 if a cyclical call-graph was found but no other reason
11369    for a stub was detected.  If called from the top level, a return of
11370    2 means the same as a return of 0.  */
11371
11372 static int
11373 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11374 {
11375   int ret;
11376
11377   /* Mark this section as checked.  */
11378   isec->call_check_done = 1;
11379
11380   /* We know none of our code bearing sections will need toc stubs.  */
11381   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11382     return 0;
11383
11384   if (isec->size == 0)
11385     return 0;
11386
11387   if (isec->output_section == NULL)
11388     return 0;
11389
11390   ret = 0;
11391   if (isec->reloc_count != 0)
11392     {
11393       Elf_Internal_Rela *relstart, *rel;
11394       Elf_Internal_Sym *local_syms;
11395       struct ppc_link_hash_table *htab;
11396
11397       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11398                                             info->keep_memory);
11399       if (relstart == NULL)
11400         return -1;
11401
11402       /* Look for branches to outside of this section.  */
11403       local_syms = NULL;
11404       htab = ppc_hash_table (info);
11405       if (htab == NULL)
11406         return -1;
11407
11408       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11409         {
11410           enum elf_ppc64_reloc_type r_type;
11411           unsigned long r_symndx;
11412           struct elf_link_hash_entry *h;
11413           struct ppc_link_hash_entry *eh;
11414           Elf_Internal_Sym *sym;
11415           asection *sym_sec;
11416           struct _opd_sec_data *opd;
11417           bfd_vma sym_value;
11418           bfd_vma dest;
11419
11420           r_type = ELF64_R_TYPE (rel->r_info);
11421           if (r_type != R_PPC64_REL24
11422               && r_type != R_PPC64_REL14
11423               && r_type != R_PPC64_REL14_BRTAKEN
11424               && r_type != R_PPC64_REL14_BRNTAKEN)
11425             continue;
11426
11427           r_symndx = ELF64_R_SYM (rel->r_info);
11428           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11429                           isec->owner))
11430             {
11431               ret = -1;
11432               break;
11433             }
11434
11435           /* Calls to dynamic lib functions go through a plt call stub
11436              that uses r2.  */
11437           eh = (struct ppc_link_hash_entry *) h;
11438           if (eh != NULL
11439               && (eh->elf.plt.plist != NULL
11440                   || (eh->oh != NULL
11441                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11442             {
11443               ret = 1;
11444               break;
11445             }
11446
11447           if (sym_sec == NULL)
11448             /* Ignore other undefined symbols.  */
11449             continue;
11450
11451           /* Assume branches to other sections not included in the
11452              link need stubs too, to cover -R and absolute syms.  */
11453           if (sym_sec->output_section == NULL)
11454             {
11455               ret = 1;
11456               break;
11457             }
11458
11459           if (h == NULL)
11460             sym_value = sym->st_value;
11461           else
11462             {
11463               if (h->root.type != bfd_link_hash_defined
11464                   && h->root.type != bfd_link_hash_defweak)
11465                 abort ();
11466               sym_value = h->root.u.def.value;
11467             }
11468           sym_value += rel->r_addend;
11469
11470           /* If this branch reloc uses an opd sym, find the code section.  */
11471           opd = get_opd_info (sym_sec);
11472           if (opd != NULL)
11473             {
11474               if (h == NULL && opd->adjust != NULL)
11475                 {
11476                   long adjust;
11477
11478                   adjust = opd->adjust[sym->st_value / 8];
11479                   if (adjust == -1)
11480                     /* Assume deleted functions won't ever be called.  */
11481                     continue;
11482                   sym_value += adjust;
11483                 }
11484
11485               dest = opd_entry_value (sym_sec, sym_value,
11486                                       &sym_sec, NULL, FALSE);
11487               if (dest == (bfd_vma) -1)
11488                 continue;
11489             }
11490           else
11491             dest = (sym_value
11492                     + sym_sec->output_offset
11493                     + sym_sec->output_section->vma);
11494
11495           /* Ignore branch to self.  */
11496           if (sym_sec == isec)
11497             continue;
11498
11499           /* If the called function uses the toc, we need a stub.  */
11500           if (sym_sec->has_toc_reloc
11501               || sym_sec->makes_toc_func_call)
11502             {
11503               ret = 1;
11504               break;
11505             }
11506
11507           /* Assume any branch that needs a long branch stub might in fact
11508              need a plt_branch stub.  A plt_branch stub uses r2.  */
11509           else if (dest - (isec->output_offset
11510                            + isec->output_section->vma
11511                            + rel->r_offset) + (1 << 25)
11512                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11513                                                              ? h->other
11514                                                              : sym->st_other))
11515             {
11516               ret = 1;
11517               break;
11518             }
11519
11520           /* If calling back to a section in the process of being
11521              tested, we can't say for sure that no toc adjusting stubs
11522              are needed, so don't return zero.  */
11523           else if (sym_sec->call_check_in_progress)
11524             ret = 2;
11525
11526           /* Branches to another section that itself doesn't have any TOC
11527              references are OK.  Recursively call ourselves to check.  */
11528           else if (!sym_sec->call_check_done)
11529             {
11530               int recur;
11531
11532               /* Mark current section as indeterminate, so that other
11533                  sections that call back to current won't be marked as
11534                  known.  */
11535               isec->call_check_in_progress = 1;
11536               recur = toc_adjusting_stub_needed (info, sym_sec);
11537               isec->call_check_in_progress = 0;
11538
11539               if (recur != 0)
11540                 {
11541                   ret = recur;
11542                   if (recur != 2)
11543                     break;
11544                 }
11545             }
11546         }
11547
11548       if (local_syms != NULL
11549           && (elf_symtab_hdr (isec->owner).contents
11550               != (unsigned char *) local_syms))
11551         free (local_syms);
11552       if (elf_section_data (isec)->relocs != relstart)
11553         free (relstart);
11554     }
11555
11556   if ((ret & 1) == 0
11557       && isec->map_head.s != NULL
11558       && (strcmp (isec->output_section->name, ".init") == 0
11559           || strcmp (isec->output_section->name, ".fini") == 0))
11560     {
11561       if (isec->map_head.s->has_toc_reloc
11562           || isec->map_head.s->makes_toc_func_call)
11563         ret = 1;
11564       else if (!isec->map_head.s->call_check_done)
11565         {
11566           int recur;
11567           isec->call_check_in_progress = 1;
11568           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11569           isec->call_check_in_progress = 0;
11570           if (recur != 0)
11571             ret = recur;
11572         }
11573     }
11574
11575   if (ret == 1)
11576     isec->makes_toc_func_call = 1;
11577
11578   return ret;
11579 }
11580
11581 /* The linker repeatedly calls this function for each input section,
11582    in the order that input sections are linked into output sections.
11583    Build lists of input sections to determine groupings between which
11584    we may insert linker stubs.  */
11585
11586 bfd_boolean
11587 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11588 {
11589   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11590
11591   if (htab == NULL)
11592     return FALSE;
11593
11594   if ((isec->output_section->flags & SEC_CODE) != 0
11595       && isec->output_section->index <= htab->top_index)
11596     {
11597       asection **list = htab->input_list + isec->output_section->index;
11598       /* Steal the link_sec pointer for our list.  */
11599 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11600       /* This happens to make the list in reverse order,
11601          which is what we want.  */
11602       PREV_SEC (isec) = *list;
11603       *list = isec;
11604     }
11605
11606   if (htab->multi_toc_needed)
11607     {
11608       /* Analyse sections that aren't already flagged as needing a
11609          valid toc pointer.  Exclude .fixup for the linux kernel.
11610          .fixup contains branches, but only back to the function that
11611          hit an exception.  */
11612       if (!(isec->has_toc_reloc
11613             || (isec->flags & SEC_CODE) == 0
11614             || strcmp (isec->name, ".fixup") == 0
11615             || isec->call_check_done))
11616         {
11617           if (toc_adjusting_stub_needed (info, isec) < 0)
11618             return FALSE;
11619         }
11620       /* Make all sections use the TOC assigned for this object file.
11621          This will be wrong for pasted sections;  We fix that in
11622          check_pasted_section().  */
11623       if (elf_gp (isec->owner) != 0)
11624         htab->toc_curr = elf_gp (isec->owner);
11625     }
11626
11627   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11628   return TRUE;
11629 }
11630
11631 /* Check that all .init and .fini sections use the same toc, if they
11632    have toc relocs.  */
11633
11634 static bfd_boolean
11635 check_pasted_section (struct bfd_link_info *info, const char *name)
11636 {
11637   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11638
11639   if (o != NULL)
11640     {
11641       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11642       bfd_vma toc_off = 0;
11643       asection *i;
11644
11645       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11646         if (i->has_toc_reloc)
11647           {
11648             if (toc_off == 0)
11649               toc_off = htab->stub_group[i->id].toc_off;
11650             else if (toc_off != htab->stub_group[i->id].toc_off)
11651               return FALSE;
11652           }
11653
11654       if (toc_off == 0)
11655         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11656           if (i->makes_toc_func_call)
11657             {
11658               toc_off = htab->stub_group[i->id].toc_off;
11659               break;
11660             }
11661
11662       /* Make sure the whole pasted function uses the same toc offset.  */
11663       if (toc_off != 0)
11664         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11665           htab->stub_group[i->id].toc_off = toc_off;
11666     }
11667   return TRUE;
11668 }
11669
11670 bfd_boolean
11671 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11672 {
11673   return (check_pasted_section (info, ".init")
11674           & check_pasted_section (info, ".fini"));
11675 }
11676
11677 /* See whether we can group stub sections together.  Grouping stub
11678    sections may result in fewer stubs.  More importantly, we need to
11679    put all .init* and .fini* stubs at the beginning of the .init or
11680    .fini output sections respectively, because glibc splits the
11681    _init and _fini functions into multiple parts.  Putting a stub in
11682    the middle of a function is not a good idea.  */
11683
11684 static void
11685 group_sections (struct ppc_link_hash_table *htab,
11686                 bfd_size_type stub_group_size,
11687                 bfd_boolean stubs_always_before_branch)
11688 {
11689   asection **list;
11690   bfd_size_type stub14_group_size;
11691   bfd_boolean suppress_size_errors;
11692
11693   suppress_size_errors = FALSE;
11694   stub14_group_size = stub_group_size;
11695   if (stub_group_size == 1)
11696     {
11697       /* Default values.  */
11698       if (stubs_always_before_branch)
11699         {
11700           stub_group_size = 0x1e00000;
11701           stub14_group_size = 0x7800;
11702         }
11703       else
11704         {
11705           stub_group_size = 0x1c00000;
11706           stub14_group_size = 0x7000;
11707         }
11708       suppress_size_errors = TRUE;
11709     }
11710
11711   list = htab->input_list + htab->top_index;
11712   do
11713     {
11714       asection *tail = *list;
11715       while (tail != NULL)
11716         {
11717           asection *curr;
11718           asection *prev;
11719           bfd_size_type total;
11720           bfd_boolean big_sec;
11721           bfd_vma curr_toc;
11722
11723           curr = tail;
11724           total = tail->size;
11725           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11726                              && ppc64_elf_section_data (tail)->has_14bit_branch
11727                              ? stub14_group_size : stub_group_size);
11728           if (big_sec && !suppress_size_errors)
11729             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11730                                      tail->owner, tail);
11731           curr_toc = htab->stub_group[tail->id].toc_off;
11732
11733           while ((prev = PREV_SEC (curr)) != NULL
11734                  && ((total += curr->output_offset - prev->output_offset)
11735                      < (ppc64_elf_section_data (prev) != NULL
11736                         && ppc64_elf_section_data (prev)->has_14bit_branch
11737                         ? stub14_group_size : stub_group_size))
11738                  && htab->stub_group[prev->id].toc_off == curr_toc)
11739             curr = prev;
11740
11741           /* OK, the size from the start of CURR to the end is less
11742              than stub_group_size and thus can be handled by one stub
11743              section.  (or the tail section is itself larger than
11744              stub_group_size, in which case we may be toast.)  We
11745              should really be keeping track of the total size of stubs
11746              added here, as stubs contribute to the final output
11747              section size.  That's a little tricky, and this way will
11748              only break if stubs added make the total size more than
11749              2^25, ie. for the default stub_group_size, if stubs total
11750              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11751           do
11752             {
11753               prev = PREV_SEC (tail);
11754               /* Set up this stub group.  */
11755               htab->stub_group[tail->id].link_sec = curr;
11756             }
11757           while (tail != curr && (tail = prev) != NULL);
11758
11759           /* But wait, there's more!  Input sections up to stub_group_size
11760              bytes before the stub section can be handled by it too.
11761              Don't do this if we have a really large section after the
11762              stubs, as adding more stubs increases the chance that
11763              branches may not reach into the stub section.  */
11764           if (!stubs_always_before_branch && !big_sec)
11765             {
11766               total = 0;
11767               while (prev != NULL
11768                      && ((total += tail->output_offset - prev->output_offset)
11769                          < (ppc64_elf_section_data (prev) != NULL
11770                             && ppc64_elf_section_data (prev)->has_14bit_branch
11771                             ? stub14_group_size : stub_group_size))
11772                      && htab->stub_group[prev->id].toc_off == curr_toc)
11773                 {
11774                   tail = prev;
11775                   prev = PREV_SEC (tail);
11776                   htab->stub_group[tail->id].link_sec = curr;
11777                 }
11778             }
11779           tail = prev;
11780         }
11781     }
11782   while (list-- != htab->input_list);
11783   free (htab->input_list);
11784 #undef PREV_SEC
11785 }
11786
11787 static const unsigned char glink_eh_frame_cie[] =
11788 {
11789   0, 0, 0, 16,                          /* length.  */
11790   0, 0, 0, 0,                           /* id.  */
11791   1,                                    /* CIE version.  */
11792   'z', 'R', 0,                          /* Augmentation string.  */
11793   4,                                    /* Code alignment.  */
11794   0x78,                                 /* Data alignment.  */
11795   65,                                   /* RA reg.  */
11796   1,                                    /* Augmentation size.  */
11797   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11798   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11799 };
11800
11801 /* Stripping output sections is normally done before dynamic section
11802    symbols have been allocated.  This function is called later, and
11803    handles cases like htab->brlt which is mapped to its own output
11804    section.  */
11805
11806 static void
11807 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11808 {
11809   if (isec->size == 0
11810       && isec->output_section->size == 0
11811       && !(isec->output_section->flags & SEC_KEEP)
11812       && !bfd_section_removed_from_list (info->output_bfd,
11813                                          isec->output_section)
11814       && elf_section_data (isec->output_section)->dynindx == 0)
11815     {
11816       isec->output_section->flags |= SEC_EXCLUDE;
11817       bfd_section_list_remove (info->output_bfd, isec->output_section);
11818       info->output_bfd->section_count--;
11819     }
11820 }
11821
11822 /* Determine and set the size of the stub section for a final link.
11823
11824    The basic idea here is to examine all the relocations looking for
11825    PC-relative calls to a target that is unreachable with a "bl"
11826    instruction.  */
11827
11828 bfd_boolean
11829 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11830                       bfd_boolean plt_static_chain, int plt_thread_safe,
11831                       int plt_stub_align)
11832 {
11833   bfd_size_type stub_group_size;
11834   bfd_boolean stubs_always_before_branch;
11835   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11836
11837   if (htab == NULL)
11838     return FALSE;
11839
11840   htab->plt_static_chain = plt_static_chain;
11841   htab->plt_stub_align = plt_stub_align;
11842   if (plt_thread_safe == -1 && !info->executable)
11843     plt_thread_safe = 1;
11844   if (!htab->opd_abi)
11845     plt_thread_safe = 0;
11846   else if (plt_thread_safe == -1)
11847     {
11848       static const char *const thread_starter[] =
11849         {
11850           "pthread_create",
11851           /* libstdc++ */
11852           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11853           /* librt */
11854           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11855           "mq_notify", "create_timer",
11856           /* libanl */
11857           "getaddrinfo_a",
11858           /* libgomp */
11859           "GOMP_parallel_start",
11860           "GOMP_parallel_loop_static_start",
11861           "GOMP_parallel_loop_dynamic_start",
11862           "GOMP_parallel_loop_guided_start",
11863           "GOMP_parallel_loop_runtime_start",
11864           "GOMP_parallel_sections_start",
11865         };
11866       unsigned i;
11867
11868       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11869         {
11870           struct elf_link_hash_entry *h;
11871           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11872                                     FALSE, FALSE, TRUE);
11873           plt_thread_safe = h != NULL && h->ref_regular;
11874           if (plt_thread_safe)
11875             break;
11876         }
11877     }
11878   htab->plt_thread_safe = plt_thread_safe;
11879   stubs_always_before_branch = group_size < 0;
11880   if (group_size < 0)
11881     stub_group_size = -group_size;
11882   else
11883     stub_group_size = 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->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->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->plt_stub_align != 0)
12249         for (stub_sec = htab->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 + (1 << htab->plt_stub_align) - 1)
12254                               & (-1 << htab->plt_stub_align));
12255
12256       for (stub_sec = htab->stub_bfd->sections;
12257            stub_sec != NULL;
12258            stub_sec = stub_sec->next)
12259         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12260             && stub_sec->rawsize != stub_sec->size)
12261           break;
12262
12263       /* Exit from this loop when no stubs have been added, and no stubs
12264          have changed size.  */
12265       if (stub_sec == NULL
12266           && (htab->glink_eh_frame == NULL
12267               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12268         break;
12269
12270       /* Ask the linker to do its stuff.  */
12271       (*htab->layout_sections_again) ();
12272     }
12273
12274   maybe_strip_output (info, htab->brlt);
12275   if (htab->glink_eh_frame != NULL)
12276     maybe_strip_output (info, htab->glink_eh_frame);
12277
12278   return TRUE;
12279 }
12280
12281 /* Called after we have determined section placement.  If sections
12282    move, we'll be called again.  Provide a value for TOCstart.  */
12283
12284 bfd_vma
12285 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12286 {
12287   asection *s;
12288   bfd_vma TOCstart;
12289
12290   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12291      order.  The TOC starts where the first of these sections starts.  */
12292   s = bfd_get_section_by_name (obfd, ".got");
12293   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12294     s = bfd_get_section_by_name (obfd, ".toc");
12295   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12296     s = bfd_get_section_by_name (obfd, ".tocbss");
12297   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12298     s = bfd_get_section_by_name (obfd, ".plt");
12299   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12300     {
12301       /* This may happen for
12302          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12303          .toc directive
12304          o  bad linker script
12305          o --gc-sections and empty TOC sections
12306
12307          FIXME: Warn user?  */
12308
12309       /* Look for a likely section.  We probably won't even be
12310          using TOCstart.  */
12311       for (s = obfd->sections; s != NULL; s = s->next)
12312         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12313                          | SEC_EXCLUDE))
12314             == (SEC_ALLOC | SEC_SMALL_DATA))
12315           break;
12316       if (s == NULL)
12317         for (s = obfd->sections; s != NULL; s = s->next)
12318           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12319               == (SEC_ALLOC | SEC_SMALL_DATA))
12320             break;
12321       if (s == NULL)
12322         for (s = obfd->sections; s != NULL; s = s->next)
12323           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12324               == SEC_ALLOC)
12325             break;
12326       if (s == NULL)
12327         for (s = obfd->sections; s != NULL; s = s->next)
12328           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12329             break;
12330     }
12331
12332   TOCstart = 0;
12333   if (s != NULL)
12334     TOCstart = s->output_section->vma + s->output_offset;
12335
12336   _bfd_set_gp_value (obfd, TOCstart);
12337
12338   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12339     {
12340       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12341
12342       if (htab != NULL
12343           && htab->elf.hgot != NULL)
12344         {
12345           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12346           htab->elf.hgot->root.u.def.section = s;
12347         }
12348     }
12349   return TOCstart;
12350 }
12351
12352 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12353    write out any global entry stubs.  */
12354
12355 static bfd_boolean
12356 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12357 {
12358   struct bfd_link_info *info;
12359   struct ppc_link_hash_table *htab;
12360   struct plt_entry *pent;
12361   asection *s;
12362
12363   if (h->root.type == bfd_link_hash_indirect)
12364     return TRUE;
12365
12366   if (!h->pointer_equality_needed)
12367     return TRUE;
12368
12369   if (h->def_regular)
12370     return TRUE;
12371
12372   info = inf;
12373   htab = ppc_hash_table (info);
12374   if (htab == NULL)
12375     return FALSE;
12376
12377   s = htab->glink;
12378   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12379     if (pent->plt.offset != (bfd_vma) -1
12380         && pent->addend == 0)
12381       {
12382         bfd_byte *p;
12383         asection *plt;
12384         bfd_vma off;
12385
12386         p = s->contents + h->root.u.def.value;
12387         plt = htab->elf.splt;
12388         if (!htab->elf.dynamic_sections_created
12389             || h->dynindx == -1)
12390           plt = htab->elf.iplt;
12391         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12392         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12393
12394         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12395           {
12396             info->callbacks->einfo
12397               (_("%P: linkage table error against `%T'\n"),
12398                h->root.root.string);
12399             bfd_set_error (bfd_error_bad_value);
12400             htab->stub_error = TRUE;
12401           }
12402
12403         if (PPC_HA (off) != 0)
12404           {
12405             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12406             p += 4;
12407           }
12408         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12409         p += 4;
12410         bfd_put_32 (s->owner, MTCTR_R12, p);
12411         p += 4;
12412         bfd_put_32 (s->owner, BCTR, p);
12413         break;
12414       }
12415   return TRUE;
12416 }
12417
12418 /* Build all the stubs associated with the current output file.
12419    The stubs are kept in a hash table attached to the main linker
12420    hash table.  This function is called via gldelf64ppc_finish.  */
12421
12422 bfd_boolean
12423 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12424                        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   htab->emit_stub_syms = emit_stub_syms;
12436
12437   /* Allocate memory to hold the linker stubs.  */
12438   for (stub_sec = htab->stub_bfd->sections;
12439        stub_sec != NULL;
12440        stub_sec = stub_sec->next)
12441     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12442         && stub_sec->size != 0)
12443       {
12444         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12445         if (stub_sec->contents == NULL)
12446           return FALSE;
12447         /* We want to check that built size is the same as calculated
12448            size.  rawsize is a convenient location to use.  */
12449         stub_sec->rawsize = stub_sec->size;
12450         stub_sec->size = 0;
12451       }
12452
12453   if (htab->glink != NULL && htab->glink->size != 0)
12454     {
12455       unsigned int indx;
12456       bfd_vma plt0;
12457
12458       /* Build the .glink plt call stub.  */
12459       if (htab->emit_stub_syms)
12460         {
12461           struct elf_link_hash_entry *h;
12462           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12463                                     TRUE, FALSE, FALSE);
12464           if (h == NULL)
12465             return FALSE;
12466           if (h->root.type == bfd_link_hash_new)
12467             {
12468               h->root.type = bfd_link_hash_defined;
12469               h->root.u.def.section = htab->glink;
12470               h->root.u.def.value = 8;
12471               h->ref_regular = 1;
12472               h->def_regular = 1;
12473               h->ref_regular_nonweak = 1;
12474               h->forced_local = 1;
12475               h->non_elf = 0;
12476             }
12477         }
12478       plt0 = (htab->elf.splt->output_section->vma
12479               + htab->elf.splt->output_offset
12480               - 16);
12481       if (info->emitrelocations)
12482         {
12483           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12484           if (r == NULL)
12485             return FALSE;
12486           r->r_offset = (htab->glink->output_offset
12487                          + htab->glink->output_section->vma);
12488           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12489           r->r_addend = plt0;
12490         }
12491       p = htab->glink->contents;
12492       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12493       bfd_put_64 (htab->glink->owner, plt0, p);
12494       p += 8;
12495       if (htab->opd_abi)
12496         {
12497           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12498           p += 4;
12499           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12500           p += 4;
12501           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12502           p += 4;
12503           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12504           p += 4;
12505           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12506           p += 4;
12507           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12508           p += 4;
12509           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12510           p += 4;
12511           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12512           p += 4;
12513           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12514           p += 4;
12515           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12516           p += 4;
12517         }
12518       else
12519         {
12520           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12521           p += 4;
12522           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12523           p += 4;
12524           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12525           p += 4;
12526           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12527           p += 4;
12528           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12529           p += 4;
12530           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12531           p += 4;
12532           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12533           p += 4;
12534           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12535           p += 4;
12536           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12537           p += 4;
12538           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12539           p += 4;
12540           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12541           p += 4;
12542           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12543           p += 4;
12544         }
12545       bfd_put_32 (htab->glink->owner, BCTR, p);
12546       p += 4;
12547       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12548         {
12549           bfd_put_32 (htab->glink->owner, NOP, p);
12550           p += 4;
12551         }
12552
12553       /* Build the .glink lazy link call stubs.  */
12554       indx = 0;
12555       while (p < htab->glink->contents + htab->glink->rawsize)
12556         {
12557           if (htab->opd_abi)
12558             {
12559               if (indx < 0x8000)
12560                 {
12561                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12562                   p += 4;
12563                 }
12564               else
12565                 {
12566                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12567                   p += 4;
12568                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12569                               p);
12570                   p += 4;
12571                 }
12572             }
12573           bfd_put_32 (htab->glink->owner,
12574                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12575           indx++;
12576           p += 4;
12577         }
12578
12579       /* Build .glink global entry stubs.  */
12580       if (htab->glink->size > htab->glink->rawsize)
12581         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12582     }
12583
12584   if (htab->brlt->size != 0)
12585     {
12586       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12587                                          htab->brlt->size);
12588       if (htab->brlt->contents == NULL)
12589         return FALSE;
12590     }
12591   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12592     {
12593       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12594                                             htab->relbrlt->size);
12595       if (htab->relbrlt->contents == NULL)
12596         return FALSE;
12597     }
12598
12599   if (htab->glink_eh_frame != NULL
12600       && htab->glink_eh_frame->size != 0)
12601     {
12602       bfd_vma val;
12603       bfd_byte *last_fde;
12604       size_t last_fde_len, size, align, pad;
12605
12606       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12607       if (p == NULL)
12608         return FALSE;
12609       htab->glink_eh_frame->contents = p;
12610       last_fde = p;
12611
12612       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12613
12614       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12615       /* CIE length (rewrite in case little-endian).  */
12616       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12617       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12618       p += sizeof (glink_eh_frame_cie);
12619
12620       for (stub_sec = htab->stub_bfd->sections;
12621            stub_sec != NULL;
12622            stub_sec = stub_sec->next)
12623         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12624           {
12625             last_fde = p;
12626             last_fde_len = 16;
12627             /* FDE length.  */
12628             bfd_put_32 (htab->elf.dynobj, 16, p);
12629             p += 4;
12630             /* CIE pointer.  */
12631             val = p - htab->glink_eh_frame->contents;
12632             bfd_put_32 (htab->elf.dynobj, val, p);
12633             p += 4;
12634             /* Offset to stub section.  */
12635             val = (stub_sec->output_section->vma
12636                    + stub_sec->output_offset);
12637             val -= (htab->glink_eh_frame->output_section->vma
12638                     + htab->glink_eh_frame->output_offset);
12639             val -= p - htab->glink_eh_frame->contents;
12640             if (val + 0x80000000 > 0xffffffff)
12641               {
12642                 info->callbacks->einfo
12643                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12644                    stub_sec->name);
12645                 return FALSE;
12646               }
12647             bfd_put_32 (htab->elf.dynobj, val, p);
12648             p += 4;
12649             /* stub section size.  */
12650             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12651             p += 4;
12652             /* Augmentation.  */
12653             p += 1;
12654             /* Pad.  */
12655             p += 3;
12656           }
12657       if (htab->glink != NULL && htab->glink->size != 0)
12658         {
12659           last_fde = p;
12660           last_fde_len = 20;
12661           /* FDE length.  */
12662           bfd_put_32 (htab->elf.dynobj, 20, p);
12663           p += 4;
12664           /* CIE pointer.  */
12665           val = p - htab->glink_eh_frame->contents;
12666           bfd_put_32 (htab->elf.dynobj, val, p);
12667           p += 4;
12668           /* Offset to .glink.  */
12669           val = (htab->glink->output_section->vma
12670                  + htab->glink->output_offset
12671                  + 8);
12672           val -= (htab->glink_eh_frame->output_section->vma
12673                   + htab->glink_eh_frame->output_offset);
12674           val -= p - htab->glink_eh_frame->contents;
12675           if (val + 0x80000000 > 0xffffffff)
12676             {
12677               info->callbacks->einfo
12678                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12679                  htab->glink->name);
12680               return FALSE;
12681             }
12682           bfd_put_32 (htab->elf.dynobj, val, p);
12683           p += 4;
12684           /* .glink size.  */
12685           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12686           p += 4;
12687           /* Augmentation.  */
12688           p += 1;
12689
12690           *p++ = DW_CFA_advance_loc + 1;
12691           *p++ = DW_CFA_register;
12692           *p++ = 65;
12693           *p++ = 12;
12694           *p++ = DW_CFA_advance_loc + 4;
12695           *p++ = DW_CFA_restore_extended;
12696           *p++ = 65;
12697         }
12698       /* Subsume any padding into the last FDE if user .eh_frame
12699          sections are aligned more than glink_eh_frame.  Otherwise any
12700          zero padding will be seen as a terminator.  */
12701       size = p - htab->glink_eh_frame->contents;
12702       align = 1;
12703       align <<= htab->glink_eh_frame->output_section->alignment_power;
12704       align -= 1;
12705       pad = ((size + align) & ~align) - size;
12706       htab->glink_eh_frame->size = size + pad;
12707       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12708     }
12709
12710   /* Build the stubs as directed by the stub hash table.  */
12711   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12712
12713   if (htab->relbrlt != NULL)
12714     htab->relbrlt->reloc_count = 0;
12715
12716   if (htab->plt_stub_align != 0)
12717     for (stub_sec = htab->stub_bfd->sections;
12718          stub_sec != NULL;
12719          stub_sec = stub_sec->next)
12720       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12721         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12722                           & (-1 << htab->plt_stub_align));
12723
12724   for (stub_sec = htab->stub_bfd->sections;
12725        stub_sec != NULL;
12726        stub_sec = stub_sec->next)
12727     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12728       {
12729         stub_sec_count += 1;
12730         if (stub_sec->rawsize != stub_sec->size)
12731           break;
12732       }
12733
12734   if (stub_sec != NULL
12735       || (htab->glink_eh_frame != NULL
12736           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12737     {
12738       htab->stub_error = TRUE;
12739       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12740     }
12741
12742   if (htab->stub_error)
12743     return FALSE;
12744
12745   if (stats != NULL)
12746     {
12747       *stats = bfd_malloc (500);
12748       if (*stats == NULL)
12749         return FALSE;
12750
12751       sprintf (*stats, _("linker stubs in %u group%s\n"
12752                          "  branch       %lu\n"
12753                          "  toc adjust   %lu\n"
12754                          "  long branch  %lu\n"
12755                          "  long toc adj %lu\n"
12756                          "  plt call     %lu\n"
12757                          "  plt call toc %lu"),
12758                stub_sec_count,
12759                stub_sec_count == 1 ? "" : "s",
12760                htab->stub_count[ppc_stub_long_branch - 1],
12761                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12762                htab->stub_count[ppc_stub_plt_branch - 1],
12763                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12764                htab->stub_count[ppc_stub_plt_call - 1],
12765                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12766     }
12767   return TRUE;
12768 }
12769
12770 /* This function undoes the changes made by add_symbol_adjust.  */
12771
12772 static bfd_boolean
12773 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12774 {
12775   struct ppc_link_hash_entry *eh;
12776
12777   if (h->root.type == bfd_link_hash_indirect)
12778     return TRUE;
12779
12780   eh = (struct ppc_link_hash_entry *) h;
12781   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12782     return TRUE;
12783
12784   eh->elf.root.type = bfd_link_hash_undefined;
12785   return TRUE;
12786 }
12787
12788 void
12789 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12790 {
12791   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12792
12793   if (htab != NULL)
12794     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12795 }
12796
12797 /* What to do when ld finds relocations against symbols defined in
12798    discarded sections.  */
12799
12800 static unsigned int
12801 ppc64_elf_action_discarded (asection *sec)
12802 {
12803   if (strcmp (".opd", sec->name) == 0)
12804     return 0;
12805
12806   if (strcmp (".toc", sec->name) == 0)
12807     return 0;
12808
12809   if (strcmp (".toc1", sec->name) == 0)
12810     return 0;
12811
12812   return _bfd_elf_default_action_discarded (sec);
12813 }
12814
12815 /* The RELOCATE_SECTION function is called by the ELF backend linker
12816    to handle the relocations for a section.
12817
12818    The relocs are always passed as Rela structures; if the section
12819    actually uses Rel structures, the r_addend field will always be
12820    zero.
12821
12822    This function is responsible for adjust the section contents as
12823    necessary, and (if using Rela relocs and generating a
12824    relocatable output file) adjusting the reloc addend as
12825    necessary.
12826
12827    This function does not have to worry about setting the reloc
12828    address or the reloc symbol index.
12829
12830    LOCAL_SYMS is a pointer to the swapped in local symbols.
12831
12832    LOCAL_SECTIONS is an array giving the section in the input file
12833    corresponding to the st_shndx field of each local symbol.
12834
12835    The global hash table entry for the global symbols can be found
12836    via elf_sym_hashes (input_bfd).
12837
12838    When generating relocatable output, this function must handle
12839    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12840    going to be the section symbol corresponding to the output
12841    section, which means that the addend must be adjusted
12842    accordingly.  */
12843
12844 static bfd_boolean
12845 ppc64_elf_relocate_section (bfd *output_bfd,
12846                             struct bfd_link_info *info,
12847                             bfd *input_bfd,
12848                             asection *input_section,
12849                             bfd_byte *contents,
12850                             Elf_Internal_Rela *relocs,
12851                             Elf_Internal_Sym *local_syms,
12852                             asection **local_sections)
12853 {
12854   struct ppc_link_hash_table *htab;
12855   Elf_Internal_Shdr *symtab_hdr;
12856   struct elf_link_hash_entry **sym_hashes;
12857   Elf_Internal_Rela *rel;
12858   Elf_Internal_Rela *relend;
12859   Elf_Internal_Rela outrel;
12860   bfd_byte *loc;
12861   struct got_entry **local_got_ents;
12862   bfd_vma TOCstart;
12863   bfd_boolean ret = TRUE;
12864   bfd_boolean is_opd;
12865   /* Assume 'at' branch hints.  */
12866   bfd_boolean is_isa_v2 = TRUE;
12867   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12868
12869   /* Initialize howto table if needed.  */
12870   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12871     ppc_howto_init ();
12872
12873   htab = ppc_hash_table (info);
12874   if (htab == NULL)
12875     return FALSE;
12876
12877   /* Don't relocate stub sections.  */
12878   if (input_section->owner == htab->stub_bfd)
12879     return TRUE;
12880
12881   BFD_ASSERT (is_ppc64_elf (input_bfd));
12882
12883   local_got_ents = elf_local_got_ents (input_bfd);
12884   TOCstart = elf_gp (output_bfd);
12885   symtab_hdr = &elf_symtab_hdr (input_bfd);
12886   sym_hashes = elf_sym_hashes (input_bfd);
12887   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12888
12889   rel = relocs;
12890   relend = relocs + input_section->reloc_count;
12891   for (; rel < relend; rel++)
12892     {
12893       enum elf_ppc64_reloc_type r_type;
12894       bfd_vma addend;
12895       bfd_reloc_status_type r;
12896       Elf_Internal_Sym *sym;
12897       asection *sec;
12898       struct elf_link_hash_entry *h_elf;
12899       struct ppc_link_hash_entry *h;
12900       struct ppc_link_hash_entry *fdh;
12901       const char *sym_name;
12902       unsigned long r_symndx, toc_symndx;
12903       bfd_vma toc_addend;
12904       unsigned char tls_mask, tls_gd, tls_type;
12905       unsigned char sym_type;
12906       bfd_vma relocation;
12907       bfd_boolean unresolved_reloc;
12908       bfd_boolean warned;
12909       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12910       unsigned int insn;
12911       unsigned int mask;
12912       struct ppc_stub_hash_entry *stub_entry;
12913       bfd_vma max_br_offset;
12914       bfd_vma from;
12915       const Elf_Internal_Rela orig_rel = *rel;
12916
12917       r_type = ELF64_R_TYPE (rel->r_info);
12918       r_symndx = ELF64_R_SYM (rel->r_info);
12919
12920       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12921          symbol of the previous ADDR64 reloc.  The symbol gives us the
12922          proper TOC base to use.  */
12923       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12924           && rel != relocs
12925           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12926           && is_opd)
12927         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12928
12929       sym = NULL;
12930       sec = NULL;
12931       h_elf = NULL;
12932       sym_name = NULL;
12933       unresolved_reloc = FALSE;
12934       warned = FALSE;
12935
12936       if (r_symndx < symtab_hdr->sh_info)
12937         {
12938           /* It's a local symbol.  */
12939           struct _opd_sec_data *opd;
12940
12941           sym = local_syms + r_symndx;
12942           sec = local_sections[r_symndx];
12943           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12944           sym_type = ELF64_ST_TYPE (sym->st_info);
12945           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12946           opd = get_opd_info (sec);
12947           if (opd != NULL && opd->adjust != NULL)
12948             {
12949               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12950               if (adjust == -1)
12951                 relocation = 0;
12952               else
12953                 {
12954                   /* If this is a relocation against the opd section sym
12955                      and we have edited .opd, adjust the reloc addend so
12956                      that ld -r and ld --emit-relocs output is correct.
12957                      If it is a reloc against some other .opd symbol,
12958                      then the symbol value will be adjusted later.  */
12959                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12960                     rel->r_addend += adjust;
12961                   else
12962                     relocation += adjust;
12963                 }
12964             }
12965         }
12966       else
12967         {
12968           bfd_boolean ignored;
12969
12970           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12971                                    r_symndx, symtab_hdr, sym_hashes,
12972                                    h_elf, sec, relocation,
12973                                    unresolved_reloc, warned, ignored);
12974           sym_name = h_elf->root.root.string;
12975           sym_type = h_elf->type;
12976           if (sec != NULL
12977               && sec->owner == output_bfd
12978               && strcmp (sec->name, ".opd") == 0)
12979             {
12980               /* This is a symbol defined in a linker script.  All
12981                  such are defined in output sections, even those
12982                  defined by simple assignment from a symbol defined in
12983                  an input section.  Transfer the symbol to an
12984                  appropriate input .opd section, so that a branch to
12985                  this symbol will be mapped to the location specified
12986                  by the opd entry.  */
12987               struct bfd_link_order *lo;
12988               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12989                 if (lo->type == bfd_indirect_link_order)
12990                   {
12991                     asection *isec = lo->u.indirect.section;
12992                     if (h_elf->root.u.def.value >= isec->output_offset
12993                         && h_elf->root.u.def.value < (isec->output_offset
12994                                                       + isec->size))
12995                       {
12996                         h_elf->root.u.def.value -= isec->output_offset;
12997                         h_elf->root.u.def.section = isec;
12998                         sec = isec;
12999                         break;
13000                       }
13001                   }
13002             }
13003         }
13004       h = (struct ppc_link_hash_entry *) h_elf;
13005
13006       if (sec != NULL && discarded_section (sec))
13007         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13008                                          rel, 1, relend,
13009                                          ppc64_elf_howto_table[r_type], 0,
13010                                          contents);
13011
13012       if (info->relocatable)
13013         continue;
13014
13015       if (h != NULL && &h->elf == htab->elf.hgot)
13016         {
13017           relocation = (TOCstart
13018                         + htab->stub_group[input_section->id].toc_off);
13019           sec = bfd_abs_section_ptr;
13020           unresolved_reloc = FALSE;
13021         }
13022
13023       /* TLS optimizations.  Replace instruction sequences and relocs
13024          based on information we collected in tls_optimize.  We edit
13025          RELOCS so that --emit-relocs will output something sensible
13026          for the final instruction stream.  */
13027       tls_mask = 0;
13028       tls_gd = 0;
13029       toc_symndx = 0;
13030       if (h != NULL)
13031         tls_mask = h->tls_mask;
13032       else if (local_got_ents != NULL)
13033         {
13034           struct plt_entry **local_plt = (struct plt_entry **)
13035             (local_got_ents + symtab_hdr->sh_info);
13036           unsigned char *lgot_masks = (unsigned char *)
13037             (local_plt + symtab_hdr->sh_info);
13038           tls_mask = lgot_masks[r_symndx];
13039         }
13040       if (tls_mask == 0
13041           && (r_type == R_PPC64_TLS
13042               || r_type == R_PPC64_TLSGD
13043               || r_type == R_PPC64_TLSLD))
13044         {
13045           /* Check for toc tls entries.  */
13046           unsigned char *toc_tls;
13047
13048           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13049                              &local_syms, rel, input_bfd))
13050             return FALSE;
13051
13052           if (toc_tls)
13053             tls_mask = *toc_tls;
13054         }
13055
13056       /* Check that tls relocs are used with tls syms, and non-tls
13057          relocs are used with non-tls syms.  */
13058       if (r_symndx != STN_UNDEF
13059           && r_type != R_PPC64_NONE
13060           && (h == NULL
13061               || h->elf.root.type == bfd_link_hash_defined
13062               || h->elf.root.type == bfd_link_hash_defweak)
13063           && (IS_PPC64_TLS_RELOC (r_type)
13064               != (sym_type == STT_TLS
13065                   || (sym_type == STT_SECTION
13066                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13067         {
13068           if (tls_mask != 0
13069               && (r_type == R_PPC64_TLS
13070                   || r_type == R_PPC64_TLSGD
13071                   || r_type == R_PPC64_TLSLD))
13072             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13073             ;
13074           else
13075             info->callbacks->einfo
13076               (!IS_PPC64_TLS_RELOC (r_type)
13077                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13078                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13079                input_bfd, input_section, rel->r_offset,
13080                ppc64_elf_howto_table[r_type]->name,
13081                sym_name);
13082         }
13083
13084       /* Ensure reloc mapping code below stays sane.  */
13085       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13086           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13087           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13088           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13089           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13090           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13091           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13092           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13093           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13094           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13095         abort ();
13096
13097       switch (r_type)
13098         {
13099         default:
13100           break;
13101
13102         case R_PPC64_LO_DS_OPT:
13103           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13104           if ((insn & (0x3f << 26)) != 58u << 26)
13105             abort ();
13106           insn += (14u << 26) - (58u << 26);
13107           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13108           r_type = R_PPC64_TOC16_LO;
13109           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13110           break;
13111
13112         case R_PPC64_TOC16:
13113         case R_PPC64_TOC16_LO:
13114         case R_PPC64_TOC16_DS:
13115         case R_PPC64_TOC16_LO_DS:
13116           {
13117             /* Check for toc tls entries.  */
13118             unsigned char *toc_tls;
13119             int retval;
13120
13121             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13122                                    &local_syms, rel, input_bfd);
13123             if (retval == 0)
13124               return FALSE;
13125
13126             if (toc_tls)
13127               {
13128                 tls_mask = *toc_tls;
13129                 if (r_type == R_PPC64_TOC16_DS
13130                     || r_type == R_PPC64_TOC16_LO_DS)
13131                   {
13132                     if (tls_mask != 0
13133                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13134                       goto toctprel;
13135                   }
13136                 else
13137                   {
13138                     /* If we found a GD reloc pair, then we might be
13139                        doing a GD->IE transition.  */
13140                     if (retval == 2)
13141                       {
13142                         tls_gd = TLS_TPRELGD;
13143                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13144                           goto tls_ldgd_opt;
13145                       }
13146                     else if (retval == 3)
13147                       {
13148                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13149                           goto tls_ldgd_opt;
13150                       }
13151                   }
13152               }
13153           }
13154           break;
13155
13156         case R_PPC64_GOT_TPREL16_HI:
13157         case R_PPC64_GOT_TPREL16_HA:
13158           if (tls_mask != 0
13159               && (tls_mask & TLS_TPREL) == 0)
13160             {
13161               rel->r_offset -= d_offset;
13162               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13163               r_type = R_PPC64_NONE;
13164               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13165             }
13166           break;
13167
13168         case R_PPC64_GOT_TPREL16_DS:
13169         case R_PPC64_GOT_TPREL16_LO_DS:
13170           if (tls_mask != 0
13171               && (tls_mask & TLS_TPREL) == 0)
13172             {
13173             toctprel:
13174               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13175               insn &= 31 << 21;
13176               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13177               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13178               r_type = R_PPC64_TPREL16_HA;
13179               if (toc_symndx != 0)
13180                 {
13181                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13182                   rel->r_addend = toc_addend;
13183                   /* We changed the symbol.  Start over in order to
13184                      get h, sym, sec etc. right.  */
13185                   rel--;
13186                   continue;
13187                 }
13188               else
13189                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13190             }
13191           break;
13192
13193         case R_PPC64_TLS:
13194           if (tls_mask != 0
13195               && (tls_mask & TLS_TPREL) == 0)
13196             {
13197               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13198               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13199               if (insn == 0)
13200                 abort ();
13201               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13202               /* Was PPC64_TLS which sits on insn boundary, now
13203                  PPC64_TPREL16_LO which is at low-order half-word.  */
13204               rel->r_offset += d_offset;
13205               r_type = R_PPC64_TPREL16_LO;
13206               if (toc_symndx != 0)
13207                 {
13208                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13209                   rel->r_addend = toc_addend;
13210                   /* We changed the symbol.  Start over in order to
13211                      get h, sym, sec etc. right.  */
13212                   rel--;
13213                   continue;
13214                 }
13215               else
13216                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13217             }
13218           break;
13219
13220         case R_PPC64_GOT_TLSGD16_HI:
13221         case R_PPC64_GOT_TLSGD16_HA:
13222           tls_gd = TLS_TPRELGD;
13223           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13224             goto tls_gdld_hi;
13225           break;
13226
13227         case R_PPC64_GOT_TLSLD16_HI:
13228         case R_PPC64_GOT_TLSLD16_HA:
13229           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13230             {
13231             tls_gdld_hi:
13232               if ((tls_mask & tls_gd) != 0)
13233                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13234                           + R_PPC64_GOT_TPREL16_DS);
13235               else
13236                 {
13237                   rel->r_offset -= d_offset;
13238                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13239                   r_type = R_PPC64_NONE;
13240                 }
13241               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13242             }
13243           break;
13244
13245         case R_PPC64_GOT_TLSGD16:
13246         case R_PPC64_GOT_TLSGD16_LO:
13247           tls_gd = TLS_TPRELGD;
13248           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13249             goto tls_ldgd_opt;
13250           break;
13251
13252         case R_PPC64_GOT_TLSLD16:
13253         case R_PPC64_GOT_TLSLD16_LO:
13254           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13255             {
13256               unsigned int insn1, insn2, insn3;
13257               bfd_vma offset;
13258
13259             tls_ldgd_opt:
13260               offset = (bfd_vma) -1;
13261               /* If not using the newer R_PPC64_TLSGD/LD to mark
13262                  __tls_get_addr calls, we must trust that the call
13263                  stays with its arg setup insns, ie. that the next
13264                  reloc is the __tls_get_addr call associated with
13265                  the current reloc.  Edit both insns.  */
13266               if (input_section->has_tls_get_addr_call
13267                   && rel + 1 < relend
13268                   && branch_reloc_hash_match (input_bfd, rel + 1,
13269                                               htab->tls_get_addr,
13270                                               htab->tls_get_addr_fd))
13271                 offset = rel[1].r_offset;
13272               if ((tls_mask & tls_gd) != 0)
13273                 {
13274                   /* IE */
13275                   insn1 = bfd_get_32 (output_bfd,
13276                                       contents + rel->r_offset - d_offset);
13277                   insn1 &= (1 << 26) - (1 << 2);
13278                   insn1 |= 58 << 26;    /* ld */
13279                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13280                   if (offset != (bfd_vma) -1)
13281                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13282                   if ((tls_mask & TLS_EXPLICIT) == 0)
13283                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13284                               + R_PPC64_GOT_TPREL16_DS);
13285                   else
13286                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13287                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13288                 }
13289               else
13290                 {
13291                   /* LE */
13292                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13293                   insn2 = 0x38630000;   /* addi 3,3,0 */
13294                   if (tls_gd == 0)
13295                     {
13296                       /* Was an LD reloc.  */
13297                       if (toc_symndx)
13298                         sec = local_sections[toc_symndx];
13299                       for (r_symndx = 0;
13300                            r_symndx < symtab_hdr->sh_info;
13301                            r_symndx++)
13302                         if (local_sections[r_symndx] == sec)
13303                           break;
13304                       if (r_symndx >= symtab_hdr->sh_info)
13305                         r_symndx = STN_UNDEF;
13306                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13307                       if (r_symndx != STN_UNDEF)
13308                         rel->r_addend -= (local_syms[r_symndx].st_value
13309                                           + sec->output_offset
13310                                           + sec->output_section->vma);
13311                     }
13312                   else if (toc_symndx != 0)
13313                     {
13314                       r_symndx = toc_symndx;
13315                       rel->r_addend = toc_addend;
13316                     }
13317                   r_type = R_PPC64_TPREL16_HA;
13318                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13319                   if (offset != (bfd_vma) -1)
13320                     {
13321                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13322                                                     R_PPC64_TPREL16_LO);
13323                       rel[1].r_offset = offset + d_offset;
13324                       rel[1].r_addend = rel->r_addend;
13325                     }
13326                 }
13327               bfd_put_32 (output_bfd, insn1,
13328                           contents + rel->r_offset - d_offset);
13329               if (offset != (bfd_vma) -1)
13330                 {
13331                   insn3 = bfd_get_32 (output_bfd,
13332                                       contents + offset + 4);
13333                   if (insn3 == NOP
13334                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13335                     {
13336                       rel[1].r_offset += 4;
13337                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13338                       insn2 = NOP;
13339                     }
13340                   bfd_put_32 (output_bfd, insn2, contents + offset);
13341                 }
13342               if ((tls_mask & tls_gd) == 0
13343                   && (tls_gd == 0 || toc_symndx != 0))
13344                 {
13345                   /* We changed the symbol.  Start over in order
13346                      to get h, sym, sec etc. right.  */
13347                   rel--;
13348                   continue;
13349                 }
13350             }
13351           break;
13352
13353         case R_PPC64_TLSGD:
13354           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13355             {
13356               unsigned int insn2, insn3;
13357               bfd_vma offset = rel->r_offset;
13358
13359               if ((tls_mask & TLS_TPRELGD) != 0)
13360                 {
13361                   /* IE */
13362                   r_type = R_PPC64_NONE;
13363                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13364                 }
13365               else
13366                 {
13367                   /* LE */
13368                   if (toc_symndx != 0)
13369                     {
13370                       r_symndx = toc_symndx;
13371                       rel->r_addend = toc_addend;
13372                     }
13373                   r_type = R_PPC64_TPREL16_LO;
13374                   rel->r_offset = offset + d_offset;
13375                   insn2 = 0x38630000;   /* addi 3,3,0 */
13376                 }
13377               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13378               /* Zap the reloc on the _tls_get_addr call too.  */
13379               BFD_ASSERT (offset == rel[1].r_offset);
13380               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13381               insn3 = bfd_get_32 (output_bfd,
13382                                   contents + offset + 4);
13383               if (insn3 == NOP
13384                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13385                 {
13386                   rel->r_offset += 4;
13387                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13388                   insn2 = NOP;
13389                 }
13390               bfd_put_32 (output_bfd, insn2, contents + offset);
13391               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13392                 {
13393                   rel--;
13394                   continue;
13395                 }
13396             }
13397           break;
13398
13399         case R_PPC64_TLSLD:
13400           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13401             {
13402               unsigned int insn2, insn3;
13403               bfd_vma offset = rel->r_offset;
13404
13405               if (toc_symndx)
13406                 sec = local_sections[toc_symndx];
13407               for (r_symndx = 0;
13408                    r_symndx < symtab_hdr->sh_info;
13409                    r_symndx++)
13410                 if (local_sections[r_symndx] == sec)
13411                   break;
13412               if (r_symndx >= symtab_hdr->sh_info)
13413                 r_symndx = STN_UNDEF;
13414               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13415               if (r_symndx != STN_UNDEF)
13416                 rel->r_addend -= (local_syms[r_symndx].st_value
13417                                   + sec->output_offset
13418                                   + sec->output_section->vma);
13419
13420               r_type = R_PPC64_TPREL16_LO;
13421               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13422               rel->r_offset = offset + d_offset;
13423               /* Zap the reloc on the _tls_get_addr call too.  */
13424               BFD_ASSERT (offset == rel[1].r_offset);
13425               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13426               insn2 = 0x38630000;       /* addi 3,3,0 */
13427               insn3 = bfd_get_32 (output_bfd,
13428                                   contents + offset + 4);
13429               if (insn3 == NOP
13430                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13431                 {
13432                   rel->r_offset += 4;
13433                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13434                   insn2 = NOP;
13435                 }
13436               bfd_put_32 (output_bfd, insn2, contents + offset);
13437               rel--;
13438               continue;
13439             }
13440           break;
13441
13442         case R_PPC64_DTPMOD64:
13443           if (rel + 1 < relend
13444               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13445               && rel[1].r_offset == rel->r_offset + 8)
13446             {
13447               if ((tls_mask & TLS_GD) == 0)
13448                 {
13449                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13450                   if ((tls_mask & TLS_TPRELGD) != 0)
13451                     r_type = R_PPC64_TPREL64;
13452                   else
13453                     {
13454                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13455                       r_type = R_PPC64_NONE;
13456                     }
13457                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13458                 }
13459             }
13460           else
13461             {
13462               if ((tls_mask & TLS_LD) == 0)
13463                 {
13464                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13465                   r_type = R_PPC64_NONE;
13466                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13467                 }
13468             }
13469           break;
13470
13471         case R_PPC64_TPREL64:
13472           if ((tls_mask & TLS_TPREL) == 0)
13473             {
13474               r_type = R_PPC64_NONE;
13475               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13476             }
13477           break;
13478
13479         case R_PPC64_REL16_HA:
13480           /* If we are generating a non-PIC executable, edit
13481              .  0:      addis 2,12,.TOC.-0b@ha
13482              .          addi 2,2,.TOC.-0b@l
13483              used by ELFv2 global entry points to set up r2, to
13484              .          lis 2,.TOC.@ha
13485              .          addi 2,2,.TOC.@l
13486              if .TOC. is in range.  */
13487           if (!info->shared
13488               && h != NULL && &h->elf == htab->elf.hgot
13489               && rel + 1 < relend
13490               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13491               && rel[1].r_offset == rel->r_offset + 4
13492               && rel[1].r_addend == rel->r_addend + 4
13493               && relocation + 0x80008000 <= 0xffffffff)
13494             {
13495               unsigned int insn1, insn2;
13496               bfd_vma offset = rel->r_offset - d_offset;
13497               insn1 = bfd_get_32 (output_bfd, contents + offset);
13498               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13499               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13500                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13501                 {
13502                   r_type = R_PPC64_ADDR16_HA;
13503                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13504                   rel->r_addend -= d_offset;
13505                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13506                   rel[1].r_addend -= d_offset + 4;
13507                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13508                 }
13509             }
13510           break;
13511         }
13512
13513       /* Handle other relocations that tweak non-addend part of insn.  */
13514       insn = 0;
13515       max_br_offset = 1 << 25;
13516       addend = rel->r_addend;
13517       reloc_dest = DEST_NORMAL;
13518       switch (r_type)
13519         {
13520         default:
13521           break;
13522
13523         case R_PPC64_TOCSAVE:
13524           if (relocation + addend == (rel->r_offset
13525                                       + input_section->output_offset
13526                                       + input_section->output_section->vma)
13527               && tocsave_find (htab, NO_INSERT,
13528                                &local_syms, rel, input_bfd))
13529             {
13530               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13531               if (insn == NOP
13532                   || insn == CROR_151515 || insn == CROR_313131)
13533                 bfd_put_32 (input_bfd,
13534                             STD_R2_0R1 + STK_TOC (htab),
13535                             contents + rel->r_offset);
13536             }
13537           break;
13538
13539           /* Branch taken prediction relocations.  */
13540         case R_PPC64_ADDR14_BRTAKEN:
13541         case R_PPC64_REL14_BRTAKEN:
13542           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13543           /* Fall thru.  */
13544
13545           /* Branch not taken prediction relocations.  */
13546         case R_PPC64_ADDR14_BRNTAKEN:
13547         case R_PPC64_REL14_BRNTAKEN:
13548           insn |= bfd_get_32 (output_bfd,
13549                               contents + rel->r_offset) & ~(0x01 << 21);
13550           /* Fall thru.  */
13551
13552         case R_PPC64_REL14:
13553           max_br_offset = 1 << 15;
13554           /* Fall thru.  */
13555
13556         case R_PPC64_REL24:
13557           /* Calls to functions with a different TOC, such as calls to
13558              shared objects, need to alter the TOC pointer.  This is
13559              done using a linkage stub.  A REL24 branching to these
13560              linkage stubs needs to be followed by a nop, as the nop
13561              will be replaced with an instruction to restore the TOC
13562              base pointer.  */
13563           fdh = h;
13564           if (h != NULL
13565               && h->oh != NULL
13566               && h->oh->is_func_descriptor)
13567             fdh = ppc_follow_link (h->oh);
13568           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13569                                            htab);
13570           if (stub_entry != NULL
13571               && (stub_entry->stub_type == ppc_stub_plt_call
13572                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13573                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13574                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13575             {
13576               bfd_boolean can_plt_call = FALSE;
13577
13578               /* All of these stubs will modify r2, so there must be a
13579                  branch and link followed by a nop.  The nop is
13580                  replaced by an insn to restore r2.  */
13581               if (rel->r_offset + 8 <= input_section->size)
13582                 {
13583                   unsigned long br;
13584
13585                   br = bfd_get_32 (input_bfd,
13586                                    contents + rel->r_offset);
13587                   if ((br & 1) != 0)
13588                     {
13589                       unsigned long nop;
13590
13591                       nop = bfd_get_32 (input_bfd,
13592                                         contents + rel->r_offset + 4);
13593                       if (nop == NOP
13594                           || nop == CROR_151515 || nop == CROR_313131)
13595                         {
13596                           if (h != NULL
13597                               && (h == htab->tls_get_addr_fd
13598                                   || h == htab->tls_get_addr)
13599                               && !htab->no_tls_get_addr_opt)
13600                             {
13601                               /* Special stub used, leave nop alone.  */
13602                             }
13603                           else
13604                             bfd_put_32 (input_bfd,
13605                                         LD_R2_0R1 + STK_TOC (htab),
13606                                         contents + rel->r_offset + 4);
13607                           can_plt_call = TRUE;
13608                         }
13609                     }
13610                 }
13611
13612               if (!can_plt_call && h != NULL)
13613                 {
13614                   const char *name = h->elf.root.root.string;
13615
13616                   if (*name == '.')
13617                     ++name;
13618
13619                   if (strncmp (name, "__libc_start_main", 17) == 0
13620                       && (name[17] == 0 || name[17] == '@'))
13621                     {
13622                       /* Allow crt1 branch to go via a toc adjusting
13623                          stub.  Other calls that never return could do
13624                          the same, if we could detect such.  */
13625                       can_plt_call = TRUE;
13626                     }
13627                 }
13628
13629               if (!can_plt_call)
13630                 {
13631                   /* g++ as of 20130507 emits self-calls without a
13632                      following nop.  This is arguably wrong since we
13633                      have conflicting information.  On the one hand a
13634                      global symbol and on the other a local call
13635                      sequence, but don't error for this special case.
13636                      It isn't possible to cheaply verify we have
13637                      exactly such a call.  Allow all calls to the same
13638                      section.  */
13639                   asection *code_sec = sec;
13640
13641                   if (get_opd_info (sec) != NULL)
13642                     {
13643                       bfd_vma off = (relocation + addend
13644                                      - sec->output_section->vma
13645                                      - sec->output_offset);
13646
13647                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13648                     }
13649                   if (code_sec == input_section)
13650                     can_plt_call = TRUE;
13651                 }
13652
13653               if (!can_plt_call)
13654                 {
13655                   info->callbacks->einfo
13656                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13657                        "recompile with -fPIC\n"),
13658                      input_bfd, input_section, rel->r_offset, sym_name);
13659
13660                   bfd_set_error (bfd_error_bad_value);
13661                   ret = FALSE;
13662                 }
13663
13664               if (can_plt_call
13665                   && (stub_entry->stub_type == ppc_stub_plt_call
13666                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13667                 unresolved_reloc = FALSE;
13668             }
13669
13670           if ((stub_entry == NULL
13671                || stub_entry->stub_type == ppc_stub_long_branch
13672                || stub_entry->stub_type == ppc_stub_plt_branch)
13673               && get_opd_info (sec) != NULL)
13674             {
13675               /* The branch destination is the value of the opd entry. */
13676               bfd_vma off = (relocation + addend
13677                              - sec->output_section->vma
13678                              - sec->output_offset);
13679               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13680               if (dest != (bfd_vma) -1)
13681                 {
13682                   relocation = dest;
13683                   addend = 0;
13684                   reloc_dest = DEST_OPD;
13685                 }
13686             }
13687
13688           /* If the branch is out of reach we ought to have a long
13689              branch stub.  */
13690           from = (rel->r_offset
13691                   + input_section->output_offset
13692                   + input_section->output_section->vma);
13693
13694           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13695                                                   ? fdh->elf.other
13696                                                   : sym->st_other);
13697
13698           if (stub_entry != NULL
13699               && (stub_entry->stub_type == ppc_stub_long_branch
13700                   || stub_entry->stub_type == ppc_stub_plt_branch)
13701               && (r_type == R_PPC64_ADDR14_BRTAKEN
13702                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13703                   || (relocation + addend - from + max_br_offset
13704                       < 2 * max_br_offset)))
13705             /* Don't use the stub if this branch is in range.  */
13706             stub_entry = NULL;
13707
13708           if (stub_entry != NULL)
13709             {
13710               /* Munge up the value and addend so that we call the stub
13711                  rather than the procedure directly.  */
13712               relocation = (stub_entry->stub_offset
13713                             + stub_entry->stub_sec->output_offset
13714                             + stub_entry->stub_sec->output_section->vma);
13715               addend = 0;
13716               reloc_dest = DEST_STUB;
13717
13718               if ((stub_entry->stub_type == ppc_stub_plt_call
13719                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13720                   && (ALWAYS_EMIT_R2SAVE
13721                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13722                   && rel + 1 < relend
13723                   && rel[1].r_offset == rel->r_offset + 4
13724                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13725                 relocation += 4;
13726             }
13727
13728           if (insn != 0)
13729             {
13730               if (is_isa_v2)
13731                 {
13732                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13733                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13734                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13735                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13736                     insn |= 0x02 << 21;
13737                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13738                     insn |= 0x08 << 21;
13739                   else
13740                     break;
13741                 }
13742               else
13743                 {
13744                   /* Invert 'y' bit if not the default.  */
13745                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13746                     insn ^= 0x01 << 21;
13747                 }
13748
13749               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13750             }
13751
13752           /* NOP out calls to undefined weak functions.
13753              We can thus call a weak function without first
13754              checking whether the function is defined.  */
13755           else if (h != NULL
13756                    && h->elf.root.type == bfd_link_hash_undefweak
13757                    && h->elf.dynindx == -1
13758                    && r_type == R_PPC64_REL24
13759                    && relocation == 0
13760                    && addend == 0)
13761             {
13762               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13763               continue;
13764             }
13765           break;
13766         }
13767
13768       /* Set `addend'.  */
13769       tls_type = 0;
13770       switch (r_type)
13771         {
13772         default:
13773           info->callbacks->einfo
13774             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13775              input_bfd, (int) r_type, sym_name);
13776
13777           bfd_set_error (bfd_error_bad_value);
13778           ret = FALSE;
13779           continue;
13780
13781         case R_PPC64_NONE:
13782         case R_PPC64_TLS:
13783         case R_PPC64_TLSGD:
13784         case R_PPC64_TLSLD:
13785         case R_PPC64_TOCSAVE:
13786         case R_PPC64_GNU_VTINHERIT:
13787         case R_PPC64_GNU_VTENTRY:
13788           continue;
13789
13790           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13791              address in the GOT as relocation value instead of the
13792              symbol's value itself.  Also, create a GOT entry for the
13793              symbol and put the symbol value there.  */
13794         case R_PPC64_GOT_TLSGD16:
13795         case R_PPC64_GOT_TLSGD16_LO:
13796         case R_PPC64_GOT_TLSGD16_HI:
13797         case R_PPC64_GOT_TLSGD16_HA:
13798           tls_type = TLS_TLS | TLS_GD;
13799           goto dogot;
13800
13801         case R_PPC64_GOT_TLSLD16:
13802         case R_PPC64_GOT_TLSLD16_LO:
13803         case R_PPC64_GOT_TLSLD16_HI:
13804         case R_PPC64_GOT_TLSLD16_HA:
13805           tls_type = TLS_TLS | TLS_LD;
13806           goto dogot;
13807
13808         case R_PPC64_GOT_TPREL16_DS:
13809         case R_PPC64_GOT_TPREL16_LO_DS:
13810         case R_PPC64_GOT_TPREL16_HI:
13811         case R_PPC64_GOT_TPREL16_HA:
13812           tls_type = TLS_TLS | TLS_TPREL;
13813           goto dogot;
13814
13815         case R_PPC64_GOT_DTPREL16_DS:
13816         case R_PPC64_GOT_DTPREL16_LO_DS:
13817         case R_PPC64_GOT_DTPREL16_HI:
13818         case R_PPC64_GOT_DTPREL16_HA:
13819           tls_type = TLS_TLS | TLS_DTPREL;
13820           goto dogot;
13821
13822         case R_PPC64_GOT16:
13823         case R_PPC64_GOT16_LO:
13824         case R_PPC64_GOT16_HI:
13825         case R_PPC64_GOT16_HA:
13826         case R_PPC64_GOT16_DS:
13827         case R_PPC64_GOT16_LO_DS:
13828         dogot:
13829           {
13830             /* Relocation is to the entry for this symbol in the global
13831                offset table.  */
13832             asection *got;
13833             bfd_vma *offp;
13834             bfd_vma off;
13835             unsigned long indx = 0;
13836             struct got_entry *ent;
13837
13838             if (tls_type == (TLS_TLS | TLS_LD)
13839                 && (h == NULL
13840                     || !h->elf.def_dynamic))
13841               ent = ppc64_tlsld_got (input_bfd);
13842             else
13843               {
13844
13845                 if (h != NULL)
13846                   {
13847                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13848                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13849                                                           &h->elf)
13850                         || (info->shared
13851                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13852                       /* This is actually a static link, or it is a
13853                          -Bsymbolic link and the symbol is defined
13854                          locally, or the symbol was forced to be local
13855                          because of a version file.  */
13856                       ;
13857                     else
13858                       {
13859                         BFD_ASSERT (h->elf.dynindx != -1);
13860                         indx = h->elf.dynindx;
13861                         unresolved_reloc = FALSE;
13862                       }
13863                     ent = h->elf.got.glist;
13864                   }
13865                 else
13866                   {
13867                     if (local_got_ents == NULL)
13868                       abort ();
13869                     ent = local_got_ents[r_symndx];
13870                   }
13871
13872                 for (; ent != NULL; ent = ent->next)
13873                   if (ent->addend == orig_rel.r_addend
13874                       && ent->owner == input_bfd
13875                       && ent->tls_type == tls_type)
13876                     break;
13877               }
13878
13879             if (ent == NULL)
13880               abort ();
13881             if (ent->is_indirect)
13882               ent = ent->got.ent;
13883             offp = &ent->got.offset;
13884             got = ppc64_elf_tdata (ent->owner)->got;
13885             if (got == NULL)
13886               abort ();
13887
13888             /* The offset must always be a multiple of 8.  We use the
13889                least significant bit to record whether we have already
13890                processed this entry.  */
13891             off = *offp;
13892             if ((off & 1) != 0)
13893               off &= ~1;
13894             else
13895               {
13896                 /* Generate relocs for the dynamic linker, except in
13897                    the case of TLSLD where we'll use one entry per
13898                    module.  */
13899                 asection *relgot;
13900                 bfd_boolean ifunc;
13901
13902                 *offp = off | 1;
13903                 relgot = NULL;
13904                 ifunc = (h != NULL
13905                          ? h->elf.type == STT_GNU_IFUNC
13906                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13907                 if (ifunc)
13908                   relgot = htab->elf.irelplt;
13909                 else if ((info->shared || indx != 0)
13910                          && (h == NULL
13911                              || (tls_type == (TLS_TLS | TLS_LD)
13912                                  && !h->elf.def_dynamic)
13913                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13914                              || h->elf.root.type != bfd_link_hash_undefweak))
13915                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13916                 if (relgot != NULL)
13917                   {
13918                     outrel.r_offset = (got->output_section->vma
13919                                        + got->output_offset
13920                                        + off);
13921                     outrel.r_addend = addend;
13922                     if (tls_type & (TLS_LD | TLS_GD))
13923                       {
13924                         outrel.r_addend = 0;
13925                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13926                         if (tls_type == (TLS_TLS | TLS_GD))
13927                           {
13928                             loc = relgot->contents;
13929                             loc += (relgot->reloc_count++
13930                                     * sizeof (Elf64_External_Rela));
13931                             bfd_elf64_swap_reloca_out (output_bfd,
13932                                                        &outrel, loc);
13933                             outrel.r_offset += 8;
13934                             outrel.r_addend = addend;
13935                             outrel.r_info
13936                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13937                           }
13938                       }
13939                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13940                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13941                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13942                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13943                     else if (indx != 0)
13944                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13945                     else
13946                       {
13947                         if (ifunc)
13948                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13949                         else
13950                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13951
13952                         /* Write the .got section contents for the sake
13953                            of prelink.  */
13954                         loc = got->contents + off;
13955                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13956                                     loc);
13957                       }
13958
13959                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13960                       {
13961                         outrel.r_addend += relocation;
13962                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13963                           outrel.r_addend -= htab->elf.tls_sec->vma;
13964                       }
13965                     loc = relgot->contents;
13966                     loc += (relgot->reloc_count++
13967                             * sizeof (Elf64_External_Rela));
13968                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13969                   }
13970
13971                 /* Init the .got section contents here if we're not
13972                    emitting a reloc.  */
13973                 else
13974                   {
13975                     relocation += addend;
13976                     if (tls_type == (TLS_TLS | TLS_LD))
13977                       relocation = 1;
13978                     else if (tls_type != 0)
13979                       {
13980                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13981                         if (tls_type == (TLS_TLS | TLS_TPREL))
13982                           relocation += DTP_OFFSET - TP_OFFSET;
13983
13984                         if (tls_type == (TLS_TLS | TLS_GD))
13985                           {
13986                             bfd_put_64 (output_bfd, relocation,
13987                                         got->contents + off + 8);
13988                             relocation = 1;
13989                           }
13990                       }
13991
13992                     bfd_put_64 (output_bfd, relocation,
13993                                 got->contents + off);
13994                   }
13995               }
13996
13997             if (off >= (bfd_vma) -2)
13998               abort ();
13999
14000             relocation = got->output_section->vma + got->output_offset + off;
14001             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14002           }
14003           break;
14004
14005         case R_PPC64_PLT16_HA:
14006         case R_PPC64_PLT16_HI:
14007         case R_PPC64_PLT16_LO:
14008         case R_PPC64_PLT32:
14009         case R_PPC64_PLT64:
14010           /* Relocation is to the entry for this symbol in the
14011              procedure linkage table.  */
14012
14013           /* Resolve a PLT reloc against a local symbol directly,
14014              without using the procedure linkage table.  */
14015           if (h == NULL)
14016             break;
14017
14018           /* It's possible that we didn't make a PLT entry for this
14019              symbol.  This happens when statically linking PIC code,
14020              or when using -Bsymbolic.  Go find a match if there is a
14021              PLT entry.  */
14022           if (htab->elf.splt != NULL)
14023             {
14024               struct plt_entry *ent;
14025               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14026                 if (ent->plt.offset != (bfd_vma) -1
14027                     && ent->addend == orig_rel.r_addend)
14028                   {
14029                     relocation = (htab->elf.splt->output_section->vma
14030                                   + htab->elf.splt->output_offset
14031                                   + ent->plt.offset);
14032                     unresolved_reloc = FALSE;
14033                     break;
14034                   }
14035             }
14036           break;
14037
14038         case R_PPC64_TOC:
14039           /* Relocation value is TOC base.  */
14040           relocation = TOCstart;
14041           if (r_symndx == STN_UNDEF)
14042             relocation += htab->stub_group[input_section->id].toc_off;
14043           else if (unresolved_reloc)
14044             ;
14045           else if (sec != NULL && sec->id <= htab->top_id)
14046             relocation += htab->stub_group[sec->id].toc_off;
14047           else
14048             unresolved_reloc = TRUE;
14049           goto dodyn;
14050
14051           /* TOC16 relocs.  We want the offset relative to the TOC base,
14052              which is the address of the start of the TOC plus 0x8000.
14053              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14054              in this order.  */
14055         case R_PPC64_TOC16:
14056         case R_PPC64_TOC16_LO:
14057         case R_PPC64_TOC16_HI:
14058         case R_PPC64_TOC16_DS:
14059         case R_PPC64_TOC16_LO_DS:
14060         case R_PPC64_TOC16_HA:
14061           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14062           break;
14063
14064           /* Relocate against the beginning of the section.  */
14065         case R_PPC64_SECTOFF:
14066         case R_PPC64_SECTOFF_LO:
14067         case R_PPC64_SECTOFF_HI:
14068         case R_PPC64_SECTOFF_DS:
14069         case R_PPC64_SECTOFF_LO_DS:
14070         case R_PPC64_SECTOFF_HA:
14071           if (sec != NULL)
14072             addend -= sec->output_section->vma;
14073           break;
14074
14075         case R_PPC64_REL16:
14076         case R_PPC64_REL16_LO:
14077         case R_PPC64_REL16_HI:
14078         case R_PPC64_REL16_HA:
14079           break;
14080
14081         case R_PPC64_REL14:
14082         case R_PPC64_REL14_BRNTAKEN:
14083         case R_PPC64_REL14_BRTAKEN:
14084         case R_PPC64_REL24:
14085           break;
14086
14087         case R_PPC64_TPREL16:
14088         case R_PPC64_TPREL16_LO:
14089         case R_PPC64_TPREL16_HI:
14090         case R_PPC64_TPREL16_HA:
14091         case R_PPC64_TPREL16_DS:
14092         case R_PPC64_TPREL16_LO_DS:
14093         case R_PPC64_TPREL16_HIGH:
14094         case R_PPC64_TPREL16_HIGHA:
14095         case R_PPC64_TPREL16_HIGHER:
14096         case R_PPC64_TPREL16_HIGHERA:
14097         case R_PPC64_TPREL16_HIGHEST:
14098         case R_PPC64_TPREL16_HIGHESTA:
14099           if (h != NULL
14100               && h->elf.root.type == bfd_link_hash_undefweak
14101               && h->elf.dynindx == -1)
14102             {
14103               /* Make this relocation against an undefined weak symbol
14104                  resolve to zero.  This is really just a tweak, since
14105                  code using weak externs ought to check that they are
14106                  defined before using them.  */
14107               bfd_byte *p = contents + rel->r_offset - d_offset;
14108
14109               insn = bfd_get_32 (output_bfd, p);
14110               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14111               if (insn != 0)
14112                 bfd_put_32 (output_bfd, insn, p);
14113               break;
14114             }
14115           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14116           if (info->shared)
14117             /* The TPREL16 relocs shouldn't really be used in shared
14118                libs as they will result in DT_TEXTREL being set, but
14119                support them anyway.  */
14120             goto dodyn;
14121           break;
14122
14123         case R_PPC64_DTPREL16:
14124         case R_PPC64_DTPREL16_LO:
14125         case R_PPC64_DTPREL16_HI:
14126         case R_PPC64_DTPREL16_HA:
14127         case R_PPC64_DTPREL16_DS:
14128         case R_PPC64_DTPREL16_LO_DS:
14129         case R_PPC64_DTPREL16_HIGH:
14130         case R_PPC64_DTPREL16_HIGHA:
14131         case R_PPC64_DTPREL16_HIGHER:
14132         case R_PPC64_DTPREL16_HIGHERA:
14133         case R_PPC64_DTPREL16_HIGHEST:
14134         case R_PPC64_DTPREL16_HIGHESTA:
14135           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14136           break;
14137
14138         case R_PPC64_DTPMOD64:
14139           relocation = 1;
14140           addend = 0;
14141           goto dodyn;
14142
14143         case R_PPC64_TPREL64:
14144           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14145           goto dodyn;
14146
14147         case R_PPC64_DTPREL64:
14148           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14149           /* Fall thru */
14150
14151           /* Relocations that may need to be propagated if this is a
14152              dynamic object.  */
14153         case R_PPC64_REL30:
14154         case R_PPC64_REL32:
14155         case R_PPC64_REL64:
14156         case R_PPC64_ADDR14:
14157         case R_PPC64_ADDR14_BRNTAKEN:
14158         case R_PPC64_ADDR14_BRTAKEN:
14159         case R_PPC64_ADDR16:
14160         case R_PPC64_ADDR16_DS:
14161         case R_PPC64_ADDR16_HA:
14162         case R_PPC64_ADDR16_HI:
14163         case R_PPC64_ADDR16_HIGH:
14164         case R_PPC64_ADDR16_HIGHA:
14165         case R_PPC64_ADDR16_HIGHER:
14166         case R_PPC64_ADDR16_HIGHERA:
14167         case R_PPC64_ADDR16_HIGHEST:
14168         case R_PPC64_ADDR16_HIGHESTA:
14169         case R_PPC64_ADDR16_LO:
14170         case R_PPC64_ADDR16_LO_DS:
14171         case R_PPC64_ADDR24:
14172         case R_PPC64_ADDR32:
14173         case R_PPC64_ADDR64:
14174         case R_PPC64_UADDR16:
14175         case R_PPC64_UADDR32:
14176         case R_PPC64_UADDR64:
14177         dodyn:
14178           if ((input_section->flags & SEC_ALLOC) == 0)
14179             break;
14180
14181           if (NO_OPD_RELOCS && is_opd)
14182             break;
14183
14184           if ((info->shared
14185                && (h == NULL
14186                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14187                    || h->elf.root.type != bfd_link_hash_undefweak)
14188                && (must_be_dyn_reloc (info, r_type)
14189                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14190               || (ELIMINATE_COPY_RELOCS
14191                   && !info->shared
14192                   && h != NULL
14193                   && h->elf.dynindx != -1
14194                   && !h->elf.non_got_ref
14195                   && !h->elf.def_regular)
14196               || (!info->shared
14197                   && (h != NULL
14198                       ? h->elf.type == STT_GNU_IFUNC
14199                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14200             {
14201               bfd_boolean skip, relocate;
14202               asection *sreloc;
14203               bfd_vma out_off;
14204
14205               /* When generating a dynamic object, these relocations
14206                  are copied into the output file to be resolved at run
14207                  time.  */
14208
14209               skip = FALSE;
14210               relocate = FALSE;
14211
14212               out_off = _bfd_elf_section_offset (output_bfd, info,
14213                                                  input_section, rel->r_offset);
14214               if (out_off == (bfd_vma) -1)
14215                 skip = TRUE;
14216               else if (out_off == (bfd_vma) -2)
14217                 skip = TRUE, relocate = TRUE;
14218               out_off += (input_section->output_section->vma
14219                           + input_section->output_offset);
14220               outrel.r_offset = out_off;
14221               outrel.r_addend = rel->r_addend;
14222
14223               /* Optimize unaligned reloc use.  */
14224               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14225                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14226                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14227               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14228                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14229                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14230               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14231                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14232                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14233
14234               if (skip)
14235                 memset (&outrel, 0, sizeof outrel);
14236               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14237                        && !is_opd
14238                        && r_type != R_PPC64_TOC)
14239                 {
14240                   BFD_ASSERT (h->elf.dynindx != -1);
14241                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14242                 }
14243               else
14244                 {
14245                   /* This symbol is local, or marked to become local,
14246                      or this is an opd section reloc which must point
14247                      at a local function.  */
14248                   outrel.r_addend += relocation;
14249                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14250                     {
14251                       if (is_opd && h != NULL)
14252                         {
14253                           /* Lie about opd entries.  This case occurs
14254                              when building shared libraries and we
14255                              reference a function in another shared
14256                              lib.  The same thing happens for a weak
14257                              definition in an application that's
14258                              overridden by a strong definition in a
14259                              shared lib.  (I believe this is a generic
14260                              bug in binutils handling of weak syms.)
14261                              In these cases we won't use the opd
14262                              entry in this lib.  */
14263                           unresolved_reloc = FALSE;
14264                         }
14265                       if (!is_opd
14266                           && r_type == R_PPC64_ADDR64
14267                           && (h != NULL
14268                               ? h->elf.type == STT_GNU_IFUNC
14269                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14270                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14271                       else
14272                         {
14273                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14274
14275                           /* We need to relocate .opd contents for ld.so.
14276                              Prelink also wants simple and consistent rules
14277                              for relocs.  This make all RELATIVE relocs have
14278                              *r_offset equal to r_addend.  */
14279                           relocate = TRUE;
14280                         }
14281                     }
14282                   else
14283                     {
14284                       long indx = 0;
14285
14286                       if (h != NULL
14287                           ? h->elf.type == STT_GNU_IFUNC
14288                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14289                         {
14290                           info->callbacks->einfo
14291                             (_("%P: %H: %s for indirect "
14292                                "function `%T' unsupported\n"),
14293                              input_bfd, input_section, rel->r_offset,
14294                              ppc64_elf_howto_table[r_type]->name,
14295                              sym_name);
14296                           ret = FALSE;
14297                         }
14298                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14299                         ;
14300                       else if (sec == NULL || sec->owner == NULL)
14301                         {
14302                           bfd_set_error (bfd_error_bad_value);
14303                           return FALSE;
14304                         }
14305                       else
14306                         {
14307                           asection *osec;
14308
14309                           osec = sec->output_section;
14310                           indx = elf_section_data (osec)->dynindx;
14311
14312                           if (indx == 0)
14313                             {
14314                               if ((osec->flags & SEC_READONLY) == 0
14315                                   && htab->elf.data_index_section != NULL)
14316                                 osec = htab->elf.data_index_section;
14317                               else
14318                                 osec = htab->elf.text_index_section;
14319                               indx = elf_section_data (osec)->dynindx;
14320                             }
14321                           BFD_ASSERT (indx != 0);
14322
14323                           /* We are turning this relocation into one
14324                              against a section symbol, so subtract out
14325                              the output section's address but not the
14326                              offset of the input section in the output
14327                              section.  */
14328                           outrel.r_addend -= osec->vma;
14329                         }
14330
14331                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14332                     }
14333                 }
14334
14335               sreloc = elf_section_data (input_section)->sreloc;
14336               if (h != NULL
14337                   ? h->elf.type == STT_GNU_IFUNC
14338                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14339                 sreloc = htab->elf.irelplt;
14340               if (sreloc == NULL)
14341                 abort ();
14342
14343               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14344                   >= sreloc->size)
14345                 abort ();
14346               loc = sreloc->contents;
14347               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14348               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14349
14350               /* If this reloc is against an external symbol, it will
14351                  be computed at runtime, so there's no need to do
14352                  anything now.  However, for the sake of prelink ensure
14353                  that the section contents are a known value.  */
14354               if (! relocate)
14355                 {
14356                   unresolved_reloc = FALSE;
14357                   /* The value chosen here is quite arbitrary as ld.so
14358                      ignores section contents except for the special
14359                      case of .opd where the contents might be accessed
14360                      before relocation.  Choose zero, as that won't
14361                      cause reloc overflow.  */
14362                   relocation = 0;
14363                   addend = 0;
14364                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14365                      to improve backward compatibility with older
14366                      versions of ld.  */
14367                   if (r_type == R_PPC64_ADDR64)
14368                     addend = outrel.r_addend;
14369                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14370                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14371                     addend = (input_section->output_section->vma
14372                               + input_section->output_offset
14373                               + rel->r_offset);
14374                 }
14375             }
14376           break;
14377
14378         case R_PPC64_COPY:
14379         case R_PPC64_GLOB_DAT:
14380         case R_PPC64_JMP_SLOT:
14381         case R_PPC64_JMP_IREL:
14382         case R_PPC64_RELATIVE:
14383           /* We shouldn't ever see these dynamic relocs in relocatable
14384              files.  */
14385           /* Fall through.  */
14386
14387         case R_PPC64_PLTGOT16:
14388         case R_PPC64_PLTGOT16_DS:
14389         case R_PPC64_PLTGOT16_HA:
14390         case R_PPC64_PLTGOT16_HI:
14391         case R_PPC64_PLTGOT16_LO:
14392         case R_PPC64_PLTGOT16_LO_DS:
14393         case R_PPC64_PLTREL32:
14394         case R_PPC64_PLTREL64:
14395           /* These ones haven't been implemented yet.  */
14396
14397           info->callbacks->einfo
14398             (_("%P: %B: %s is not supported for `%T'\n"),
14399              input_bfd,
14400              ppc64_elf_howto_table[r_type]->name, sym_name);
14401
14402           bfd_set_error (bfd_error_invalid_operation);
14403           ret = FALSE;
14404           continue;
14405         }
14406
14407       /* Multi-instruction sequences that access the TOC can be
14408          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14409          to             nop;           addi rb,r2,x;  */
14410       switch (r_type)
14411         {
14412         default:
14413           break;
14414
14415         case R_PPC64_GOT_TLSLD16_HI:
14416         case R_PPC64_GOT_TLSGD16_HI:
14417         case R_PPC64_GOT_TPREL16_HI:
14418         case R_PPC64_GOT_DTPREL16_HI:
14419         case R_PPC64_GOT16_HI:
14420         case R_PPC64_TOC16_HI:
14421           /* These relocs would only be useful if building up an
14422              offset to later add to r2, perhaps in an indexed
14423              addressing mode instruction.  Don't try to optimize.
14424              Unfortunately, the possibility of someone building up an
14425              offset like this or even with the HA relocs, means that
14426              we need to check the high insn when optimizing the low
14427              insn.  */
14428           break;
14429
14430         case R_PPC64_GOT_TLSLD16_HA:
14431         case R_PPC64_GOT_TLSGD16_HA:
14432         case R_PPC64_GOT_TPREL16_HA:
14433         case R_PPC64_GOT_DTPREL16_HA:
14434         case R_PPC64_GOT16_HA:
14435         case R_PPC64_TOC16_HA:
14436           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14437               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14438             {
14439               bfd_byte *p = contents + (rel->r_offset & ~3);
14440               bfd_put_32 (input_bfd, NOP, p);
14441             }
14442           break;
14443
14444         case R_PPC64_GOT_TLSLD16_LO:
14445         case R_PPC64_GOT_TLSGD16_LO:
14446         case R_PPC64_GOT_TPREL16_LO_DS:
14447         case R_PPC64_GOT_DTPREL16_LO_DS:
14448         case R_PPC64_GOT16_LO:
14449         case R_PPC64_GOT16_LO_DS:
14450         case R_PPC64_TOC16_LO:
14451         case R_PPC64_TOC16_LO_DS:
14452           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14453               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14454             {
14455               bfd_byte *p = contents + (rel->r_offset & ~3);
14456               insn = bfd_get_32 (input_bfd, p);
14457               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14458                 {
14459                   /* Transform addic to addi when we change reg.  */
14460                   insn &= ~((0x3f << 26) | (0x1f << 16));
14461                   insn |= (14u << 26) | (2 << 16);
14462                 }
14463               else
14464                 {
14465                   insn &= ~(0x1f << 16);
14466                   insn |= 2 << 16;
14467                 }
14468               bfd_put_32 (input_bfd, insn, p);
14469             }
14470           break;
14471         }
14472
14473       /* Do any further special processing.  */
14474       switch (r_type)
14475         {
14476         default:
14477           break;
14478
14479         case R_PPC64_REL16_HA:
14480         case R_PPC64_ADDR16_HA:
14481         case R_PPC64_ADDR16_HIGHA:
14482         case R_PPC64_ADDR16_HIGHERA:
14483         case R_PPC64_ADDR16_HIGHESTA:
14484         case R_PPC64_TOC16_HA:
14485         case R_PPC64_SECTOFF_HA:
14486         case R_PPC64_TPREL16_HA:
14487         case R_PPC64_TPREL16_HIGHA:
14488         case R_PPC64_TPREL16_HIGHERA:
14489         case R_PPC64_TPREL16_HIGHESTA:
14490         case R_PPC64_DTPREL16_HA:
14491         case R_PPC64_DTPREL16_HIGHA:
14492         case R_PPC64_DTPREL16_HIGHERA:
14493         case R_PPC64_DTPREL16_HIGHESTA:
14494           /* It's just possible that this symbol is a weak symbol
14495              that's not actually defined anywhere. In that case,
14496              'sec' would be NULL, and we should leave the symbol
14497              alone (it will be set to zero elsewhere in the link).  */
14498           if (sec == NULL)
14499             break;
14500           /* Fall thru */
14501
14502         case R_PPC64_GOT16_HA:
14503         case R_PPC64_PLTGOT16_HA:
14504         case R_PPC64_PLT16_HA:
14505         case R_PPC64_GOT_TLSGD16_HA:
14506         case R_PPC64_GOT_TLSLD16_HA:
14507         case R_PPC64_GOT_TPREL16_HA:
14508         case R_PPC64_GOT_DTPREL16_HA:
14509           /* Add 0x10000 if sign bit in 0:15 is set.
14510              Bits 0:15 are not used.  */
14511           addend += 0x8000;
14512           break;
14513
14514         case R_PPC64_ADDR16_DS:
14515         case R_PPC64_ADDR16_LO_DS:
14516         case R_PPC64_GOT16_DS:
14517         case R_PPC64_GOT16_LO_DS:
14518         case R_PPC64_PLT16_LO_DS:
14519         case R_PPC64_SECTOFF_DS:
14520         case R_PPC64_SECTOFF_LO_DS:
14521         case R_PPC64_TOC16_DS:
14522         case R_PPC64_TOC16_LO_DS:
14523         case R_PPC64_PLTGOT16_DS:
14524         case R_PPC64_PLTGOT16_LO_DS:
14525         case R_PPC64_GOT_TPREL16_DS:
14526         case R_PPC64_GOT_TPREL16_LO_DS:
14527         case R_PPC64_GOT_DTPREL16_DS:
14528         case R_PPC64_GOT_DTPREL16_LO_DS:
14529         case R_PPC64_TPREL16_DS:
14530         case R_PPC64_TPREL16_LO_DS:
14531         case R_PPC64_DTPREL16_DS:
14532         case R_PPC64_DTPREL16_LO_DS:
14533           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14534           mask = 3;
14535           /* If this reloc is against an lq insn, then the value must be
14536              a multiple of 16.  This is somewhat of a hack, but the
14537              "correct" way to do this by defining _DQ forms of all the
14538              _DS relocs bloats all reloc switches in this file.  It
14539              doesn't seem to make much sense to use any of these relocs
14540              in data, so testing the insn should be safe.  */
14541           if ((insn & (0x3f << 26)) == (56u << 26))
14542             mask = 15;
14543           if (((relocation + addend) & mask) != 0)
14544             {
14545               info->callbacks->einfo
14546                 (_("%P: %H: error: %s not a multiple of %u\n"),
14547                  input_bfd, input_section, rel->r_offset,
14548                  ppc64_elf_howto_table[r_type]->name,
14549                  mask + 1);
14550               bfd_set_error (bfd_error_bad_value);
14551               ret = FALSE;
14552               continue;
14553             }
14554           break;
14555         }
14556
14557       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14558          because such sections are not SEC_ALLOC and thus ld.so will
14559          not process them.  */
14560       if (unresolved_reloc
14561           && !((input_section->flags & SEC_DEBUGGING) != 0
14562                && h->elf.def_dynamic)
14563           && _bfd_elf_section_offset (output_bfd, info, input_section,
14564                                       rel->r_offset) != (bfd_vma) -1)
14565         {
14566           info->callbacks->einfo
14567             (_("%P: %H: unresolvable %s against `%T'\n"),
14568              input_bfd, input_section, rel->r_offset,
14569              ppc64_elf_howto_table[(int) r_type]->name,
14570              h->elf.root.root.string);
14571           ret = FALSE;
14572         }
14573
14574       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14575                                     input_bfd,
14576                                     input_section,
14577                                     contents,
14578                                     rel->r_offset,
14579                                     relocation,
14580                                     addend);
14581
14582       if (r != bfd_reloc_ok)
14583         {
14584           char *more_info = NULL;
14585           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14586
14587           if (reloc_dest != DEST_NORMAL)
14588             {
14589               more_info = bfd_malloc (strlen (reloc_name) + 8);
14590               if (more_info != NULL)
14591                 {
14592                   strcpy (more_info, reloc_name);
14593                   strcat (more_info, (reloc_dest == DEST_OPD
14594                                       ? " (OPD)" : " (stub)"));
14595                   reloc_name = more_info;
14596                 }
14597             }
14598
14599           if (r == bfd_reloc_overflow)
14600             {
14601               if (warned)
14602                 continue;
14603               if (h != NULL
14604                   && h->elf.root.type == bfd_link_hash_undefweak
14605                   && ppc64_elf_howto_table[r_type]->pc_relative)
14606                 {
14607                   /* Assume this is a call protected by other code that
14608                      detects the symbol is undefined.  If this is the case,
14609                      we can safely ignore the overflow.  If not, the
14610                      program is hosed anyway, and a little warning isn't
14611                      going to help.  */
14612
14613                   continue;
14614                 }
14615
14616               if (!((*info->callbacks->reloc_overflow)
14617                     (info, &h->elf.root, sym_name,
14618                      reloc_name, orig_rel.r_addend,
14619                      input_bfd, input_section, rel->r_offset)))
14620                 return FALSE;
14621             }
14622           else
14623             {
14624               info->callbacks->einfo
14625                 (_("%P: %H: %s against `%T': error %d\n"),
14626                  input_bfd, input_section, rel->r_offset,
14627                  reloc_name, sym_name, (int) r);
14628               ret = FALSE;
14629             }
14630           if (more_info != NULL)
14631             free (more_info);
14632         }
14633     }
14634
14635   /* If we're emitting relocations, then shortly after this function
14636      returns, reloc offsets and addends for this section will be
14637      adjusted.  Worse, reloc symbol indices will be for the output
14638      file rather than the input.  Save a copy of the relocs for
14639      opd_entry_value.  */
14640   if (is_opd && (info->emitrelocations || info->relocatable))
14641     {
14642       bfd_size_type amt;
14643       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14644       rel = bfd_alloc (input_bfd, amt);
14645       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14646       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14647       if (rel == NULL)
14648         return FALSE;
14649       memcpy (rel, relocs, amt);
14650     }
14651   return ret;
14652 }
14653
14654 /* Adjust the value of any local symbols in opd sections.  */
14655
14656 static int
14657 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14658                               const char *name ATTRIBUTE_UNUSED,
14659                               Elf_Internal_Sym *elfsym,
14660                               asection *input_sec,
14661                               struct elf_link_hash_entry *h)
14662 {
14663   struct _opd_sec_data *opd;
14664   long adjust;
14665   bfd_vma value;
14666
14667   if (h != NULL)
14668     return 1;
14669
14670   opd = get_opd_info (input_sec);
14671   if (opd == NULL || opd->adjust == NULL)
14672     return 1;
14673
14674   value = elfsym->st_value - input_sec->output_offset;
14675   if (!info->relocatable)
14676     value -= input_sec->output_section->vma;
14677
14678   adjust = opd->adjust[value / 8];
14679   if (adjust == -1)
14680     return 2;
14681
14682   elfsym->st_value += adjust;
14683   return 1;
14684 }
14685
14686 /* Finish up dynamic symbol handling.  We set the contents of various
14687    dynamic sections here.  */
14688
14689 static bfd_boolean
14690 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14691                                  struct bfd_link_info *info,
14692                                  struct elf_link_hash_entry *h,
14693                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14694 {
14695   struct ppc_link_hash_table *htab;
14696   struct plt_entry *ent;
14697   Elf_Internal_Rela rela;
14698   bfd_byte *loc;
14699
14700   htab = ppc_hash_table (info);
14701   if (htab == NULL)
14702     return FALSE;
14703
14704   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14705     if (ent->plt.offset != (bfd_vma) -1)
14706       {
14707         /* This symbol has an entry in the procedure linkage
14708            table.  Set it up.  */
14709         if (!htab->elf.dynamic_sections_created
14710             || h->dynindx == -1)
14711           {
14712             BFD_ASSERT (h->type == STT_GNU_IFUNC
14713                         && h->def_regular
14714                         && (h->root.type == bfd_link_hash_defined
14715                             || h->root.type == bfd_link_hash_defweak));
14716             rela.r_offset = (htab->elf.iplt->output_section->vma
14717                              + htab->elf.iplt->output_offset
14718                              + ent->plt.offset);
14719             if (htab->opd_abi)
14720               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14721             else
14722               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14723             rela.r_addend = (h->root.u.def.value
14724                              + h->root.u.def.section->output_offset
14725                              + h->root.u.def.section->output_section->vma
14726                              + ent->addend);
14727             loc = (htab->elf.irelplt->contents
14728                    + (htab->elf.irelplt->reloc_count++
14729                       * sizeof (Elf64_External_Rela)));
14730           }
14731         else
14732           {
14733             rela.r_offset = (htab->elf.splt->output_section->vma
14734                              + htab->elf.splt->output_offset
14735                              + ent->plt.offset);
14736             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14737             rela.r_addend = ent->addend;
14738             loc = (htab->elf.srelplt->contents
14739                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14740                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14741           }
14742         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14743
14744         if (!htab->opd_abi)
14745           {
14746             if (!h->def_regular)
14747               {
14748                 /* Mark the symbol as undefined, rather than as
14749                    defined in glink.  Leave the value if there were
14750                    any relocations where pointer equality matters
14751                    (this is a clue for the dynamic linker, to make
14752                    function pointer comparisons work between an
14753                    application and shared library), otherwise set it
14754                    to zero.  */
14755                 sym->st_shndx = SHN_UNDEF;
14756                 if (!h->pointer_equality_needed)
14757                   sym->st_value = 0;
14758                 else if (!h->ref_regular_nonweak)
14759                   {
14760                     /* This breaks function pointer comparisons, but
14761                        that is better than breaking tests for a NULL
14762                        function pointer.  */
14763                     sym->st_value = 0;
14764                   }
14765               }
14766           }
14767       }
14768
14769   if (h->needs_copy)
14770     {
14771       /* This symbol needs a copy reloc.  Set it up.  */
14772
14773       if (h->dynindx == -1
14774           || (h->root.type != bfd_link_hash_defined
14775               && h->root.type != bfd_link_hash_defweak)
14776           || htab->relbss == NULL)
14777         abort ();
14778
14779       rela.r_offset = (h->root.u.def.value
14780                        + h->root.u.def.section->output_section->vma
14781                        + h->root.u.def.section->output_offset);
14782       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14783       rela.r_addend = 0;
14784       loc = htab->relbss->contents;
14785       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14786       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14787     }
14788
14789   return TRUE;
14790 }
14791
14792 /* Used to decide how to sort relocs in an optimal manner for the
14793    dynamic linker, before writing them out.  */
14794
14795 static enum elf_reloc_type_class
14796 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14797                             const asection *rel_sec,
14798                             const Elf_Internal_Rela *rela)
14799 {
14800   enum elf_ppc64_reloc_type r_type;
14801   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14802
14803   if (rel_sec == htab->elf.irelplt)
14804     return reloc_class_ifunc;
14805
14806   r_type = ELF64_R_TYPE (rela->r_info);
14807   switch (r_type)
14808     {
14809     case R_PPC64_RELATIVE:
14810       return reloc_class_relative;
14811     case R_PPC64_JMP_SLOT:
14812       return reloc_class_plt;
14813     case R_PPC64_COPY:
14814       return reloc_class_copy;
14815     default:
14816       return reloc_class_normal;
14817     }
14818 }
14819
14820 /* Finish up the dynamic sections.  */
14821
14822 static bfd_boolean
14823 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14824                                    struct bfd_link_info *info)
14825 {
14826   struct ppc_link_hash_table *htab;
14827   bfd *dynobj;
14828   asection *sdyn;
14829
14830   htab = ppc_hash_table (info);
14831   if (htab == NULL)
14832     return FALSE;
14833
14834   dynobj = htab->elf.dynobj;
14835   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14836
14837   if (htab->elf.dynamic_sections_created)
14838     {
14839       Elf64_External_Dyn *dyncon, *dynconend;
14840
14841       if (sdyn == NULL || htab->elf.sgot == NULL)
14842         abort ();
14843
14844       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14845       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14846       for (; dyncon < dynconend; dyncon++)
14847         {
14848           Elf_Internal_Dyn dyn;
14849           asection *s;
14850
14851           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14852
14853           switch (dyn.d_tag)
14854             {
14855             default:
14856               continue;
14857
14858             case DT_PPC64_GLINK:
14859               s = htab->glink;
14860               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14861               /* We stupidly defined DT_PPC64_GLINK to be the start
14862                  of glink rather than the first entry point, which is
14863                  what ld.so needs, and now have a bigger stub to
14864                  support automatic multiple TOCs.  */
14865               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14866               break;
14867
14868             case DT_PPC64_OPD:
14869               s = bfd_get_section_by_name (output_bfd, ".opd");
14870               if (s == NULL)
14871                 continue;
14872               dyn.d_un.d_ptr = s->vma;
14873               break;
14874
14875             case DT_PPC64_OPT:
14876               if (htab->do_multi_toc && htab->multi_toc_needed)
14877                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14878               break;
14879
14880             case DT_PPC64_OPDSZ:
14881               s = bfd_get_section_by_name (output_bfd, ".opd");
14882               if (s == NULL)
14883                 continue;
14884               dyn.d_un.d_val = s->size;
14885               break;
14886
14887             case DT_PLTGOT:
14888               s = htab->elf.splt;
14889               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14890               break;
14891
14892             case DT_JMPREL:
14893               s = htab->elf.srelplt;
14894               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14895               break;
14896
14897             case DT_PLTRELSZ:
14898               dyn.d_un.d_val = htab->elf.srelplt->size;
14899               break;
14900
14901             case DT_RELASZ:
14902               /* Don't count procedure linkage table relocs in the
14903                  overall reloc count.  */
14904               s = htab->elf.srelplt;
14905               if (s == NULL)
14906                 continue;
14907               dyn.d_un.d_val -= s->size;
14908               break;
14909
14910             case DT_RELA:
14911               /* We may not be using the standard ELF linker script.
14912                  If .rela.plt is the first .rela section, we adjust
14913                  DT_RELA to not include it.  */
14914               s = htab->elf.srelplt;
14915               if (s == NULL)
14916                 continue;
14917               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14918                 continue;
14919               dyn.d_un.d_ptr += s->size;
14920               break;
14921             }
14922
14923           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14924         }
14925     }
14926
14927   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14928     {
14929       /* Fill in the first entry in the global offset table.
14930          We use it to hold the link-time TOCbase.  */
14931       bfd_put_64 (output_bfd,
14932                   elf_gp (output_bfd) + TOC_BASE_OFF,
14933                   htab->elf.sgot->contents);
14934
14935       /* Set .got entry size.  */
14936       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14937     }
14938
14939   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14940     {
14941       /* Set .plt entry size.  */
14942       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14943         = PLT_ENTRY_SIZE (htab);
14944     }
14945
14946   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14947      brlt ourselves if emitrelocations.  */
14948   if (htab->brlt != NULL
14949       && htab->brlt->reloc_count != 0
14950       && !_bfd_elf_link_output_relocs (output_bfd,
14951                                        htab->brlt,
14952                                        elf_section_data (htab->brlt)->rela.hdr,
14953                                        elf_section_data (htab->brlt)->relocs,
14954                                        NULL))
14955     return FALSE;
14956
14957   if (htab->glink != NULL
14958       && htab->glink->reloc_count != 0
14959       && !_bfd_elf_link_output_relocs (output_bfd,
14960                                        htab->glink,
14961                                        elf_section_data (htab->glink)->rela.hdr,
14962                                        elf_section_data (htab->glink)->relocs,
14963                                        NULL))
14964     return FALSE;
14965
14966
14967   if (htab->glink_eh_frame != NULL
14968       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14969       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14970                                            htab->glink_eh_frame,
14971                                            htab->glink_eh_frame->contents))
14972     return FALSE;
14973
14974   /* We need to handle writing out multiple GOT sections ourselves,
14975      since we didn't add them to DYNOBJ.  We know dynobj is the first
14976      bfd.  */
14977   while ((dynobj = dynobj->link_next) != NULL)
14978     {
14979       asection *s;
14980
14981       if (!is_ppc64_elf (dynobj))
14982         continue;
14983
14984       s = ppc64_elf_tdata (dynobj)->got;
14985       if (s != NULL
14986           && s->size != 0
14987           && s->output_section != bfd_abs_section_ptr
14988           && !bfd_set_section_contents (output_bfd, s->output_section,
14989                                         s->contents, s->output_offset,
14990                                         s->size))
14991         return FALSE;
14992       s = ppc64_elf_tdata (dynobj)->relgot;
14993       if (s != NULL
14994           && s->size != 0
14995           && s->output_section != bfd_abs_section_ptr
14996           && !bfd_set_section_contents (output_bfd, s->output_section,
14997                                         s->contents, s->output_offset,
14998                                         s->size))
14999         return FALSE;
15000     }
15001
15002   return TRUE;
15003 }
15004
15005 #include "elf64-target.h"
15006
15007 /* FreeBSD support */
15008
15009 #undef  TARGET_LITTLE_SYM
15010 #undef  TARGET_LITTLE_NAME
15011
15012 #undef  TARGET_BIG_SYM
15013 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15014 #undef  TARGET_BIG_NAME
15015 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15016
15017 #undef  ELF_OSABI
15018 #define ELF_OSABI       ELFOSABI_FREEBSD
15019
15020 #undef  elf64_bed
15021 #define elf64_bed       elf64_powerpc_fbsd_bed
15022
15023 #include "elf64-target.h"
15024