bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37 #include "dwarf2.h"
  38
  39 static bfd_reloc_status_type ppc64_elf_ha_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_branch_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_toc_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57 static bfd_vma opd_entry_value
  58   (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
  59
  60 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  61 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  62 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  63 #define TARGET_BIG_NAME         "elf64-powerpc"
  64 #define ELF_ARCH                bfd_arch_powerpc
  65 #define ELF_TARGET_ID           PPC64_ELF_DATA
  66 #define ELF_MACHINE_CODE        EM_PPC64
  67 #define ELF_MAXPAGESIZE         0x10000
  68 #define ELF_COMMONPAGESIZE      0x1000
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  85 #define bfd_elf64_bfd_print_private_bfd_data  ppc64_elf_print_private_bfd_data
  86 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  87 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  88 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  89 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  90 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  91
  92 #define elf_backend_object_p                  ppc64_elf_object_p
  93 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  94 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  95 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  96 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  97 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  98 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  99 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
 100 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 101 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 102 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 103 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 104 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 105 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 106 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 107 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 108 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 109 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 110 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 111 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 112 #define elf_backend_hash_symbol               ppc64_elf_hash_symbol
 113 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 114 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 115 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 116 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 117 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 118 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 119 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 120 #define elf_backend_special_sections          ppc64_elf_special_sections
 121 #define elf_backend_merge_symbol_attribute    ppc64_elf_merge_symbol_attribute
 122
 123 /* The name of the dynamic interpreter.  This is put in the .interp
 124    section.  */
 125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 126
 127 /* The size in bytes of an entry in the procedure linkage table.  */
 128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
 129
 130 /* The initial size of the plt reserved for the dynamic linker.  */
 131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
 132
 133 /* Offsets to some stack save slots.  */
 134 #define STK_LR 16
 135 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
 136 /* This one is dodgy.  ELFv2 does not have a linker word, so use the
 137    CR save slot.  Used only by optimised __tls_get_addr call stub,
 138    relying on __tls_get_addr_opt not saving CR..  */
 139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
 140
 141 /* TOC base pointers offset from start of TOC.  */
 142 #define TOC_BASE_OFF    0x8000
 143
 144 /* Offset of tp and dtp pointers from start of TLS block.  */
 145 #define TP_OFFSET       0x7000
 146 #define DTP_OFFSET      0x8000
 147
 148 /* .plt call stub instructions.  The normal stub is like this, but
 149    sometimes the .plt entry crosses a 64k boundary and we need to
 150    insert an addi to adjust r11.  */
 151 #define STD_R2_0R1      0xf8410000      /* std   %r2,0+40(%r1)       */
 152 #define ADDIS_R11_R2    0x3d620000      /* addis %r11,%r2,xxx@ha     */
 153 #define LD_R12_0R11     0xe98b0000      /* ld    %r12,xxx+0@l(%r11)  */
 154 #define MTCTR_R12       0x7d8903a6      /* mtctr %r12                */
 155 #define LD_R2_0R11      0xe84b0000      /* ld    %r2,xxx+8@l(%r11)   */
 156 #define LD_R11_0R11     0xe96b0000      /* ld    %r11,xxx+16@l(%r11) */
 157 #define BCTR            0x4e800420      /* bctr                      */
 158
 159 #define ADDI_R11_R11    0x396b0000      /* addi %r11,%r11,off@l  */
 160 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 161 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 162
 163 #define XOR_R2_R12_R12  0x7d826278      /* xor   %r2,%r12,%r12   */
 164 #define ADD_R11_R11_R2  0x7d6b1214      /* add   %r11,%r11,%r2   */
 165 #define XOR_R11_R12_R12 0x7d8b6278      /* xor   %r11,%r12,%r12  */
 166 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 167 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 168 #define BNECTR          0x4ca20420      /* bnectr+               */
 169 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 170
 171 #define LD_R12_0R2      0xe9820000      /* ld    %r12,xxx+0(%r2) */
 172 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 173 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 174
 175 #define LD_R2_0R1       0xe8410000      /* ld    %r2,0(%r1)      */
 176
 177 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,xxx@ha */
 178 #define LD_R12_0R12     0xe98c0000      /* ld    %r12,xxx@l(%r12) */
 179
 180 /* glink call stub instructions.  We enter with the index in R0.  */
 181 #define GLINK_CALL_STUB_SIZE (16*4)
 182                                         /* 0:                           */
 183                                         /*  .quad plt0-1f               */
 184                                         /* __glink:                     */
 185 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 186 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 187                                         /* 1:                           */
 188 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 189                                         /*  ld %2,(0b-1b)(%11)          */
 190 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 191 #define ADD_R11_R2_R11  0x7d625a14      /*  add %11,%2,%11              */
 192                                         /*  ld %12,0(%11)               */
 193                                         /*  ld %2,8(%11)                */
 194                                         /*  mtctr %12                   */
 195                                         /*  ld %11,16(%11)              */
 196                                         /*  bctr                        */
 197 #define MFLR_R0         0x7c0802a6      /*  mflr %r0                    */
 198 #define MTLR_R0         0x7c0803a6      /*  mtlr %r0                    */
 199 #define SUB_R12_R12_R11 0x7d8b6050      /*  subf %r12,%r11,%r12         */
 200 #define ADDI_R0_R12     0x380c0000      /*  addi %r0,%r12,0             */
 201 #define SRDI_R0_R0_2    0x7800f082      /*  rldicl %r0,%r0,62,2         */
 202
 203 /* Pad with this.  */
 204 #define NOP             0x60000000
 205
 206 /* Some other nops.  */
 207 #define CROR_151515     0x4def7b82
 208 #define CROR_313131     0x4ffffb82
 209
 210 /* .glink entries for the first 32k functions are two instructions.  */
 211 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 212 #define B_DOT           0x48000000      /* b     .              */
 213
 214 /* After that, we need two instructions to load the index, followed by
 215    a branch.  */
 216 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 217 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 218
 219 /* Instructions used by the save and restore reg functions.  */
 220 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 221 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 222 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 223 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 224 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 225 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 226 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 227 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 228 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 229 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 230 #define BLR             0x4e800020      /* blr                  */
 231
 232 /* Since .opd is an array of descriptors and each entry will end up
 233    with identical R_PPC64_RELATIVE relocs, there is really no need to
 234    propagate .opd relocs;  The dynamic linker should be taught to
 235    relocate .opd without reloc entries.  */
 236 #ifndef NO_OPD_RELOCS
 237 #define NO_OPD_RELOCS 0
 238 #endif
 239 \f
 240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 241
 242 /* Relocation HOWTO's.  */
 243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 244
 245 static reloc_howto_type ppc64_elf_howto_raw[] = {
 246   /* This reloc does nothing.  */
 247   HOWTO (R_PPC64_NONE,          /* type */
 248          0,                     /* rightshift */
 249          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          32,                    /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_dont, /* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_PPC64_NONE",        /* name */
 256          FALSE,                 /* partial_inplace */
 257          0,                     /* src_mask */
 258          0,                     /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* A standard 32 bit relocation.  */
 262   HOWTO (R_PPC64_ADDR32,        /* type */
 263          0,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          32,                    /* bitsize */
 266          FALSE,                 /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_bitfield, /* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_PPC64_ADDR32",      /* name */
 271          FALSE,                 /* partial_inplace */
 272          0,                     /* src_mask */
 273          0xffffffff,            /* dst_mask */
 274          FALSE),                /* pcrel_offset */
 275
 276   /* An absolute 26 bit branch; the lower two bits must be zero.
 277      FIXME: we don't check that, we just clear them.  */
 278   HOWTO (R_PPC64_ADDR24,        /* type */
 279          0,                     /* rightshift */
 280          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          26,                    /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_bitfield, /* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_PPC64_ADDR24",      /* name */
 287          FALSE,                 /* partial_inplace */
 288          0,                     /* src_mask */
 289          0x03fffffc,            /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* A standard 16 bit relocation.  */
 293   HOWTO (R_PPC64_ADDR16,        /* type */
 294          0,                     /* rightshift */
 295          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          16,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_PPC64_ADDR16",      /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffff,                /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* A 16 bit relocation without overflow.  */
 308   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 309          0,                     /* rightshift */
 310          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          16,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_dont,/* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_PPC64_ADDR16_LO",   /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0xffff,                /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   /* Bits 16-31 of an address.  */
 323   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 324          16,                    /* rightshift */
 325          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_signed, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_PPC64_ADDR16_HI",   /* name */
 332          FALSE,                 /* partial_inplace */
 333          0,                     /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 338      bits, treated as a signed number, is negative.  */
 339   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 340          16,                    /* rightshift */
 341          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_signed, /* complain_on_overflow */
 346          ppc64_elf_ha_reloc,    /* special_function */
 347          "R_PPC64_ADDR16_HA",   /* name */
 348          FALSE,                 /* partial_inplace */
 349          0,                     /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* An absolute 16 bit branch; the lower two bits must be zero.
 354      FIXME: we don't check that, we just clear them.  */
 355   HOWTO (R_PPC64_ADDR14,        /* type */
 356          0,                     /* rightshift */
 357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          FALSE,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_bitfield, /* complain_on_overflow */
 362          ppc64_elf_branch_reloc, /* special_function */
 363          "R_PPC64_ADDR14",      /* name */
 364          FALSE,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0x0000fffc,            /* dst_mask */
 367          FALSE),                /* pcrel_offset */
 368
 369   /* An absolute 16 bit branch, for which bit 10 should be set to
 370      indicate that the branch is expected to be taken.  The lower two
 371      bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          16,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_bitfield, /* complain_on_overflow */
 379          ppc64_elf_brtaken_reloc, /* special_function */
 380          "R_PPC64_ADDR14_BRTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* An absolute 16 bit branch, for which bit 10 should be set to
 387      indicate that the branch is not expected to be taken.  The lower
 388      two bits must be zero.  */
 389   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 390          0,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          16,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_bitfield, /* complain_on_overflow */
 396          ppc64_elf_brtaken_reloc, /* special_function */
 397          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 398          FALSE,                 /* partial_inplace */
 399          0,                     /* src_mask */
 400          0x0000fffc,            /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403   /* A relative 26 bit branch; the lower two bits must be zero.  */
 404   HOWTO (R_PPC64_REL24,         /* type */
 405          0,                     /* rightshift */
 406          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 407          26,                    /* bitsize */
 408          TRUE,                  /* pc_relative */
 409          0,                     /* bitpos */
 410          complain_overflow_signed, /* complain_on_overflow */
 411          ppc64_elf_branch_reloc, /* special_function */
 412          "R_PPC64_REL24",       /* name */
 413          FALSE,                 /* partial_inplace */
 414          0,                     /* src_mask */
 415          0x03fffffc,            /* dst_mask */
 416          TRUE),                 /* pcrel_offset */
 417
 418   /* A relative 16 bit branch; the lower two bits must be zero.  */
 419   HOWTO (R_PPC64_REL14,         /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          TRUE,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_branch_reloc, /* special_function */
 427          "R_PPC64_REL14",       /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          TRUE),                 /* pcrel_offset */
 432
 433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 434      the branch is expected to be taken.  The lower two bits must be
 435      zero.  */
 436   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          ppc64_elf_brtaken_reloc, /* special_function */
 444          "R_PPC64_REL14_BRTAKEN", /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 451      the branch is not expected to be taken.  The lower two bits must
 452      be zero.  */
 453   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          16,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_signed, /* complain_on_overflow */
 460          ppc64_elf_brtaken_reloc, /* special_function */
 461          "R_PPC64_REL14_BRNTAKEN",/* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0x0000fffc,            /* dst_mask */
 465          TRUE),                 /* pcrel_offset */
 466
 467   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 468      symbol.  */
 469   HOWTO (R_PPC64_GOT16,         /* type */
 470          0,                     /* rightshift */
 471          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          16,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_signed, /* complain_on_overflow */
 476          ppc64_elf_unhandled_reloc, /* special_function */
 477          "R_PPC64_GOT16",       /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0xffff,                /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 484      the symbol.  */
 485   HOWTO (R_PPC64_GOT16_LO,      /* type */
 486          0,                     /* rightshift */
 487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          ppc64_elf_unhandled_reloc, /* special_function */
 493          "R_PPC64_GOT16_LO",    /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 500      the symbol.  */
 501   HOWTO (R_PPC64_GOT16_HI,      /* type */
 502          16,                    /* rightshift */
 503          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          16,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_signed,/* complain_on_overflow */
 508          ppc64_elf_unhandled_reloc, /* special_function */
 509          "R_PPC64_GOT16_HI",    /* name */
 510          FALSE,                 /* partial_inplace */
 511          0,                     /* src_mask */
 512          0xffff,                /* dst_mask */
 513          FALSE),                /* pcrel_offset */
 514
 515   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 516      the symbol.  */
 517   HOWTO (R_PPC64_GOT16_HA,      /* type */
 518          16,                    /* rightshift */
 519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 520          16,                    /* bitsize */
 521          FALSE,                 /* pc_relative */
 522          0,                     /* bitpos */
 523          complain_overflow_signed,/* complain_on_overflow */
 524          ppc64_elf_unhandled_reloc, /* special_function */
 525          "R_PPC64_GOT16_HA",    /* name */
 526          FALSE,                 /* partial_inplace */
 527          0,                     /* src_mask */
 528          0xffff,                /* dst_mask */
 529          FALSE),                /* pcrel_offset */
 530
 531   /* This is used only by the dynamic linker.  The symbol should exist
 532      both in the object being run and in some shared library.  The
 533      dynamic linker copies the data addressed by the symbol from the
 534      shared library into the object, because the object being
 535      run has to have the data at some particular address.  */
 536   HOWTO (R_PPC64_COPY,          /* type */
 537          0,                     /* rightshift */
 538          0,                     /* this one is variable size */
 539          0,                     /* bitsize */
 540          FALSE,                 /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont, /* complain_on_overflow */
 543          ppc64_elf_unhandled_reloc, /* special_function */
 544          "R_PPC64_COPY",        /* name */
 545          FALSE,                 /* partial_inplace */
 546          0,                     /* src_mask */
 547          0,                     /* dst_mask */
 548          FALSE),                /* pcrel_offset */
 549
 550   /* Like R_PPC64_ADDR64, but used when setting global offset table
 551      entries.  */
 552   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 553          0,                     /* rightshift */
 554          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 555          64,                    /* bitsize */
 556          FALSE,                 /* pc_relative */
 557          0,                     /* bitpos */
 558          complain_overflow_dont, /* complain_on_overflow */
 559          ppc64_elf_unhandled_reloc,  /* special_function */
 560          "R_PPC64_GLOB_DAT",    /* name */
 561          FALSE,                 /* partial_inplace */
 562          0,                     /* src_mask */
 563          ONES (64),             /* dst_mask */
 564          FALSE),                /* pcrel_offset */
 565
 566   /* Created by the link editor.  Marks a procedure linkage table
 567      entry for a symbol.  */
 568   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 569          0,                     /* rightshift */
 570          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          0,                     /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          ppc64_elf_unhandled_reloc, /* special_function */
 576          "R_PPC64_JMP_SLOT",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          0,                     /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Used only by the dynamic linker.  When the object is run, this
 583      doubleword64 is set to the load address of the object, plus the
 584      addend.  */
 585   HOWTO (R_PPC64_RELATIVE,      /* type */
 586          0,                     /* rightshift */
 587          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 588          64,                    /* bitsize */
 589          FALSE,                 /* pc_relative */
 590          0,                     /* bitpos */
 591          complain_overflow_dont, /* complain_on_overflow */
 592          bfd_elf_generic_reloc, /* special_function */
 593          "R_PPC64_RELATIVE",    /* name */
 594          FALSE,                 /* partial_inplace */
 595          0,                     /* src_mask */
 596          ONES (64),             /* dst_mask */
 597          FALSE),                /* pcrel_offset */
 598
 599   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 600   HOWTO (R_PPC64_UADDR32,       /* type */
 601          0,                     /* rightshift */
 602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 603          32,                    /* bitsize */
 604          FALSE,                 /* pc_relative */
 605          0,                     /* bitpos */
 606          complain_overflow_bitfield, /* complain_on_overflow */
 607          bfd_elf_generic_reloc, /* special_function */
 608          "R_PPC64_UADDR32",     /* name */
 609          FALSE,                 /* partial_inplace */
 610          0,                     /* src_mask */
 611          0xffffffff,            /* dst_mask */
 612          FALSE),                /* pcrel_offset */
 613
 614   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 615   HOWTO (R_PPC64_UADDR16,       /* type */
 616          0,                     /* rightshift */
 617          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 618          16,                    /* bitsize */
 619          FALSE,                 /* pc_relative */
 620          0,                     /* bitpos */
 621          complain_overflow_bitfield, /* complain_on_overflow */
 622          bfd_elf_generic_reloc, /* special_function */
 623          "R_PPC64_UADDR16",     /* name */
 624          FALSE,                 /* partial_inplace */
 625          0,                     /* src_mask */
 626          0xffff,                /* dst_mask */
 627          FALSE),                /* pcrel_offset */
 628
 629   /* 32-bit PC relative.  */
 630   HOWTO (R_PPC64_REL32,         /* type */
 631          0,                     /* rightshift */
 632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 633          32,                    /* bitsize */
 634          TRUE,                  /* pc_relative */
 635          0,                     /* bitpos */
 636          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 637          complain_overflow_signed, /* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_PPC64_REL32",       /* name */
 640          FALSE,                 /* partial_inplace */
 641          0,                     /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          TRUE),                 /* pcrel_offset */
 644
 645   /* 32-bit relocation to the symbol's procedure linkage table.  */
 646   HOWTO (R_PPC64_PLT32,         /* type */
 647          0,                     /* rightshift */
 648          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 649          32,                    /* bitsize */
 650          FALSE,                 /* pc_relative */
 651          0,                     /* bitpos */
 652          complain_overflow_bitfield, /* complain_on_overflow */
 653          ppc64_elf_unhandled_reloc, /* special_function */
 654          "R_PPC64_PLT32",       /* name */
 655          FALSE,                 /* partial_inplace */
 656          0,                     /* src_mask */
 657          0xffffffff,            /* dst_mask */
 658          FALSE),                /* pcrel_offset */
 659
 660   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 661      FIXME: R_PPC64_PLTREL32 not supported.  */
 662   HOWTO (R_PPC64_PLTREL32,      /* type */
 663          0,                     /* rightshift */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          32,                    /* bitsize */
 666          TRUE,                  /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_signed, /* complain_on_overflow */
 669          bfd_elf_generic_reloc, /* special_function */
 670          "R_PPC64_PLTREL32",    /* name */
 671          FALSE,                 /* partial_inplace */
 672          0,                     /* src_mask */
 673          0xffffffff,            /* dst_mask */
 674          TRUE),                 /* pcrel_offset */
 675
 676   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 677      the symbol.  */
 678   HOWTO (R_PPC64_PLT16_LO,      /* type */
 679          0,                     /* rightshift */
 680          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          16,                    /* bitsize */
 682          FALSE,                 /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_dont, /* complain_on_overflow */
 685          ppc64_elf_unhandled_reloc, /* special_function */
 686          "R_PPC64_PLT16_LO",    /* name */
 687          FALSE,                 /* partial_inplace */
 688          0,                     /* src_mask */
 689          0xffff,                /* dst_mask */
 690          FALSE),                /* pcrel_offset */
 691
 692   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 693      the symbol.  */
 694   HOWTO (R_PPC64_PLT16_HI,      /* type */
 695          16,                    /* rightshift */
 696          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          16,                    /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_signed, /* complain_on_overflow */
 701          ppc64_elf_unhandled_reloc, /* special_function */
 702          "R_PPC64_PLT16_HI",    /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0xffff,                /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 709      the symbol.  */
 710   HOWTO (R_PPC64_PLT16_HA,      /* type */
 711          16,                    /* rightshift */
 712          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          16,                    /* bitsize */
 714          FALSE,                 /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_signed, /* complain_on_overflow */
 717          ppc64_elf_unhandled_reloc, /* special_function */
 718          "R_PPC64_PLT16_HA",    /* name */
 719          FALSE,                 /* partial_inplace */
 720          0,                     /* src_mask */
 721          0xffff,                /* dst_mask */
 722          FALSE),                /* pcrel_offset */
 723
 724   /* 16-bit section relative relocation.  */
 725   HOWTO (R_PPC64_SECTOFF,       /* type */
 726          0,                     /* rightshift */
 727          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 728          16,                    /* bitsize */
 729          FALSE,                 /* pc_relative */
 730          0,                     /* bitpos */
 731          complain_overflow_bitfield, /* complain_on_overflow */
 732          ppc64_elf_sectoff_reloc, /* special_function */
 733          "R_PPC64_SECTOFF",     /* name */
 734          FALSE,                 /* partial_inplace */
 735          0,                     /* src_mask */
 736          0xffff,                /* dst_mask */
 737          FALSE),                /* pcrel_offset */
 738
 739   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 740   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 741          0,                     /* rightshift */
 742          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          16,                    /* bitsize */
 744          FALSE,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_dont, /* complain_on_overflow */
 747          ppc64_elf_sectoff_reloc, /* special_function */
 748          "R_PPC64_SECTOFF_LO",  /* name */
 749          FALSE,                 /* partial_inplace */
 750          0,                     /* src_mask */
 751          0xffff,                /* dst_mask */
 752          FALSE),                /* pcrel_offset */
 753
 754   /* 16-bit upper half section relative relocation.  */
 755   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 756          16,                    /* rightshift */
 757          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 758          16,                    /* bitsize */
 759          FALSE,                 /* pc_relative */
 760          0,                     /* bitpos */
 761          complain_overflow_signed, /* complain_on_overflow */
 762          ppc64_elf_sectoff_reloc, /* special_function */
 763          "R_PPC64_SECTOFF_HI",  /* name */
 764          FALSE,                 /* partial_inplace */
 765          0,                     /* src_mask */
 766          0xffff,                /* dst_mask */
 767          FALSE),                /* pcrel_offset */
 768
 769   /* 16-bit upper half adjusted section relative relocation.  */
 770   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 771          16,                    /* rightshift */
 772          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 773          16,                    /* bitsize */
 774          FALSE,                 /* pc_relative */
 775          0,                     /* bitpos */
 776          complain_overflow_signed, /* complain_on_overflow */
 777          ppc64_elf_sectoff_ha_reloc, /* special_function */
 778          "R_PPC64_SECTOFF_HA",  /* name */
 779          FALSE,                 /* partial_inplace */
 780          0,                     /* src_mask */
 781          0xffff,                /* dst_mask */
 782          FALSE),                /* pcrel_offset */
 783
 784   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 785   HOWTO (R_PPC64_REL30,         /* type */
 786          2,                     /* rightshift */
 787          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          30,                    /* bitsize */
 789          TRUE,                  /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_PPC64_REL30",       /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          0xfffffffc,            /* dst_mask */
 797          TRUE),                 /* pcrel_offset */
 798
 799   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 800
 801   /* A standard 64-bit relocation.  */
 802   HOWTO (R_PPC64_ADDR64,        /* type */
 803          0,                     /* rightshift */
 804          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 805          64,                    /* bitsize */
 806          FALSE,                 /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_dont, /* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_PPC64_ADDR64",      /* name */
 811          FALSE,                 /* partial_inplace */
 812          0,                     /* src_mask */
 813          ONES (64),             /* dst_mask */
 814          FALSE),                /* pcrel_offset */
 815
 816   /* The bits 32-47 of an address.  */
 817   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 818          32,                    /* rightshift */
 819          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 820          16,                    /* bitsize */
 821          FALSE,                 /* pc_relative */
 822          0,                     /* bitpos */
 823          complain_overflow_dont, /* complain_on_overflow */
 824          bfd_elf_generic_reloc, /* special_function */
 825          "R_PPC64_ADDR16_HIGHER", /* name */
 826          FALSE,                 /* partial_inplace */
 827          0,                     /* src_mask */
 828          0xffff,                /* dst_mask */
 829          FALSE),                /* pcrel_offset */
 830
 831   /* The bits 32-47 of an address, plus 1 if the contents of the low
 832      16 bits, treated as a signed number, is negative.  */
 833   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 834          32,                    /* rightshift */
 835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 836          16,                    /* bitsize */
 837          FALSE,                 /* pc_relative */
 838          0,                     /* bitpos */
 839          complain_overflow_dont, /* complain_on_overflow */
 840          ppc64_elf_ha_reloc,    /* special_function */
 841          "R_PPC64_ADDR16_HIGHERA", /* name */
 842          FALSE,                 /* partial_inplace */
 843          0,                     /* src_mask */
 844          0xffff,                /* dst_mask */
 845          FALSE),                /* pcrel_offset */
 846
 847   /* The bits 48-63 of an address.  */
 848   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 849          48,                    /* rightshift */
 850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 851          16,                    /* bitsize */
 852          FALSE,                 /* pc_relative */
 853          0,                     /* bitpos */
 854          complain_overflow_dont, /* complain_on_overflow */
 855          bfd_elf_generic_reloc, /* special_function */
 856          "R_PPC64_ADDR16_HIGHEST", /* name */
 857          FALSE,                 /* partial_inplace */
 858          0,                     /* src_mask */
 859          0xffff,                /* dst_mask */
 860          FALSE),                /* pcrel_offset */
 861
 862   /* The bits 48-63 of an address, plus 1 if the contents of the low
 863      16 bits, treated as a signed number, is negative.  */
 864   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 865          48,                    /* rightshift */
 866          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          16,                    /* bitsize */
 868          FALSE,                 /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_dont, /* complain_on_overflow */
 871          ppc64_elf_ha_reloc,    /* special_function */
 872          "R_PPC64_ADDR16_HIGHESTA", /* name */
 873          FALSE,                 /* partial_inplace */
 874          0,                     /* src_mask */
 875          0xffff,                /* dst_mask */
 876          FALSE),                /* pcrel_offset */
 877
 878   /* Like ADDR64, but may be unaligned.  */
 879   HOWTO (R_PPC64_UADDR64,       /* type */
 880          0,                     /* rightshift */
 881          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 882          64,                    /* bitsize */
 883          FALSE,                 /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_dont, /* complain_on_overflow */
 886          bfd_elf_generic_reloc, /* special_function */
 887          "R_PPC64_UADDR64",     /* name */
 888          FALSE,                 /* partial_inplace */
 889          0,                     /* src_mask */
 890          ONES (64),             /* dst_mask */
 891          FALSE),                /* pcrel_offset */
 892
 893   /* 64-bit relative relocation.  */
 894   HOWTO (R_PPC64_REL64,         /* type */
 895          0,                     /* rightshift */
 896          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 897          64,                    /* bitsize */
 898          TRUE,                  /* pc_relative */
 899          0,                     /* bitpos */
 900          complain_overflow_dont, /* complain_on_overflow */
 901          bfd_elf_generic_reloc, /* special_function */
 902          "R_PPC64_REL64",       /* name */
 903          FALSE,                 /* partial_inplace */
 904          0,                     /* src_mask */
 905          ONES (64),             /* dst_mask */
 906          TRUE),                 /* pcrel_offset */
 907
 908   /* 64-bit relocation to the symbol's procedure linkage table.  */
 909   HOWTO (R_PPC64_PLT64,         /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          FALSE,                 /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          ppc64_elf_unhandled_reloc, /* special_function */
 917          "R_PPC64_PLT64",       /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          FALSE),                /* pcrel_offset */
 922
 923   /* 64-bit PC relative relocation to the symbol's procedure linkage
 924      table.  */
 925   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 926   HOWTO (R_PPC64_PLTREL64,      /* type */
 927          0,                     /* rightshift */
 928          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 929          64,                    /* bitsize */
 930          TRUE,                  /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_dont, /* complain_on_overflow */
 933          ppc64_elf_unhandled_reloc, /* special_function */
 934          "R_PPC64_PLTREL64",    /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          ONES (64),             /* dst_mask */
 938          TRUE),                 /* pcrel_offset */
 939
 940   /* 16 bit TOC-relative relocation.  */
 941
 942   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 943   HOWTO (R_PPC64_TOC16,         /* type */
 944          0,                     /* rightshift */
 945          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 946          16,                    /* bitsize */
 947          FALSE,                 /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_signed, /* complain_on_overflow */
 950          ppc64_elf_toc_reloc,   /* special_function */
 951          "R_PPC64_TOC16",       /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          0xffff,                /* dst_mask */
 955          FALSE),                /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation without overflow.  */
 958
 959   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 960   HOWTO (R_PPC64_TOC16_LO,      /* type */
 961          0,                     /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_dont, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16_LO",    /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation, high 16 bits.  */
 975
 976   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 977   HOWTO (R_PPC64_TOC16_HI,      /* type */
 978          16,                    /* rightshift */
 979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          16,                    /* bitsize */
 981          FALSE,                 /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_signed, /* complain_on_overflow */
 984          ppc64_elf_toc_reloc,   /* special_function */
 985          "R_PPC64_TOC16_HI",    /* name */
 986          FALSE,                 /* partial_inplace */
 987          0,                     /* src_mask */
 988          0xffff,                /* dst_mask */
 989          FALSE),                /* pcrel_offset */
 990
 991   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 992      contents of the low 16 bits, treated as a signed number, is
 993      negative.  */
 994
 995   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 996   HOWTO (R_PPC64_TOC16_HA,      /* type */
 997          16,                    /* rightshift */
 998          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 999          16,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_signed, /* complain_on_overflow */
1003          ppc64_elf_toc_ha_reloc, /* special_function */
1004          "R_PPC64_TOC16_HA",    /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          0xffff,                /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
1011
1012   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
1013   HOWTO (R_PPC64_TOC,           /* type */
1014          0,                     /* rightshift */
1015          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1016          64,                    /* bitsize */
1017          FALSE,                 /* pc_relative */
1018          0,                     /* bitpos */
1019          complain_overflow_bitfield, /* complain_on_overflow */
1020          ppc64_elf_toc64_reloc, /* special_function */
1021          "R_PPC64_TOC",         /* name */
1022          FALSE,                 /* partial_inplace */
1023          0,                     /* src_mask */
1024          ONES (64),             /* dst_mask */
1025          FALSE),                /* pcrel_offset */
1026
1027   /* Like R_PPC64_GOT16, but also informs the link editor that the
1028      value to relocate may (!) refer to a PLT entry which the link
1029      editor (a) may replace with the symbol value.  If the link editor
1030      is unable to fully resolve the symbol, it may (b) create a PLT
1031      entry and store the address to the new PLT entry in the GOT.
1032      This permits lazy resolution of function symbols at run time.
1033      The link editor may also skip all of this and just (c) emit a
1034      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1035   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1036     HOWTO (R_PPC64_PLTGOT16,    /* type */
1037          0,                     /* rightshift */
1038          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1039          16,                    /* bitsize */
1040          FALSE,                 /* pc_relative */
1041          0,                     /* bitpos */
1042          complain_overflow_signed, /* complain_on_overflow */
1043          ppc64_elf_unhandled_reloc, /* special_function */
1044          "R_PPC64_PLTGOT16",    /* name */
1045          FALSE,                 /* partial_inplace */
1046          0,                     /* src_mask */
1047          0xffff,                /* dst_mask */
1048          FALSE),                /* pcrel_offset */
1049
1050   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1051   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1052   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1053          0,                     /* rightshift */
1054          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1055          16,                    /* bitsize */
1056          FALSE,                 /* pc_relative */
1057          0,                     /* bitpos */
1058          complain_overflow_dont, /* complain_on_overflow */
1059          ppc64_elf_unhandled_reloc, /* special_function */
1060          "R_PPC64_PLTGOT16_LO", /* name */
1061          FALSE,                 /* partial_inplace */
1062          0,                     /* src_mask */
1063          0xffff,                /* dst_mask */
1064          FALSE),                /* pcrel_offset */
1065
1066   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1067   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1068   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1069          16,                    /* rightshift */
1070          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1071          16,                    /* bitsize */
1072          FALSE,                 /* pc_relative */
1073          0,                     /* bitpos */
1074          complain_overflow_signed, /* complain_on_overflow */
1075          ppc64_elf_unhandled_reloc, /* special_function */
1076          "R_PPC64_PLTGOT16_HI", /* name */
1077          FALSE,                 /* partial_inplace */
1078          0,                     /* src_mask */
1079          0xffff,                /* dst_mask */
1080          FALSE),                /* pcrel_offset */
1081
1082   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083      1 if the contents of the low 16 bits, treated as a signed number,
1084      is negative.  */
1085   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1086   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1087          16,                    /* rightshift */
1088          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1089          16,                    /* bitsize */
1090          FALSE,                 /* pc_relative */
1091          0,                     /* bitpos */
1092          complain_overflow_signed, /* complain_on_overflow */
1093          ppc64_elf_unhandled_reloc, /* special_function */
1094          "R_PPC64_PLTGOT16_HA", /* name */
1095          FALSE,                 /* partial_inplace */
1096          0,                     /* src_mask */
1097          0xffff,                /* dst_mask */
1098          FALSE),                /* pcrel_offset */
1099
1100   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1101   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1102          0,                     /* rightshift */
1103          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1104          16,                    /* bitsize */
1105          FALSE,                 /* pc_relative */
1106          0,                     /* bitpos */
1107          complain_overflow_bitfield, /* complain_on_overflow */
1108          bfd_elf_generic_reloc, /* special_function */
1109          "R_PPC64_ADDR16_DS",   /* name */
1110          FALSE,                 /* partial_inplace */
1111          0,                     /* src_mask */
1112          0xfffc,                /* dst_mask */
1113          FALSE),                /* pcrel_offset */
1114
1115   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1116   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1117          0,                     /* rightshift */
1118          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1119          16,                    /* bitsize */
1120          FALSE,                 /* pc_relative */
1121          0,                     /* bitpos */
1122          complain_overflow_dont,/* complain_on_overflow */
1123          bfd_elf_generic_reloc, /* special_function */
1124          "R_PPC64_ADDR16_LO_DS",/* name */
1125          FALSE,                 /* partial_inplace */
1126          0,                     /* src_mask */
1127          0xfffc,                /* dst_mask */
1128          FALSE),                /* pcrel_offset */
1129
1130   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1131   HOWTO (R_PPC64_GOT16_DS,      /* type */
1132          0,                     /* rightshift */
1133          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          16,                    /* bitsize */
1135          FALSE,                 /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_signed, /* complain_on_overflow */
1138          ppc64_elf_unhandled_reloc, /* special_function */
1139          "R_PPC64_GOT16_DS",    /* name */
1140          FALSE,                 /* partial_inplace */
1141          0,                     /* src_mask */
1142          0xfffc,                /* dst_mask */
1143          FALSE),                /* pcrel_offset */
1144
1145   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1146   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1147          0,                     /* rightshift */
1148          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1149          16,                    /* bitsize */
1150          FALSE,                 /* pc_relative */
1151          0,                     /* bitpos */
1152          complain_overflow_dont, /* complain_on_overflow */
1153          ppc64_elf_unhandled_reloc, /* special_function */
1154          "R_PPC64_GOT16_LO_DS", /* name */
1155          FALSE,                 /* partial_inplace */
1156          0,                     /* src_mask */
1157          0xfffc,                /* dst_mask */
1158          FALSE),                /* pcrel_offset */
1159
1160   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1161   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1162          0,                     /* rightshift */
1163          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          16,                    /* bitsize */
1165          FALSE,                 /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont, /* complain_on_overflow */
1168          ppc64_elf_unhandled_reloc, /* special_function */
1169          "R_PPC64_PLT16_LO_DS", /* name */
1170          FALSE,                 /* partial_inplace */
1171          0,                     /* src_mask */
1172          0xfffc,                /* dst_mask */
1173          FALSE),                /* pcrel_offset */
1174
1175   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1176   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1177          0,                     /* rightshift */
1178          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1179          16,                    /* bitsize */
1180          FALSE,                 /* pc_relative */
1181          0,                     /* bitpos */
1182          complain_overflow_bitfield, /* complain_on_overflow */
1183          ppc64_elf_sectoff_reloc, /* special_function */
1184          "R_PPC64_SECTOFF_DS",  /* name */
1185          FALSE,                 /* partial_inplace */
1186          0,                     /* src_mask */
1187          0xfffc,                /* dst_mask */
1188          FALSE),                /* pcrel_offset */
1189
1190   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1191   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1192          0,                     /* rightshift */
1193          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1194          16,                    /* bitsize */
1195          FALSE,                 /* pc_relative */
1196          0,                     /* bitpos */
1197          complain_overflow_dont, /* complain_on_overflow */
1198          ppc64_elf_sectoff_reloc, /* special_function */
1199          "R_PPC64_SECTOFF_LO_DS",/* name */
1200          FALSE,                 /* partial_inplace */
1201          0,                     /* src_mask */
1202          0xfffc,                /* dst_mask */
1203          FALSE),                /* pcrel_offset */
1204
1205   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1206   HOWTO (R_PPC64_TOC16_DS,      /* type */
1207          0,                     /* rightshift */
1208          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1209          16,                    /* bitsize */
1210          FALSE,                 /* pc_relative */
1211          0,                     /* bitpos */
1212          complain_overflow_signed, /* complain_on_overflow */
1213          ppc64_elf_toc_reloc,   /* special_function */
1214          "R_PPC64_TOC16_DS",    /* name */
1215          FALSE,                 /* partial_inplace */
1216          0,                     /* src_mask */
1217          0xfffc,                /* dst_mask */
1218          FALSE),                /* pcrel_offset */
1219
1220   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1221   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1222          0,                     /* rightshift */
1223          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1224          16,                    /* bitsize */
1225          FALSE,                 /* pc_relative */
1226          0,                     /* bitpos */
1227          complain_overflow_dont, /* complain_on_overflow */
1228          ppc64_elf_toc_reloc,   /* special_function */
1229          "R_PPC64_TOC16_LO_DS", /* name */
1230          FALSE,                 /* partial_inplace */
1231          0,                     /* src_mask */
1232          0xfffc,                /* dst_mask */
1233          FALSE),                /* pcrel_offset */
1234
1235   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1236   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1237   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1238          0,                     /* rightshift */
1239          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1240          16,                    /* bitsize */
1241          FALSE,                 /* pc_relative */
1242          0,                     /* bitpos */
1243          complain_overflow_signed, /* complain_on_overflow */
1244          ppc64_elf_unhandled_reloc, /* special_function */
1245          "R_PPC64_PLTGOT16_DS", /* name */
1246          FALSE,                 /* partial_inplace */
1247          0,                     /* src_mask */
1248          0xfffc,                /* dst_mask */
1249          FALSE),                /* pcrel_offset */
1250
1251   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1252   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1253   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1254          0,                     /* rightshift */
1255          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1256          16,                    /* bitsize */
1257          FALSE,                 /* pc_relative */
1258          0,                     /* bitpos */
1259          complain_overflow_dont, /* complain_on_overflow */
1260          ppc64_elf_unhandled_reloc, /* special_function */
1261          "R_PPC64_PLTGOT16_LO_DS",/* name */
1262          FALSE,                 /* partial_inplace */
1263          0,                     /* src_mask */
1264          0xfffc,                /* dst_mask */
1265          FALSE),                /* pcrel_offset */
1266
1267   /* Marker relocs for TLS.  */
1268   HOWTO (R_PPC64_TLS,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLS",         /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   HOWTO (R_PPC64_TLSGD,
1283          0,                     /* rightshift */
1284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1285          32,                    /* bitsize */
1286          FALSE,                 /* pc_relative */
1287          0,                     /* bitpos */
1288          complain_overflow_dont, /* complain_on_overflow */
1289          bfd_elf_generic_reloc, /* special_function */
1290          "R_PPC64_TLSGD",       /* name */
1291          FALSE,                 /* partial_inplace */
1292          0,                     /* src_mask */
1293          0,                     /* dst_mask */
1294          FALSE),                /* pcrel_offset */
1295
1296   HOWTO (R_PPC64_TLSLD,
1297          0,                     /* rightshift */
1298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1299          32,                    /* bitsize */
1300          FALSE,                 /* pc_relative */
1301          0,                     /* bitpos */
1302          complain_overflow_dont, /* complain_on_overflow */
1303          bfd_elf_generic_reloc, /* special_function */
1304          "R_PPC64_TLSLD",       /* name */
1305          FALSE,                 /* partial_inplace */
1306          0,                     /* src_mask */
1307          0,                     /* dst_mask */
1308          FALSE),                /* pcrel_offset */
1309
1310   HOWTO (R_PPC64_TOCSAVE,
1311          0,                     /* rightshift */
1312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1313          32,                    /* bitsize */
1314          FALSE,                 /* pc_relative */
1315          0,                     /* bitpos */
1316          complain_overflow_dont, /* complain_on_overflow */
1317          bfd_elf_generic_reloc, /* special_function */
1318          "R_PPC64_TOCSAVE",     /* name */
1319          FALSE,                 /* partial_inplace */
1320          0,                     /* src_mask */
1321          0,                     /* dst_mask */
1322          FALSE),                /* pcrel_offset */
1323
1324   /* Computes the load module index of the load module that contains the
1325      definition of its TLS sym.  */
1326   HOWTO (R_PPC64_DTPMOD64,
1327          0,                     /* rightshift */
1328          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          64,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          ppc64_elf_unhandled_reloc, /* special_function */
1334          "R_PPC64_DTPMOD64",    /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          ONES (64),             /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* Computes a dtv-relative displacement, the difference between the value
1341      of sym+add and the base address of the thread-local storage block that
1342      contains the definition of sym, minus 0x8000.  */
1343   HOWTO (R_PPC64_DTPREL64,
1344          0,                     /* rightshift */
1345          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          64,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont, /* complain_on_overflow */
1350          ppc64_elf_unhandled_reloc, /* special_function */
1351          "R_PPC64_DTPREL64",    /* name */
1352          FALSE,                 /* partial_inplace */
1353          0,                     /* src_mask */
1354          ONES (64),             /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   /* A 16 bit dtprel reloc.  */
1358   HOWTO (R_PPC64_DTPREL16,
1359          0,                     /* rightshift */
1360          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1361          16,                    /* bitsize */
1362          FALSE,                 /* pc_relative */
1363          0,                     /* bitpos */
1364          complain_overflow_signed, /* complain_on_overflow */
1365          ppc64_elf_unhandled_reloc, /* special_function */
1366          "R_PPC64_DTPREL16",    /* name */
1367          FALSE,                 /* partial_inplace */
1368          0,                     /* src_mask */
1369          0xffff,                /* dst_mask */
1370          FALSE),                /* pcrel_offset */
1371
1372   /* Like DTPREL16, but no overflow.  */
1373   HOWTO (R_PPC64_DTPREL16_LO,
1374          0,                     /* rightshift */
1375          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1376          16,                    /* bitsize */
1377          FALSE,                 /* pc_relative */
1378          0,                     /* bitpos */
1379          complain_overflow_dont, /* complain_on_overflow */
1380          ppc64_elf_unhandled_reloc, /* special_function */
1381          "R_PPC64_DTPREL16_LO", /* name */
1382          FALSE,                 /* partial_inplace */
1383          0,                     /* src_mask */
1384          0xffff,                /* dst_mask */
1385          FALSE),                /* pcrel_offset */
1386
1387   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1388   HOWTO (R_PPC64_DTPREL16_HI,
1389          16,                    /* rightshift */
1390          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1391          16,                    /* bitsize */
1392          FALSE,                 /* pc_relative */
1393          0,                     /* bitpos */
1394          complain_overflow_signed, /* complain_on_overflow */
1395          ppc64_elf_unhandled_reloc, /* special_function */
1396          "R_PPC64_DTPREL16_HI", /* name */
1397          FALSE,                 /* partial_inplace */
1398          0,                     /* src_mask */
1399          0xffff,                /* dst_mask */
1400          FALSE),                /* pcrel_offset */
1401
1402   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1403   HOWTO (R_PPC64_DTPREL16_HA,
1404          16,                    /* rightshift */
1405          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1406          16,                    /* bitsize */
1407          FALSE,                 /* pc_relative */
1408          0,                     /* bitpos */
1409          complain_overflow_signed, /* complain_on_overflow */
1410          ppc64_elf_unhandled_reloc, /* special_function */
1411          "R_PPC64_DTPREL16_HA", /* name */
1412          FALSE,                 /* partial_inplace */
1413          0,                     /* src_mask */
1414          0xffff,                /* dst_mask */
1415          FALSE),                /* pcrel_offset */
1416
1417   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1418   HOWTO (R_PPC64_DTPREL16_HIGHER,
1419          32,                    /* rightshift */
1420          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1421          16,                    /* bitsize */
1422          FALSE,                 /* pc_relative */
1423          0,                     /* bitpos */
1424          complain_overflow_dont, /* complain_on_overflow */
1425          ppc64_elf_unhandled_reloc, /* special_function */
1426          "R_PPC64_DTPREL16_HIGHER", /* name */
1427          FALSE,                 /* partial_inplace */
1428          0,                     /* src_mask */
1429          0xffff,                /* dst_mask */
1430          FALSE),                /* pcrel_offset */
1431
1432   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1433   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434          32,                    /* rightshift */
1435          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1436          16,                    /* bitsize */
1437          FALSE,                 /* pc_relative */
1438          0,                     /* bitpos */
1439          complain_overflow_dont, /* complain_on_overflow */
1440          ppc64_elf_unhandled_reloc, /* special_function */
1441          "R_PPC64_DTPREL16_HIGHERA", /* name */
1442          FALSE,                 /* partial_inplace */
1443          0,                     /* src_mask */
1444          0xffff,                /* dst_mask */
1445          FALSE),                /* pcrel_offset */
1446
1447   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1448   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449          48,                    /* rightshift */
1450          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          16,                    /* bitsize */
1452          FALSE,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_dont, /* complain_on_overflow */
1455          ppc64_elf_unhandled_reloc, /* special_function */
1456          "R_PPC64_DTPREL16_HIGHEST", /* name */
1457          FALSE,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0xffff,                /* dst_mask */
1460          FALSE),                /* pcrel_offset */
1461
1462   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1463   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464          48,                    /* rightshift */
1465          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1466          16,                    /* bitsize */
1467          FALSE,                 /* pc_relative */
1468          0,                     /* bitpos */
1469          complain_overflow_dont, /* complain_on_overflow */
1470          ppc64_elf_unhandled_reloc, /* special_function */
1471          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472          FALSE,                 /* partial_inplace */
1473          0,                     /* src_mask */
1474          0xffff,                /* dst_mask */
1475          FALSE),                /* pcrel_offset */
1476
1477   /* Like DTPREL16, but for insns with a DS field.  */
1478   HOWTO (R_PPC64_DTPREL16_DS,
1479          0,                     /* rightshift */
1480          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1481          16,                    /* bitsize */
1482          FALSE,                 /* pc_relative */
1483          0,                     /* bitpos */
1484          complain_overflow_signed, /* complain_on_overflow */
1485          ppc64_elf_unhandled_reloc, /* special_function */
1486          "R_PPC64_DTPREL16_DS", /* name */
1487          FALSE,                 /* partial_inplace */
1488          0,                     /* src_mask */
1489          0xfffc,                /* dst_mask */
1490          FALSE),                /* pcrel_offset */
1491
1492   /* Like DTPREL16_DS, but no overflow.  */
1493   HOWTO (R_PPC64_DTPREL16_LO_DS,
1494          0,                     /* rightshift */
1495          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          16,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_dont, /* complain_on_overflow */
1500          ppc64_elf_unhandled_reloc, /* special_function */
1501          "R_PPC64_DTPREL16_LO_DS", /* name */
1502          FALSE,                 /* partial_inplace */
1503          0,                     /* src_mask */
1504          0xfffc,                /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   /* Computes a tp-relative displacement, the difference between the value of
1508      sym+add and the value of the thread pointer (r13).  */
1509   HOWTO (R_PPC64_TPREL64,
1510          0,                     /* rightshift */
1511          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1512          64,                    /* bitsize */
1513          FALSE,                 /* pc_relative */
1514          0,                     /* bitpos */
1515          complain_overflow_dont, /* complain_on_overflow */
1516          ppc64_elf_unhandled_reloc, /* special_function */
1517          "R_PPC64_TPREL64",     /* name */
1518          FALSE,                 /* partial_inplace */
1519          0,                     /* src_mask */
1520          ONES (64),             /* dst_mask */
1521          FALSE),                /* pcrel_offset */
1522
1523   /* A 16 bit tprel reloc.  */
1524   HOWTO (R_PPC64_TPREL16,
1525          0,                     /* rightshift */
1526          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1527          16,                    /* bitsize */
1528          FALSE,                 /* pc_relative */
1529          0,                     /* bitpos */
1530          complain_overflow_signed, /* complain_on_overflow */
1531          ppc64_elf_unhandled_reloc, /* special_function */
1532          "R_PPC64_TPREL16",     /* name */
1533          FALSE,                 /* partial_inplace */
1534          0,                     /* src_mask */
1535          0xffff,                /* dst_mask */
1536          FALSE),                /* pcrel_offset */
1537
1538   /* Like TPREL16, but no overflow.  */
1539   HOWTO (R_PPC64_TPREL16_LO,
1540          0,                     /* rightshift */
1541          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1542          16,                    /* bitsize */
1543          FALSE,                 /* pc_relative */
1544          0,                     /* bitpos */
1545          complain_overflow_dont, /* complain_on_overflow */
1546          ppc64_elf_unhandled_reloc, /* special_function */
1547          "R_PPC64_TPREL16_LO",  /* name */
1548          FALSE,                 /* partial_inplace */
1549          0,                     /* src_mask */
1550          0xffff,                /* dst_mask */
1551          FALSE),                /* pcrel_offset */
1552
1553   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1554   HOWTO (R_PPC64_TPREL16_HI,
1555          16,                    /* rightshift */
1556          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1557          16,                    /* bitsize */
1558          FALSE,                 /* pc_relative */
1559          0,                     /* bitpos */
1560          complain_overflow_signed, /* complain_on_overflow */
1561          ppc64_elf_unhandled_reloc, /* special_function */
1562          "R_PPC64_TPREL16_HI",  /* name */
1563          FALSE,                 /* partial_inplace */
1564          0,                     /* src_mask */
1565          0xffff,                /* dst_mask */
1566          FALSE),                /* pcrel_offset */
1567
1568   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1569   HOWTO (R_PPC64_TPREL16_HA,
1570          16,                    /* rightshift */
1571          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1572          16,                    /* bitsize */
1573          FALSE,                 /* pc_relative */
1574          0,                     /* bitpos */
1575          complain_overflow_signed, /* complain_on_overflow */
1576          ppc64_elf_unhandled_reloc, /* special_function */
1577          "R_PPC64_TPREL16_HA",  /* name */
1578          FALSE,                 /* partial_inplace */
1579          0,                     /* src_mask */
1580          0xffff,                /* dst_mask */
1581          FALSE),                /* pcrel_offset */
1582
1583   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1584   HOWTO (R_PPC64_TPREL16_HIGHER,
1585          32,                    /* rightshift */
1586          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          16,                    /* bitsize */
1588          FALSE,                 /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_dont, /* complain_on_overflow */
1591          ppc64_elf_unhandled_reloc, /* special_function */
1592          "R_PPC64_TPREL16_HIGHER",      /* name */
1593          FALSE,                 /* partial_inplace */
1594          0,                     /* src_mask */
1595          0xffff,                /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1599   HOWTO (R_PPC64_TPREL16_HIGHERA,
1600          32,                    /* rightshift */
1601          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1602          16,                    /* bitsize */
1603          FALSE,                 /* pc_relative */
1604          0,                     /* bitpos */
1605          complain_overflow_dont, /* complain_on_overflow */
1606          ppc64_elf_unhandled_reloc, /* special_function */
1607          "R_PPC64_TPREL16_HIGHERA", /* name */
1608          FALSE,                 /* partial_inplace */
1609          0,                     /* src_mask */
1610          0xffff,                /* dst_mask */
1611          FALSE),                /* pcrel_offset */
1612
1613   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1614   HOWTO (R_PPC64_TPREL16_HIGHEST,
1615          48,                    /* rightshift */
1616          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          16,                    /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_dont, /* complain_on_overflow */
1621          ppc64_elf_unhandled_reloc, /* special_function */
1622          "R_PPC64_TPREL16_HIGHEST", /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0xffff,                /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1629   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630          48,                    /* rightshift */
1631          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1632          16,                    /* bitsize */
1633          FALSE,                 /* pc_relative */
1634          0,                     /* bitpos */
1635          complain_overflow_dont, /* complain_on_overflow */
1636          ppc64_elf_unhandled_reloc, /* special_function */
1637          "R_PPC64_TPREL16_HIGHESTA", /* name */
1638          FALSE,                 /* partial_inplace */
1639          0,                     /* src_mask */
1640          0xffff,                /* dst_mask */
1641          FALSE),                /* pcrel_offset */
1642
1643   /* Like TPREL16, but for insns with a DS field.  */
1644   HOWTO (R_PPC64_TPREL16_DS,
1645          0,                     /* rightshift */
1646          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          16,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_signed, /* complain_on_overflow */
1651          ppc64_elf_unhandled_reloc, /* special_function */
1652          "R_PPC64_TPREL16_DS",  /* name */
1653          FALSE,                 /* partial_inplace */
1654          0,                     /* src_mask */
1655          0xfffc,                /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   /* Like TPREL16_DS, but no overflow.  */
1659   HOWTO (R_PPC64_TPREL16_LO_DS,
1660          0,                     /* rightshift */
1661          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1662          16,                    /* bitsize */
1663          FALSE,                 /* pc_relative */
1664          0,                     /* bitpos */
1665          complain_overflow_dont, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_TPREL16_LO_DS", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xfffc,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675      to the first entry relative to the TOC base (r2).  */
1676   HOWTO (R_PPC64_GOT_TLSGD16,
1677          0,                     /* rightshift */
1678          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1679          16,                    /* bitsize */
1680          FALSE,                 /* pc_relative */
1681          0,                     /* bitpos */
1682          complain_overflow_signed, /* complain_on_overflow */
1683          ppc64_elf_unhandled_reloc, /* special_function */
1684          "R_PPC64_GOT_TLSGD16", /* name */
1685          FALSE,                 /* partial_inplace */
1686          0,                     /* src_mask */
1687          0xffff,                /* dst_mask */
1688          FALSE),                /* pcrel_offset */
1689
1690   /* Like GOT_TLSGD16, but no overflow.  */
1691   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1692          0,                     /* rightshift */
1693          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1694          16,                    /* bitsize */
1695          FALSE,                 /* pc_relative */
1696          0,                     /* bitpos */
1697          complain_overflow_dont, /* complain_on_overflow */
1698          ppc64_elf_unhandled_reloc, /* special_function */
1699          "R_PPC64_GOT_TLSGD16_LO", /* name */
1700          FALSE,                 /* partial_inplace */
1701          0,                     /* src_mask */
1702          0xffff,                /* dst_mask */
1703          FALSE),                /* pcrel_offset */
1704
1705   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1706   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707          16,                    /* rightshift */
1708          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1709          16,                    /* bitsize */
1710          FALSE,                 /* pc_relative */
1711          0,                     /* bitpos */
1712          complain_overflow_signed, /* complain_on_overflow */
1713          ppc64_elf_unhandled_reloc, /* special_function */
1714          "R_PPC64_GOT_TLSGD16_HI", /* name */
1715          FALSE,                 /* partial_inplace */
1716          0,                     /* src_mask */
1717          0xffff,                /* dst_mask */
1718          FALSE),                /* pcrel_offset */
1719
1720   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1721   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722          16,                    /* rightshift */
1723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1724          16,                    /* bitsize */
1725          FALSE,                 /* pc_relative */
1726          0,                     /* bitpos */
1727          complain_overflow_signed, /* complain_on_overflow */
1728          ppc64_elf_unhandled_reloc, /* special_function */
1729          "R_PPC64_GOT_TLSGD16_HA", /* name */
1730          FALSE,                 /* partial_inplace */
1731          0,                     /* src_mask */
1732          0xffff,                /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736      with values (sym+add)@dtpmod and zero, and computes the offset to the
1737      first entry relative to the TOC base (r2).  */
1738   HOWTO (R_PPC64_GOT_TLSLD16,
1739          0,                     /* rightshift */
1740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1741          16,                    /* bitsize */
1742          FALSE,                 /* pc_relative */
1743          0,                     /* bitpos */
1744          complain_overflow_signed, /* complain_on_overflow */
1745          ppc64_elf_unhandled_reloc, /* special_function */
1746          "R_PPC64_GOT_TLSLD16", /* name */
1747          FALSE,                 /* partial_inplace */
1748          0,                     /* src_mask */
1749          0xffff,                /* dst_mask */
1750          FALSE),                /* pcrel_offset */
1751
1752   /* Like GOT_TLSLD16, but no overflow.  */
1753   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1754          0,                     /* rightshift */
1755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1756          16,                    /* bitsize */
1757          FALSE,                 /* pc_relative */
1758          0,                     /* bitpos */
1759          complain_overflow_dont, /* complain_on_overflow */
1760          ppc64_elf_unhandled_reloc, /* special_function */
1761          "R_PPC64_GOT_TLSLD16_LO", /* name */
1762          FALSE,                 /* partial_inplace */
1763          0,                     /* src_mask */
1764          0xffff,                /* dst_mask */
1765          FALSE),                /* pcrel_offset */
1766
1767   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1768   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769          16,                    /* rightshift */
1770          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1771          16,                    /* bitsize */
1772          FALSE,                 /* pc_relative */
1773          0,                     /* bitpos */
1774          complain_overflow_signed, /* complain_on_overflow */
1775          ppc64_elf_unhandled_reloc, /* special_function */
1776          "R_PPC64_GOT_TLSLD16_HI", /* name */
1777          FALSE,                 /* partial_inplace */
1778          0,                     /* src_mask */
1779          0xffff,                /* dst_mask */
1780          FALSE),                /* pcrel_offset */
1781
1782   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1783   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784          16,                    /* rightshift */
1785          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1786          16,                    /* bitsize */
1787          FALSE,                 /* pc_relative */
1788          0,                     /* bitpos */
1789          complain_overflow_signed, /* complain_on_overflow */
1790          ppc64_elf_unhandled_reloc, /* special_function */
1791          "R_PPC64_GOT_TLSLD16_HA", /* name */
1792          FALSE,                 /* partial_inplace */
1793          0,                     /* src_mask */
1794          0xffff,                /* dst_mask */
1795          FALSE),                /* pcrel_offset */
1796
1797   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798      the offset to the entry relative to the TOC base (r2).  */
1799   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1800          0,                     /* rightshift */
1801          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1802          16,                    /* bitsize */
1803          FALSE,                 /* pc_relative */
1804          0,                     /* bitpos */
1805          complain_overflow_signed, /* complain_on_overflow */
1806          ppc64_elf_unhandled_reloc, /* special_function */
1807          "R_PPC64_GOT_DTPREL16_DS", /* name */
1808          FALSE,                 /* partial_inplace */
1809          0,                     /* src_mask */
1810          0xfffc,                /* dst_mask */
1811          FALSE),                /* pcrel_offset */
1812
1813   /* Like GOT_DTPREL16_DS, but no overflow.  */
1814   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1815          0,                     /* rightshift */
1816          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1817          16,                    /* bitsize */
1818          FALSE,                 /* pc_relative */
1819          0,                     /* bitpos */
1820          complain_overflow_dont, /* complain_on_overflow */
1821          ppc64_elf_unhandled_reloc, /* special_function */
1822          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823          FALSE,                 /* partial_inplace */
1824          0,                     /* src_mask */
1825          0xfffc,                /* dst_mask */
1826          FALSE),                /* pcrel_offset */
1827
1828   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1829   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830          16,                    /* rightshift */
1831          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1832          16,                    /* bitsize */
1833          FALSE,                 /* pc_relative */
1834          0,                     /* bitpos */
1835          complain_overflow_signed, /* complain_on_overflow */
1836          ppc64_elf_unhandled_reloc, /* special_function */
1837          "R_PPC64_GOT_DTPREL16_HI", /* name */
1838          FALSE,                 /* partial_inplace */
1839          0,                     /* src_mask */
1840          0xffff,                /* dst_mask */
1841          FALSE),                /* pcrel_offset */
1842
1843   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1844   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845          16,                    /* rightshift */
1846          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1847          16,                    /* bitsize */
1848          FALSE,                 /* pc_relative */
1849          0,                     /* bitpos */
1850          complain_overflow_signed, /* complain_on_overflow */
1851          ppc64_elf_unhandled_reloc, /* special_function */
1852          "R_PPC64_GOT_DTPREL16_HA", /* name */
1853          FALSE,                 /* partial_inplace */
1854          0,                     /* src_mask */
1855          0xffff,                /* dst_mask */
1856          FALSE),                /* pcrel_offset */
1857
1858   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859      offset to the entry relative to the TOC base (r2).  */
1860   HOWTO (R_PPC64_GOT_TPREL16_DS,
1861          0,                     /* rightshift */
1862          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1863          16,                    /* bitsize */
1864          FALSE,                 /* pc_relative */
1865          0,                     /* bitpos */
1866          complain_overflow_signed, /* complain_on_overflow */
1867          ppc64_elf_unhandled_reloc, /* special_function */
1868          "R_PPC64_GOT_TPREL16_DS", /* name */
1869          FALSE,                 /* partial_inplace */
1870          0,                     /* src_mask */
1871          0xfffc,                /* dst_mask */
1872          FALSE),                /* pcrel_offset */
1873
1874   /* Like GOT_TPREL16_DS, but no overflow.  */
1875   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1876          0,                     /* rightshift */
1877          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1878          16,                    /* bitsize */
1879          FALSE,                 /* pc_relative */
1880          0,                     /* bitpos */
1881          complain_overflow_dont, /* complain_on_overflow */
1882          ppc64_elf_unhandled_reloc, /* special_function */
1883          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884          FALSE,                 /* partial_inplace */
1885          0,                     /* src_mask */
1886          0xfffc,                /* dst_mask */
1887          FALSE),                /* pcrel_offset */
1888
1889   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1890   HOWTO (R_PPC64_GOT_TPREL16_HI,
1891          16,                    /* rightshift */
1892          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1893          16,                    /* bitsize */
1894          FALSE,                 /* pc_relative */
1895          0,                     /* bitpos */
1896          complain_overflow_signed, /* complain_on_overflow */
1897          ppc64_elf_unhandled_reloc, /* special_function */
1898          "R_PPC64_GOT_TPREL16_HI", /* name */
1899          FALSE,                 /* partial_inplace */
1900          0,                     /* src_mask */
1901          0xffff,                /* dst_mask */
1902          FALSE),                /* pcrel_offset */
1903
1904   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1905   HOWTO (R_PPC64_GOT_TPREL16_HA,
1906          16,                    /* rightshift */
1907          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1908          16,                    /* bitsize */
1909          FALSE,                 /* pc_relative */
1910          0,                     /* bitpos */
1911          complain_overflow_signed, /* complain_on_overflow */
1912          ppc64_elf_unhandled_reloc, /* special_function */
1913          "R_PPC64_GOT_TPREL16_HA", /* name */
1914          FALSE,                 /* partial_inplace */
1915          0,                     /* src_mask */
1916          0xffff,                /* dst_mask */
1917          FALSE),                /* pcrel_offset */
1918
1919   HOWTO (R_PPC64_JMP_IREL,      /* type */
1920          0,                     /* rightshift */
1921          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1922          0,                     /* bitsize */
1923          FALSE,                 /* pc_relative */
1924          0,                     /* bitpos */
1925          complain_overflow_dont, /* complain_on_overflow */
1926          ppc64_elf_unhandled_reloc, /* special_function */
1927          "R_PPC64_JMP_IREL",    /* name */
1928          FALSE,                 /* partial_inplace */
1929          0,                     /* src_mask */
1930          0,                     /* dst_mask */
1931          FALSE),                /* pcrel_offset */
1932
1933   HOWTO (R_PPC64_IRELATIVE,     /* type */
1934          0,                     /* rightshift */
1935          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1936          64,                    /* bitsize */
1937          FALSE,                 /* pc_relative */
1938          0,                     /* bitpos */
1939          complain_overflow_dont, /* complain_on_overflow */
1940          bfd_elf_generic_reloc, /* special_function */
1941          "R_PPC64_IRELATIVE",   /* name */
1942          FALSE,                 /* partial_inplace */
1943          0,                     /* src_mask */
1944          ONES (64),             /* dst_mask */
1945          FALSE),                /* pcrel_offset */
1946
1947   /* A 16 bit relative relocation.  */
1948   HOWTO (R_PPC64_REL16,         /* type */
1949          0,                     /* rightshift */
1950          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1951          16,                    /* bitsize */
1952          TRUE,                  /* pc_relative */
1953          0,                     /* bitpos */
1954          complain_overflow_bitfield, /* complain_on_overflow */
1955          bfd_elf_generic_reloc, /* special_function */
1956          "R_PPC64_REL16",       /* name */
1957          FALSE,                 /* partial_inplace */
1958          0,                     /* src_mask */
1959          0xffff,                /* dst_mask */
1960          TRUE),                 /* pcrel_offset */
1961
1962   /* A 16 bit relative relocation without overflow.  */
1963   HOWTO (R_PPC64_REL16_LO,      /* type */
1964          0,                     /* rightshift */
1965          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1966          16,                    /* bitsize */
1967          TRUE,                  /* pc_relative */
1968          0,                     /* bitpos */
1969          complain_overflow_dont,/* complain_on_overflow */
1970          bfd_elf_generic_reloc, /* special_function */
1971          "R_PPC64_REL16_LO",    /* name */
1972          FALSE,                 /* partial_inplace */
1973          0,                     /* src_mask */
1974          0xffff,                /* dst_mask */
1975          TRUE),                 /* pcrel_offset */
1976
1977   /* The high order 16 bits of a relative address.  */
1978   HOWTO (R_PPC64_REL16_HI,      /* type */
1979          16,                    /* rightshift */
1980          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1981          16,                    /* bitsize */
1982          TRUE,                  /* pc_relative */
1983          0,                     /* bitpos */
1984          complain_overflow_signed, /* complain_on_overflow */
1985          bfd_elf_generic_reloc, /* special_function */
1986          "R_PPC64_REL16_HI",    /* name */
1987          FALSE,                 /* partial_inplace */
1988          0,                     /* src_mask */
1989          0xffff,                /* dst_mask */
1990          TRUE),                 /* pcrel_offset */
1991
1992   /* The high order 16 bits of a relative address, plus 1 if the contents of
1993      the low 16 bits, treated as a signed number, is negative.  */
1994   HOWTO (R_PPC64_REL16_HA,      /* type */
1995          16,                    /* rightshift */
1996          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1997          16,                    /* bitsize */
1998          TRUE,                  /* pc_relative */
1999          0,                     /* bitpos */
2000          complain_overflow_signed, /* complain_on_overflow */
2001          ppc64_elf_ha_reloc,    /* special_function */
2002          "R_PPC64_REL16_HA",    /* name */
2003          FALSE,                 /* partial_inplace */
2004          0,                     /* src_mask */
2005          0xffff,                /* dst_mask */
2006          TRUE),                 /* pcrel_offset */
2007
2008   /* Like R_PPC64_ADDR16_HI, but no overflow.  */
2009   HOWTO (R_PPC64_ADDR16_HIGH,   /* type */
2010          16,                    /* rightshift */
2011          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2012          16,                    /* bitsize */
2013          FALSE,                 /* pc_relative */
2014          0,                     /* bitpos */
2015          complain_overflow_dont, /* complain_on_overflow */
2016          bfd_elf_generic_reloc, /* special_function */
2017          "R_PPC64_ADDR16_HIGH", /* name */
2018          FALSE,                 /* partial_inplace */
2019          0,                     /* src_mask */
2020          0xffff,                /* dst_mask */
2021          FALSE),                /* pcrel_offset */
2022
2023   /* Like R_PPC64_ADDR16_HA, but no overflow.  */
2024   HOWTO (R_PPC64_ADDR16_HIGHA,  /* type */
2025          16,                    /* rightshift */
2026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2027          16,                    /* bitsize */
2028          FALSE,                 /* pc_relative */
2029          0,                     /* bitpos */
2030          complain_overflow_dont, /* complain_on_overflow */
2031          ppc64_elf_ha_reloc,    /* special_function */
2032          "R_PPC64_ADDR16_HIGHA",        /* name */
2033          FALSE,                 /* partial_inplace */
2034          0,                     /* src_mask */
2035          0xffff,                /* dst_mask */
2036          FALSE),                /* pcrel_offset */
2037
2038   /* Like R_PPC64_DTPREL16_HI, but no overflow.  */
2039   HOWTO (R_PPC64_DTPREL16_HIGH,
2040          16,                    /* rightshift */
2041          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2042          16,                    /* bitsize */
2043          FALSE,                 /* pc_relative */
2044          0,                     /* bitpos */
2045          complain_overflow_dont, /* complain_on_overflow */
2046          ppc64_elf_unhandled_reloc, /* special_function */
2047          "R_PPC64_DTPREL16_HIGH", /* name */
2048          FALSE,                 /* partial_inplace */
2049          0,                     /* src_mask */
2050          0xffff,                /* dst_mask */
2051          FALSE),                /* pcrel_offset */
2052
2053   /* Like R_PPC64_DTPREL16_HA, but no overflow.  */
2054   HOWTO (R_PPC64_DTPREL16_HIGHA,
2055          16,                    /* rightshift */
2056          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2057          16,                    /* bitsize */
2058          FALSE,                 /* pc_relative */
2059          0,                     /* bitpos */
2060          complain_overflow_dont, /* complain_on_overflow */
2061          ppc64_elf_unhandled_reloc, /* special_function */
2062          "R_PPC64_DTPREL16_HIGHA", /* name */
2063          FALSE,                 /* partial_inplace */
2064          0,                     /* src_mask */
2065          0xffff,                /* dst_mask */
2066          FALSE),                /* pcrel_offset */
2067
2068   /* Like R_PPC64_TPREL16_HI, but no overflow.  */
2069   HOWTO (R_PPC64_TPREL16_HIGH,
2070          16,                    /* rightshift */
2071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2072          16,                    /* bitsize */
2073          FALSE,                 /* pc_relative */
2074          0,                     /* bitpos */
2075          complain_overflow_dont, /* complain_on_overflow */
2076          ppc64_elf_unhandled_reloc, /* special_function */
2077          "R_PPC64_TPREL16_HIGH",        /* name */
2078          FALSE,                 /* partial_inplace */
2079          0,                     /* src_mask */
2080          0xffff,                /* dst_mask */
2081          FALSE),                /* pcrel_offset */
2082
2083   /* Like R_PPC64_TPREL16_HA, but no overflow.  */
2084   HOWTO (R_PPC64_TPREL16_HIGHA,
2085          16,                    /* rightshift */
2086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
2087          16,                    /* bitsize */
2088          FALSE,                 /* pc_relative */
2089          0,                     /* bitpos */
2090          complain_overflow_dont, /* complain_on_overflow */
2091          ppc64_elf_unhandled_reloc, /* special_function */
2092          "R_PPC64_TPREL16_HIGHA",       /* name */
2093          FALSE,                 /* partial_inplace */
2094          0,                     /* src_mask */
2095          0xffff,                /* dst_mask */
2096          FALSE),                /* pcrel_offset */
2097
2098   /* GNU extension to record C++ vtable hierarchy.  */
2099   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2100          0,                     /* rightshift */
2101          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2102          0,                     /* bitsize */
2103          FALSE,                 /* pc_relative */
2104          0,                     /* bitpos */
2105          complain_overflow_dont, /* complain_on_overflow */
2106          NULL,                  /* special_function */
2107          "R_PPC64_GNU_VTINHERIT", /* name */
2108          FALSE,                 /* partial_inplace */
2109          0,                     /* src_mask */
2110          0,                     /* dst_mask */
2111          FALSE),                /* pcrel_offset */
2112
2113   /* GNU extension to record C++ vtable member usage.  */
2114   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2115          0,                     /* rightshift */
2116          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2117          0,                     /* bitsize */
2118          FALSE,                 /* pc_relative */
2119          0,                     /* bitpos */
2120          complain_overflow_dont, /* complain_on_overflow */
2121          NULL,                  /* special_function */
2122          "R_PPC64_GNU_VTENTRY", /* name */
2123          FALSE,                 /* partial_inplace */
2124          0,                     /* src_mask */
2125          0,                     /* dst_mask */
2126          FALSE),                /* pcrel_offset */
2127 };
2128
2129 \f
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2131    be done.  */
2132
2133 static void
2134 ppc_howto_init (void)
2135 {
2136   unsigned int i, type;
2137
2138   for (i = 0;
2139        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2140        i++)
2141     {
2142       type = ppc64_elf_howto_raw[i].type;
2143       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144                           / sizeof (ppc64_elf_howto_table[0])));
2145       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2146     }
2147 }
2148
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151                              bfd_reloc_code_real_type code)
2152 {
2153   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2154
2155   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156     /* Initialize howto table if needed.  */
2157     ppc_howto_init ();
2158
2159   switch (code)
2160     {
2161     default:
2162       return NULL;
2163
2164     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2165       break;
2166     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2167       break;
2168     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2169       break;
2170     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2171       break;
2172     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2173       break;
2174     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2175       break;
2176     case BFD_RELOC_PPC64_ADDR16_HIGH:           r = R_PPC64_ADDR16_HIGH;
2177       break;
2178     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2179       break;
2180     case BFD_RELOC_PPC64_ADDR16_HIGHA:          r = R_PPC64_ADDR16_HIGHA;
2181       break;
2182     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2183       break;
2184     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2185       break;
2186     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2187       break;
2188     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2189       break;
2190     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2191       break;
2192     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2193       break;
2194     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2195       break;
2196     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2197       break;
2198     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2199       break;
2200     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2201       break;
2202     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2203       break;
2204     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2205       break;
2206     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2207       break;
2208     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2209       break;
2210     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2211       break;
2212     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2213       break;
2214     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2215       break;
2216     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2217       break;
2218     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2219       break;
2220     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2221       break;
2222     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2223       break;
2224     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2225       break;
2226     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2227       break;
2228     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2229       break;
2230     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2231       break;
2232     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2233       break;
2234     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2235       break;
2236     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2237       break;
2238     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2239       break;
2240     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2241       break;
2242     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2243       break;
2244     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2245       break;
2246     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2247       break;
2248     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2249       break;
2250     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2251       break;
2252     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2253       break;
2254     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2255       break;
2256     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2257       break;
2258     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2259       break;
2260     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2261       break;
2262     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2263       break;
2264     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2265       break;
2266     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2267       break;
2268     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2269       break;
2270     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2271       break;
2272     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2273       break;
2274     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2275       break;
2276     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2277       break;
2278     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2279       break;
2280     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2281       break;
2282     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2283       break;
2284     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2285       break;
2286     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2287       break;
2288     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2289       break;
2290     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2291       break;
2292     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2293       break;
2294     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2295       break;
2296     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2297       break;
2298     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2299       break;
2300     case BFD_RELOC_PPC64_TPREL16_HIGH:          r = R_PPC64_TPREL16_HIGH;
2301       break;
2302     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2303       break;
2304     case BFD_RELOC_PPC64_TPREL16_HIGHA:         r = R_PPC64_TPREL16_HIGHA;
2305       break;
2306     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2307       break;
2308     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2309       break;
2310     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2311       break;
2312     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2313       break;
2314     case BFD_RELOC_PPC64_DTPREL16_HIGH:         r = R_PPC64_DTPREL16_HIGH;
2315       break;
2316     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2317       break;
2318     case BFD_RELOC_PPC64_DTPREL16_HIGHA:        r = R_PPC64_DTPREL16_HIGHA;
2319       break;
2320     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2321       break;
2322     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2323       break;
2324     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2325       break;
2326     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2327       break;
2328     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2329       break;
2330     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2331       break;
2332     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2333       break;
2334     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2335       break;
2336     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2337       break;
2338     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2339       break;
2340     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2341       break;
2342     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2343       break;
2344     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2345       break;
2346     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2347       break;
2348     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2349       break;
2350     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2351       break;
2352     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2353       break;
2354     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2355       break;
2356     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2357       break;
2358     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2359       break;
2360     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2361       break;
2362     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2363       break;
2364     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2365       break;
2366     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2367       break;
2368     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2369       break;
2370     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2371       break;
2372     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2373       break;
2374     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2375       break;
2376     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2377       break;
2378     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2379       break;
2380     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2381       break;
2382     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2383       break;
2384     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2385       break;
2386     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2387       break;
2388     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2389       break;
2390     }
2391
2392   return ppc64_elf_howto_table[r];
2393 };
2394
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2397                              const char *r_name)
2398 {
2399   unsigned int i;
2400
2401   for (i = 0;
2402        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2403        i++)
2404     if (ppc64_elf_howto_raw[i].name != NULL
2405         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406       return &ppc64_elf_howto_raw[i];
2407
2408   return NULL;
2409 }
2410
2411 /* Set the howto pointer for a PowerPC ELF reloc.  */
2412
2413 static void
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415                          Elf_Internal_Rela *dst)
2416 {
2417   unsigned int type;
2418
2419   /* Initialize howto table if needed.  */
2420   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2421     ppc_howto_init ();
2422
2423   type = ELF64_R_TYPE (dst->r_info);
2424   if (type >= (sizeof (ppc64_elf_howto_table)
2425                / sizeof (ppc64_elf_howto_table[0])))
2426     {
2427       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2428                              abfd, (int) type);
2429       type = R_PPC64_NONE;
2430     }
2431   cache_ptr->howto = ppc64_elf_howto_table[type];
2432 }
2433
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2435
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438                     void *data, asection *input_section,
2439                     bfd *output_bfd, char **error_message)
2440 {
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   /* Adjust the addend for sign extension of the low 16 bits.
2449      We won't actually be using the low 16 bits, so trashing them
2450      doesn't matter.  */
2451   reloc_entry->addend += 0x8000;
2452   return bfd_reloc_continue;
2453 }
2454
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457                         void *data, asection *input_section,
2458                         bfd *output_bfd, char **error_message)
2459 {
2460   if (output_bfd != NULL)
2461     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462                                   input_section, output_bfd, error_message);
2463
2464   if (strcmp (symbol->section->name, ".opd") == 0
2465       && (symbol->section->owner->flags & DYNAMIC) == 0)
2466     {
2467       bfd_vma dest = opd_entry_value (symbol->section,
2468                                       symbol->value + reloc_entry->addend,
2469                                       NULL, NULL, FALSE);
2470       if (dest != (bfd_vma) -1)
2471         reloc_entry->addend = dest - (symbol->value
2472                                       + symbol->section->output_section->vma
2473                                       + symbol->section->output_offset);
2474     }
2475   return bfd_reloc_continue;
2476 }
2477
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480                          void *data, asection *input_section,
2481                          bfd *output_bfd, char **error_message)
2482 {
2483   long insn;
2484   enum elf_ppc64_reloc_type r_type;
2485   bfd_size_type octets;
2486   /* Assume 'at' branch hints.  */
2487   bfd_boolean is_isa_v2 = TRUE;
2488
2489   /* If this is a relocatable link (output_bfd test tells us), just
2490      call the generic function.  Any adjustment will be done at final
2491      link time.  */
2492   if (output_bfd != NULL)
2493     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494                                   input_section, output_bfd, error_message);
2495
2496   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498   insn &= ~(0x01 << 21);
2499   r_type = reloc_entry->howto->type;
2500   if (r_type == R_PPC64_ADDR14_BRTAKEN
2501       || r_type == R_PPC64_REL14_BRTAKEN)
2502     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2503
2504   if (is_isa_v2)
2505     {
2506       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2507          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2509       if ((insn & (0x14 << 21)) == (0x04 << 21))
2510         insn |= 0x02 << 21;
2511       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2512         insn |= 0x08 << 21;
2513       else
2514         goto out;
2515     }
2516   else
2517     {
2518       bfd_vma target = 0;
2519       bfd_vma from;
2520
2521       if (!bfd_is_com_section (symbol->section))
2522         target = symbol->value;
2523       target += symbol->section->output_section->vma;
2524       target += symbol->section->output_offset;
2525       target += reloc_entry->addend;
2526
2527       from = (reloc_entry->address
2528               + input_section->output_offset
2529               + input_section->output_section->vma);
2530
2531       /* Invert 'y' bit if not the default.  */
2532       if ((bfd_signed_vma) (target - from) < 0)
2533         insn ^= 0x01 << 21;
2534     }
2535   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2536  out:
2537   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538                                  input_section, output_bfd, error_message);
2539 }
2540
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543                          void *data, asection *input_section,
2544                          bfd *output_bfd, char **error_message)
2545 {
2546   /* If this is a relocatable link (output_bfd test tells us), just
2547      call the generic function.  Any adjustment will be done at final
2548      link time.  */
2549   if (output_bfd != NULL)
2550     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551                                   input_section, output_bfd, error_message);
2552
2553   /* Subtract the symbol section base address.  */
2554   reloc_entry->addend -= symbol->section->output_section->vma;
2555   return bfd_reloc_continue;
2556 }
2557
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560                             void *data, asection *input_section,
2561                             bfd *output_bfd, char **error_message)
2562 {
2563   /* If this is a relocatable link (output_bfd test tells us), just
2564      call the generic function.  Any adjustment will be done at final
2565      link time.  */
2566   if (output_bfd != NULL)
2567     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568                                   input_section, output_bfd, error_message);
2569
2570   /* Subtract the symbol section base address.  */
2571   reloc_entry->addend -= symbol->section->output_section->vma;
2572
2573   /* Adjust the addend for sign extension of the low 16 bits.  */
2574   reloc_entry->addend += 0x8000;
2575   return bfd_reloc_continue;
2576 }
2577
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580                      void *data, asection *input_section,
2581                      bfd *output_bfd, char **error_message)
2582 {
2583   bfd_vma TOCstart;
2584
2585   /* If this is a relocatable link (output_bfd test tells us), just
2586      call the generic function.  Any adjustment will be done at final
2587      link time.  */
2588   if (output_bfd != NULL)
2589     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590                                   input_section, output_bfd, error_message);
2591
2592   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2593   if (TOCstart == 0)
2594     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2595
2596   /* Subtract the TOC base address.  */
2597   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598   return bfd_reloc_continue;
2599 }
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603                         void *data, asection *input_section,
2604                         bfd *output_bfd, char **error_message)
2605 {
2606   bfd_vma TOCstart;
2607
2608   /* If this is a relocatable link (output_bfd test tells us), just
2609      call the generic function.  Any adjustment will be done at final
2610      link time.  */
2611   if (output_bfd != NULL)
2612     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613                                   input_section, output_bfd, error_message);
2614
2615   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2616   if (TOCstart == 0)
2617     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2618
2619   /* Subtract the TOC base address.  */
2620   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2621
2622   /* Adjust the addend for sign extension of the low 16 bits.  */
2623   reloc_entry->addend += 0x8000;
2624   return bfd_reloc_continue;
2625 }
2626
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629                        void *data, asection *input_section,
2630                        bfd *output_bfd, char **error_message)
2631 {
2632   bfd_vma TOCstart;
2633   bfd_size_type octets;
2634
2635   /* If this is a relocatable link (output_bfd test tells us), just
2636      call the generic function.  Any adjustment will be done at final
2637      link time.  */
2638   if (output_bfd != NULL)
2639     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640                                   input_section, output_bfd, error_message);
2641
2642   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2643   if (TOCstart == 0)
2644     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2645
2646   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648   return bfd_reloc_ok;
2649 }
2650
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653                            void *data, asection *input_section,
2654                            bfd *output_bfd, char **error_message)
2655 {
2656   /* If this is a relocatable link (output_bfd test tells us), just
2657      call the generic function.  Any adjustment will be done at final
2658      link time.  */
2659   if (output_bfd != NULL)
2660     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661                                   input_section, output_bfd, error_message);
2662
2663   if (error_message != NULL)
2664     {
2665       static char buf[60];
2666       sprintf (buf, "generic linker can't handle %s",
2667                reloc_entry->howto->name);
2668       *error_message = buf;
2669     }
2670   return bfd_reloc_dangerous;
2671 }
2672
2673 /* Track GOT entries needed for a given symbol.  We might need more
2674    than one got entry per symbol.  */
2675 struct got_entry
2676 {
2677   struct got_entry *next;
2678
2679   /* The symbol addend that we'll be placing in the GOT.  */
2680   bfd_vma addend;
2681
2682   /* Unlike other ELF targets, we use separate GOT entries for the same
2683      symbol referenced from different input files.  This is to support
2684      automatic multiple TOC/GOT sections, where the TOC base can vary
2685      from one input file to another.  After partitioning into TOC groups
2686      we merge entries within the group.
2687
2688      Point to the BFD owning this GOT entry.  */
2689   bfd *owner;
2690
2691   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692      TLS_TPREL or TLS_DTPREL for tls entries.  */
2693   unsigned char tls_type;
2694
2695   /* Non-zero if got.ent points to real entry.  */
2696   unsigned char is_indirect;
2697
2698   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2699   union
2700     {
2701       bfd_signed_vma refcount;
2702       bfd_vma offset;
2703       struct got_entry *ent;
2704     } got;
2705 };
2706
2707 /* The same for PLT.  */
2708 struct plt_entry
2709 {
2710   struct plt_entry *next;
2711
2712   bfd_vma addend;
2713
2714   union
2715     {
2716       bfd_signed_vma refcount;
2717       bfd_vma offset;
2718     } plt;
2719 };
2720
2721 struct ppc64_elf_obj_tdata
2722 {
2723   struct elf_obj_tdata elf;
2724
2725   /* Shortcuts to dynamic linker sections.  */
2726   asection *got;
2727   asection *relgot;
2728
2729   /* Used during garbage collection.  We attach global symbols defined
2730      on removed .opd entries to this section so that the sym is removed.  */
2731   asection *deleted_section;
2732
2733   /* TLS local dynamic got entry handling.  Support for multiple GOT
2734      sections means we potentially need one of these for each input bfd.  */
2735   struct got_entry tlsld_got;
2736
2737   union {
2738     /* A copy of relocs before they are modified for --emit-relocs.  */
2739     Elf_Internal_Rela *relocs;
2740
2741     /* Section contents.  */
2742     bfd_byte *contents;
2743   } opd;
2744
2745   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746      the reloc to be in the range -32768 to 32767.  */
2747   unsigned int has_small_toc_reloc : 1;
2748
2749   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750      instruction not one we handle.  */
2751   unsigned int unexpected_toc_insn : 1;
2752 };
2753
2754 #define ppc64_elf_tdata(bfd) \
2755   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2756
2757 #define ppc64_tlsld_got(bfd) \
2758   (&ppc64_elf_tdata (bfd)->tlsld_got)
2759
2760 #define is_ppc64_elf(bfd) \
2761   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762    && elf_object_id (bfd) == PPC64_ELF_DATA)
2763
2764 /* Override the generic function because we store some extras.  */
2765
2766 static bfd_boolean
2767 ppc64_elf_mkobject (bfd *abfd)
2768 {
2769   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2770                                   PPC64_ELF_DATA);
2771 }
2772
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774    default is 32 bit.  */
2775
2776 static bfd_boolean
2777 ppc64_elf_object_p (bfd *abfd)
2778 {
2779   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2780     {
2781       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2782
2783       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2784         {
2785           /* Relies on arch after 32 bit default being 64 bit default.  */
2786           abfd->arch_info = abfd->arch_info->next;
2787           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2788         }
2789     }
2790   return TRUE;
2791 }
2792
2793 /* Support for core dump NOTE sections.  */
2794
2795 static bfd_boolean
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2797 {
2798   size_t offset, size;
2799
2800   if (note->descsz != 504)
2801     return FALSE;
2802
2803   /* pr_cursig */
2804   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2805
2806   /* pr_pid */
2807   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2808
2809   /* pr_reg */
2810   offset = 112;
2811   size = 384;
2812
2813   /* Make a ".reg/999" section.  */
2814   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815                                           size, note->descpos + offset);
2816 }
2817
2818 static bfd_boolean
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2820 {
2821   if (note->descsz != 136)
2822     return FALSE;
2823
2824   elf_tdata (abfd)->core->pid
2825     = bfd_get_32 (abfd, note->descdata + 24);
2826   elf_tdata (abfd)->core->program
2827     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828   elf_tdata (abfd)->core->command
2829     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2830
2831   return TRUE;
2832 }
2833
2834 static char *
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2836                            ...)
2837 {
2838   switch (note_type)
2839     {
2840     default:
2841       return NULL;
2842
2843     case NT_PRPSINFO:
2844       {
2845         char data[136];
2846         va_list ap;
2847
2848         va_start (ap, note_type);
2849         memset (data, 0, sizeof (data));
2850         strncpy (data + 40, va_arg (ap, const char *), 16);
2851         strncpy (data + 56, va_arg (ap, const char *), 80);
2852         va_end (ap);
2853         return elfcore_write_note (abfd, buf, bufsiz,
2854                                    "CORE", note_type, data, sizeof (data));
2855       }
2856
2857     case NT_PRSTATUS:
2858       {
2859         char data[504];
2860         va_list ap;
2861         long pid;
2862         int cursig;
2863         const void *greg;
2864
2865         va_start (ap, note_type);
2866         memset (data, 0, 112);
2867         pid = va_arg (ap, long);
2868         bfd_put_32 (abfd, pid, data + 32);
2869         cursig = va_arg (ap, int);
2870         bfd_put_16 (abfd, cursig, data + 12);
2871         greg = va_arg (ap, const void *);
2872         memcpy (data + 112, greg, 384);
2873         memset (data + 496, 0, 8);
2874         va_end (ap);
2875         return elfcore_write_note (abfd, buf, bufsiz,
2876                                    "CORE", note_type, data, sizeof (data));
2877       }
2878     }
2879 }
2880
2881 /* Add extra PPC sections.  */
2882
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2884 {
2885   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2886   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2887   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2891   { NULL,                     0,  0, 0,            0 }
2892 };
2893
2894 enum _ppc64_sec_type {
2895   sec_normal = 0,
2896   sec_opd = 1,
2897   sec_toc = 2
2898 };
2899
2900 struct _ppc64_elf_section_data
2901 {
2902   struct bfd_elf_section_data elf;
2903
2904   union
2905   {
2906     /* An array with one entry for each opd function descriptor.  */
2907     struct _opd_sec_data
2908     {
2909       /* Points to the function code section for local opd entries.  */
2910       asection **func_sec;
2911
2912       /* After editing .opd, adjust references to opd local syms.  */
2913       long *adjust;
2914     } opd;
2915
2916     /* An array for toc sections, indexed by offset/8.  */
2917     struct _toc_sec_data
2918     {
2919       /* Specifies the relocation symbol index used at a given toc offset.  */
2920       unsigned *symndx;
2921
2922       /* And the relocation addend.  */
2923       bfd_vma *add;
2924     } toc;
2925   } u;
2926
2927   enum _ppc64_sec_type sec_type:2;
2928
2929   /* Flag set when small branches are detected.  Used to
2930      select suitable defaults for the stub group size.  */
2931   unsigned int has_14bit_branch:1;
2932 };
2933
2934 #define ppc64_elf_section_data(sec) \
2935   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2936
2937 static bfd_boolean
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2939 {
2940   if (!sec->used_by_bfd)
2941     {
2942       struct _ppc64_elf_section_data *sdata;
2943       bfd_size_type amt = sizeof (*sdata);
2944
2945       sdata = bfd_zalloc (abfd, amt);
2946       if (sdata == NULL)
2947         return FALSE;
2948       sec->used_by_bfd = sdata;
2949     }
2950
2951   return _bfd_elf_new_section_hook (abfd, sec);
2952 }
2953
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2956 {
2957   if (sec != NULL
2958       && ppc64_elf_section_data (sec) != NULL
2959       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960     return &ppc64_elf_section_data (sec)->u.opd;
2961   return NULL;
2962 }
2963
2964 static inline int
2965 abiversion (bfd *abfd)
2966 {
2967   return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2968 }
2969
2970 static inline void
2971 set_abiversion (bfd *abfd, int ver)
2972 {
2973   elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974   elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2975 }
2976 \f
2977 /* Parameters for the qsort hook.  */
2978 static bfd_boolean synthetic_relocatable;
2979
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2981
2982 static int
2983 compare_symbols (const void *ap, const void *bp)
2984 {
2985   const asymbol *a = * (const asymbol **) ap;
2986   const asymbol *b = * (const asymbol **) bp;
2987
2988   /* Section symbols first.  */
2989   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2990     return -1;
2991   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2992     return 1;
2993
2994   /* then .opd symbols.  */
2995   if (strcmp (a->section->name, ".opd") == 0
2996       && strcmp (b->section->name, ".opd") != 0)
2997     return -1;
2998   if (strcmp (a->section->name, ".opd") != 0
2999       && strcmp (b->section->name, ".opd") == 0)
3000     return 1;
3001
3002   /* then other code symbols.  */
3003   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004       == (SEC_CODE | SEC_ALLOC)
3005       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006          != (SEC_CODE | SEC_ALLOC))
3007     return -1;
3008
3009   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010       != (SEC_CODE | SEC_ALLOC)
3011       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012          == (SEC_CODE | SEC_ALLOC))
3013     return 1;
3014
3015   if (synthetic_relocatable)
3016     {
3017       if (a->section->id < b->section->id)
3018         return -1;
3019
3020       if (a->section->id > b->section->id)
3021         return 1;
3022     }
3023
3024   if (a->value + a->section->vma < b->value + b->section->vma)
3025     return -1;
3026
3027   if (a->value + a->section->vma > b->value + b->section->vma)
3028     return 1;
3029
3030   /* For syms with the same value, prefer strong dynamic global function
3031      syms over other syms.  */
3032   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3033     return -1;
3034
3035   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3036     return 1;
3037
3038   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3039     return -1;
3040
3041   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3042     return 1;
3043
3044   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3045     return -1;
3046
3047   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3048     return 1;
3049
3050   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3051     return -1;
3052
3053   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3054     return 1;
3055
3056   return 0;
3057 }
3058
3059 /* Search SYMS for a symbol of the given VALUE.  */
3060
3061 static asymbol *
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3063 {
3064   long mid;
3065
3066   if (id == -1)
3067     {
3068       while (lo < hi)
3069         {
3070           mid = (lo + hi) >> 1;
3071           if (syms[mid]->value + syms[mid]->section->vma < value)
3072             lo = mid + 1;
3073           else if (syms[mid]->value + syms[mid]->section->vma > value)
3074             hi = mid;
3075           else
3076             return syms[mid];
3077         }
3078     }
3079   else
3080     {
3081       while (lo < hi)
3082         {
3083           mid = (lo + hi) >> 1;
3084           if (syms[mid]->section->id < id)
3085             lo = mid + 1;
3086           else if (syms[mid]->section->id > id)
3087             hi = mid;
3088           else if (syms[mid]->value < value)
3089             lo = mid + 1;
3090           else if (syms[mid]->value > value)
3091             hi = mid;
3092           else
3093             return syms[mid];
3094         }
3095     }
3096   return NULL;
3097 }
3098
3099 static bfd_boolean
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3101 {
3102   bfd_vma vma = *(bfd_vma *) ptr;
3103   return ((section->flags & SEC_ALLOC) != 0
3104           && section->vma <= vma
3105           && vma < section->vma + section->size);
3106 }
3107
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109    entry syms.  Also generate @plt symbols for the glink branch table.  */
3110
3111 static long
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113                                 long static_count, asymbol **static_syms,
3114                                 long dyn_count, asymbol **dyn_syms,
3115                                 asymbol **ret)
3116 {
3117   asymbol *s;
3118   long i;
3119   long count;
3120   char *names;
3121   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122   asection *opd = NULL;
3123   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3124   asymbol **syms;
3125   int abi = abiversion (abfd);
3126
3127   *ret = NULL;
3128
3129   if (abi < 2)
3130     {
3131       opd = bfd_get_section_by_name (abfd, ".opd");
3132       if (opd == NULL && abi == 1)
3133         return 0;
3134     }
3135
3136   symcount = static_count;
3137   if (!relocatable)
3138     symcount += dyn_count;
3139   if (symcount == 0)
3140     return 0;
3141
3142   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3143   if (syms == NULL)
3144     return -1;
3145
3146   if (!relocatable && static_count != 0 && dyn_count != 0)
3147     {
3148       /* Use both symbol tables.  */
3149       memcpy (syms, static_syms, static_count * sizeof (*syms));
3150       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3151     }
3152   else if (!relocatable && static_count == 0)
3153     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3154   else
3155     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3156
3157   synthetic_relocatable = relocatable;
3158   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3159
3160   if (!relocatable && symcount > 1)
3161     {
3162       long j;
3163       /* Trim duplicate syms, since we may have merged the normal and
3164          dynamic symbols.  Actually, we only care about syms that have
3165          different values, so trim any with the same value.  */
3166       for (i = 1, j = 1; i < symcount; ++i)
3167         if (syms[i - 1]->value + syms[i - 1]->section->vma
3168             != syms[i]->value + syms[i]->section->vma)
3169           syms[j++] = syms[i];
3170       symcount = j;
3171     }
3172
3173   i = 0;
3174   if (strcmp (syms[i]->section->name, ".opd") == 0)
3175     ++i;
3176   codesecsym = i;
3177
3178   for (; i < symcount; ++i)
3179     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180          != (SEC_CODE | SEC_ALLOC))
3181         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3182       break;
3183   codesecsymend = i;
3184
3185   for (; i < symcount; ++i)
3186     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3187       break;
3188   secsymend = i;
3189
3190   for (; i < symcount; ++i)
3191     if (strcmp (syms[i]->section->name, ".opd") != 0)
3192       break;
3193   opdsymend = i;
3194
3195   for (; i < symcount; ++i)
3196     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197         != (SEC_CODE | SEC_ALLOC))
3198       break;
3199   symcount = i;
3200
3201   count = 0;
3202
3203   if (relocatable)
3204     {
3205       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3206       arelent *r;
3207       size_t size;
3208       long relcount;
3209
3210       if (opdsymend == secsymend)
3211         goto done;
3212
3213       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3215       if (relcount == 0)
3216         goto done;
3217
3218       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3219         {
3220           count = -1;
3221           goto done;
3222         }
3223
3224       size = 0;
3225       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3226         {
3227           asymbol *sym;
3228
3229           while (r < opd->relocation + relcount
3230                  && r->address < syms[i]->value + opd->vma)
3231             ++r;
3232
3233           if (r == opd->relocation + relcount)
3234             break;
3235
3236           if (r->address != syms[i]->value + opd->vma)
3237             continue;
3238
3239           if (r->howto->type != R_PPC64_ADDR64)
3240             continue;
3241
3242           sym = *r->sym_ptr_ptr;
3243           if (!sym_exists_at (syms, opdsymend, symcount,
3244                               sym->section->id, sym->value + r->addend))
3245             {
3246               ++count;
3247               size += sizeof (asymbol);
3248               size += strlen (syms[i]->name) + 2;
3249             }
3250         }
3251
3252       s = *ret = bfd_malloc (size);
3253       if (s == NULL)
3254         {
3255           count = -1;
3256           goto done;
3257         }
3258
3259       names = (char *) (s + count);
3260
3261       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3262         {
3263           asymbol *sym;
3264
3265           while (r < opd->relocation + relcount
3266                  && r->address < syms[i]->value + opd->vma)
3267             ++r;
3268
3269           if (r == opd->relocation + relcount)
3270             break;
3271
3272           if (r->address != syms[i]->value + opd->vma)
3273             continue;
3274
3275           if (r->howto->type != R_PPC64_ADDR64)
3276             continue;
3277
3278           sym = *r->sym_ptr_ptr;
3279           if (!sym_exists_at (syms, opdsymend, symcount,
3280                               sym->section->id, sym->value + r->addend))
3281             {
3282               size_t len;
3283
3284               *s = *syms[i];
3285               s->flags |= BSF_SYNTHETIC;
3286               s->section = sym->section;
3287               s->value = sym->value + r->addend;
3288               s->name = names;
3289               *names++ = '.';
3290               len = strlen (syms[i]->name);
3291               memcpy (names, syms[i]->name, len + 1);
3292               names += len + 1;
3293               /* Have udata.p point back to the original symbol this
3294                  synthetic symbol was derived from.  */
3295               s->udata.p = syms[i];
3296               s++;
3297             }
3298         }
3299     }
3300   else
3301     {
3302       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303       bfd_byte *contents = NULL;
3304       size_t size;
3305       long plt_count = 0;
3306       bfd_vma glink_vma = 0, resolv_vma = 0;
3307       asection *dynamic, *glink = NULL, *relplt = NULL;
3308       arelent *p;
3309
3310       if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3311         {
3312         free_contents_and_exit:
3313           if (contents)
3314             free (contents);
3315           count = -1;
3316           goto done;
3317         }
3318
3319       size = 0;
3320       for (i = secsymend; i < opdsymend; ++i)
3321         {
3322           bfd_vma ent;
3323
3324           /* Ignore bogus symbols.  */
3325           if (syms[i]->value > opd->size - 8)
3326             continue;
3327
3328           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3330             {
3331               ++count;
3332               size += sizeof (asymbol);
3333               size += strlen (syms[i]->name) + 2;
3334             }
3335         }
3336
3337       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3338       if (dyn_count != 0
3339           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3340         {
3341           bfd_byte *dynbuf, *extdyn, *extdynend;
3342           size_t extdynsize;
3343           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3344
3345           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346             goto free_contents_and_exit;
3347
3348           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3350
3351           extdyn = dynbuf;
3352           extdynend = extdyn + dynamic->size;
3353           for (; extdyn < extdynend; extdyn += extdynsize)
3354             {
3355               Elf_Internal_Dyn dyn;
3356               (*swap_dyn_in) (abfd, extdyn, &dyn);
3357
3358               if (dyn.d_tag == DT_NULL)
3359                 break;
3360
3361               if (dyn.d_tag == DT_PPC64_GLINK)
3362                 {
3363                   /* The first glink stub starts at offset 32; see
3364                      comment in ppc64_elf_finish_dynamic_sections. */
3365                   glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366                   /* The .glink section usually does not survive the final
3367                      link; search for the section (usually .text) where the
3368                      glink stubs now reside.  */
3369                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3370                                                 &glink_vma);
3371                   break;
3372                 }
3373             }
3374
3375           free (dynbuf);
3376         }
3377
3378       if (glink != NULL)
3379         {
3380           /* Determine __glink trampoline by reading the relative branch
3381              from the first glink stub.  */
3382           bfd_byte buf[4];
3383           unsigned int off = 0;
3384
3385           while (bfd_get_section_contents (abfd, glink, buf,
3386                                            glink_vma + off - glink->vma, 4))
3387             {
3388               unsigned int insn = bfd_get_32 (abfd, buf);
3389               insn ^= B_DOT;
3390               if ((insn & ~0x3fffffc) == 0)
3391                 {
3392                   resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3393                   break;
3394                 }
3395               off += 4;
3396               if (off > 4)
3397                 break;
3398             }
3399
3400           if (resolv_vma)
3401             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3402
3403           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3404           if (relplt != NULL)
3405             {
3406               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408                 goto free_contents_and_exit;
3409
3410               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411               size += plt_count * sizeof (asymbol);
3412
3413               p = relplt->relocation;
3414               for (i = 0; i < plt_count; i++, p++)
3415                 {
3416                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3417                   if (p->addend != 0)
3418                     size += sizeof ("+0x") - 1 + 16;
3419                 }
3420             }
3421         }
3422
3423       s = *ret = bfd_malloc (size);
3424       if (s == NULL)
3425         goto free_contents_and_exit;
3426
3427       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3428
3429       for (i = secsymend; i < opdsymend; ++i)
3430         {
3431           bfd_vma ent;
3432
3433           if (syms[i]->value > opd->size - 8)
3434             continue;
3435
3436           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3438             {
3439               long lo, hi;
3440               size_t len;
3441               asection *sec = abfd->sections;
3442
3443               *s = *syms[i];
3444               lo = codesecsym;
3445               hi = codesecsymend;
3446               while (lo < hi)
3447                 {
3448                   long mid = (lo + hi) >> 1;
3449                   if (syms[mid]->section->vma < ent)
3450                     lo = mid + 1;
3451                   else if (syms[mid]->section->vma > ent)
3452                     hi = mid;
3453                   else
3454                     {
3455                       sec = syms[mid]->section;
3456                       break;
3457                     }
3458                 }
3459
3460               if (lo >= hi && lo > codesecsym)
3461                 sec = syms[lo - 1]->section;
3462
3463               for (; sec != NULL; sec = sec->next)
3464                 {
3465                   if (sec->vma > ent)
3466                     break;
3467                   /* SEC_LOAD may not be set if SEC is from a separate debug
3468                      info file.  */
3469                   if ((sec->flags & SEC_ALLOC) == 0)
3470                     break;
3471                   if ((sec->flags & SEC_CODE) != 0)
3472                     s->section = sec;
3473                 }
3474               s->flags |= BSF_SYNTHETIC;
3475               s->value = ent - s->section->vma;
3476               s->name = names;
3477               *names++ = '.';
3478               len = strlen (syms[i]->name);
3479               memcpy (names, syms[i]->name, len + 1);
3480               names += len + 1;
3481               /* Have udata.p point back to the original symbol this
3482                  synthetic symbol was derived from.  */
3483               s->udata.p = syms[i];
3484               s++;
3485             }
3486         }
3487       free (contents);
3488
3489       if (glink != NULL && relplt != NULL)
3490         {
3491           if (resolv_vma)
3492             {
3493               /* Add a symbol for the main glink trampoline.  */
3494               memset (s, 0, sizeof *s);
3495               s->the_bfd = abfd;
3496               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3497               s->section = glink;
3498               s->value = resolv_vma - glink->vma;
3499               s->name = names;
3500               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501               names += sizeof ("__glink_PLTresolve");
3502               s++;
3503               count++;
3504             }
3505
3506           /* FIXME: It would be very much nicer to put sym@plt on the
3507              stub rather than on the glink branch table entry.  The
3508              objdump disassembler would then use a sensible symbol
3509              name on plt calls.  The difficulty in doing so is
3510              a) finding the stubs, and,
3511              b) matching stubs against plt entries, and,
3512              c) there can be multiple stubs for a given plt entry.
3513
3514              Solving (a) could be done by code scanning, but older
3515              ppc64 binaries used different stubs to current code.
3516              (b) is the tricky one since you need to known the toc
3517              pointer for at least one function that uses a pic stub to
3518              be able to calculate the plt address referenced.
3519              (c) means gdb would need to set multiple breakpoints (or
3520              find the glink branch itself) when setting breakpoints
3521              for pending shared library loads.  */
3522           p = relplt->relocation;
3523           for (i = 0; i < plt_count; i++, p++)
3524             {
3525               size_t len;
3526
3527               *s = **p->sym_ptr_ptr;
3528               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3529                  we are defining a symbol, ensure one of them is set.  */
3530               if ((s->flags & BSF_LOCAL) == 0)
3531                 s->flags |= BSF_GLOBAL;
3532               s->flags |= BSF_SYNTHETIC;
3533               s->section = glink;
3534               s->value = glink_vma - glink->vma;
3535               s->name = names;
3536               s->udata.p = NULL;
3537               len = strlen ((*p->sym_ptr_ptr)->name);
3538               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3539               names += len;
3540               if (p->addend != 0)
3541                 {
3542                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3543                   names += sizeof ("+0x") - 1;
3544                   bfd_sprintf_vma (abfd, names, p->addend);
3545                   names += strlen (names);
3546                 }
3547               memcpy (names, "@plt", sizeof ("@plt"));
3548               names += sizeof ("@plt");
3549               s++;
3550               if (abi < 2)
3551                 {
3552                   glink_vma += 8;
3553                   if (i >= 0x8000)
3554                     glink_vma += 4;
3555                 }
3556               else
3557                 glink_vma += 4;
3558             }
3559           count += plt_count;
3560         }
3561     }
3562
3563  done:
3564   free (syms);
3565   return count;
3566 }
3567 \f
3568 /* The following functions are specific to the ELF linker, while
3569    functions above are used generally.  Those named ppc64_elf_* are
3570    called by the main ELF linker code.  They appear in this file more
3571    or less in the order in which they are called.  eg.
3572    ppc64_elf_check_relocs is called early in the link process,
3573    ppc64_elf_finish_dynamic_sections is one of the last functions
3574    called.
3575
3576    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577    functions have both a function code symbol and a function descriptor
3578    symbol.  A call to foo in a relocatable object file looks like:
3579
3580    .            .text
3581    .    x:
3582    .            bl      .foo
3583    .            nop
3584
3585    The function definition in another object file might be:
3586
3587    .            .section .opd
3588    .    foo:    .quad   .foo
3589    .            .quad   .TOC.@tocbase
3590    .            .quad   0
3591    .
3592    .            .text
3593    .    .foo:   blr
3594
3595    When the linker resolves the call during a static link, the branch
3596    unsurprisingly just goes to .foo and the .opd information is unused.
3597    If the function definition is in a shared library, things are a little
3598    different:  The call goes via a plt call stub, the opd information gets
3599    copied to the plt, and the linker patches the nop.
3600
3601    .    x:
3602    .            bl      .foo_stub
3603    .            ld      2,40(1)
3604    .
3605    .
3606    .    .foo_stub:
3607    .            std     2,40(1)                 # in practice, the call stub
3608    .            addis   11,2,Lfoo@toc@ha        # is slightly optimized, but
3609    .            addi    11,11,Lfoo@toc@l        # this is the general idea
3610    .            ld      12,0(11)
3611    .            ld      2,8(11)
3612    .            mtctr   12
3613    .            ld      11,16(11)
3614    .            bctr
3615    .
3616    .            .section .plt
3617    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3618
3619    The "reloc ()" notation is supposed to indicate that the linker emits
3620    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3621    copying.
3622
3623    What are the difficulties here?  Well, firstly, the relocations
3624    examined by the linker in check_relocs are against the function code
3625    sym .foo, while the dynamic relocation in the plt is emitted against
3626    the function descriptor symbol, foo.  Somewhere along the line, we need
3627    to carefully copy dynamic link information from one symbol to the other.
3628    Secondly, the generic part of the elf linker will make .foo a dynamic
3629    symbol as is normal for most other backends.  We need foo dynamic
3630    instead, at least for an application final link.  However, when
3631    creating a shared library containing foo, we need to have both symbols
3632    dynamic so that references to .foo are satisfied during the early
3633    stages of linking.  Otherwise the linker might decide to pull in a
3634    definition from some other object, eg. a static library.
3635
3636    Update: As of August 2004, we support a new convention.  Function
3637    calls may use the function descriptor symbol, ie. "bl foo".  This
3638    behaves exactly as "bl .foo".  */
3639
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641    selects those that must be copied when linking a shared library,
3642    even when the symbol is local.  */
3643
3644 static int
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646                    enum elf_ppc64_reloc_type r_type)
3647 {
3648   switch (r_type)
3649     {
3650     default:
3651       return 1;
3652
3653     case R_PPC64_REL32:
3654     case R_PPC64_REL64:
3655     case R_PPC64_REL30:
3656       return 0;
3657
3658     case R_PPC64_TPREL16:
3659     case R_PPC64_TPREL16_LO:
3660     case R_PPC64_TPREL16_HI:
3661     case R_PPC64_TPREL16_HA:
3662     case R_PPC64_TPREL16_DS:
3663     case R_PPC64_TPREL16_LO_DS:
3664     case R_PPC64_TPREL16_HIGH:
3665     case R_PPC64_TPREL16_HIGHA:
3666     case R_PPC64_TPREL16_HIGHER:
3667     case R_PPC64_TPREL16_HIGHERA:
3668     case R_PPC64_TPREL16_HIGHEST:
3669     case R_PPC64_TPREL16_HIGHESTA:
3670     case R_PPC64_TPREL64:
3671       return !info->executable;
3672     }
3673 }
3674
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676    copying dynamic variables from a shared lib into an app's dynbss
3677    section, and instead use a dynamic relocation to point into the
3678    shared lib.  With code that gcc generates, it's vital that this be
3679    enabled;  In the PowerPC64 ABI, the address of a function is actually
3680    the address of a function descriptor, which resides in the .opd
3681    section.  gcc uses the descriptor directly rather than going via the
3682    GOT as some other ABI's do, which means that initialized function
3683    pointers must reference the descriptor.  Thus, a function pointer
3684    initialized to the address of a function in a shared library will
3685    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3686    redefines the function descriptor symbol to point to the copy.  This
3687    presents a problem as a plt entry for that function is also
3688    initialized from the function descriptor symbol and the copy reloc
3689    may not be initialized first.  */
3690 #define ELIMINATE_COPY_RELOCS 1
3691
3692 /* Section name for stubs is the associated section name plus this
3693    string.  */
3694 #define STUB_SUFFIX ".stub"
3695
3696 /* Linker stubs.
3697    ppc_stub_long_branch:
3698    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699    destination, but a 24 bit branch in a stub section will reach.
3700    .    b       dest
3701
3702    ppc_stub_plt_branch:
3703    Similar to the above, but a 24 bit branch in the stub section won't
3704    reach its destination.
3705    .    addis   %r11,%r2,xxx@toc@ha
3706    .    ld      %r12,xxx@toc@l(%r11)
3707    .    mtctr   %r12
3708    .    bctr
3709
3710    ppc_stub_plt_call:
3711    Used to call a function in a shared library.  If it so happens that
3712    the plt entry referenced crosses a 64k boundary, then an extra
3713    "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3714    .    std     %r2,40(%r1)
3715    .    addis   %r11,%r2,xxx@toc@ha
3716    .    ld      %r12,xxx+0@toc@l(%r11)
3717    .    mtctr   %r12
3718    .    ld      %r2,xxx+8@toc@l(%r11)
3719    .    ld      %r11,xxx+16@toc@l(%r11)
3720    .    bctr
3721
3722    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723    code to adjust the value and save r2 to support multiple toc sections.
3724    A ppc_stub_long_branch with an r2 offset looks like:
3725    .    std     %r2,40(%r1)
3726    .    addis   %r2,%r2,off@ha
3727    .    addi    %r2,%r2,off@l
3728    .    b       dest
3729
3730    A ppc_stub_plt_branch with an r2 offset looks like:
3731    .    std     %r2,40(%r1)
3732    .    addis   %r11,%r2,xxx@toc@ha
3733    .    ld      %r12,xxx@toc@l(%r11)
3734    .    addis   %r2,%r2,off@ha
3735    .    addi    %r2,%r2,off@l
3736    .    mtctr   %r12
3737    .    bctr
3738
3739    In cases where the "addis" instruction would add zero, the "addis" is
3740    omitted and following instructions modified slightly in some cases.
3741 */
3742
3743 enum ppc_stub_type {
3744   ppc_stub_none,
3745   ppc_stub_long_branch,
3746   ppc_stub_long_branch_r2off,
3747   ppc_stub_plt_branch,
3748   ppc_stub_plt_branch_r2off,
3749   ppc_stub_plt_call,
3750   ppc_stub_plt_call_r2save
3751 };
3752
3753 struct ppc_stub_hash_entry {
3754
3755   /* Base hash table entry structure.  */
3756   struct bfd_hash_entry root;
3757
3758   enum ppc_stub_type stub_type;
3759
3760   /* The stub section.  */
3761   asection *stub_sec;
3762
3763   /* Offset within stub_sec of the beginning of this stub.  */
3764   bfd_vma stub_offset;
3765
3766   /* Given the symbol's value and its section we can determine its final
3767      value when building the stubs (so the stub knows where to jump.  */
3768   bfd_vma target_value;
3769   asection *target_section;
3770
3771   /* The symbol table entry, if any, that this was derived from.  */
3772   struct ppc_link_hash_entry *h;
3773   struct plt_entry *plt_ent;
3774
3775   /* Where this stub is being called from, or, in the case of combined
3776      stub sections, the first input section in the group.  */
3777   asection *id_sec;
3778
3779   /* Symbol st_other.  */
3780   unsigned char other;
3781 };
3782
3783 struct ppc_branch_hash_entry {
3784
3785   /* Base hash table entry structure.  */
3786   struct bfd_hash_entry root;
3787
3788   /* Offset within branch lookup table.  */
3789   unsigned int offset;
3790
3791   /* Generation marker.  */
3792   unsigned int iter;
3793 };
3794
3795 /* Used to track dynamic relocations for local symbols.  */
3796 struct ppc_dyn_relocs
3797 {
3798   struct ppc_dyn_relocs *next;
3799
3800   /* The input section of the reloc.  */
3801   asection *sec;
3802
3803   /* Total number of relocs copied for the input section.  */
3804   unsigned int count : 31;
3805
3806   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3807   unsigned int ifunc : 1;
3808 };
3809
3810 struct ppc_link_hash_entry
3811 {
3812   struct elf_link_hash_entry elf;
3813
3814   union {
3815     /* A pointer to the most recently used stub hash entry against this
3816        symbol.  */
3817     struct ppc_stub_hash_entry *stub_cache;
3818
3819     /* A pointer to the next symbol starting with a '.'  */
3820     struct ppc_link_hash_entry *next_dot_sym;
3821   } u;
3822
3823   /* Track dynamic relocs copied for this symbol.  */
3824   struct elf_dyn_relocs *dyn_relocs;
3825
3826   /* Link between function code and descriptor symbols.  */
3827   struct ppc_link_hash_entry *oh;
3828
3829   /* Flag function code and descriptor symbols.  */
3830   unsigned int is_func:1;
3831   unsigned int is_func_descriptor:1;
3832   unsigned int fake:1;
3833
3834   /* Whether global opd/toc sym has been adjusted or not.
3835      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836      should be set for all globals defined in any opd/toc section.  */
3837   unsigned int adjust_done:1;
3838
3839   /* Set if we twiddled this symbol to weak at some stage.  */
3840   unsigned int was_undefined:1;
3841
3842   /* Contexts in which symbol is used in the GOT (or TOC).
3843      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844      corresponding relocs are encountered during check_relocs.
3845      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846      indicate the corresponding GOT entry type is not needed.
3847      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848      a TPREL one.  We use a separate flag rather than setting TPREL
3849      just for convenience in distinguishing the two cases.  */
3850 #define TLS_GD           1      /* GD reloc. */
3851 #define TLS_LD           2      /* LD reloc. */
3852 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3853 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3854 #define TLS_TLS         16      /* Any TLS reloc.  */
3855 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3858   unsigned char tls_mask;
3859 };
3860
3861 /* ppc64 ELF linker hash table.  */
3862
3863 struct ppc_link_hash_table
3864 {
3865   struct elf_link_hash_table elf;
3866
3867   /* The stub hash table.  */
3868   struct bfd_hash_table stub_hash_table;
3869
3870   /* Another hash table for plt_branch stubs.  */
3871   struct bfd_hash_table branch_hash_table;
3872
3873   /* Hash table for function prologue tocsave.  */
3874   htab_t tocsave_htab;
3875
3876   /* Linker stub bfd.  */
3877   bfd *stub_bfd;
3878
3879   /* Linker call-backs.  */
3880   asection * (*add_stub_section) (const char *, asection *);
3881   void (*layout_sections_again) (void);
3882
3883   /* Array to keep track of which stub sections have been created, and
3884      information on stub grouping.  */
3885   struct map_stub {
3886     /* This is the section to which stubs in the group will be attached.  */
3887     asection *link_sec;
3888     /* The stub section.  */
3889     asection *stub_sec;
3890     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3891     bfd_vma toc_off;
3892   } *stub_group;
3893
3894   /* Temp used when calculating TOC pointers.  */
3895   bfd_vma toc_curr;
3896   bfd *toc_bfd;
3897   asection *toc_first_sec;
3898
3899   /* Highest input section id.  */
3900   int top_id;
3901
3902   /* Highest output section index.  */
3903   int top_index;
3904
3905   /* Used when adding symbols.  */
3906   struct ppc_link_hash_entry *dot_syms;
3907
3908   /* List of input sections for each output section.  */
3909   asection **input_list;
3910
3911   /* Shortcuts to get to dynamic linker sections.  */
3912   asection *dynbss;
3913   asection *relbss;
3914   asection *glink;
3915   asection *sfpr;
3916   asection *brlt;
3917   asection *relbrlt;
3918   asection *glink_eh_frame;
3919
3920   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3921   struct ppc_link_hash_entry *tls_get_addr;
3922   struct ppc_link_hash_entry *tls_get_addr_fd;
3923
3924   /* The size of reliplt used by got entry relocs.  */
3925   bfd_size_type got_reli_size;
3926
3927   /* Statistics.  */
3928   unsigned long stub_count[ppc_stub_plt_call_r2save];
3929
3930   /* Number of stubs against global syms.  */
3931   unsigned long stub_globals;
3932
3933   /* Alignment of PLT call stubs.  */
3934   unsigned int plt_stub_align:4;
3935
3936   /* Set if we're linking code with function descriptors.  */
3937   unsigned int opd_abi:1;
3938
3939   /* Set if PLT call stubs should load r11.  */
3940   unsigned int plt_static_chain:1;
3941
3942   /* Set if PLT call stubs need a read-read barrier.  */
3943   unsigned int plt_thread_safe:1;
3944
3945   /* Set if we should emit symbols for stubs.  */
3946   unsigned int emit_stub_syms:1;
3947
3948   /* Set if __tls_get_addr optimization should not be done.  */
3949   unsigned int no_tls_get_addr_opt:1;
3950
3951   /* Support for multiple toc sections.  */
3952   unsigned int do_multi_toc:1;
3953   unsigned int multi_toc_needed:1;
3954   unsigned int second_toc_pass:1;
3955   unsigned int do_toc_opt:1;
3956
3957   /* Set on error.  */
3958   unsigned int stub_error:1;
3959
3960   /* Temp used by ppc64_elf_process_dot_syms.  */
3961   unsigned int twiddled_syms:1;
3962
3963   /* Incremented every time we size stubs.  */
3964   unsigned int stub_iteration;
3965
3966   /* Small local sym cache.  */
3967   struct sym_cache sym_cache;
3968 };
3969
3970 /* Rename some of the generic section flags to better document how they
3971    are used here.  */
3972
3973 /* Nonzero if this section has TLS related relocations.  */
3974 #define has_tls_reloc sec_flg0
3975
3976 /* Nonzero if this section has a call to __tls_get_addr.  */
3977 #define has_tls_get_addr_call sec_flg1
3978
3979 /* Nonzero if this section has any toc or got relocs.  */
3980 #define has_toc_reloc sec_flg2
3981
3982 /* Nonzero if this section has a call to another section that uses
3983    the toc or got.  */
3984 #define makes_toc_func_call sec_flg3
3985
3986 /* Recursion protection when determining above flag.  */
3987 #define call_check_in_progress sec_flg4
3988 #define call_check_done sec_flg5
3989
3990 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3991
3992 #define ppc_hash_table(p) \
3993   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3994   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3995
3996 #define ppc_stub_hash_lookup(table, string, create, copy) \
3997   ((struct ppc_stub_hash_entry *) \
3998    bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 #define ppc_branch_hash_lookup(table, string, create, copy) \
4001   ((struct ppc_branch_hash_entry *) \
4002    bfd_hash_lookup ((table), (string), (create), (copy)))
4003
4004 /* Create an entry in the stub hash table.  */
4005
4006 static struct bfd_hash_entry *
4007 stub_hash_newfunc (struct bfd_hash_entry *entry,
4008                    struct bfd_hash_table *table,
4009                    const char *string)
4010 {
4011   /* Allocate the structure if it has not already been allocated by a
4012      subclass.  */
4013   if (entry == NULL)
4014     {
4015       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016       if (entry == NULL)
4017         return entry;
4018     }
4019
4020   /* Call the allocation method of the superclass.  */
4021   entry = bfd_hash_newfunc (entry, table, string);
4022   if (entry != NULL)
4023     {
4024       struct ppc_stub_hash_entry *eh;
4025
4026       /* Initialize the local fields.  */
4027       eh = (struct ppc_stub_hash_entry *) entry;
4028       eh->stub_type = ppc_stub_none;
4029       eh->stub_sec = NULL;
4030       eh->stub_offset = 0;
4031       eh->target_value = 0;
4032       eh->target_section = NULL;
4033       eh->h = NULL;
4034       eh->plt_ent = NULL;
4035       eh->id_sec = NULL;
4036       eh->other = 0;
4037     }
4038
4039   return entry;
4040 }
4041
4042 /* Create an entry in the branch hash table.  */
4043
4044 static struct bfd_hash_entry *
4045 branch_hash_newfunc (struct bfd_hash_entry *entry,
4046                      struct bfd_hash_table *table,
4047                      const char *string)
4048 {
4049   /* Allocate the structure if it has not already been allocated by a
4050      subclass.  */
4051   if (entry == NULL)
4052     {
4053       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054       if (entry == NULL)
4055         return entry;
4056     }
4057
4058   /* Call the allocation method of the superclass.  */
4059   entry = bfd_hash_newfunc (entry, table, string);
4060   if (entry != NULL)
4061     {
4062       struct ppc_branch_hash_entry *eh;
4063
4064       /* Initialize the local fields.  */
4065       eh = (struct ppc_branch_hash_entry *) entry;
4066       eh->offset = 0;
4067       eh->iter = 0;
4068     }
4069
4070   return entry;
4071 }
4072
4073 /* Create an entry in a ppc64 ELF linker hash table.  */
4074
4075 static struct bfd_hash_entry *
4076 link_hash_newfunc (struct bfd_hash_entry *entry,
4077                    struct bfd_hash_table *table,
4078                    const char *string)
4079 {
4080   /* Allocate the structure if it has not already been allocated by a
4081      subclass.  */
4082   if (entry == NULL)
4083     {
4084       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085       if (entry == NULL)
4086         return entry;
4087     }
4088
4089   /* Call the allocation method of the superclass.  */
4090   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4091   if (entry != NULL)
4092     {
4093       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4094
4095       memset (&eh->u.stub_cache, 0,
4096               (sizeof (struct ppc_link_hash_entry)
4097                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4098
4099       /* When making function calls, old ABI code references function entry
4100          points (dot symbols), while new ABI code references the function
4101          descriptor symbol.  We need to make any combination of reference and
4102          definition work together, without breaking archive linking.
4103
4104          For a defined function "foo" and an undefined call to "bar":
4105          An old object defines "foo" and ".foo", references ".bar" (possibly
4106          "bar" too).
4107          A new object defines "foo" and references "bar".
4108
4109          A new object thus has no problem with its undefined symbols being
4110          satisfied by definitions in an old object.  On the other hand, the
4111          old object won't have ".bar" satisfied by a new object.
4112
4113          Keep a list of newly added dot-symbols.  */
4114
4115       if (string[0] == '.')
4116         {
4117           struct ppc_link_hash_table *htab;
4118
4119           htab = (struct ppc_link_hash_table *) table;
4120           eh->u.next_dot_sym = htab->dot_syms;
4121           htab->dot_syms = eh;
4122         }
4123     }
4124
4125   return entry;
4126 }
4127
4128 struct tocsave_entry {
4129   asection *sec;
4130   bfd_vma offset;
4131 };
4132
4133 static hashval_t
4134 tocsave_htab_hash (const void *p)
4135 {
4136   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4137   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4138 }
4139
4140 static int
4141 tocsave_htab_eq (const void *p1, const void *p2)
4142 {
4143   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4144   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4145   return e1->sec == e2->sec && e1->offset == e2->offset;
4146 }
4147
4148 /* Create a ppc64 ELF linker hash table.  */
4149
4150 static struct bfd_link_hash_table *
4151 ppc64_elf_link_hash_table_create (bfd *abfd)
4152 {
4153   struct ppc_link_hash_table *htab;
4154   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4155
4156   htab = bfd_zmalloc (amt);
4157   if (htab == NULL)
4158     return NULL;
4159
4160   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4161                                       sizeof (struct ppc_link_hash_entry),
4162                                       PPC64_ELF_DATA))
4163     {
4164       free (htab);
4165       return NULL;
4166     }
4167
4168   /* Init the stub hash table too.  */
4169   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4170                             sizeof (struct ppc_stub_hash_entry)))
4171     {
4172       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4173       return NULL;
4174     }
4175
4176   /* And the branch hash table.  */
4177   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4178                             sizeof (struct ppc_branch_hash_entry)))
4179     {
4180       bfd_hash_table_free (&htab->stub_hash_table);
4181       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4182       return NULL;
4183     }
4184
4185   htab->tocsave_htab = htab_try_create (1024,
4186                                         tocsave_htab_hash,
4187                                         tocsave_htab_eq,
4188                                         NULL);
4189   if (htab->tocsave_htab == NULL)
4190     {
4191       bfd_hash_table_free (&htab->branch_hash_table);
4192       bfd_hash_table_free (&htab->stub_hash_table);
4193       _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4194       return NULL;
4195     }
4196
4197   /* Initializing two fields of the union is just cosmetic.  We really
4198      only care about glist, but when compiled on a 32-bit host the
4199      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4200      debugger inspection of these fields look nicer.  */
4201   htab->elf.init_got_refcount.refcount = 0;
4202   htab->elf.init_got_refcount.glist = NULL;
4203   htab->elf.init_plt_refcount.refcount = 0;
4204   htab->elf.init_plt_refcount.glist = NULL;
4205   htab->elf.init_got_offset.offset = 0;
4206   htab->elf.init_got_offset.glist = NULL;
4207   htab->elf.init_plt_offset.offset = 0;
4208   htab->elf.init_plt_offset.glist = NULL;
4209
4210   return &htab->elf.root;
4211 }
4212
4213 /* Free the derived linker hash table.  */
4214
4215 static void
4216 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4217 {
4218   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4219
4220   bfd_hash_table_free (&htab->stub_hash_table);
4221   bfd_hash_table_free (&htab->branch_hash_table);
4222   if (htab->tocsave_htab)
4223     htab_delete (htab->tocsave_htab);
4224   _bfd_elf_link_hash_table_free (hash);
4225 }
4226
4227 /* Create sections for linker generated code.  */
4228
4229 static bfd_boolean
4230 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4231 {
4232   struct ppc_link_hash_table *htab;
4233   flagword flags;
4234
4235   htab = ppc_hash_table (info);
4236
4237   /* Create .sfpr for code to save and restore fp regs.  */
4238   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4239            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4240   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4241                                                    flags);
4242   if (htab->sfpr == NULL
4243       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4244     return FALSE;
4245
4246   /* Create .glink for lazy dynamic linking support.  */
4247   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4248                                                     flags);
4249   if (htab->glink == NULL
4250       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4251     return FALSE;
4252
4253   if (!info->no_ld_generated_unwind_info)
4254     {
4255       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4256                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4257       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4258                                                                  ".eh_frame",
4259                                                                  flags);
4260       if (htab->glink_eh_frame == NULL
4261           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4262         return FALSE;
4263     }
4264
4265   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4266   htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4267   if (htab->elf.iplt == NULL
4268       || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4269     return FALSE;
4270
4271   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4272            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4273   htab->elf.irelplt
4274     = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4275   if (htab->elf.irelplt == NULL
4276       || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4277     return FALSE;
4278
4279   /* Create branch lookup table for plt_branch stubs.  */
4280   flags = (SEC_ALLOC | SEC_LOAD
4281            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4282   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4283                                                    flags);
4284   if (htab->brlt == NULL
4285       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4286     return FALSE;
4287
4288   if (!info->shared)
4289     return TRUE;
4290
4291   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4292            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4293   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4294                                                       ".rela.branch_lt",
4295                                                       flags);
4296   if (htab->relbrlt == NULL
4297       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4298     return FALSE;
4299
4300   return TRUE;
4301 }
4302
4303 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4304
4305 bfd_boolean
4306 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4307 {
4308   struct ppc_link_hash_table *htab;
4309
4310   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4311
4312 /* Always hook our dynamic sections into the first bfd, which is the
4313    linker created stub bfd.  This ensures that the GOT header is at
4314    the start of the output TOC section.  */
4315   htab = ppc_hash_table (info);
4316   if (htab == NULL)
4317     return FALSE;
4318   htab->stub_bfd = abfd;
4319   htab->elf.dynobj = abfd;
4320
4321   if (info->relocatable)
4322     return TRUE;
4323
4324   return create_linkage_sections (htab->elf.dynobj, info);
4325 }
4326
4327 /* Build a name for an entry in the stub hash table.  */
4328
4329 static char *
4330 ppc_stub_name (const asection *input_section,
4331                const asection *sym_sec,
4332                const struct ppc_link_hash_entry *h,
4333                const Elf_Internal_Rela *rel)
4334 {
4335   char *stub_name;
4336   ssize_t len;
4337
4338   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4339      offsets from a sym as a branch target?  In fact, we could
4340      probably assume the addend is always zero.  */
4341   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4342
4343   if (h)
4344     {
4345       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4346       stub_name = bfd_malloc (len);
4347       if (stub_name == NULL)
4348         return stub_name;
4349
4350       len = sprintf (stub_name, "%08x.%s+%x",
4351                      input_section->id & 0xffffffff,
4352                      h->elf.root.root.string,
4353                      (int) rel->r_addend & 0xffffffff);
4354     }
4355   else
4356     {
4357       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4358       stub_name = bfd_malloc (len);
4359       if (stub_name == NULL)
4360         return stub_name;
4361
4362       len = sprintf (stub_name, "%08x.%x:%x+%x",
4363                      input_section->id & 0xffffffff,
4364                      sym_sec->id & 0xffffffff,
4365                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4366                      (int) rel->r_addend & 0xffffffff);
4367     }
4368   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4369     stub_name[len - 2] = 0;
4370   return stub_name;
4371 }
4372
4373 /* Look up an entry in the stub hash.  Stub entries are cached because
4374    creating the stub name takes a bit of time.  */
4375
4376 static struct ppc_stub_hash_entry *
4377 ppc_get_stub_entry (const asection *input_section,
4378                     const asection *sym_sec,
4379                     struct ppc_link_hash_entry *h,
4380                     const Elf_Internal_Rela *rel,
4381                     struct ppc_link_hash_table *htab)
4382 {
4383   struct ppc_stub_hash_entry *stub_entry;
4384   const asection *id_sec;
4385
4386   /* If this input section is part of a group of sections sharing one
4387      stub section, then use the id of the first section in the group.
4388      Stub names need to include a section id, as there may well be
4389      more than one stub used to reach say, printf, and we need to
4390      distinguish between them.  */
4391   id_sec = htab->stub_group[input_section->id].link_sec;
4392
4393   if (h != NULL && h->u.stub_cache != NULL
4394       && h->u.stub_cache->h == h
4395       && h->u.stub_cache->id_sec == id_sec)
4396     {
4397       stub_entry = h->u.stub_cache;
4398     }
4399   else
4400     {
4401       char *stub_name;
4402
4403       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4404       if (stub_name == NULL)
4405         return NULL;
4406
4407       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4408                                          stub_name, FALSE, FALSE);
4409       if (h != NULL)
4410         h->u.stub_cache = stub_entry;
4411
4412       free (stub_name);
4413     }
4414
4415   return stub_entry;
4416 }
4417
4418 /* Add a new stub entry to the stub hash.  Not all fields of the new
4419    stub entry are initialised.  */
4420
4421 static struct ppc_stub_hash_entry *
4422 ppc_add_stub (const char *stub_name,
4423               asection *section,
4424               struct bfd_link_info *info)
4425 {
4426   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4427   asection *link_sec;
4428   asection *stub_sec;
4429   struct ppc_stub_hash_entry *stub_entry;
4430
4431   link_sec = htab->stub_group[section->id].link_sec;
4432   stub_sec = htab->stub_group[section->id].stub_sec;
4433   if (stub_sec == NULL)
4434     {
4435       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4436       if (stub_sec == NULL)
4437         {
4438           size_t namelen;
4439           bfd_size_type len;
4440           char *s_name;
4441
4442           namelen = strlen (link_sec->name);
4443           len = namelen + sizeof (STUB_SUFFIX);
4444           s_name = bfd_alloc (htab->stub_bfd, len);
4445           if (s_name == NULL)
4446             return NULL;
4447
4448           memcpy (s_name, link_sec->name, namelen);
4449           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4450           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4451           if (stub_sec == NULL)
4452             return NULL;
4453           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4454         }
4455       htab->stub_group[section->id].stub_sec = stub_sec;
4456     }
4457
4458   /* Enter this entry into the linker stub hash table.  */
4459   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4460                                      TRUE, FALSE);
4461   if (stub_entry == NULL)
4462     {
4463       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4464                               section->owner, stub_name);
4465       return NULL;
4466     }
4467
4468   stub_entry->stub_sec = stub_sec;
4469   stub_entry->stub_offset = 0;
4470   stub_entry->id_sec = link_sec;
4471   return stub_entry;
4472 }
4473
4474 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4475    not already done.  */
4476
4477 static bfd_boolean
4478 create_got_section (bfd *abfd, struct bfd_link_info *info)
4479 {
4480   asection *got, *relgot;
4481   flagword flags;
4482   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4483
4484   if (!is_ppc64_elf (abfd))
4485     return FALSE;
4486   if (htab == NULL)
4487     return FALSE;
4488
4489   if (!htab->elf.sgot
4490       && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4491     return FALSE;
4492
4493   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4494            | SEC_LINKER_CREATED);
4495
4496   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4497   if (!got
4498       || !bfd_set_section_alignment (abfd, got, 3))
4499     return FALSE;
4500
4501   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4502                                                flags | SEC_READONLY);
4503   if (!relgot
4504       || ! bfd_set_section_alignment (abfd, relgot, 3))
4505     return FALSE;
4506
4507   ppc64_elf_tdata (abfd)->got = got;
4508   ppc64_elf_tdata (abfd)->relgot = relgot;
4509   return TRUE;
4510 }
4511
4512 /* Create the dynamic sections, and set up shortcuts.  */
4513
4514 static bfd_boolean
4515 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4516 {
4517   struct ppc_link_hash_table *htab;
4518
4519   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4520     return FALSE;
4521
4522   htab = ppc_hash_table (info);
4523   if (htab == NULL)
4524     return FALSE;
4525
4526   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4527   if (!info->shared)
4528     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4529
4530   if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4531       || (!info->shared && !htab->relbss))
4532     abort ();
4533
4534   return TRUE;
4535 }
4536
4537 /* Follow indirect and warning symbol links.  */
4538
4539 static inline struct bfd_link_hash_entry *
4540 follow_link (struct bfd_link_hash_entry *h)
4541 {
4542   while (h->type == bfd_link_hash_indirect
4543          || h->type == bfd_link_hash_warning)
4544     h = h->u.i.link;
4545   return h;
4546 }
4547
4548 static inline struct elf_link_hash_entry *
4549 elf_follow_link (struct elf_link_hash_entry *h)
4550 {
4551   return (struct elf_link_hash_entry *) follow_link (&h->root);
4552 }
4553
4554 static inline struct ppc_link_hash_entry *
4555 ppc_follow_link (struct ppc_link_hash_entry *h)
4556 {
4557   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4558 }
4559
4560 /* Merge PLT info on FROM with that on TO.  */
4561
4562 static void
4563 move_plt_plist (struct ppc_link_hash_entry *from,
4564                 struct ppc_link_hash_entry *to)
4565 {
4566   if (from->elf.plt.plist != NULL)
4567     {
4568       if (to->elf.plt.plist != NULL)
4569         {
4570           struct plt_entry **entp;
4571           struct plt_entry *ent;
4572
4573           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4574             {
4575               struct plt_entry *dent;
4576
4577               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4578                 if (dent->addend == ent->addend)
4579                   {
4580                     dent->plt.refcount += ent->plt.refcount;
4581                     *entp = ent->next;
4582                     break;
4583                   }
4584               if (dent == NULL)
4585                 entp = &ent->next;
4586             }
4587           *entp = to->elf.plt.plist;
4588         }
4589
4590       to->elf.plt.plist = from->elf.plt.plist;
4591       from->elf.plt.plist = NULL;
4592     }
4593 }
4594
4595 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4596
4597 static void
4598 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4599                                 struct elf_link_hash_entry *dir,
4600                                 struct elf_link_hash_entry *ind)
4601 {
4602   struct ppc_link_hash_entry *edir, *eind;
4603
4604   edir = (struct ppc_link_hash_entry *) dir;
4605   eind = (struct ppc_link_hash_entry *) ind;
4606
4607   edir->is_func |= eind->is_func;
4608   edir->is_func_descriptor |= eind->is_func_descriptor;
4609   edir->tls_mask |= eind->tls_mask;
4610   if (eind->oh != NULL)
4611     edir->oh = ppc_follow_link (eind->oh);
4612
4613   /* If called to transfer flags for a weakdef during processing
4614      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4615      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4616   if (!(ELIMINATE_COPY_RELOCS
4617         && eind->elf.root.type != bfd_link_hash_indirect
4618         && edir->elf.dynamic_adjusted))
4619     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4620
4621   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4622   edir->elf.ref_regular |= eind->elf.ref_regular;
4623   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4624   edir->elf.needs_plt |= eind->elf.needs_plt;
4625   edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4626
4627   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4628   if (eind->dyn_relocs != NULL)
4629     {
4630       if (edir->dyn_relocs != NULL)
4631         {
4632           struct elf_dyn_relocs **pp;
4633           struct elf_dyn_relocs *p;
4634
4635           /* Add reloc counts against the indirect sym to the direct sym
4636              list.  Merge any entries against the same section.  */
4637           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4638             {
4639               struct elf_dyn_relocs *q;
4640
4641               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4642                 if (q->sec == p->sec)
4643                   {
4644                     q->pc_count += p->pc_count;
4645                     q->count += p->count;
4646                     *pp = p->next;
4647                     break;
4648                   }
4649               if (q == NULL)
4650                 pp = &p->next;
4651             }
4652           *pp = edir->dyn_relocs;
4653         }
4654
4655       edir->dyn_relocs = eind->dyn_relocs;
4656       eind->dyn_relocs = NULL;
4657     }
4658
4659   /* If we were called to copy over info for a weak sym, that's all.
4660      You might think dyn_relocs need not be copied over;  After all,
4661      both syms will be dynamic or both non-dynamic so we're just
4662      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4663      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4664      dyn_relocs in read-only sections, and it does so on what is the
4665      DIR sym here.  */
4666   if (eind->elf.root.type != bfd_link_hash_indirect)
4667     return;
4668
4669   /* Copy over got entries that we may have already seen to the
4670      symbol which just became indirect.  */
4671   if (eind->elf.got.glist != NULL)
4672     {
4673       if (edir->elf.got.glist != NULL)
4674         {
4675           struct got_entry **entp;
4676           struct got_entry *ent;
4677
4678           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4679             {
4680               struct got_entry *dent;
4681
4682               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4683                 if (dent->addend == ent->addend
4684                     && dent->owner == ent->owner
4685                     && dent->tls_type == ent->tls_type)
4686                   {
4687                     dent->got.refcount += ent->got.refcount;
4688                     *entp = ent->next;
4689                     break;
4690                   }
4691               if (dent == NULL)
4692                 entp = &ent->next;
4693             }
4694           *entp = edir->elf.got.glist;
4695         }
4696
4697       edir->elf.got.glist = eind->elf.got.glist;
4698       eind->elf.got.glist = NULL;
4699     }
4700
4701   /* And plt entries.  */
4702   move_plt_plist (eind, edir);
4703
4704   if (eind->elf.dynindx != -1)
4705     {
4706       if (edir->elf.dynindx != -1)
4707         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4708                                 edir->elf.dynstr_index);
4709       edir->elf.dynindx = eind->elf.dynindx;
4710       edir->elf.dynstr_index = eind->elf.dynstr_index;
4711       eind->elf.dynindx = -1;
4712       eind->elf.dynstr_index = 0;
4713     }
4714 }
4715
4716 /* Find the function descriptor hash entry from the given function code
4717    hash entry FH.  Link the entries via their OH fields.  */
4718
4719 static struct ppc_link_hash_entry *
4720 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4721 {
4722   struct ppc_link_hash_entry *fdh = fh->oh;
4723
4724   if (fdh == NULL)
4725     {
4726       const char *fd_name = fh->elf.root.root.string + 1;
4727
4728       fdh = (struct ppc_link_hash_entry *)
4729         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4730       if (fdh == NULL)
4731         return fdh;
4732
4733       fdh->is_func_descriptor = 1;
4734       fdh->oh = fh;
4735       fh->is_func = 1;
4736       fh->oh = fdh;
4737     }
4738
4739   return ppc_follow_link (fdh);
4740 }
4741
4742 /* Make a fake function descriptor sym for the code sym FH.  */
4743
4744 static struct ppc_link_hash_entry *
4745 make_fdh (struct bfd_link_info *info,
4746           struct ppc_link_hash_entry *fh)
4747 {
4748   bfd *abfd;
4749   asymbol *newsym;
4750   struct bfd_link_hash_entry *bh;
4751   struct ppc_link_hash_entry *fdh;
4752
4753   abfd = fh->elf.root.u.undef.abfd;
4754   newsym = bfd_make_empty_symbol (abfd);
4755   newsym->name = fh->elf.root.root.string + 1;
4756   newsym->section = bfd_und_section_ptr;
4757   newsym->value = 0;
4758   newsym->flags = BSF_WEAK;
4759
4760   bh = NULL;
4761   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4762                                          newsym->flags, newsym->section,
4763                                          newsym->value, NULL, FALSE, FALSE,
4764                                          &bh))
4765     return NULL;
4766
4767   fdh = (struct ppc_link_hash_entry *) bh;
4768   fdh->elf.non_elf = 0;
4769   fdh->fake = 1;
4770   fdh->is_func_descriptor = 1;
4771   fdh->oh = fh;
4772   fh->is_func = 1;
4773   fh->oh = fdh;
4774   return fdh;
4775 }
4776
4777 /* Fix function descriptor symbols defined in .opd sections to be
4778    function type.  */
4779
4780 static bfd_boolean
4781 ppc64_elf_add_symbol_hook (bfd *ibfd,
4782                            struct bfd_link_info *info,
4783                            Elf_Internal_Sym *isym,
4784                            const char **name,
4785                            flagword *flags ATTRIBUTE_UNUSED,
4786                            asection **sec,
4787                            bfd_vma *value ATTRIBUTE_UNUSED)
4788 {
4789   if ((ibfd->flags & DYNAMIC) == 0
4790       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4791     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4792
4793   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4794     {
4795       if ((ibfd->flags & DYNAMIC) == 0)
4796         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4797     }
4798   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4799     ;
4800   else if (*sec != NULL
4801            && strcmp ((*sec)->name, ".opd") == 0)
4802     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4803
4804   if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4805     {
4806       if (abiversion (ibfd) == 0)
4807         set_abiversion (ibfd, 2);
4808       else if (abiversion (ibfd) == 1)
4809         {
4810           info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4811                                     " for ABI version 1\n"), name);
4812           bfd_set_error (bfd_error_bad_value);
4813           return FALSE;
4814         }
4815     }
4816
4817   return TRUE;
4818 }
4819
4820 /* Merge non-visibility st_other attributes: local entry point.  */
4821
4822 static void
4823 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4824                                   const Elf_Internal_Sym *isym,
4825                                   bfd_boolean definition,
4826                                   bfd_boolean dynamic)
4827 {
4828   if (definition && !dynamic)
4829     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4830                 | ELF_ST_VISIBILITY (h->other));
4831 }
4832
4833 /* This function makes an old ABI object reference to ".bar" cause the
4834    inclusion of a new ABI object archive that defines "bar".
4835    NAME is a symbol defined in an archive.  Return a symbol in the hash
4836    table that might be satisfied by the archive symbols.  */
4837
4838 static struct elf_link_hash_entry *
4839 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4840                                  struct bfd_link_info *info,
4841                                  const char *name)
4842 {
4843   struct elf_link_hash_entry *h;
4844   char *dot_name;
4845   size_t len;
4846
4847   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4848   if (h != NULL
4849       /* Don't return this sym if it is a fake function descriptor
4850          created by add_symbol_adjust.  */
4851       && !(h->root.type == bfd_link_hash_undefweak
4852            && ((struct ppc_link_hash_entry *) h)->fake))
4853     return h;
4854
4855   if (name[0] == '.')
4856     return h;
4857
4858   len = strlen (name);
4859   dot_name = bfd_alloc (abfd, len + 2);
4860   if (dot_name == NULL)
4861     return (struct elf_link_hash_entry *) 0 - 1;
4862   dot_name[0] = '.';
4863   memcpy (dot_name + 1, name, len + 1);
4864   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4865   bfd_release (abfd, dot_name);
4866   return h;
4867 }
4868
4869 /* This function satisfies all old ABI object references to ".bar" if a
4870    new ABI object defines "bar".  Well, at least, undefined dot symbols
4871    are made weak.  This stops later archive searches from including an
4872    object if we already have a function descriptor definition.  It also
4873    prevents the linker complaining about undefined symbols.
4874    We also check and correct mismatched symbol visibility here.  The
4875    most restrictive visibility of the function descriptor and the
4876    function entry symbol is used.  */
4877
4878 static bfd_boolean
4879 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4880 {
4881   struct ppc_link_hash_table *htab;
4882   struct ppc_link_hash_entry *fdh;
4883
4884   if (eh->elf.root.type == bfd_link_hash_indirect)
4885     return TRUE;
4886
4887   if (eh->elf.root.type == bfd_link_hash_warning)
4888     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4889
4890   if (eh->elf.root.root.string[0] != '.')
4891     abort ();
4892
4893   htab = ppc_hash_table (info);
4894   if (htab == NULL)
4895     return FALSE;
4896
4897   fdh = lookup_fdh (eh, htab);
4898   if (fdh == NULL)
4899     {
4900       if (!info->relocatable
4901           && (eh->elf.root.type == bfd_link_hash_undefined
4902               || eh->elf.root.type == bfd_link_hash_undefweak)
4903           && eh->elf.ref_regular)
4904         {
4905           /* Make an undefweak function descriptor sym, which is enough to
4906              pull in an --as-needed shared lib, but won't cause link
4907              errors.  Archives are handled elsewhere.  */
4908           fdh = make_fdh (info, eh);
4909           if (fdh == NULL)
4910             return FALSE;
4911           fdh->elf.ref_regular = 1;
4912         }
4913     }
4914   else
4915     {
4916       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4917       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4918       if (entry_vis < descr_vis)
4919         fdh->elf.other += entry_vis - descr_vis;
4920       else if (entry_vis > descr_vis)
4921         eh->elf.other += descr_vis - entry_vis;
4922
4923       if ((fdh->elf.root.type == bfd_link_hash_defined
4924            || fdh->elf.root.type == bfd_link_hash_defweak)
4925           && eh->elf.root.type == bfd_link_hash_undefined)
4926         {
4927           eh->elf.root.type = bfd_link_hash_undefweak;
4928           eh->was_undefined = 1;
4929           htab->twiddled_syms = 1;
4930         }
4931     }
4932
4933   return TRUE;
4934 }
4935
4936 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4937
4938 static bfd_boolean
4939 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4940 {
4941   struct ppc_link_hash_table *htab;
4942   struct ppc_link_hash_entry **p, *eh;
4943
4944   if (!is_ppc64_elf (info->output_bfd))
4945     return TRUE;
4946   htab = ppc_hash_table (info);
4947   if (htab == NULL)
4948     return FALSE;
4949
4950   if (is_ppc64_elf (ibfd))
4951     {
4952       p = &htab->dot_syms;
4953       while ((eh = *p) != NULL)
4954         {
4955           *p = NULL;
4956           if (&eh->elf == htab->elf.hgot)
4957             ;
4958           else if (htab->elf.hgot == NULL
4959                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4960             htab->elf.hgot = &eh->elf;
4961           else if (!add_symbol_adjust (eh, info))
4962             return FALSE;
4963           p = &eh->u.next_dot_sym;
4964         }
4965     }
4966
4967   /* Clear the list for non-ppc64 input files.  */
4968   p = &htab->dot_syms;
4969   while ((eh = *p) != NULL)
4970     {
4971       *p = NULL;
4972       p = &eh->u.next_dot_sym;
4973     }
4974
4975   /* We need to fix the undefs list for any syms we have twiddled to
4976      undef_weak.  */
4977   if (htab->twiddled_syms)
4978     {
4979       bfd_link_repair_undef_list (&htab->elf.root);
4980       htab->twiddled_syms = 0;
4981     }
4982   return TRUE;
4983 }
4984
4985 /* Undo hash table changes when an --as-needed input file is determined
4986    not to be needed.  */
4987
4988 static bfd_boolean
4989 ppc64_elf_notice_as_needed (bfd *ibfd,
4990                             struct bfd_link_info *info,
4991                             enum notice_asneeded_action act)
4992 {
4993   if (act == notice_not_needed)
4994     {
4995       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4996
4997       if (htab == NULL)
4998         return FALSE;
4999
5000       htab->dot_syms = NULL;
5001     }
5002   return _bfd_elf_notice_as_needed (ibfd, info, act);
5003 }
5004
5005 /* If --just-symbols against a final linked binary, then assume we need
5006    toc adjusting stubs when calling functions defined there.  */
5007
5008 static void
5009 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5010 {
5011   if ((sec->flags & SEC_CODE) != 0
5012       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5013       && is_ppc64_elf (sec->owner))
5014     {
5015       if (abiversion (sec->owner) >= 2
5016           || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5017         sec->has_toc_reloc = 1;
5018     }
5019   _bfd_elf_link_just_syms (sec, info);
5020 }
5021
5022 static struct plt_entry **
5023 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5024                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5025 {
5026   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5027   struct plt_entry **local_plt;
5028   unsigned char *local_got_tls_masks;
5029
5030   if (local_got_ents == NULL)
5031     {
5032       bfd_size_type size = symtab_hdr->sh_info;
5033
5034       size *= (sizeof (*local_got_ents)
5035                + sizeof (*local_plt)
5036                + sizeof (*local_got_tls_masks));
5037       local_got_ents = bfd_zalloc (abfd, size);
5038       if (local_got_ents == NULL)
5039         return NULL;
5040       elf_local_got_ents (abfd) = local_got_ents;
5041     }
5042
5043   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5044     {
5045       struct got_entry *ent;
5046
5047       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5048         if (ent->addend == r_addend
5049             && ent->owner == abfd
5050             && ent->tls_type == tls_type)
5051           break;
5052       if (ent == NULL)
5053         {
5054           bfd_size_type amt = sizeof (*ent);
5055           ent = bfd_alloc (abfd, amt);
5056           if (ent == NULL)
5057             return FALSE;
5058           ent->next = local_got_ents[r_symndx];
5059           ent->addend = r_addend;
5060           ent->owner = abfd;
5061           ent->tls_type = tls_type;
5062           ent->is_indirect = FALSE;
5063           ent->got.refcount = 0;
5064           local_got_ents[r_symndx] = ent;
5065         }
5066       ent->got.refcount += 1;
5067     }
5068
5069   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5070   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5071   local_got_tls_masks[r_symndx] |= tls_type;
5072
5073   return local_plt + r_symndx;
5074 }
5075
5076 static bfd_boolean
5077 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5078 {
5079   struct plt_entry *ent;
5080
5081   for (ent = *plist; ent != NULL; ent = ent->next)
5082     if (ent->addend == addend)
5083       break;
5084   if (ent == NULL)
5085     {
5086       bfd_size_type amt = sizeof (*ent);
5087       ent = bfd_alloc (abfd, amt);
5088       if (ent == NULL)
5089         return FALSE;
5090       ent->next = *plist;
5091       ent->addend = addend;
5092       ent->plt.refcount = 0;
5093       *plist = ent;
5094     }
5095   ent->plt.refcount += 1;
5096   return TRUE;
5097 }
5098
5099 static bfd_boolean
5100 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5101 {
5102   return (r_type == R_PPC64_REL24
5103           || r_type == R_PPC64_REL14
5104           || r_type == R_PPC64_REL14_BRTAKEN
5105           || r_type == R_PPC64_REL14_BRNTAKEN
5106           || r_type == R_PPC64_ADDR24
5107           || r_type == R_PPC64_ADDR14
5108           || r_type == R_PPC64_ADDR14_BRTAKEN
5109           || r_type == R_PPC64_ADDR14_BRNTAKEN);
5110 }
5111
5112 /* Look through the relocs for a section during the first phase, and
5113    calculate needed space in the global offset table, procedure
5114    linkage table, and dynamic reloc sections.  */
5115
5116 static bfd_boolean
5117 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5118                         asection *sec, const Elf_Internal_Rela *relocs)
5119 {
5120   struct ppc_link_hash_table *htab;
5121   Elf_Internal_Shdr *symtab_hdr;
5122   struct elf_link_hash_entry **sym_hashes;
5123   const Elf_Internal_Rela *rel;
5124   const Elf_Internal_Rela *rel_end;
5125   asection *sreloc;
5126   asection **opd_sym_map;
5127   struct elf_link_hash_entry *tga, *dottga;
5128
5129   if (info->relocatable)
5130     return TRUE;
5131
5132   /* Don't do anything special with non-loaded, non-alloced sections.
5133      In particular, any relocs in such sections should not affect GOT
5134      and PLT reference counting (ie. we don't allow them to create GOT
5135      or PLT entries), there's no possibility or desire to optimize TLS
5136      relocs, and there's not much point in propagating relocs to shared
5137      libs that the dynamic linker won't relocate.  */
5138   if ((sec->flags & SEC_ALLOC) == 0)
5139     return TRUE;
5140
5141   BFD_ASSERT (is_ppc64_elf (abfd));
5142
5143   htab = ppc_hash_table (info);
5144   if (htab == NULL)
5145     return FALSE;
5146
5147   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5148                               FALSE, FALSE, TRUE);
5149   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5150                                  FALSE, FALSE, TRUE);
5151   symtab_hdr = &elf_symtab_hdr (abfd);
5152   sym_hashes = elf_sym_hashes (abfd);
5153   sreloc = NULL;
5154   opd_sym_map = NULL;
5155   if (strcmp (sec->name, ".opd") == 0)
5156     {
5157       /* Garbage collection needs some extra help with .opd sections.
5158          We don't want to necessarily keep everything referenced by
5159          relocs in .opd, as that would keep all functions.  Instead,
5160          if we reference an .opd symbol (a function descriptor), we
5161          want to keep the function code symbol's section.  This is
5162          easy for global symbols, but for local syms we need to keep
5163          information about the associated function section.  */
5164       bfd_size_type amt;
5165
5166       if (abiversion (abfd) == 0)
5167         set_abiversion (abfd, 1);
5168       else if (abiversion (abfd) == 2)
5169         {
5170           info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5171                                   abiversion (abfd));
5172           bfd_set_error (bfd_error_bad_value);
5173           return FALSE;
5174         }
5175       amt = sec->size * sizeof (*opd_sym_map) / 8;
5176       opd_sym_map = bfd_zalloc (abfd, amt);
5177       if (opd_sym_map == NULL)
5178         return FALSE;
5179       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5180       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5181       ppc64_elf_section_data (sec)->sec_type = sec_opd;
5182     }
5183
5184   rel_end = relocs + sec->reloc_count;
5185   for (rel = relocs; rel < rel_end; rel++)
5186     {
5187       unsigned long r_symndx;
5188       struct elf_link_hash_entry *h;
5189       enum elf_ppc64_reloc_type r_type;
5190       int tls_type;
5191       struct _ppc64_elf_section_data *ppc64_sec;
5192       struct plt_entry **ifunc;
5193
5194       r_symndx = ELF64_R_SYM (rel->r_info);
5195       if (r_symndx < symtab_hdr->sh_info)
5196         h = NULL;
5197       else
5198         {
5199           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5200           h = elf_follow_link (h);
5201
5202           /* PR15323, ref flags aren't set for references in the same
5203              object.  */
5204           h->root.non_ir_ref = 1;
5205
5206           if (h == htab->elf.hgot)
5207             sec->has_toc_reloc = 1;
5208         }
5209
5210       tls_type = 0;
5211       ifunc = NULL;
5212       if (h != NULL)
5213         {
5214           if (h->type == STT_GNU_IFUNC)
5215             {
5216               h->needs_plt = 1;
5217               ifunc = &h->plt.plist;
5218             }
5219         }
5220       else
5221         {
5222           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5223                                                           abfd, r_symndx);
5224           if (isym == NULL)
5225             return FALSE;
5226
5227           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5228             {
5229               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5230                                              rel->r_addend, PLT_IFUNC);
5231               if (ifunc == NULL)
5232                 return FALSE;
5233             }
5234         }
5235       r_type = ELF64_R_TYPE (rel->r_info);
5236       if (is_branch_reloc (r_type))
5237         {
5238           if (h != NULL && (h == tga || h == dottga))
5239             {
5240               if (rel != relocs
5241                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5242                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5243                 /* We have a new-style __tls_get_addr call with a marker
5244                    reloc.  */
5245                 ;
5246               else
5247                 /* Mark this section as having an old-style call.  */
5248                 sec->has_tls_get_addr_call = 1;
5249             }
5250
5251           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5252           if (ifunc != NULL
5253               && !update_plt_info (abfd, ifunc, rel->r_addend))
5254             return FALSE;
5255         }
5256
5257       switch (r_type)
5258         {
5259         case R_PPC64_TLSGD:
5260         case R_PPC64_TLSLD:
5261           /* These special tls relocs tie a call to __tls_get_addr with
5262              its parameter symbol.  */
5263           break;
5264
5265         case R_PPC64_GOT_TLSLD16:
5266         case R_PPC64_GOT_TLSLD16_LO:
5267         case R_PPC64_GOT_TLSLD16_HI:
5268         case R_PPC64_GOT_TLSLD16_HA:
5269           tls_type = TLS_TLS | TLS_LD;
5270           goto dogottls;
5271
5272         case R_PPC64_GOT_TLSGD16:
5273         case R_PPC64_GOT_TLSGD16_LO:
5274         case R_PPC64_GOT_TLSGD16_HI:
5275         case R_PPC64_GOT_TLSGD16_HA:
5276           tls_type = TLS_TLS | TLS_GD;
5277           goto dogottls;
5278
5279         case R_PPC64_GOT_TPREL16_DS:
5280         case R_PPC64_GOT_TPREL16_LO_DS:
5281         case R_PPC64_GOT_TPREL16_HI:
5282         case R_PPC64_GOT_TPREL16_HA:
5283           if (!info->executable)
5284             info->flags |= DF_STATIC_TLS;
5285           tls_type = TLS_TLS | TLS_TPREL;
5286           goto dogottls;
5287
5288         case R_PPC64_GOT_DTPREL16_DS:
5289         case R_PPC64_GOT_DTPREL16_LO_DS:
5290         case R_PPC64_GOT_DTPREL16_HI:
5291         case R_PPC64_GOT_DTPREL16_HA:
5292           tls_type = TLS_TLS | TLS_DTPREL;
5293         dogottls:
5294           sec->has_tls_reloc = 1;
5295           /* Fall thru */
5296
5297         case R_PPC64_GOT16:
5298         case R_PPC64_GOT16_DS:
5299         case R_PPC64_GOT16_HA:
5300         case R_PPC64_GOT16_HI:
5301         case R_PPC64_GOT16_LO:
5302         case R_PPC64_GOT16_LO_DS:
5303           /* This symbol requires a global offset table entry.  */
5304           sec->has_toc_reloc = 1;
5305           if (r_type == R_PPC64_GOT_TLSLD16
5306               || r_type == R_PPC64_GOT_TLSGD16
5307               || r_type == R_PPC64_GOT_TPREL16_DS
5308               || r_type == R_PPC64_GOT_DTPREL16_DS
5309               || r_type == R_PPC64_GOT16
5310               || r_type == R_PPC64_GOT16_DS)
5311             {
5312               htab->do_multi_toc = 1;
5313               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5314             }
5315
5316           if (ppc64_elf_tdata (abfd)->got == NULL
5317               && !create_got_section (abfd, info))
5318             return FALSE;
5319
5320           if (h != NULL)
5321             {
5322               struct ppc_link_hash_entry *eh;
5323               struct got_entry *ent;
5324
5325               eh = (struct ppc_link_hash_entry *) h;
5326               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5327                 if (ent->addend == rel->r_addend
5328                     && ent->owner == abfd
5329                     && ent->tls_type == tls_type)
5330                   break;
5331               if (ent == NULL)
5332                 {
5333                   bfd_size_type amt = sizeof (*ent);
5334                   ent = bfd_alloc (abfd, amt);
5335                   if (ent == NULL)
5336                     return FALSE;
5337                   ent->next = eh->elf.got.glist;
5338                   ent->addend = rel->r_addend;
5339                   ent->owner = abfd;
5340                   ent->tls_type = tls_type;
5341                   ent->is_indirect = FALSE;
5342                   ent->got.refcount = 0;
5343                   eh->elf.got.glist = ent;
5344                 }
5345               ent->got.refcount += 1;
5346               eh->tls_mask |= tls_type;
5347             }
5348           else
5349             /* This is a global offset table entry for a local symbol.  */
5350             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5351                                         rel->r_addend, tls_type))
5352               return FALSE;
5353
5354           /* We may also need a plt entry if the symbol turns out to be
5355              an ifunc.  */
5356           if (h != NULL && !info->shared && abiversion (abfd) == 2)
5357             {
5358               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5359                 return FALSE;
5360             }
5361           break;
5362
5363         case R_PPC64_PLT16_HA:
5364         case R_PPC64_PLT16_HI:
5365         case R_PPC64_PLT16_LO:
5366         case R_PPC64_PLT32:
5367         case R_PPC64_PLT64:
5368           /* This symbol requires a procedure linkage table entry.  We
5369              actually build the entry in adjust_dynamic_symbol,
5370              because this might be a case of linking PIC code without
5371              linking in any dynamic objects, in which case we don't
5372              need to generate a procedure linkage table after all.  */
5373           if (h == NULL)
5374             {
5375               /* It does not make sense to have a procedure linkage
5376                  table entry for a local symbol.  */
5377               bfd_set_error (bfd_error_bad_value);
5378               return FALSE;
5379             }
5380           else
5381             {
5382               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5383                 return FALSE;
5384               h->needs_plt = 1;
5385               if (h->root.root.string[0] == '.'
5386                   && h->root.root.string[1] != '\0')
5387                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5388             }
5389           break;
5390
5391           /* The following relocations don't need to propagate the
5392              relocation if linking a shared object since they are
5393              section relative.  */
5394         case R_PPC64_SECTOFF:
5395         case R_PPC64_SECTOFF_LO:
5396         case R_PPC64_SECTOFF_HI:
5397         case R_PPC64_SECTOFF_HA:
5398         case R_PPC64_SECTOFF_DS:
5399         case R_PPC64_SECTOFF_LO_DS:
5400         case R_PPC64_DTPREL16:
5401         case R_PPC64_DTPREL16_LO:
5402         case R_PPC64_DTPREL16_HI:
5403         case R_PPC64_DTPREL16_HA:
5404         case R_PPC64_DTPREL16_DS:
5405         case R_PPC64_DTPREL16_LO_DS:
5406         case R_PPC64_DTPREL16_HIGH:
5407         case R_PPC64_DTPREL16_HIGHA:
5408         case R_PPC64_DTPREL16_HIGHER:
5409         case R_PPC64_DTPREL16_HIGHERA:
5410         case R_PPC64_DTPREL16_HIGHEST:
5411         case R_PPC64_DTPREL16_HIGHESTA:
5412           break;
5413
5414           /* Nor do these.  */
5415         case R_PPC64_REL16:
5416         case R_PPC64_REL16_LO:
5417         case R_PPC64_REL16_HI:
5418         case R_PPC64_REL16_HA:
5419           break;
5420
5421         case R_PPC64_TOC16:
5422         case R_PPC64_TOC16_DS:
5423           htab->do_multi_toc = 1;
5424           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5425         case R_PPC64_TOC16_LO:
5426         case R_PPC64_TOC16_HI:
5427         case R_PPC64_TOC16_HA:
5428         case R_PPC64_TOC16_LO_DS:
5429           sec->has_toc_reloc = 1;
5430           break;
5431
5432           /* This relocation describes the C++ object vtable hierarchy.
5433              Reconstruct it for later use during GC.  */
5434         case R_PPC64_GNU_VTINHERIT:
5435           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5436             return FALSE;
5437           break;
5438
5439           /* This relocation describes which C++ vtable entries are actually
5440              used.  Record for later use during GC.  */
5441         case R_PPC64_GNU_VTENTRY:
5442           BFD_ASSERT (h != NULL);
5443           if (h != NULL
5444               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5445             return FALSE;
5446           break;
5447
5448         case R_PPC64_REL14:
5449         case R_PPC64_REL14_BRTAKEN:
5450         case R_PPC64_REL14_BRNTAKEN:
5451           {
5452             asection *dest = NULL;
5453
5454             /* Heuristic: If jumping outside our section, chances are
5455                we are going to need a stub.  */
5456             if (h != NULL)
5457               {
5458                 /* If the sym is weak it may be overridden later, so
5459                    don't assume we know where a weak sym lives.  */
5460                 if (h->root.type == bfd_link_hash_defined)
5461                   dest = h->root.u.def.section;
5462               }
5463             else
5464               {
5465                 Elf_Internal_Sym *isym;
5466
5467                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5468                                               abfd, r_symndx);
5469                 if (isym == NULL)
5470                   return FALSE;
5471
5472                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5473               }
5474
5475             if (dest != sec)
5476               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5477           }
5478           /* Fall through.  */
5479
5480         case R_PPC64_REL24:
5481           if (h != NULL && ifunc == NULL)
5482             {
5483               /* We may need a .plt entry if the function this reloc
5484                  refers to is in a shared lib.  */
5485               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5486                 return FALSE;
5487               h->needs_plt = 1;
5488               if (h->root.root.string[0] == '.'
5489                   && h->root.root.string[1] != '\0')
5490                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5491               if (h == tga || h == dottga)
5492                 sec->has_tls_reloc = 1;
5493             }
5494           break;
5495
5496         case R_PPC64_TPREL64:
5497           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5498           if (!info->executable)
5499             info->flags |= DF_STATIC_TLS;
5500           goto dotlstoc;
5501
5502         case R_PPC64_DTPMOD64:
5503           if (rel + 1 < rel_end
5504               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5505               && rel[1].r_offset == rel->r_offset + 8)
5506             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5507           else
5508             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5509           goto dotlstoc;
5510
5511         case R_PPC64_DTPREL64:
5512           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5513           if (rel != relocs
5514               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5515               && rel[-1].r_offset == rel->r_offset - 8)
5516             /* This is the second reloc of a dtpmod, dtprel pair.
5517                Don't mark with TLS_DTPREL.  */
5518             goto dodyn;
5519
5520         dotlstoc:
5521           sec->has_tls_reloc = 1;
5522           if (h != NULL)
5523             {
5524               struct ppc_link_hash_entry *eh;
5525               eh = (struct ppc_link_hash_entry *) h;
5526               eh->tls_mask |= tls_type;
5527             }
5528           else
5529             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5530                                         rel->r_addend, tls_type))
5531               return FALSE;
5532
5533           ppc64_sec = ppc64_elf_section_data (sec);
5534           if (ppc64_sec->sec_type != sec_toc)
5535             {
5536               bfd_size_type amt;
5537
5538               /* One extra to simplify get_tls_mask.  */
5539               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5540               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5541               if (ppc64_sec->u.toc.symndx == NULL)
5542                 return FALSE;
5543               amt = sec->size * sizeof (bfd_vma) / 8;
5544               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5545               if (ppc64_sec->u.toc.add == NULL)
5546                 return FALSE;
5547               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5548               ppc64_sec->sec_type = sec_toc;
5549             }
5550           BFD_ASSERT (rel->r_offset % 8 == 0);
5551           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5552           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5553
5554           /* Mark the second slot of a GD or LD entry.
5555              -1 to indicate GD and -2 to indicate LD.  */
5556           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5557             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5558           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5559             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5560           goto dodyn;
5561
5562         case R_PPC64_TPREL16:
5563         case R_PPC64_TPREL16_LO:
5564         case R_PPC64_TPREL16_HI:
5565         case R_PPC64_TPREL16_HA:
5566         case R_PPC64_TPREL16_DS:
5567         case R_PPC64_TPREL16_LO_DS:
5568         case R_PPC64_TPREL16_HIGH:
5569         case R_PPC64_TPREL16_HIGHA:
5570         case R_PPC64_TPREL16_HIGHER:
5571         case R_PPC64_TPREL16_HIGHERA:
5572         case R_PPC64_TPREL16_HIGHEST:
5573         case R_PPC64_TPREL16_HIGHESTA:
5574           if (info->shared)
5575             {
5576               if (!info->executable)
5577                 info->flags |= DF_STATIC_TLS;
5578               goto dodyn;
5579             }
5580           break;
5581
5582         case R_PPC64_ADDR64:
5583           if (opd_sym_map != NULL
5584               && rel + 1 < rel_end
5585               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5586             {
5587               if (h != NULL)
5588                 {
5589                   if (h->root.root.string[0] == '.'
5590                       && h->root.root.string[1] != 0
5591                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5592                     ;
5593                   else
5594                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5595                 }
5596               else
5597                 {
5598                   asection *s;
5599                   Elf_Internal_Sym *isym;
5600
5601                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5602                                                 abfd, r_symndx);
5603                   if (isym == NULL)
5604                     return FALSE;
5605
5606                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5607                   if (s != NULL && s != sec)
5608                     opd_sym_map[rel->r_offset / 8] = s;
5609                 }
5610             }
5611           /* Fall through.  */
5612
5613         case R_PPC64_ADDR16:
5614         case R_PPC64_ADDR16_DS:
5615         case R_PPC64_ADDR16_HA:
5616         case R_PPC64_ADDR16_HI:
5617         case R_PPC64_ADDR16_HIGH:
5618         case R_PPC64_ADDR16_HIGHA:
5619         case R_PPC64_ADDR16_HIGHER:
5620         case R_PPC64_ADDR16_HIGHERA:
5621         case R_PPC64_ADDR16_HIGHEST:
5622         case R_PPC64_ADDR16_HIGHESTA:
5623         case R_PPC64_ADDR16_LO:
5624         case R_PPC64_ADDR16_LO_DS:
5625           if (h != NULL && !info->shared && abiversion (abfd) == 2
5626               && rel->r_addend == 0)
5627             {
5628               /* We may need a .plt entry if this reloc refers to a
5629                  function in a shared lib.  */
5630               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5631                 return FALSE;
5632               h->pointer_equality_needed = 1;
5633             }
5634           /* Fall through.  */
5635
5636         case R_PPC64_REL30:
5637         case R_PPC64_REL32:
5638         case R_PPC64_REL64:
5639         case R_PPC64_ADDR14:
5640         case R_PPC64_ADDR14_BRNTAKEN:
5641         case R_PPC64_ADDR14_BRTAKEN:
5642         case R_PPC64_ADDR24:
5643         case R_PPC64_ADDR32:
5644         case R_PPC64_UADDR16:
5645         case R_PPC64_UADDR32:
5646         case R_PPC64_UADDR64:
5647         case R_PPC64_TOC:
5648           if (h != NULL && !info->shared)
5649             /* We may need a copy reloc.  */
5650             h->non_got_ref = 1;
5651
5652           /* Don't propagate .opd relocs.  */
5653           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5654             break;
5655
5656           /* If we are creating a shared library, and this is a reloc
5657              against a global symbol, or a non PC relative reloc
5658              against a local symbol, then we need to copy the reloc
5659              into the shared library.  However, if we are linking with
5660              -Bsymbolic, we do not need to copy a reloc against a
5661              global symbol which is defined in an object we are
5662              including in the link (i.e., DEF_REGULAR is set).  At
5663              this point we have not seen all the input files, so it is
5664              possible that DEF_REGULAR is not set now but will be set
5665              later (it is never cleared).  In case of a weak definition,
5666              DEF_REGULAR may be cleared later by a strong definition in
5667              a shared library.  We account for that possibility below by
5668              storing information in the dyn_relocs field of the hash
5669              table entry.  A similar situation occurs when creating
5670              shared libraries and symbol visibility changes render the
5671              symbol local.
5672
5673              If on the other hand, we are creating an executable, we
5674              may need to keep relocations for symbols satisfied by a
5675              dynamic library if we manage to avoid copy relocs for the
5676              symbol.  */
5677         dodyn:
5678           if ((info->shared
5679                && (must_be_dyn_reloc (info, r_type)
5680                    || (h != NULL
5681                        && (!SYMBOLIC_BIND (info, h)
5682                            || h->root.type == bfd_link_hash_defweak
5683                            || !h->def_regular))))
5684               || (ELIMINATE_COPY_RELOCS
5685                   && !info->shared
5686                   && h != NULL
5687                   && (h->root.type == bfd_link_hash_defweak
5688                       || !h->def_regular))
5689               || (!info->shared
5690                   && ifunc != NULL))
5691             {
5692               /* We must copy these reloc types into the output file.
5693                  Create a reloc section in dynobj and make room for
5694                  this reloc.  */
5695               if (sreloc == NULL)
5696                 {
5697                   sreloc = _bfd_elf_make_dynamic_reloc_section
5698                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5699
5700                   if (sreloc == NULL)
5701                     return FALSE;
5702                 }
5703
5704               /* If this is a global symbol, we count the number of
5705                  relocations we need for this symbol.  */
5706               if (h != NULL)
5707                 {
5708                   struct elf_dyn_relocs *p;
5709                   struct elf_dyn_relocs **head;
5710
5711                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5712                   p = *head;
5713                   if (p == NULL || p->sec != sec)
5714                     {
5715                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5716                       if (p == NULL)
5717                         return FALSE;
5718                       p->next = *head;
5719                       *head = p;
5720                       p->sec = sec;
5721                       p->count = 0;
5722                       p->pc_count = 0;
5723                     }
5724                   p->count += 1;
5725                   if (!must_be_dyn_reloc (info, r_type))
5726                     p->pc_count += 1;
5727                 }
5728               else
5729                 {
5730                   /* Track dynamic relocs needed for local syms too.
5731                      We really need local syms available to do this
5732                      easily.  Oh well.  */
5733                   struct ppc_dyn_relocs *p;
5734                   struct ppc_dyn_relocs **head;
5735                   bfd_boolean is_ifunc;
5736                   asection *s;
5737                   void *vpp;
5738                   Elf_Internal_Sym *isym;
5739
5740                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5741                                                 abfd, r_symndx);
5742                   if (isym == NULL)
5743                     return FALSE;
5744
5745                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5746                   if (s == NULL)
5747                     s = sec;
5748
5749                   vpp = &elf_section_data (s)->local_dynrel;
5750                   head = (struct ppc_dyn_relocs **) vpp;
5751                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5752                   p = *head;
5753                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5754                     p = p->next;
5755                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5756                     {
5757                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5758                       if (p == NULL)
5759                         return FALSE;
5760                       p->next = *head;
5761                       *head = p;
5762                       p->sec = sec;
5763                       p->ifunc = is_ifunc;
5764                       p->count = 0;
5765                     }
5766                   p->count += 1;
5767                 }
5768             }
5769           break;
5770
5771         default:
5772           break;
5773         }
5774     }
5775
5776   return TRUE;
5777 }
5778
5779 /* Merge backend specific data from an object file to the output
5780    object file when linking.  */
5781
5782 static bfd_boolean
5783 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5784 {
5785   unsigned long iflags, oflags;
5786
5787   if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5788     return TRUE;
5789
5790   if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5791     return TRUE;
5792
5793   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5794     return FALSE;
5795
5796   iflags = elf_elfheader (ibfd)->e_flags;
5797   oflags = elf_elfheader (obfd)->e_flags;
5798
5799   if (!elf_flags_init (obfd) || oflags == 0)
5800     {
5801       elf_flags_init (obfd) = TRUE;
5802       elf_elfheader (obfd)->e_flags = iflags;
5803     }
5804   else if (iflags == oflags || iflags == 0)
5805     ;
5806   else if (iflags & ~EF_PPC64_ABI)
5807     {
5808       (*_bfd_error_handler)
5809         (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5810       bfd_set_error (bfd_error_bad_value);
5811       return FALSE;
5812     }
5813   else
5814     {
5815       (*_bfd_error_handler)
5816         (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5817          ibfd, iflags, oflags);
5818       bfd_set_error (bfd_error_bad_value);
5819       return FALSE;
5820     }
5821
5822   /* Merge Tag_compatibility attributes and any common GNU ones.  */
5823   _bfd_elf_merge_object_attributes (ibfd, obfd);
5824
5825   return TRUE;
5826 }
5827
5828 static bfd_boolean
5829 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5830 {
5831   /* Print normal ELF private data.  */
5832   _bfd_elf_print_private_bfd_data (abfd, ptr);
5833
5834   if (elf_elfheader (abfd)->e_flags != 0)
5835     {
5836       FILE *file = ptr;
5837
5838       /* xgettext:c-format */
5839       fprintf (file, _("private flags = 0x%lx:"),
5840                elf_elfheader (abfd)->e_flags);
5841
5842       if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5843         fprintf (file, _(" [abiv%ld]"),
5844                  elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5845       fputc ('\n', file);
5846     }
5847
5848   return TRUE;
5849 }
5850
5851 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5852    of the code entry point, and its section.  */
5853
5854 static bfd_vma
5855 opd_entry_value (asection *opd_sec,
5856                  bfd_vma offset,
5857                  asection **code_sec,
5858                  bfd_vma *code_off,
5859                  bfd_boolean in_code_sec)
5860 {
5861   bfd *opd_bfd = opd_sec->owner;
5862   Elf_Internal_Rela *relocs;
5863   Elf_Internal_Rela *lo, *hi, *look;
5864   bfd_vma val;
5865
5866   /* No relocs implies we are linking a --just-symbols object, or looking
5867      at a final linked executable with addr2line or somesuch.  */
5868   if (opd_sec->reloc_count == 0)
5869     {
5870       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5871
5872       if (contents == NULL)
5873         {
5874           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5875             return (bfd_vma) -1;
5876           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5877         }
5878
5879       val = bfd_get_64 (opd_bfd, contents + offset);
5880       if (code_sec != NULL)
5881         {
5882           asection *sec, *likely = NULL;
5883
5884           if (in_code_sec)
5885             {
5886               sec = *code_sec;
5887               if (sec->vma <= val
5888                   && val < sec->vma + sec->size)
5889                 likely = sec;
5890               else
5891                 val = -1;
5892             }
5893           else
5894             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5895               if (sec->vma <= val
5896                   && (sec->flags & SEC_LOAD) != 0
5897                   && (sec->flags & SEC_ALLOC) != 0)
5898                 likely = sec;
5899           if (likely != NULL)
5900             {
5901               *code_sec = likely;
5902               if (code_off != NULL)
5903                 *code_off = val - likely->vma;
5904             }
5905         }
5906       return val;
5907     }
5908
5909   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5910
5911   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5912   if (relocs == NULL)
5913     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5914
5915   /* Go find the opd reloc at the sym address.  */
5916   lo = relocs;
5917   BFD_ASSERT (lo != NULL);
5918   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5919   val = (bfd_vma) -1;
5920   while (lo < hi)
5921     {
5922       look = lo + (hi - lo) / 2;
5923       if (look->r_offset < offset)
5924         lo = look + 1;
5925       else if (look->r_offset > offset)
5926         hi = look;
5927       else
5928         {
5929           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5930
5931           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5932               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5933             {
5934               unsigned long symndx = ELF64_R_SYM (look->r_info);
5935               asection *sec;
5936
5937               if (symndx < symtab_hdr->sh_info
5938                   || elf_sym_hashes (opd_bfd) == NULL)
5939                 {
5940                   Elf_Internal_Sym *sym;
5941
5942                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5943                   if (sym == NULL)
5944                     {
5945                       size_t symcnt = symtab_hdr->sh_info;
5946                       if (elf_sym_hashes (opd_bfd) == NULL)
5947                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5948                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5949                                                   0, NULL, NULL, NULL);
5950                       if (sym == NULL)
5951                         break;
5952                       symtab_hdr->contents = (bfd_byte *) sym;
5953                     }
5954
5955                   sym += symndx;
5956                   val = sym->st_value;
5957                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5958                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5959                 }
5960               else
5961                 {
5962                   struct elf_link_hash_entry **sym_hashes;
5963                   struct elf_link_hash_entry *rh;
5964
5965                   sym_hashes = elf_sym_hashes (opd_bfd);
5966                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5967                   if (rh != NULL)
5968                     {
5969                       rh = elf_follow_link (rh);
5970                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5971                                   || rh->root.type == bfd_link_hash_defweak);
5972                       val = rh->root.u.def.value;
5973                       sec = rh->root.u.def.section;
5974                     }
5975                   else
5976                     {
5977                       /* Handle the odd case where we can be called
5978                          during bfd_elf_link_add_symbols before the
5979                          symbol hashes have been fully populated.  */
5980                       Elf_Internal_Sym *sym;
5981
5982                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5983                                                   symndx, NULL, NULL, NULL);
5984                       if (sym == NULL)
5985                         break;
5986
5987                       val = sym->st_value;
5988                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5989                       free (sym);
5990                     }
5991                 }
5992               val += look->r_addend;
5993               if (code_off != NULL)
5994                 *code_off = val;
5995               if (code_sec != NULL)
5996                 {
5997                   if (in_code_sec && *code_sec != sec)
5998                     return -1;
5999                   else
6000                     *code_sec = sec;
6001                 }
6002               if (sec != NULL && sec->output_section != NULL)
6003                 val += sec->output_section->vma + sec->output_offset;
6004             }
6005           break;
6006         }
6007     }
6008
6009   return val;
6010 }
6011
6012 /* If the ELF symbol SYM might be a function in SEC, return the
6013    function size and set *CODE_OFF to the function's entry point,
6014    otherwise return zero.  */
6015
6016 static bfd_size_type
6017 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6018                               bfd_vma *code_off)
6019 {
6020   bfd_size_type size;
6021
6022   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6023                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6024     return 0;
6025
6026   size = 0;
6027   if (!(sym->flags & BSF_SYNTHETIC))
6028     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6029
6030   if (strcmp (sym->section->name, ".opd") == 0)
6031     {
6032       if (opd_entry_value (sym->section, sym->value,
6033                            &sec, code_off, TRUE) == (bfd_vma) -1)
6034         return 0;
6035       /* An old ABI binary with dot-syms has a size of 24 on the .opd
6036          symbol.  This size has nothing to do with the code size of the
6037          function, which is what we're supposed to return, but the
6038          code size isn't available without looking up the dot-sym.
6039          However, doing that would be a waste of time particularly
6040          since elf_find_function will look at the dot-sym anyway.
6041          Now, elf_find_function will keep the largest size of any
6042          function sym found at the code address of interest, so return
6043          1 here to avoid it incorrectly caching a larger function size
6044          for a small function.  This does mean we return the wrong
6045          size for a new-ABI function of size 24, but all that does is
6046          disable caching for such functions.  */
6047       if (size == 24)
6048         size = 1;
6049     }
6050   else
6051     {
6052       if (sym->section != sec)
6053         return 0;
6054       *code_off = sym->value;
6055     }
6056   if (size == 0)
6057     size = 1;
6058   return size;
6059 }
6060
6061 /* Return true if symbol is defined in a regular object file.  */
6062
6063 static bfd_boolean
6064 is_static_defined (struct elf_link_hash_entry *h)
6065 {
6066   return ((h->root.type == bfd_link_hash_defined
6067            || h->root.type == bfd_link_hash_defweak)
6068           && h->root.u.def.section != NULL
6069           && h->root.u.def.section->output_section != NULL);
6070 }
6071
6072 /* If FDH is a function descriptor symbol, return the associated code
6073    entry symbol if it is defined.  Return NULL otherwise.  */
6074
6075 static struct ppc_link_hash_entry *
6076 defined_code_entry (struct ppc_link_hash_entry *fdh)
6077 {
6078   if (fdh->is_func_descriptor)
6079     {
6080       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6081       if (fh->elf.root.type == bfd_link_hash_defined
6082           || fh->elf.root.type == bfd_link_hash_defweak)
6083         return fh;
6084     }
6085   return NULL;
6086 }
6087
6088 /* If FH is a function code entry symbol, return the associated
6089    function descriptor symbol if it is defined.  Return NULL otherwise.  */
6090
6091 static struct ppc_link_hash_entry *
6092 defined_func_desc (struct ppc_link_hash_entry *fh)
6093 {
6094   if (fh->oh != NULL
6095       && fh->oh->is_func_descriptor)
6096     {
6097       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6098       if (fdh->elf.root.type == bfd_link_hash_defined
6099           || fdh->elf.root.type == bfd_link_hash_defweak)
6100         return fdh;
6101     }
6102   return NULL;
6103 }
6104
6105 /* Mark all our entry sym sections, both opd and code section.  */
6106
6107 static void
6108 ppc64_elf_gc_keep (struct bfd_link_info *info)
6109 {
6110   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6111   struct bfd_sym_chain *sym;
6112
6113   if (htab == NULL)
6114     return;
6115
6116   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6117     {
6118       struct ppc_link_hash_entry *eh, *fh;
6119       asection *sec;
6120
6121       eh = (struct ppc_link_hash_entry *)
6122         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6123       if (eh == NULL)
6124         continue;
6125       if (eh->elf.root.type != bfd_link_hash_defined
6126           && eh->elf.root.type != bfd_link_hash_defweak)
6127         continue;
6128
6129       fh = defined_code_entry (eh);
6130       if (fh != NULL)
6131         {
6132           sec = fh->elf.root.u.def.section;
6133           sec->flags |= SEC_KEEP;
6134         }
6135       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6136                && opd_entry_value (eh->elf.root.u.def.section,
6137                                    eh->elf.root.u.def.value,
6138                                    &sec, NULL, FALSE) != (bfd_vma) -1)
6139         sec->flags |= SEC_KEEP;
6140
6141       sec = eh->elf.root.u.def.section;
6142       sec->flags |= SEC_KEEP;
6143     }
6144 }
6145
6146 /* Mark sections containing dynamically referenced symbols.  When
6147    building shared libraries, we must assume that any visible symbol is
6148    referenced.  */
6149
6150 static bfd_boolean
6151 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6152 {
6153   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6154   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6155   struct ppc_link_hash_entry *fdh;
6156   struct bfd_elf_dynamic_list *d = info->dynamic_list;
6157
6158   /* Dynamic linking info is on the func descriptor sym.  */
6159   fdh = defined_func_desc (eh);
6160   if (fdh != NULL)
6161     eh = fdh;
6162
6163   if ((eh->elf.root.type == bfd_link_hash_defined
6164        || eh->elf.root.type == bfd_link_hash_defweak)
6165       && (eh->elf.ref_dynamic
6166           || (eh->elf.def_regular
6167               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6168               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6169               && (!info->executable
6170                   || info->export_dynamic
6171                   || (eh->elf.dynamic
6172                       && d != NULL
6173                       && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6174               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6175                   || !bfd_hide_sym_by_version (info->version_info,
6176                                                eh->elf.root.root.string)))))
6177     {
6178       asection *code_sec;
6179       struct ppc_link_hash_entry *fh;
6180
6181       eh->elf.root.u.def.section->flags |= SEC_KEEP;
6182
6183       /* Function descriptor syms cause the associated
6184          function code sym section to be marked.  */
6185       fh = defined_code_entry (eh);
6186       if (fh != NULL)
6187         {
6188           code_sec = fh->elf.root.u.def.section;
6189           code_sec->flags |= SEC_KEEP;
6190         }
6191       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6192                && opd_entry_value (eh->elf.root.u.def.section,
6193                                    eh->elf.root.u.def.value,
6194                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
6195         code_sec->flags |= SEC_KEEP;
6196     }
6197
6198   return TRUE;
6199 }
6200
6201 /* Return the section that should be marked against GC for a given
6202    relocation.  */
6203
6204 static asection *
6205 ppc64_elf_gc_mark_hook (asection *sec,
6206                         struct bfd_link_info *info,
6207                         Elf_Internal_Rela *rel,
6208                         struct elf_link_hash_entry *h,
6209                         Elf_Internal_Sym *sym)
6210 {
6211   asection *rsec;
6212
6213   /* Syms return NULL if we're marking .opd, so we avoid marking all
6214      function sections, as all functions are referenced in .opd.  */
6215   rsec = NULL;
6216   if (get_opd_info (sec) != NULL)
6217     return rsec;
6218
6219   if (h != NULL)
6220     {
6221       enum elf_ppc64_reloc_type r_type;
6222       struct ppc_link_hash_entry *eh, *fh, *fdh;
6223
6224       r_type = ELF64_R_TYPE (rel->r_info);
6225       switch (r_type)
6226         {
6227         case R_PPC64_GNU_VTINHERIT:
6228         case R_PPC64_GNU_VTENTRY:
6229           break;
6230
6231         default:
6232           switch (h->root.type)
6233             {
6234             case bfd_link_hash_defined:
6235             case bfd_link_hash_defweak:
6236               eh = (struct ppc_link_hash_entry *) h;
6237               fdh = defined_func_desc (eh);
6238               if (fdh != NULL)
6239                 eh = fdh;
6240
6241               /* Function descriptor syms cause the associated
6242                  function code sym section to be marked.  */
6243               fh = defined_code_entry (eh);
6244               if (fh != NULL)
6245                 {
6246                   /* They also mark their opd section.  */
6247                   eh->elf.root.u.def.section->gc_mark = 1;
6248
6249                   rsec = fh->elf.root.u.def.section;
6250                 }
6251               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6252                        && opd_entry_value (eh->elf.root.u.def.section,
6253                                            eh->elf.root.u.def.value,
6254                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
6255                 eh->elf.root.u.def.section->gc_mark = 1;
6256               else
6257                 rsec = h->root.u.def.section;
6258               break;
6259
6260             case bfd_link_hash_common:
6261               rsec = h->root.u.c.p->section;
6262               break;
6263
6264             default:
6265               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6266             }
6267         }
6268     }
6269   else
6270     {
6271       struct _opd_sec_data *opd;
6272
6273       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6274       opd = get_opd_info (rsec);
6275       if (opd != NULL && opd->func_sec != NULL)
6276         {
6277           rsec->gc_mark = 1;
6278
6279           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6280         }
6281     }
6282
6283   return rsec;
6284 }
6285
6286 /* Update the .got, .plt. and dynamic reloc reference counts for the
6287    section being removed.  */
6288
6289 static bfd_boolean
6290 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6291                          asection *sec, const Elf_Internal_Rela *relocs)
6292 {
6293   struct ppc_link_hash_table *htab;
6294   Elf_Internal_Shdr *symtab_hdr;
6295   struct elf_link_hash_entry **sym_hashes;
6296   struct got_entry **local_got_ents;
6297   const Elf_Internal_Rela *rel, *relend;
6298
6299   if (info->relocatable)
6300     return TRUE;
6301
6302   if ((sec->flags & SEC_ALLOC) == 0)
6303     return TRUE;
6304
6305   elf_section_data (sec)->local_dynrel = NULL;
6306
6307   htab = ppc_hash_table (info);
6308   if (htab == NULL)
6309     return FALSE;
6310
6311   symtab_hdr = &elf_symtab_hdr (abfd);
6312   sym_hashes = elf_sym_hashes (abfd);
6313   local_got_ents = elf_local_got_ents (abfd);
6314
6315   relend = relocs + sec->reloc_count;
6316   for (rel = relocs; rel < relend; rel++)
6317     {
6318       unsigned long r_symndx;
6319       enum elf_ppc64_reloc_type r_type;
6320       struct elf_link_hash_entry *h = NULL;
6321       unsigned char tls_type = 0;
6322
6323       r_symndx = ELF64_R_SYM (rel->r_info);
6324       r_type = ELF64_R_TYPE (rel->r_info);
6325       if (r_symndx >= symtab_hdr->sh_info)
6326         {
6327           struct ppc_link_hash_entry *eh;
6328           struct elf_dyn_relocs **pp;
6329           struct elf_dyn_relocs *p;
6330
6331           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6332           h = elf_follow_link (h);
6333           eh = (struct ppc_link_hash_entry *) h;
6334
6335           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6336             if (p->sec == sec)
6337               {
6338                 /* Everything must go for SEC.  */
6339                 *pp = p->next;
6340                 break;
6341               }
6342         }
6343
6344       if (is_branch_reloc (r_type))
6345         {
6346           struct plt_entry **ifunc = NULL;
6347           if (h != NULL)
6348             {
6349               if (h->type == STT_GNU_IFUNC)
6350                 ifunc = &h->plt.plist;
6351             }
6352           else if (local_got_ents != NULL)
6353             {
6354               struct plt_entry **local_plt = (struct plt_entry **)
6355                 (local_got_ents + symtab_hdr->sh_info);
6356               unsigned char *local_got_tls_masks = (unsigned char *)
6357                 (local_plt + symtab_hdr->sh_info);
6358               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6359                 ifunc = local_plt + r_symndx;
6360             }
6361           if (ifunc != NULL)
6362             {
6363               struct plt_entry *ent;
6364
6365               for (ent = *ifunc; ent != NULL; ent = ent->next)
6366                 if (ent->addend == rel->r_addend)
6367                   break;
6368               if (ent == NULL)
6369                 abort ();
6370               if (ent->plt.refcount > 0)
6371                 ent->plt.refcount -= 1;
6372               continue;
6373             }
6374         }
6375
6376       switch (r_type)
6377         {
6378         case R_PPC64_GOT_TLSLD16:
6379         case R_PPC64_GOT_TLSLD16_LO:
6380         case R_PPC64_GOT_TLSLD16_HI:
6381         case R_PPC64_GOT_TLSLD16_HA:
6382           tls_type = TLS_TLS | TLS_LD;
6383           goto dogot;
6384
6385         case R_PPC64_GOT_TLSGD16:
6386         case R_PPC64_GOT_TLSGD16_LO:
6387         case R_PPC64_GOT_TLSGD16_HI:
6388         case R_PPC64_GOT_TLSGD16_HA:
6389           tls_type = TLS_TLS | TLS_GD;
6390           goto dogot;
6391
6392         case R_PPC64_GOT_TPREL16_DS:
6393         case R_PPC64_GOT_TPREL16_LO_DS:
6394         case R_PPC64_GOT_TPREL16_HI:
6395         case R_PPC64_GOT_TPREL16_HA:
6396           tls_type = TLS_TLS | TLS_TPREL;
6397           goto dogot;
6398
6399         case R_PPC64_GOT_DTPREL16_DS:
6400         case R_PPC64_GOT_DTPREL16_LO_DS:
6401         case R_PPC64_GOT_DTPREL16_HI:
6402         case R_PPC64_GOT_DTPREL16_HA:
6403           tls_type = TLS_TLS | TLS_DTPREL;
6404           goto dogot;
6405
6406         case R_PPC64_GOT16:
6407         case R_PPC64_GOT16_DS:
6408         case R_PPC64_GOT16_HA:
6409         case R_PPC64_GOT16_HI:
6410         case R_PPC64_GOT16_LO:
6411         case R_PPC64_GOT16_LO_DS:
6412         dogot:
6413           {
6414             struct got_entry *ent;
6415
6416             if (h != NULL)
6417               ent = h->got.glist;
6418             else
6419               ent = local_got_ents[r_symndx];
6420
6421             for (; ent != NULL; ent = ent->next)
6422               if (ent->addend == rel->r_addend
6423                   && ent->owner == abfd
6424                   && ent->tls_type == tls_type)
6425                 break;
6426             if (ent == NULL)
6427               abort ();
6428             if (ent->got.refcount > 0)
6429               ent->got.refcount -= 1;
6430           }
6431           break;
6432
6433         case R_PPC64_PLT16_HA:
6434         case R_PPC64_PLT16_HI:
6435         case R_PPC64_PLT16_LO:
6436         case R_PPC64_PLT32:
6437         case R_PPC64_PLT64:
6438         case R_PPC64_REL14:
6439         case R_PPC64_REL14_BRNTAKEN:
6440         case R_PPC64_REL14_BRTAKEN:
6441         case R_PPC64_REL24:
6442           if (h != NULL)
6443             {
6444               struct plt_entry *ent;
6445
6446               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6447                 if (ent->addend == rel->r_addend)
6448                   break;
6449               if (ent != NULL && ent->plt.refcount > 0)
6450                 ent->plt.refcount -= 1;
6451             }
6452           break;
6453
6454         default:
6455           break;
6456         }
6457     }
6458   return TRUE;
6459 }
6460
6461 /* The maximum size of .sfpr.  */
6462 #define SFPR_MAX (218*4)
6463
6464 struct sfpr_def_parms
6465 {
6466   const char name[12];
6467   unsigned char lo, hi;
6468   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6469   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6470 };
6471
6472 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6473
6474 static bfd_boolean
6475 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6476 {
6477   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6478   unsigned int i;
6479   size_t len = strlen (parm->name);
6480   bfd_boolean writing = FALSE;
6481   char sym[16];
6482
6483   if (htab == NULL)
6484     return FALSE;
6485
6486   memcpy (sym, parm->name, len);
6487   sym[len + 2] = 0;
6488
6489   for (i = parm->lo; i <= parm->hi; i++)
6490     {
6491       struct elf_link_hash_entry *h;
6492
6493       sym[len + 0] = i / 10 + '0';
6494       sym[len + 1] = i % 10 + '0';
6495       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6496       if (h != NULL
6497           && !h->def_regular)
6498         {
6499           h->root.type = bfd_link_hash_defined;
6500           h->root.u.def.section = htab->sfpr;
6501           h->root.u.def.value = htab->sfpr->size;
6502           h->type = STT_FUNC;
6503           h->def_regular = 1;
6504           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6505           writing = TRUE;
6506           if (htab->sfpr->contents == NULL)
6507             {
6508               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6509               if (htab->sfpr->contents == NULL)
6510                 return FALSE;
6511             }
6512         }
6513       if (writing)
6514         {
6515           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6516           if (i != parm->hi)
6517             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6518           else
6519             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6520           htab->sfpr->size = p - htab->sfpr->contents;
6521         }
6522     }
6523
6524   return TRUE;
6525 }
6526
6527 static bfd_byte *
6528 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6529 {
6530   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6531   return p + 4;
6532 }
6533
6534 static bfd_byte *
6535 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 {
6537   p = savegpr0 (abfd, p, r);
6538   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6539   p = p + 4;
6540   bfd_put_32 (abfd, BLR, p);
6541   return p + 4;
6542 }
6543
6544 static bfd_byte *
6545 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6546 {
6547   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6548   return p + 4;
6549 }
6550
6551 static bfd_byte *
6552 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6553 {
6554   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6555   p = p + 4;
6556   p = restgpr0 (abfd, p, r);
6557   bfd_put_32 (abfd, MTLR_R0, p);
6558   p = p + 4;
6559   if (r == 29)
6560     {
6561       p = restgpr0 (abfd, p, 30);
6562       p = restgpr0 (abfd, p, 31);
6563     }
6564   bfd_put_32 (abfd, BLR, p);
6565   return p + 4;
6566 }
6567
6568 static bfd_byte *
6569 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6570 {
6571   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6572   return p + 4;
6573 }
6574
6575 static bfd_byte *
6576 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6577 {
6578   p = savegpr1 (abfd, p, r);
6579   bfd_put_32 (abfd, BLR, p);
6580   return p + 4;
6581 }
6582
6583 static bfd_byte *
6584 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6585 {
6586   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6587   return p + 4;
6588 }
6589
6590 static bfd_byte *
6591 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6592 {
6593   p = restgpr1 (abfd, p, r);
6594   bfd_put_32 (abfd, BLR, p);
6595   return p + 4;
6596 }
6597
6598 static bfd_byte *
6599 savefpr (bfd *abfd, bfd_byte *p, int r)
6600 {
6601   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6602   return p + 4;
6603 }
6604
6605 static bfd_byte *
6606 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 {
6608   p = savefpr (abfd, p, r);
6609   bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6610   p = p + 4;
6611   bfd_put_32 (abfd, BLR, p);
6612   return p + 4;
6613 }
6614
6615 static bfd_byte *
6616 restfpr (bfd *abfd, bfd_byte *p, int r)
6617 {
6618   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6619   return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625   bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6626   p = p + 4;
6627   p = restfpr (abfd, p, r);
6628   bfd_put_32 (abfd, MTLR_R0, p);
6629   p = p + 4;
6630   if (r == 29)
6631     {
6632       p = restfpr (abfd, p, 30);
6633       p = restfpr (abfd, p, 31);
6634     }
6635   bfd_put_32 (abfd, BLR, p);
6636   return p + 4;
6637 }
6638
6639 static bfd_byte *
6640 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6641 {
6642   p = savefpr (abfd, p, r);
6643   bfd_put_32 (abfd, BLR, p);
6644   return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6649 {
6650   p = restfpr (abfd, p, r);
6651   bfd_put_32 (abfd, BLR, p);
6652   return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 savevr (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, STVX_VR0_R12_R0 + (r << 21), p);
6661   return p + 4;
6662 }
6663
6664 static bfd_byte *
6665 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6666 {
6667   p = savevr (abfd, p, r);
6668   bfd_put_32 (abfd, BLR, p);
6669   return p + 4;
6670 }
6671
6672 static bfd_byte *
6673 restvr (bfd *abfd, bfd_byte *p, int r)
6674 {
6675   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6676   p = p + 4;
6677   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6678   return p + 4;
6679 }
6680
6681 static bfd_byte *
6682 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6683 {
6684   p = restvr (abfd, p, r);
6685   bfd_put_32 (abfd, BLR, p);
6686   return p + 4;
6687 }
6688
6689 /* Called via elf_link_hash_traverse to transfer dynamic linking
6690    information on function code symbol entries to their corresponding
6691    function descriptor symbol entries.  */
6692
6693 static bfd_boolean
6694 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6695 {
6696   struct bfd_link_info *info;
6697   struct ppc_link_hash_table *htab;
6698   struct plt_entry *ent;
6699   struct ppc_link_hash_entry *fh;
6700   struct ppc_link_hash_entry *fdh;
6701   bfd_boolean force_local;
6702
6703   fh = (struct ppc_link_hash_entry *) h;
6704   if (fh->elf.root.type == bfd_link_hash_indirect)
6705     return TRUE;
6706
6707   info = inf;
6708   htab = ppc_hash_table (info);
6709   if (htab == NULL)
6710     return FALSE;
6711
6712   /* Resolve undefined references to dot-symbols as the value
6713      in the function descriptor, if we have one in a regular object.
6714      This is to satisfy cases like ".quad .foo".  Calls to functions
6715      in dynamic objects are handled elsewhere.  */
6716   if (fh->elf.root.type == bfd_link_hash_undefweak
6717       && fh->was_undefined
6718       && (fdh = defined_func_desc (fh)) != NULL
6719       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6720       && opd_entry_value (fdh->elf.root.u.def.section,
6721                           fdh->elf.root.u.def.value,
6722                           &fh->elf.root.u.def.section,
6723                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6724     {
6725       fh->elf.root.type = fdh->elf.root.type;
6726       fh->elf.forced_local = 1;
6727       fh->elf.def_regular = fdh->elf.def_regular;
6728       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6729     }
6730
6731   /* If this is a function code symbol, transfer dynamic linking
6732      information to the function descriptor symbol.  */
6733   if (!fh->is_func)
6734     return TRUE;
6735
6736   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6737     if (ent->plt.refcount > 0)
6738       break;
6739   if (ent == NULL
6740       || fh->elf.root.root.string[0] != '.'
6741       || fh->elf.root.root.string[1] == '\0')
6742     return TRUE;
6743
6744   /* Find the corresponding function descriptor symbol.  Create it
6745      as undefined if necessary.  */
6746
6747   fdh = lookup_fdh (fh, htab);
6748   if (fdh == NULL
6749       && !info->executable
6750       && (fh->elf.root.type == bfd_link_hash_undefined
6751           || fh->elf.root.type == bfd_link_hash_undefweak))
6752     {
6753       fdh = make_fdh (info, fh);
6754       if (fdh == NULL)
6755         return FALSE;
6756     }
6757
6758   /* Fake function descriptors are made undefweak.  If the function
6759      code symbol is strong undefined, make the fake sym the same.
6760      If the function code symbol is defined, then force the fake
6761      descriptor local;  We can't support overriding of symbols in a
6762      shared library on a fake descriptor.  */
6763
6764   if (fdh != NULL
6765       && fdh->fake
6766       && fdh->elf.root.type == bfd_link_hash_undefweak)
6767     {
6768       if (fh->elf.root.type == bfd_link_hash_undefined)
6769         {
6770           fdh->elf.root.type = bfd_link_hash_undefined;
6771           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6772         }
6773       else if (fh->elf.root.type == bfd_link_hash_defined
6774                || fh->elf.root.type == bfd_link_hash_defweak)
6775         {
6776           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6777         }
6778     }
6779
6780   if (fdh != NULL
6781       && !fdh->elf.forced_local
6782       && (!info->executable
6783           || fdh->elf.def_dynamic
6784           || fdh->elf.ref_dynamic
6785           || (fdh->elf.root.type == bfd_link_hash_undefweak
6786               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6787     {
6788       if (fdh->elf.dynindx == -1)
6789         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6790           return FALSE;
6791       fdh->elf.ref_regular |= fh->elf.ref_regular;
6792       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6793       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6794       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6795       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6796         {
6797           move_plt_plist (fh, fdh);
6798           fdh->elf.needs_plt = 1;
6799         }
6800       fdh->is_func_descriptor = 1;
6801       fdh->oh = fh;
6802       fh->oh = fdh;
6803     }
6804
6805   /* Now that the info is on the function descriptor, clear the
6806      function code sym info.  Any function code syms for which we
6807      don't have a definition in a regular file, we force local.
6808      This prevents a shared library from exporting syms that have
6809      been imported from another library.  Function code syms that
6810      are really in the library we must leave global to prevent the
6811      linker dragging in a definition from a static library.  */
6812   force_local = (!fh->elf.def_regular
6813                  || fdh == NULL
6814                  || !fdh->elf.def_regular
6815                  || fdh->elf.forced_local);
6816   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6817
6818   return TRUE;
6819 }
6820
6821 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6822    this hook to a) provide some gcc support functions, and b) transfer
6823    dynamic linking information gathered so far on function code symbol
6824    entries, to their corresponding function descriptor symbol entries.  */
6825
6826 static bfd_boolean
6827 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6828                             struct bfd_link_info *info)
6829 {
6830   struct ppc_link_hash_table *htab;
6831   unsigned int i;
6832   static const struct sfpr_def_parms funcs[] =
6833     {
6834       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6835       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6836       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6837       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6838       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6839       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6840       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6841       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6842       { "._savef", 14, 31, savefpr, savefpr1_tail },
6843       { "._restf", 14, 31, restfpr, restfpr1_tail },
6844       { "_savevr_", 20, 31, savevr, savevr_tail },
6845       { "_restvr_", 20, 31, restvr, restvr_tail }
6846     };
6847
6848   htab = ppc_hash_table (info);
6849   if (htab == NULL)
6850     return FALSE;
6851
6852   if (!info->relocatable
6853       && htab->elf.hgot != NULL)
6854     {
6855       _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6856       /* Make .TOC. defined so as to prevent it being made dynamic.
6857          The wrong value here is fixed later in ppc64_elf_set_toc.  */
6858       htab->elf.hgot->type = STT_OBJECT;
6859       htab->elf.hgot->root.type = bfd_link_hash_defined;
6860       htab->elf.hgot->root.u.def.value = 0;
6861       htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6862       htab->elf.hgot->def_regular = 1;
6863       htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6864                                | STV_HIDDEN);
6865     }
6866
6867   if (htab->sfpr == NULL)
6868     /* We don't have any relocs.  */
6869     return TRUE;
6870
6871   /* Provide any missing _save* and _rest* functions.  */
6872   htab->sfpr->size = 0;
6873   if (!info->relocatable)
6874     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6875       if (!sfpr_define (info, &funcs[i]))
6876         return FALSE;
6877
6878   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6879
6880   if (htab->sfpr->size == 0)
6881     htab->sfpr->flags |= SEC_EXCLUDE;
6882
6883   return TRUE;
6884 }
6885
6886 /* Return true if we have dynamic relocs that apply to read-only sections.  */
6887
6888 static bfd_boolean
6889 readonly_dynrelocs (struct elf_link_hash_entry *h)
6890 {
6891   struct ppc_link_hash_entry *eh;
6892   struct elf_dyn_relocs *p;
6893
6894   eh = (struct ppc_link_hash_entry *) h;
6895   for (p = eh->dyn_relocs; p != NULL; p = p->next)
6896     {
6897       asection *s = p->sec->output_section;
6898
6899       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6900         return TRUE;
6901     }
6902   return FALSE;
6903 }
6904
6905 /* Adjust a symbol defined by a dynamic object and referenced by a
6906    regular object.  The current definition is in some section of the
6907    dynamic object, but we're not including those sections.  We have to
6908    change the definition to something the rest of the link can
6909    understand.  */
6910
6911 static bfd_boolean
6912 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6913                                  struct elf_link_hash_entry *h)
6914 {
6915   struct ppc_link_hash_table *htab;
6916   asection *s;
6917
6918   htab = ppc_hash_table (info);
6919   if (htab == NULL)
6920     return FALSE;
6921
6922   /* Deal with function syms.  */
6923   if (h->type == STT_FUNC
6924       || h->type == STT_GNU_IFUNC
6925       || h->needs_plt)
6926     {
6927       /* Clear procedure linkage table information for any symbol that
6928          won't need a .plt entry.  */
6929       struct plt_entry *ent;
6930       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6931         if (ent->plt.refcount > 0)
6932           break;
6933       if (ent == NULL
6934           || (h->type != STT_GNU_IFUNC
6935               && (SYMBOL_CALLS_LOCAL (info, h)
6936                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6937                       && h->root.type == bfd_link_hash_undefweak))))
6938         {
6939           h->plt.plist = NULL;
6940           h->needs_plt = 0;
6941         }
6942       else if (abiversion (info->output_bfd) == 2)
6943         {
6944           /* After adjust_dynamic_symbol, non_got_ref set in the
6945              non-shared case means that we have allocated space in
6946              .dynbss for the symbol and thus dyn_relocs for this
6947              symbol should be discarded.
6948              If we get here we know we are making a PLT entry for this
6949              symbol, and in an executable we'd normally resolve
6950              relocations against this symbol to the PLT entry.  Allow
6951              dynamic relocs if the reference is weak, and the dynamic
6952              relocs will not cause text relocation.  */
6953           if (!h->ref_regular_nonweak
6954               && h->non_got_ref
6955               && h->type != STT_GNU_IFUNC
6956               && !readonly_dynrelocs (h))
6957             h->non_got_ref = 0;
6958
6959           /* If making a plt entry, then we don't need copy relocs.  */
6960           return TRUE;
6961         }
6962     }
6963   else
6964     h->plt.plist = NULL;
6965
6966   /* If this is a weak symbol, and there is a real definition, the
6967      processor independent code will have arranged for us to see the
6968      real definition first, and we can just use the same value.  */
6969   if (h->u.weakdef != NULL)
6970     {
6971       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6972                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6973       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6974       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6975       if (ELIMINATE_COPY_RELOCS)
6976         h->non_got_ref = h->u.weakdef->non_got_ref;
6977       return TRUE;
6978     }
6979
6980   /* If we are creating a shared library, we must presume that the
6981      only references to the symbol are via the global offset table.
6982      For such cases we need not do anything here; the relocations will
6983      be handled correctly by relocate_section.  */
6984   if (info->shared)
6985     return TRUE;
6986
6987   /* If there are no references to this symbol that do not use the
6988      GOT, we don't need to generate a copy reloc.  */
6989   if (!h->non_got_ref)
6990     return TRUE;
6991
6992   /* Don't generate a copy reloc for symbols defined in the executable.  */
6993   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6994     return TRUE;
6995
6996   /* If we didn't find any dynamic relocs in read-only sections, then
6997      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6998   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6999     {
7000       h->non_got_ref = 0;
7001       return TRUE;
7002     }
7003
7004   if (h->plt.plist != NULL)
7005     {
7006       /* We should never get here, but unfortunately there are versions
7007          of gcc out there that improperly (for this ABI) put initialized
7008          function pointers, vtable refs and suchlike in read-only
7009          sections.  Allow them to proceed, but warn that this might
7010          break at runtime.  */
7011       info->callbacks->einfo
7012         (_("%P: copy reloc against `%T' requires lazy plt linking; "
7013            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7014          h->root.root.string);
7015     }
7016
7017   /* This is a reference to a symbol defined by a dynamic object which
7018      is not a function.  */
7019
7020   /* We must allocate the symbol in our .dynbss section, which will
7021      become part of the .bss section of the executable.  There will be
7022      an entry for this symbol in the .dynsym section.  The dynamic
7023      object will contain position independent code, so all references
7024      from the dynamic object to this symbol will go through the global
7025      offset table.  The dynamic linker will use the .dynsym entry to
7026      determine the address it must put in the global offset table, so
7027      both the dynamic object and the regular object will refer to the
7028      same memory location for the variable.  */
7029
7030   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7031      to copy the initial value out of the dynamic object and into the
7032      runtime process image.  We need to remember the offset into the
7033      .rela.bss section we are going to use.  */
7034   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7035     {
7036       htab->relbss->size += sizeof (Elf64_External_Rela);
7037       h->needs_copy = 1;
7038     }
7039
7040   s = htab->dynbss;
7041
7042   return _bfd_elf_adjust_dynamic_copy (h, s);
7043 }
7044
7045 /* If given a function descriptor symbol, hide both the function code
7046    sym and the descriptor.  */
7047 static void
7048 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7049                        struct elf_link_hash_entry *h,
7050                        bfd_boolean force_local)
7051 {
7052   struct ppc_link_hash_entry *eh;
7053   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7054
7055   eh = (struct ppc_link_hash_entry *) h;
7056   if (eh->is_func_descriptor)
7057     {
7058       struct ppc_link_hash_entry *fh = eh->oh;
7059
7060       if (fh == NULL)
7061         {
7062           const char *p, *q;
7063           struct ppc_link_hash_table *htab;
7064           char save;
7065
7066           /* We aren't supposed to use alloca in BFD because on
7067              systems which do not have alloca the version in libiberty
7068              calls xmalloc, which might cause the program to crash
7069              when it runs out of memory.  This function doesn't have a
7070              return status, so there's no way to gracefully return an
7071              error.  So cheat.  We know that string[-1] can be safely
7072              accessed;  It's either a string in an ELF string table,
7073              or allocated in an objalloc structure.  */
7074
7075           p = eh->elf.root.root.string - 1;
7076           save = *p;
7077           *(char *) p = '.';
7078           htab = ppc_hash_table (info);
7079           if (htab == NULL)
7080             return;
7081
7082           fh = (struct ppc_link_hash_entry *)
7083             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7084           *(char *) p = save;
7085
7086           /* Unfortunately, if it so happens that the string we were
7087              looking for was allocated immediately before this string,
7088              then we overwrote the string terminator.  That's the only
7089              reason the lookup should fail.  */
7090           if (fh == NULL)
7091             {
7092               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7093               while (q >= eh->elf.root.root.string && *q == *p)
7094                 --q, --p;
7095               if (q < eh->elf.root.root.string && *p == '.')
7096                 fh = (struct ppc_link_hash_entry *)
7097                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7098             }
7099           if (fh != NULL)
7100             {
7101               eh->oh = fh;
7102               fh->oh = eh;
7103             }
7104         }
7105       if (fh != NULL)
7106         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7107     }
7108 }
7109
7110 static bfd_boolean
7111 get_sym_h (struct elf_link_hash_entry **hp,
7112            Elf_Internal_Sym **symp,
7113            asection **symsecp,
7114            unsigned char **tls_maskp,
7115            Elf_Internal_Sym **locsymsp,
7116            unsigned long r_symndx,
7117            bfd *ibfd)
7118 {
7119   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7120
7121   if (r_symndx >= symtab_hdr->sh_info)
7122     {
7123       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7124       struct elf_link_hash_entry *h;
7125
7126       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7127       h = elf_follow_link (h);
7128
7129       if (hp != NULL)
7130         *hp = h;
7131
7132       if (symp != NULL)
7133         *symp = NULL;
7134
7135       if (symsecp != NULL)
7136         {
7137           asection *symsec = NULL;
7138           if (h->root.type == bfd_link_hash_defined
7139               || h->root.type == bfd_link_hash_defweak)
7140             symsec = h->root.u.def.section;
7141           *symsecp = symsec;
7142         }
7143
7144       if (tls_maskp != NULL)
7145         {
7146           struct ppc_link_hash_entry *eh;
7147
7148           eh = (struct ppc_link_hash_entry *) h;
7149           *tls_maskp = &eh->tls_mask;
7150         }
7151     }
7152   else
7153     {
7154       Elf_Internal_Sym *sym;
7155       Elf_Internal_Sym *locsyms = *locsymsp;
7156
7157       if (locsyms == NULL)
7158         {
7159           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7160           if (locsyms == NULL)
7161             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7162                                             symtab_hdr->sh_info,
7163                                             0, NULL, NULL, NULL);
7164           if (locsyms == NULL)
7165             return FALSE;
7166           *locsymsp = locsyms;
7167         }
7168       sym = locsyms + r_symndx;
7169
7170       if (hp != NULL)
7171         *hp = NULL;
7172
7173       if (symp != NULL)
7174         *symp = sym;
7175
7176       if (symsecp != NULL)
7177         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7178
7179       if (tls_maskp != NULL)
7180         {
7181           struct got_entry **lgot_ents;
7182           unsigned char *tls_mask;
7183
7184           tls_mask = NULL;
7185           lgot_ents = elf_local_got_ents (ibfd);
7186           if (lgot_ents != NULL)
7187             {
7188               struct plt_entry **local_plt = (struct plt_entry **)
7189                 (lgot_ents + symtab_hdr->sh_info);
7190               unsigned char *lgot_masks = (unsigned char *)
7191                 (local_plt + symtab_hdr->sh_info);
7192               tls_mask = &lgot_masks[r_symndx];
7193             }
7194           *tls_maskp = tls_mask;
7195         }
7196     }
7197   return TRUE;
7198 }
7199
7200 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
7201    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7202    type suitable for optimization, and 1 otherwise.  */
7203
7204 static int
7205 get_tls_mask (unsigned char **tls_maskp,
7206               unsigned long *toc_symndx,
7207               bfd_vma *toc_addend,
7208               Elf_Internal_Sym **locsymsp,
7209               const Elf_Internal_Rela *rel,
7210               bfd *ibfd)
7211 {
7212   unsigned long r_symndx;
7213   int next_r;
7214   struct elf_link_hash_entry *h;
7215   Elf_Internal_Sym *sym;
7216   asection *sec;
7217   bfd_vma off;
7218
7219   r_symndx = ELF64_R_SYM (rel->r_info);
7220   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7221     return 0;
7222
7223   if ((*tls_maskp != NULL && **tls_maskp != 0)
7224       || sec == NULL
7225       || ppc64_elf_section_data (sec) == NULL
7226       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7227     return 1;
7228
7229   /* Look inside a TOC section too.  */
7230   if (h != NULL)
7231     {
7232       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7233       off = h->root.u.def.value;
7234     }
7235   else
7236     off = sym->st_value;
7237   off += rel->r_addend;
7238   BFD_ASSERT (off % 8 == 0);
7239   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7240   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7241   if (toc_symndx != NULL)
7242     *toc_symndx = r_symndx;
7243   if (toc_addend != NULL)
7244     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7245   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7246     return 0;
7247   if ((h == NULL || is_static_defined (h))
7248       && (next_r == -1 || next_r == -2))
7249     return 1 - next_r;
7250   return 1;
7251 }
7252
7253 /* Find (or create) an entry in the tocsave hash table.  */
7254
7255 static struct tocsave_entry *
7256 tocsave_find (struct ppc_link_hash_table *htab,
7257               enum insert_option insert,
7258               Elf_Internal_Sym **local_syms,
7259               const Elf_Internal_Rela *irela,
7260               bfd *ibfd)
7261 {
7262   unsigned long r_indx;
7263   struct elf_link_hash_entry *h;
7264   Elf_Internal_Sym *sym;
7265   struct tocsave_entry ent, *p;
7266   hashval_t hash;
7267   struct tocsave_entry **slot;
7268
7269   r_indx = ELF64_R_SYM (irela->r_info);
7270   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7271     return NULL;
7272   if (ent.sec == NULL || ent.sec->output_section == NULL)
7273     {
7274       (*_bfd_error_handler)
7275         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7276       return NULL;
7277     }
7278
7279   if (h != NULL)
7280     ent.offset = h->root.u.def.value;
7281   else
7282     ent.offset = sym->st_value;
7283   ent.offset += irela->r_addend;
7284
7285   hash = tocsave_htab_hash (&ent);
7286   slot = ((struct tocsave_entry **)
7287           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7288   if (slot == NULL)
7289     return NULL;
7290
7291   if (*slot == NULL)
7292     {
7293       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7294       if (p == NULL)
7295         return NULL;
7296       *p = ent;
7297       *slot = p;
7298     }
7299   return *slot;
7300 }
7301
7302 /* Adjust all global syms defined in opd sections.  In gcc generated
7303    code for the old ABI, these will already have been done.  */
7304
7305 static bfd_boolean
7306 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7307 {
7308   struct ppc_link_hash_entry *eh;
7309   asection *sym_sec;
7310   struct _opd_sec_data *opd;
7311
7312   if (h->root.type == bfd_link_hash_indirect)
7313     return TRUE;
7314
7315   if (h->root.type != bfd_link_hash_defined
7316       && h->root.type != bfd_link_hash_defweak)
7317     return TRUE;
7318
7319   eh = (struct ppc_link_hash_entry *) h;
7320   if (eh->adjust_done)
7321     return TRUE;
7322
7323   sym_sec = eh->elf.root.u.def.section;
7324   opd = get_opd_info (sym_sec);
7325   if (opd != NULL && opd->adjust != NULL)
7326     {
7327       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7328       if (adjust == -1)
7329         {
7330           /* This entry has been deleted.  */
7331           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7332           if (dsec == NULL)
7333             {
7334               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7335                 if (discarded_section (dsec))
7336                   {
7337                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7338                     break;
7339                   }
7340             }
7341           eh->elf.root.u.def.value = 0;
7342           eh->elf.root.u.def.section = dsec;
7343         }
7344       else
7345         eh->elf.root.u.def.value += adjust;
7346       eh->adjust_done = 1;
7347     }
7348   return TRUE;
7349 }
7350
7351 /* Handles decrementing dynamic reloc counts for the reloc specified by
7352    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7353    have already been determined.  */
7354
7355 static bfd_boolean
7356 dec_dynrel_count (bfd_vma r_info,
7357                   asection *sec,
7358                   struct bfd_link_info *info,
7359                   Elf_Internal_Sym **local_syms,
7360                   struct elf_link_hash_entry *h,
7361                   Elf_Internal_Sym *sym)
7362 {
7363   enum elf_ppc64_reloc_type r_type;
7364   asection *sym_sec = NULL;
7365
7366   /* Can this reloc be dynamic?  This switch, and later tests here
7367      should be kept in sync with the code in check_relocs.  */
7368   r_type = ELF64_R_TYPE (r_info);
7369   switch (r_type)
7370     {
7371     default:
7372       return TRUE;
7373
7374     case R_PPC64_TPREL16:
7375     case R_PPC64_TPREL16_LO:
7376     case R_PPC64_TPREL16_HI:
7377     case R_PPC64_TPREL16_HA:
7378     case R_PPC64_TPREL16_DS:
7379     case R_PPC64_TPREL16_LO_DS:
7380     case R_PPC64_TPREL16_HIGH:
7381     case R_PPC64_TPREL16_HIGHA:
7382     case R_PPC64_TPREL16_HIGHER:
7383     case R_PPC64_TPREL16_HIGHERA:
7384     case R_PPC64_TPREL16_HIGHEST:
7385     case R_PPC64_TPREL16_HIGHESTA:
7386       if (!info->shared)
7387         return TRUE;
7388
7389     case R_PPC64_TPREL64:
7390     case R_PPC64_DTPMOD64:
7391     case R_PPC64_DTPREL64:
7392     case R_PPC64_ADDR64:
7393     case R_PPC64_REL30:
7394     case R_PPC64_REL32:
7395     case R_PPC64_REL64:
7396     case R_PPC64_ADDR14:
7397     case R_PPC64_ADDR14_BRNTAKEN:
7398     case R_PPC64_ADDR14_BRTAKEN:
7399     case R_PPC64_ADDR16:
7400     case R_PPC64_ADDR16_DS:
7401     case R_PPC64_ADDR16_HA:
7402     case R_PPC64_ADDR16_HI:
7403     case R_PPC64_ADDR16_HIGH:
7404     case R_PPC64_ADDR16_HIGHA:
7405     case R_PPC64_ADDR16_HIGHER:
7406     case R_PPC64_ADDR16_HIGHERA:
7407     case R_PPC64_ADDR16_HIGHEST:
7408     case R_PPC64_ADDR16_HIGHESTA:
7409     case R_PPC64_ADDR16_LO:
7410     case R_PPC64_ADDR16_LO_DS:
7411     case R_PPC64_ADDR24:
7412     case R_PPC64_ADDR32:
7413     case R_PPC64_UADDR16:
7414     case R_PPC64_UADDR32:
7415     case R_PPC64_UADDR64:
7416     case R_PPC64_TOC:
7417       break;
7418     }
7419
7420   if (local_syms != NULL)
7421     {
7422       unsigned long r_symndx;
7423       bfd *ibfd = sec->owner;
7424
7425       r_symndx = ELF64_R_SYM (r_info);
7426       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7427         return FALSE;
7428     }
7429
7430   if ((info->shared
7431        && (must_be_dyn_reloc (info, r_type)
7432            || (h != NULL
7433                && (!SYMBOLIC_BIND (info, h)
7434                    || h->root.type == bfd_link_hash_defweak
7435                    || !h->def_regular))))
7436       || (ELIMINATE_COPY_RELOCS
7437           && !info->shared
7438           && h != NULL
7439           && (h->root.type == bfd_link_hash_defweak
7440               || !h->def_regular)))
7441     ;
7442   else
7443     return TRUE;
7444
7445   if (h != NULL)
7446     {
7447       struct elf_dyn_relocs *p;
7448       struct elf_dyn_relocs **pp;
7449       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7450
7451       /* elf_gc_sweep may have already removed all dyn relocs associated
7452          with local syms for a given section.  Also, symbol flags are
7453          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7454          report a dynreloc miscount.  */
7455       if (*pp == NULL && info->gc_sections)
7456         return TRUE;
7457
7458       while ((p = *pp) != NULL)
7459         {
7460           if (p->sec == sec)
7461             {
7462               if (!must_be_dyn_reloc (info, r_type))
7463                 p->pc_count -= 1;
7464               p->count -= 1;
7465               if (p->count == 0)
7466                 *pp = p->next;
7467               return TRUE;
7468             }
7469           pp = &p->next;
7470         }
7471     }
7472   else
7473     {
7474       struct ppc_dyn_relocs *p;
7475       struct ppc_dyn_relocs **pp;
7476       void *vpp;
7477       bfd_boolean is_ifunc;
7478
7479       if (local_syms == NULL)
7480         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7481       if (sym_sec == NULL)
7482         sym_sec = sec;
7483
7484       vpp = &elf_section_data (sym_sec)->local_dynrel;
7485       pp = (struct ppc_dyn_relocs **) vpp;
7486
7487       if (*pp == NULL && info->gc_sections)
7488         return TRUE;
7489
7490       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7491       while ((p = *pp) != NULL)
7492         {
7493           if (p->sec == sec && p->ifunc == is_ifunc)
7494             {
7495               p->count -= 1;
7496               if (p->count == 0)
7497                 *pp = p->next;
7498               return TRUE;
7499             }
7500           pp = &p->next;
7501         }
7502     }
7503
7504   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7505                           sec->owner, sec);
7506   bfd_set_error (bfd_error_bad_value);
7507   return FALSE;
7508 }
7509
7510 /* Remove unused Official Procedure Descriptor entries.  Currently we
7511    only remove those associated with functions in discarded link-once
7512    sections, or weakly defined functions that have been overridden.  It
7513    would be possible to remove many more entries for statically linked
7514    applications.  */
7515
7516 bfd_boolean
7517 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7518 {
7519   bfd *ibfd;
7520   bfd_boolean some_edited = FALSE;
7521   asection *need_pad = NULL;
7522
7523   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7524     {
7525       asection *sec;
7526       Elf_Internal_Rela *relstart, *rel, *relend;
7527       Elf_Internal_Shdr *symtab_hdr;
7528       Elf_Internal_Sym *local_syms;
7529       bfd_vma offset;
7530       struct _opd_sec_data *opd;
7531       bfd_boolean need_edit, add_aux_fields;
7532       bfd_size_type cnt_16b = 0;
7533
7534       if (!is_ppc64_elf (ibfd))
7535         continue;
7536
7537       sec = bfd_get_section_by_name (ibfd, ".opd");
7538       if (sec == NULL || sec->size == 0)
7539         continue;
7540
7541       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7542         continue;
7543
7544       if (sec->output_section == bfd_abs_section_ptr)
7545         continue;
7546
7547       /* Look through the section relocs.  */
7548       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7549         continue;
7550
7551       local_syms = NULL;
7552       symtab_hdr = &elf_symtab_hdr (ibfd);
7553
7554       /* Read the relocations.  */
7555       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7556                                             info->keep_memory);
7557       if (relstart == NULL)
7558         return FALSE;
7559
7560       /* First run through the relocs to check they are sane, and to
7561          determine whether we need to edit this opd section.  */
7562       need_edit = FALSE;
7563       need_pad = sec;
7564       offset = 0;
7565       relend = relstart + sec->reloc_count;
7566       for (rel = relstart; rel < relend; )
7567         {
7568           enum elf_ppc64_reloc_type r_type;
7569           unsigned long r_symndx;
7570           asection *sym_sec;
7571           struct elf_link_hash_entry *h;
7572           Elf_Internal_Sym *sym;
7573
7574           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7575              only interested in the reloc pointing to a function entry
7576              point.  */
7577           if (rel->r_offset != offset
7578               || rel + 1 >= relend
7579               || (rel + 1)->r_offset != offset + 8)
7580             {
7581               /* If someone messes with .opd alignment then after a
7582                  "ld -r" we might have padding in the middle of .opd.
7583                  Also, there's nothing to prevent someone putting
7584                  something silly in .opd with the assembler.  No .opd
7585                  optimization for them!  */
7586             broken_opd:
7587               (*_bfd_error_handler)
7588                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7589               need_edit = FALSE;
7590               break;
7591             }
7592
7593           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7594               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7595             {
7596               (*_bfd_error_handler)
7597                 (_("%B: unexpected reloc type %u in .opd section"),
7598                  ibfd, r_type);
7599               need_edit = FALSE;
7600               break;
7601             }
7602
7603           r_symndx = ELF64_R_SYM (rel->r_info);
7604           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7605                           r_symndx, ibfd))
7606             goto error_ret;
7607
7608           if (sym_sec == NULL || sym_sec->owner == NULL)
7609             {
7610               const char *sym_name;
7611               if (h != NULL)
7612                 sym_name = h->root.root.string;
7613               else
7614                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7615                                              sym_sec);
7616
7617               (*_bfd_error_handler)
7618                 (_("%B: undefined sym `%s' in .opd section"),
7619                  ibfd, sym_name);
7620               need_edit = FALSE;
7621               break;
7622             }
7623
7624           /* opd entries are always for functions defined in the
7625              current input bfd.  If the symbol isn't defined in the
7626              input bfd, then we won't be using the function in this
7627              bfd;  It must be defined in a linkonce section in another
7628              bfd, or is weak.  It's also possible that we are
7629              discarding the function due to a linker script /DISCARD/,
7630              which we test for via the output_section.  */
7631           if (sym_sec->owner != ibfd
7632               || sym_sec->output_section == bfd_abs_section_ptr)
7633             need_edit = TRUE;
7634
7635           rel += 2;
7636           if (rel == relend
7637               || (rel + 1 == relend && rel->r_offset == offset + 16))
7638             {
7639               if (sec->size == offset + 24)
7640                 {
7641                   need_pad = NULL;
7642                   break;
7643                 }
7644               if (rel == relend && sec->size == offset + 16)
7645                 {
7646                   cnt_16b++;
7647                   break;
7648                 }
7649               goto broken_opd;
7650             }
7651
7652           if (rel->r_offset == offset + 24)
7653             offset += 24;
7654           else if (rel->r_offset != offset + 16)
7655             goto broken_opd;
7656           else if (rel + 1 < relend
7657                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7658                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7659             {
7660               offset += 16;
7661               cnt_16b++;
7662             }
7663           else if (rel + 2 < relend
7664                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7665                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7666             {
7667               offset += 24;
7668               rel += 1;
7669             }
7670           else
7671             goto broken_opd;
7672         }
7673
7674       add_aux_fields = non_overlapping && cnt_16b > 0;
7675
7676       if (need_edit || add_aux_fields)
7677         {
7678           Elf_Internal_Rela *write_rel;
7679           Elf_Internal_Shdr *rel_hdr;
7680           bfd_byte *rptr, *wptr;
7681           bfd_byte *new_contents;
7682           bfd_boolean skip;
7683           long opd_ent_size;
7684           bfd_size_type amt;
7685
7686           new_contents = NULL;
7687           amt = sec->size * sizeof (long) / 8;
7688           opd = &ppc64_elf_section_data (sec)->u.opd;
7689           opd->adjust = bfd_zalloc (sec->owner, amt);
7690           if (opd->adjust == NULL)
7691             return FALSE;
7692           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7693
7694           /* This seems a waste of time as input .opd sections are all
7695              zeros as generated by gcc, but I suppose there's no reason
7696              this will always be so.  We might start putting something in
7697              the third word of .opd entries.  */
7698           if ((sec->flags & SEC_IN_MEMORY) == 0)
7699             {
7700               bfd_byte *loc;
7701               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7702                 {
7703                   if (loc != NULL)
7704                     free (loc);
7705                 error_ret:
7706                   if (local_syms != NULL
7707                       && symtab_hdr->contents != (unsigned char *) local_syms)
7708                     free (local_syms);
7709                   if (elf_section_data (sec)->relocs != relstart)
7710                     free (relstart);
7711                   return FALSE;
7712                 }
7713               sec->contents = loc;
7714               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7715             }
7716
7717           elf_section_data (sec)->relocs = relstart;
7718
7719           new_contents = sec->contents;
7720           if (add_aux_fields)
7721             {
7722               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7723               if (new_contents == NULL)
7724                 return FALSE;
7725               need_pad = FALSE;
7726             }
7727           wptr = new_contents;
7728           rptr = sec->contents;
7729
7730           write_rel = relstart;
7731           skip = FALSE;
7732           offset = 0;
7733           opd_ent_size = 0;
7734           for (rel = relstart; rel < relend; rel++)
7735             {
7736               unsigned long r_symndx;
7737               asection *sym_sec;
7738               struct elf_link_hash_entry *h;
7739               Elf_Internal_Sym *sym;
7740
7741               r_symndx = ELF64_R_SYM (rel->r_info);
7742               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7743                               r_symndx, ibfd))
7744                 goto error_ret;
7745
7746               if (rel->r_offset == offset)
7747                 {
7748                   struct ppc_link_hash_entry *fdh = NULL;
7749
7750                   /* See if the .opd entry is full 24 byte or
7751                      16 byte (with fd_aux entry overlapped with next
7752                      fd_func).  */
7753                   opd_ent_size = 24;
7754                   if ((rel + 2 == relend && sec->size == offset + 16)
7755                       || (rel + 3 < relend
7756                           && rel[2].r_offset == offset + 16
7757                           && rel[3].r_offset == offset + 24
7758                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7759                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7760                     opd_ent_size = 16;
7761
7762                   if (h != NULL
7763                       && h->root.root.string[0] == '.')
7764                     {
7765                       struct ppc_link_hash_table *htab;
7766
7767                       htab = ppc_hash_table (info);
7768                       if (htab != NULL)
7769                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7770                                           htab);
7771                       if (fdh != NULL
7772                           && fdh->elf.root.type != bfd_link_hash_defined
7773                           && fdh->elf.root.type != bfd_link_hash_defweak)
7774                         fdh = NULL;
7775                     }
7776
7777                   skip = (sym_sec->owner != ibfd
7778                           || sym_sec->output_section == bfd_abs_section_ptr);
7779                   if (skip)
7780                     {
7781                       if (fdh != NULL && sym_sec->owner == ibfd)
7782                         {
7783                           /* Arrange for the function descriptor sym
7784                              to be dropped.  */
7785                           fdh->elf.root.u.def.value = 0;
7786                           fdh->elf.root.u.def.section = sym_sec;
7787                         }
7788                       opd->adjust[rel->r_offset / 8] = -1;
7789                     }
7790                   else
7791                     {
7792                       /* We'll be keeping this opd entry.  */
7793
7794                       if (fdh != NULL)
7795                         {
7796                           /* Redefine the function descriptor symbol to
7797                              this location in the opd section.  It is
7798                              necessary to update the value here rather
7799                              than using an array of adjustments as we do
7800                              for local symbols, because various places
7801                              in the generic ELF code use the value
7802                              stored in u.def.value.  */
7803                           fdh->elf.root.u.def.value = wptr - new_contents;
7804                           fdh->adjust_done = 1;
7805                         }
7806
7807                       /* Local syms are a bit tricky.  We could
7808                          tweak them as they can be cached, but
7809                          we'd need to look through the local syms
7810                          for the function descriptor sym which we
7811                          don't have at the moment.  So keep an
7812                          array of adjustments.  */
7813                       opd->adjust[rel->r_offset / 8]
7814                         = (wptr - new_contents) - (rptr - sec->contents);
7815
7816                       if (wptr != rptr)
7817                         memcpy (wptr, rptr, opd_ent_size);
7818                       wptr += opd_ent_size;
7819                       if (add_aux_fields && opd_ent_size == 16)
7820                         {
7821                           memset (wptr, '\0', 8);
7822                           wptr += 8;
7823                         }
7824                     }
7825                   rptr += opd_ent_size;
7826                   offset += opd_ent_size;
7827                 }
7828
7829               if (skip)
7830                 {
7831                   if (!NO_OPD_RELOCS
7832                       && !info->relocatable
7833                       && !dec_dynrel_count (rel->r_info, sec, info,
7834                                             NULL, h, sym))
7835                     goto error_ret;
7836                 }
7837               else
7838                 {
7839                   /* We need to adjust any reloc offsets to point to the
7840                      new opd entries.  While we're at it, we may as well
7841                      remove redundant relocs.  */
7842                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7843                   if (write_rel != rel)
7844                     memcpy (write_rel, rel, sizeof (*rel));
7845                   ++write_rel;
7846                 }
7847             }
7848
7849           sec->size = wptr - new_contents;
7850           sec->reloc_count = write_rel - relstart;
7851           if (add_aux_fields)
7852             {
7853               free (sec->contents);
7854               sec->contents = new_contents;
7855             }
7856
7857           /* Fudge the header size too, as this is used later in
7858              elf_bfd_final_link if we are emitting relocs.  */
7859           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7860           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7861           some_edited = TRUE;
7862         }
7863       else if (elf_section_data (sec)->relocs != relstart)
7864         free (relstart);
7865
7866       if (local_syms != NULL
7867           && symtab_hdr->contents != (unsigned char *) local_syms)
7868         {
7869           if (!info->keep_memory)
7870             free (local_syms);
7871           else
7872             symtab_hdr->contents = (unsigned char *) local_syms;
7873         }
7874     }
7875
7876   if (some_edited)
7877     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7878
7879   /* If we are doing a final link and the last .opd entry is just 16 byte
7880      long, add a 8 byte padding after it.  */
7881   if (need_pad != NULL && !info->relocatable)
7882     {
7883       bfd_byte *p;
7884
7885       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7886         {
7887           BFD_ASSERT (need_pad->size > 0);
7888
7889           p = bfd_malloc (need_pad->size + 8);
7890           if (p == NULL)
7891             return FALSE;
7892
7893           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7894                                           p, 0, need_pad->size))
7895             return FALSE;
7896
7897           need_pad->contents = p;
7898           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7899         }
7900       else
7901         {
7902           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7903           if (p == NULL)
7904             return FALSE;
7905
7906           need_pad->contents = p;
7907         }
7908
7909       memset (need_pad->contents + need_pad->size, 0, 8);
7910       need_pad->size += 8;
7911     }
7912
7913   return TRUE;
7914 }
7915
7916 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7917
7918 asection *
7919 ppc64_elf_tls_setup (struct bfd_link_info *info,
7920                      int no_tls_get_addr_opt,
7921                      int *no_multi_toc)
7922 {
7923   struct ppc_link_hash_table *htab;
7924
7925   htab = ppc_hash_table (info);
7926   if (htab == NULL)
7927     return NULL;
7928
7929   if (abiversion (info->output_bfd) == 1)
7930     htab->opd_abi = 1;
7931
7932   if (*no_multi_toc)
7933     htab->do_multi_toc = 0;
7934   else if (!htab->do_multi_toc)
7935     *no_multi_toc = 1;
7936
7937   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7938                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7939                                               FALSE, FALSE, TRUE));
7940   /* Move dynamic linking info to the function descriptor sym.  */
7941   if (htab->tls_get_addr != NULL)
7942     func_desc_adjust (&htab->tls_get_addr->elf, info);
7943   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7944                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7945                                                  FALSE, FALSE, TRUE));
7946   if (!no_tls_get_addr_opt)
7947     {
7948       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7949
7950       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7951                                   FALSE, FALSE, TRUE);
7952       if (opt != NULL)
7953         func_desc_adjust (opt, info);
7954       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7955                                      FALSE, FALSE, TRUE);
7956       if (opt_fd != NULL
7957           && (opt_fd->root.type == bfd_link_hash_defined
7958               || opt_fd->root.type == bfd_link_hash_defweak))
7959         {
7960           /* If glibc supports an optimized __tls_get_addr call stub,
7961              signalled by the presence of __tls_get_addr_opt, and we'll
7962              be calling __tls_get_addr via a plt call stub, then
7963              make __tls_get_addr point to __tls_get_addr_opt.  */
7964           tga_fd = &htab->tls_get_addr_fd->elf;
7965           if (htab->elf.dynamic_sections_created
7966               && tga_fd != NULL
7967               && (tga_fd->type == STT_FUNC
7968                   || tga_fd->needs_plt)
7969               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7970                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7971                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7972             {
7973               struct plt_entry *ent;
7974
7975               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7976                 if (ent->plt.refcount > 0)
7977                   break;
7978               if (ent != NULL)
7979                 {
7980                   tga_fd->root.type = bfd_link_hash_indirect;
7981                   tga_fd->root.u.i.link = &opt_fd->root;
7982                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7983                   if (opt_fd->dynindx != -1)
7984                     {
7985                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7986                       opt_fd->dynindx = -1;
7987                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7988                                               opt_fd->dynstr_index);
7989                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7990                         return NULL;
7991                     }
7992                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7993                   tga = &htab->tls_get_addr->elf;
7994                   if (opt != NULL && tga != NULL)
7995                     {
7996                       tga->root.type = bfd_link_hash_indirect;
7997                       tga->root.u.i.link = &opt->root;
7998                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7999                       _bfd_elf_link_hash_hide_symbol (info, opt,
8000                                                       tga->forced_local);
8001                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8002                     }
8003                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8004                   htab->tls_get_addr_fd->is_func_descriptor = 1;
8005                   if (htab->tls_get_addr != NULL)
8006                     {
8007                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8008                       htab->tls_get_addr->is_func = 1;
8009                     }
8010                 }
8011             }
8012         }
8013       else
8014         no_tls_get_addr_opt = TRUE;
8015     }
8016   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8017   return _bfd_elf_tls_setup (info->output_bfd, info);
8018 }
8019
8020 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8021    HASH1 or HASH2.  */
8022
8023 static bfd_boolean
8024 branch_reloc_hash_match (const bfd *ibfd,
8025                          const Elf_Internal_Rela *rel,
8026                          const struct ppc_link_hash_entry *hash1,
8027                          const struct ppc_link_hash_entry *hash2)
8028 {
8029   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8030   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8031   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8032
8033   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8034     {
8035       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8036       struct elf_link_hash_entry *h;
8037
8038       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8039       h = elf_follow_link (h);
8040       if (h == &hash1->elf || h == &hash2->elf)
8041         return TRUE;
8042     }
8043   return FALSE;
8044 }
8045
8046 /* Run through all the TLS relocs looking for optimization
8047    opportunities.  The linker has been hacked (see ppc64elf.em) to do
8048    a preliminary section layout so that we know the TLS segment
8049    offsets.  We can't optimize earlier because some optimizations need
8050    to know the tp offset, and we need to optimize before allocating
8051    dynamic relocations.  */
8052
8053 bfd_boolean
8054 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8055 {
8056   bfd *ibfd;
8057   asection *sec;
8058   struct ppc_link_hash_table *htab;
8059   unsigned char *toc_ref;
8060   int pass;
8061
8062   if (info->relocatable || !info->executable)
8063     return TRUE;
8064
8065   htab = ppc_hash_table (info);
8066   if (htab == NULL)
8067     return FALSE;
8068
8069   /* Make two passes over the relocs.  On the first pass, mark toc
8070      entries involved with tls relocs, and check that tls relocs
8071      involved in setting up a tls_get_addr call are indeed followed by
8072      such a call.  If they are not, we can't do any tls optimization.
8073      On the second pass twiddle tls_mask flags to notify
8074      relocate_section that optimization can be done, and adjust got
8075      and plt refcounts.  */
8076   toc_ref = NULL;
8077   for (pass = 0; pass < 2; ++pass)
8078     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8079       {
8080         Elf_Internal_Sym *locsyms = NULL;
8081         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8082
8083         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8084           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8085             {
8086               Elf_Internal_Rela *relstart, *rel, *relend;
8087               bfd_boolean found_tls_get_addr_arg = 0;
8088
8089               /* Read the relocations.  */
8090               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8091                                                     info->keep_memory);
8092               if (relstart == NULL)
8093                 {
8094                   free (toc_ref);
8095                   return FALSE;
8096                 }
8097
8098               relend = relstart + sec->reloc_count;
8099               for (rel = relstart; rel < relend; rel++)
8100                 {
8101                   enum elf_ppc64_reloc_type r_type;
8102                   unsigned long r_symndx;
8103                   struct elf_link_hash_entry *h;
8104                   Elf_Internal_Sym *sym;
8105                   asection *sym_sec;
8106                   unsigned char *tls_mask;
8107                   unsigned char tls_set, tls_clear, tls_type = 0;
8108                   bfd_vma value;
8109                   bfd_boolean ok_tprel, is_local;
8110                   long toc_ref_index = 0;
8111                   int expecting_tls_get_addr = 0;
8112                   bfd_boolean ret = FALSE;
8113
8114                   r_symndx = ELF64_R_SYM (rel->r_info);
8115                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8116                                   r_symndx, ibfd))
8117                     {
8118                     err_free_rel:
8119                       if (elf_section_data (sec)->relocs != relstart)
8120                         free (relstart);
8121                       if (toc_ref != NULL)
8122                         free (toc_ref);
8123                       if (locsyms != NULL
8124                           && (elf_symtab_hdr (ibfd).contents
8125                               != (unsigned char *) locsyms))
8126                         free (locsyms);
8127                       return ret;
8128                     }
8129
8130                   if (h != NULL)
8131                     {
8132                       if (h->root.type == bfd_link_hash_defined
8133                           || h->root.type == bfd_link_hash_defweak)
8134                         value = h->root.u.def.value;
8135                       else if (h->root.type == bfd_link_hash_undefweak)
8136                         value = 0;
8137                       else
8138                         {
8139                           found_tls_get_addr_arg = 0;
8140                           continue;
8141                         }
8142                     }
8143                   else
8144                     /* Symbols referenced by TLS relocs must be of type
8145                        STT_TLS.  So no need for .opd local sym adjust.  */
8146                     value = sym->st_value;
8147
8148                   ok_tprel = FALSE;
8149                   is_local = FALSE;
8150                   if (h == NULL
8151                       || !h->def_dynamic)
8152                     {
8153                       is_local = TRUE;
8154                       if (h != NULL
8155                           && h->root.type == bfd_link_hash_undefweak)
8156                         ok_tprel = TRUE;
8157                       else
8158                         {
8159                           value += sym_sec->output_offset;
8160                           value += sym_sec->output_section->vma;
8161                           value -= htab->elf.tls_sec->vma;
8162                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8163                                       < (bfd_vma) 1 << 32);
8164                         }
8165                     }
8166
8167                   r_type = ELF64_R_TYPE (rel->r_info);
8168                   /* If this section has old-style __tls_get_addr calls
8169                      without marker relocs, then check that each
8170                      __tls_get_addr call reloc is preceded by a reloc
8171                      that conceivably belongs to the __tls_get_addr arg
8172                      setup insn.  If we don't find matching arg setup
8173                      relocs, don't do any tls optimization.  */
8174                   if (pass == 0
8175                       && sec->has_tls_get_addr_call
8176                       && h != NULL
8177                       && (h == &htab->tls_get_addr->elf
8178                           || h == &htab->tls_get_addr_fd->elf)
8179                       && !found_tls_get_addr_arg
8180                       && is_branch_reloc (r_type))
8181                     {
8182                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8183                                                 "TLS optimization disabled\n"),
8184                                               ibfd, sec, rel->r_offset);
8185                       ret = TRUE;
8186                       goto err_free_rel;
8187                     }
8188
8189                   found_tls_get_addr_arg = 0;
8190                   switch (r_type)
8191                     {
8192                     case R_PPC64_GOT_TLSLD16:
8193                     case R_PPC64_GOT_TLSLD16_LO:
8194                       expecting_tls_get_addr = 1;
8195                       found_tls_get_addr_arg = 1;
8196                       /* Fall thru */
8197
8198                     case R_PPC64_GOT_TLSLD16_HI:
8199                     case R_PPC64_GOT_TLSLD16_HA:
8200                       /* These relocs should never be against a symbol
8201                          defined in a shared lib.  Leave them alone if
8202                          that turns out to be the case.  */
8203                       if (!is_local)
8204                         continue;
8205
8206                       /* LD -> LE */
8207                       tls_set = 0;
8208                       tls_clear = TLS_LD;
8209                       tls_type = TLS_TLS | TLS_LD;
8210                       break;
8211
8212                     case R_PPC64_GOT_TLSGD16:
8213                     case R_PPC64_GOT_TLSGD16_LO:
8214                       expecting_tls_get_addr = 1;
8215                       found_tls_get_addr_arg = 1;
8216                       /* Fall thru */
8217
8218                     case R_PPC64_GOT_TLSGD16_HI:
8219                     case R_PPC64_GOT_TLSGD16_HA:
8220                       if (ok_tprel)
8221                         /* GD -> LE */
8222                         tls_set = 0;
8223                       else
8224                         /* GD -> IE */
8225                         tls_set = TLS_TLS | TLS_TPRELGD;
8226                       tls_clear = TLS_GD;
8227                       tls_type = TLS_TLS | TLS_GD;
8228                       break;
8229
8230                     case R_PPC64_GOT_TPREL16_DS:
8231                     case R_PPC64_GOT_TPREL16_LO_DS:
8232                     case R_PPC64_GOT_TPREL16_HI:
8233                     case R_PPC64_GOT_TPREL16_HA:
8234                       if (ok_tprel)
8235                         {
8236                           /* IE -> LE */
8237                           tls_set = 0;
8238                           tls_clear = TLS_TPREL;
8239                           tls_type = TLS_TLS | TLS_TPREL;
8240                           break;
8241                         }
8242                       continue;
8243
8244                     case R_PPC64_TLSGD:
8245                     case R_PPC64_TLSLD:
8246                       found_tls_get_addr_arg = 1;
8247                       /* Fall thru */
8248
8249                     case R_PPC64_TLS:
8250                     case R_PPC64_TOC16:
8251                     case R_PPC64_TOC16_LO:
8252                       if (sym_sec == NULL || sym_sec != toc)
8253                         continue;
8254
8255                       /* Mark this toc entry as referenced by a TLS
8256                          code sequence.  We can do that now in the
8257                          case of R_PPC64_TLS, and after checking for
8258                          tls_get_addr for the TOC16 relocs.  */
8259                       if (toc_ref == NULL)
8260                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8261                       if (toc_ref == NULL)
8262                         goto err_free_rel;
8263
8264                       if (h != NULL)
8265                         value = h->root.u.def.value;
8266                       else
8267                         value = sym->st_value;
8268                       value += rel->r_addend;
8269                       BFD_ASSERT (value < toc->size && value % 8 == 0);
8270                       toc_ref_index = (value + toc->output_offset) / 8;
8271                       if (r_type == R_PPC64_TLS
8272                           || r_type == R_PPC64_TLSGD
8273                           || r_type == R_PPC64_TLSLD)
8274                         {
8275                           toc_ref[toc_ref_index] = 1;
8276                           continue;
8277                         }
8278
8279                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
8280                         continue;
8281
8282                       tls_set = 0;
8283                       tls_clear = 0;
8284                       expecting_tls_get_addr = 2;
8285                       break;
8286
8287                     case R_PPC64_TPREL64:
8288                       if (pass == 0
8289                           || sec != toc
8290                           || toc_ref == NULL
8291                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8292                         continue;
8293                       if (ok_tprel)
8294                         {
8295                           /* IE -> LE */
8296                           tls_set = TLS_EXPLICIT;
8297                           tls_clear = TLS_TPREL;
8298                           break;
8299                         }
8300                       continue;
8301
8302                     case R_PPC64_DTPMOD64:
8303                       if (pass == 0
8304                           || sec != toc
8305                           || toc_ref == NULL
8306                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8307                         continue;
8308                       if (rel + 1 < relend
8309                           && (rel[1].r_info
8310                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8311                           && rel[1].r_offset == rel->r_offset + 8)
8312                         {
8313                           if (ok_tprel)
8314                             /* GD -> LE */
8315                             tls_set = TLS_EXPLICIT | TLS_GD;
8316                           else
8317                             /* GD -> IE */
8318                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8319                           tls_clear = TLS_GD;
8320                         }
8321                       else
8322                         {
8323                           if (!is_local)
8324                             continue;
8325
8326                           /* LD -> LE */
8327                           tls_set = TLS_EXPLICIT;
8328                           tls_clear = TLS_LD;
8329                         }
8330                       break;
8331
8332                     default:
8333                       continue;
8334                     }
8335
8336                   if (pass == 0)
8337                     {
8338                       if (!expecting_tls_get_addr
8339                           || !sec->has_tls_get_addr_call)
8340                         continue;
8341
8342                       if (rel + 1 < relend
8343                           && branch_reloc_hash_match (ibfd, rel + 1,
8344                                                       htab->tls_get_addr,
8345                                                       htab->tls_get_addr_fd))
8346                         {
8347                           if (expecting_tls_get_addr == 2)
8348                             {
8349                               /* Check for toc tls entries.  */
8350                               unsigned char *toc_tls;
8351                               int retval;
8352
8353                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8354                                                      &locsyms,
8355                                                      rel, ibfd);
8356                               if (retval == 0)
8357                                 goto err_free_rel;
8358                               if (toc_tls != NULL)
8359                                 {
8360                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8361                                     found_tls_get_addr_arg = 1;
8362                                   if (retval > 1)
8363                                     toc_ref[toc_ref_index] = 1;
8364                                 }
8365                             }
8366                           continue;
8367                         }
8368
8369                       if (expecting_tls_get_addr != 1)
8370                         continue;
8371
8372                       /* Uh oh, we didn't find the expected call.  We
8373                          could just mark this symbol to exclude it
8374                          from tls optimization but it's safer to skip
8375                          the entire optimization.  */
8376                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8377                                                 "TLS optimization disabled\n"),
8378                                               ibfd, sec, rel->r_offset);
8379                       ret = TRUE;
8380                       goto err_free_rel;
8381                     }
8382
8383                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8384                     {
8385                       struct plt_entry *ent;
8386                       for (ent = htab->tls_get_addr->elf.plt.plist;
8387                            ent != NULL;
8388                            ent = ent->next)
8389                         if (ent->addend == 0)
8390                           {
8391                             if (ent->plt.refcount > 0)
8392                               {
8393                                 ent->plt.refcount -= 1;
8394                                 expecting_tls_get_addr = 0;
8395                               }
8396                             break;
8397                           }
8398                     }
8399
8400                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8401                     {
8402                       struct plt_entry *ent;
8403                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8404                            ent != NULL;
8405                            ent = ent->next)
8406                         if (ent->addend == 0)
8407                           {
8408                             if (ent->plt.refcount > 0)
8409                               ent->plt.refcount -= 1;
8410                             break;
8411                           }
8412                     }
8413
8414                   if (tls_clear == 0)
8415                     continue;
8416
8417                   if ((tls_set & TLS_EXPLICIT) == 0)
8418                     {
8419                       struct got_entry *ent;
8420
8421                       /* Adjust got entry for this reloc.  */
8422                       if (h != NULL)
8423                         ent = h->got.glist;
8424                       else
8425                         ent = elf_local_got_ents (ibfd)[r_symndx];
8426
8427                       for (; ent != NULL; ent = ent->next)
8428                         if (ent->addend == rel->r_addend
8429                             && ent->owner == ibfd
8430                             && ent->tls_type == tls_type)
8431                           break;
8432                       if (ent == NULL)
8433                         abort ();
8434
8435                       if (tls_set == 0)
8436                         {
8437                           /* We managed to get rid of a got entry.  */
8438                           if (ent->got.refcount > 0)
8439                             ent->got.refcount -= 1;
8440                         }
8441                     }
8442                   else
8443                     {
8444                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8445                          we'll lose one or two dyn relocs.  */
8446                       if (!dec_dynrel_count (rel->r_info, sec, info,
8447                                              NULL, h, sym))
8448                         return FALSE;
8449
8450                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8451                         {
8452                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8453                                                  NULL, h, sym))
8454                             return FALSE;
8455                         }
8456                     }
8457
8458                   *tls_mask |= tls_set;
8459                   *tls_mask &= ~tls_clear;
8460                 }
8461
8462               if (elf_section_data (sec)->relocs != relstart)
8463                 free (relstart);
8464             }
8465
8466         if (locsyms != NULL
8467             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8468           {
8469             if (!info->keep_memory)
8470               free (locsyms);
8471             else
8472               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8473           }
8474       }
8475
8476   if (toc_ref != NULL)
8477     free (toc_ref);
8478   return TRUE;
8479 }
8480
8481 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8482    the values of any global symbols in a toc section that has been
8483    edited.  Globals in toc sections should be a rarity, so this function
8484    sets a flag if any are found in toc sections other than the one just
8485    edited, so that futher hash table traversals can be avoided.  */
8486
8487 struct adjust_toc_info
8488 {
8489   asection *toc;
8490   unsigned long *skip;
8491   bfd_boolean global_toc_syms;
8492 };
8493
8494 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8495
8496 static bfd_boolean
8497 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8498 {
8499   struct ppc_link_hash_entry *eh;
8500   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8501   unsigned long i;
8502
8503   if (h->root.type != bfd_link_hash_defined
8504       && h->root.type != bfd_link_hash_defweak)
8505     return TRUE;
8506
8507   eh = (struct ppc_link_hash_entry *) h;
8508   if (eh->adjust_done)
8509     return TRUE;
8510
8511   if (eh->elf.root.u.def.section == toc_inf->toc)
8512     {
8513       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8514         i = toc_inf->toc->rawsize >> 3;
8515       else
8516         i = eh->elf.root.u.def.value >> 3;
8517
8518       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8519         {
8520           (*_bfd_error_handler)
8521             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8522           do
8523             ++i;
8524           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8525           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8526         }
8527
8528       eh->elf.root.u.def.value -= toc_inf->skip[i];
8529       eh->adjust_done = 1;
8530     }
8531   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8532     toc_inf->global_toc_syms = TRUE;
8533
8534   return TRUE;
8535 }
8536
8537 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8538
8539 static bfd_boolean
8540 ok_lo_toc_insn (unsigned int insn)
8541 {
8542   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8543           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8544           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8545           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8546           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8547           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8548           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8549           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8550           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8551           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8552           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8553           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8554           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8555           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8556           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8557               && (insn & 3) != 1)
8558           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8559               && ((insn & 3) == 0 || (insn & 3) == 3))
8560           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8561 }
8562
8563 /* Examine all relocs referencing .toc sections in order to remove
8564    unused .toc entries.  */
8565
8566 bfd_boolean
8567 ppc64_elf_edit_toc (struct bfd_link_info *info)
8568 {
8569   bfd *ibfd;
8570   struct adjust_toc_info toc_inf;
8571   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8572
8573   htab->do_toc_opt = 1;
8574   toc_inf.global_toc_syms = TRUE;
8575   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8576     {
8577       asection *toc, *sec;
8578       Elf_Internal_Shdr *symtab_hdr;
8579       Elf_Internal_Sym *local_syms;
8580       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8581       unsigned long *skip, *drop;
8582       unsigned char *used;
8583       unsigned char *keep, last, some_unused;
8584
8585       if (!is_ppc64_elf (ibfd))
8586         continue;
8587
8588       toc = bfd_get_section_by_name (ibfd, ".toc");
8589       if (toc == NULL
8590           || toc->size == 0
8591           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8592           || discarded_section (toc))
8593         continue;
8594
8595       toc_relocs = NULL;
8596       local_syms = NULL;
8597       symtab_hdr = &elf_symtab_hdr (ibfd);
8598
8599       /* Look at sections dropped from the final link.  */
8600       skip = NULL;
8601       relstart = NULL;
8602       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8603         {
8604           if (sec->reloc_count == 0
8605               || !discarded_section (sec)
8606               || get_opd_info (sec)
8607               || (sec->flags & SEC_ALLOC) == 0
8608               || (sec->flags & SEC_DEBUGGING) != 0)
8609             continue;
8610
8611           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8612           if (relstart == NULL)
8613             goto error_ret;
8614
8615           /* Run through the relocs to see which toc entries might be
8616              unused.  */
8617           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8618             {
8619               enum elf_ppc64_reloc_type r_type;
8620               unsigned long r_symndx;
8621               asection *sym_sec;
8622               struct elf_link_hash_entry *h;
8623               Elf_Internal_Sym *sym;
8624               bfd_vma val;
8625
8626               r_type = ELF64_R_TYPE (rel->r_info);
8627               switch (r_type)
8628                 {
8629                 default:
8630                   continue;
8631
8632                 case R_PPC64_TOC16:
8633                 case R_PPC64_TOC16_LO:
8634                 case R_PPC64_TOC16_HI:
8635                 case R_PPC64_TOC16_HA:
8636                 case R_PPC64_TOC16_DS:
8637                 case R_PPC64_TOC16_LO_DS:
8638                   break;
8639                 }
8640
8641               r_symndx = ELF64_R_SYM (rel->r_info);
8642               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8643                               r_symndx, ibfd))
8644                 goto error_ret;
8645
8646               if (sym_sec != toc)
8647                 continue;
8648
8649               if (h != NULL)
8650                 val = h->root.u.def.value;
8651               else
8652                 val = sym->st_value;
8653               val += rel->r_addend;
8654
8655               if (val >= toc->size)
8656                 continue;
8657
8658               /* Anything in the toc ought to be aligned to 8 bytes.
8659                  If not, don't mark as unused.  */
8660               if (val & 7)
8661                 continue;
8662
8663               if (skip == NULL)
8664                 {
8665                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8666                   if (skip == NULL)
8667                     goto error_ret;
8668                 }
8669
8670               skip[val >> 3] = ref_from_discarded;
8671             }
8672
8673           if (elf_section_data (sec)->relocs != relstart)
8674             free (relstart);
8675         }
8676
8677       /* For largetoc loads of address constants, we can convert
8678          .  addis rx,2,addr@got@ha
8679          .  ld ry,addr@got@l(rx)
8680          to
8681          .  addis rx,2,addr@toc@ha
8682          .  addi ry,rx,addr@toc@l
8683          when addr is within 2G of the toc pointer.  This then means
8684          that the word storing "addr" in the toc is no longer needed.  */
8685
8686       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8687           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8688           && toc->reloc_count != 0)
8689         {
8690           /* Read toc relocs.  */
8691           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8692                                                   info->keep_memory);
8693           if (toc_relocs == NULL)
8694             goto error_ret;
8695
8696           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8697             {
8698               enum elf_ppc64_reloc_type r_type;
8699               unsigned long r_symndx;
8700               asection *sym_sec;
8701               struct elf_link_hash_entry *h;
8702               Elf_Internal_Sym *sym;
8703               bfd_vma val, addr;
8704
8705               r_type = ELF64_R_TYPE (rel->r_info);
8706               if (r_type != R_PPC64_ADDR64)
8707                 continue;
8708
8709               r_symndx = ELF64_R_SYM (rel->r_info);
8710               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8711                               r_symndx, ibfd))
8712                 goto error_ret;
8713
8714               if (sym_sec == NULL
8715                   || discarded_section (sym_sec))
8716                 continue;
8717
8718               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8719                 continue;
8720
8721               if (h != NULL)
8722                 {
8723                   if (h->type == STT_GNU_IFUNC)
8724                     continue;
8725                   val = h->root.u.def.value;
8726                 }
8727               else
8728                 {
8729                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8730                     continue;
8731                   val = sym->st_value;
8732                 }
8733               val += rel->r_addend;
8734               val += sym_sec->output_section->vma + sym_sec->output_offset;
8735
8736               /* We don't yet know the exact toc pointer value, but we
8737                  know it will be somewhere in the toc section.  Don't
8738                  optimize if the difference from any possible toc
8739                  pointer is outside [ff..f80008000, 7fff7fff].  */
8740               addr = toc->output_section->vma + TOC_BASE_OFF;
8741               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8742                 continue;
8743
8744               addr = toc->output_section->vma + toc->output_section->rawsize;
8745               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8746                 continue;
8747
8748               if (skip == NULL)
8749                 {
8750                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8751                   if (skip == NULL)
8752                     goto error_ret;
8753                 }
8754
8755               skip[rel->r_offset >> 3]
8756                 |= can_optimize | ((rel - toc_relocs) << 2);
8757             }
8758         }
8759
8760       if (skip == NULL)
8761         continue;
8762
8763       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8764       if (used == NULL)
8765         {
8766         error_ret:
8767           if (local_syms != NULL
8768               && symtab_hdr->contents != (unsigned char *) local_syms)
8769             free (local_syms);
8770           if (sec != NULL
8771               && relstart != NULL
8772               && elf_section_data (sec)->relocs != relstart)
8773             free (relstart);
8774           if (toc_relocs != NULL
8775               && elf_section_data (toc)->relocs != toc_relocs)
8776             free (toc_relocs);
8777           if (skip != NULL)
8778             free (skip);
8779           return FALSE;
8780         }
8781
8782       /* Now check all kept sections that might reference the toc.
8783          Check the toc itself last.  */
8784       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8785                   : ibfd->sections);
8786            sec != NULL;
8787            sec = (sec == toc ? NULL
8788                   : sec->next == NULL ? toc
8789                   : sec->next == toc && toc->next ? toc->next
8790                   : sec->next))
8791         {
8792           int repeat;
8793
8794           if (sec->reloc_count == 0
8795               || discarded_section (sec)
8796               || get_opd_info (sec)
8797               || (sec->flags & SEC_ALLOC) == 0
8798               || (sec->flags & SEC_DEBUGGING) != 0)
8799             continue;
8800
8801           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8802                                                 info->keep_memory);
8803           if (relstart == NULL)
8804             {
8805               free (used);
8806               goto error_ret;
8807             }
8808
8809           /* Mark toc entries referenced as used.  */
8810           do
8811             {
8812               repeat = 0;
8813               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8814                 {
8815                   enum elf_ppc64_reloc_type r_type;
8816                   unsigned long r_symndx;
8817                   asection *sym_sec;
8818                   struct elf_link_hash_entry *h;
8819                   Elf_Internal_Sym *sym;
8820                   bfd_vma val;
8821                   enum {no_check, check_lo, check_ha} insn_check;
8822
8823                   r_type = ELF64_R_TYPE (rel->r_info);
8824                   switch (r_type)
8825                     {
8826                     default:
8827                       insn_check = no_check;
8828                       break;
8829
8830                     case R_PPC64_GOT_TLSLD16_HA:
8831                     case R_PPC64_GOT_TLSGD16_HA:
8832                     case R_PPC64_GOT_TPREL16_HA:
8833                     case R_PPC64_GOT_DTPREL16_HA:
8834                     case R_PPC64_GOT16_HA:
8835                     case R_PPC64_TOC16_HA:
8836                       insn_check = check_ha;
8837                       break;
8838
8839                     case R_PPC64_GOT_TLSLD16_LO:
8840                     case R_PPC64_GOT_TLSGD16_LO:
8841                     case R_PPC64_GOT_TPREL16_LO_DS:
8842                     case R_PPC64_GOT_DTPREL16_LO_DS:
8843                     case R_PPC64_GOT16_LO:
8844                     case R_PPC64_GOT16_LO_DS:
8845                     case R_PPC64_TOC16_LO:
8846                     case R_PPC64_TOC16_LO_DS:
8847                       insn_check = check_lo;
8848                       break;
8849                     }
8850
8851                   if (insn_check != no_check)
8852                     {
8853                       bfd_vma off = rel->r_offset & ~3;
8854                       unsigned char buf[4];
8855                       unsigned int insn;
8856
8857                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8858                         {
8859                           free (used);
8860                           goto error_ret;
8861                         }
8862                       insn = bfd_get_32 (ibfd, buf);
8863                       if (insn_check == check_lo
8864                           ? !ok_lo_toc_insn (insn)
8865                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8866                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8867                         {
8868                           char str[12];
8869
8870                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8871                           sprintf (str, "%#08x", insn);
8872                           info->callbacks->einfo
8873                             (_("%P: %H: toc optimization is not supported for"
8874                                " %s instruction.\n"),
8875                              ibfd, sec, rel->r_offset & ~3, str);
8876                         }
8877                     }
8878
8879                   switch (r_type)
8880                     {
8881                     case R_PPC64_TOC16:
8882                     case R_PPC64_TOC16_LO:
8883                     case R_PPC64_TOC16_HI:
8884                     case R_PPC64_TOC16_HA:
8885                     case R_PPC64_TOC16_DS:
8886                     case R_PPC64_TOC16_LO_DS:
8887                       /* In case we're taking addresses of toc entries.  */
8888                     case R_PPC64_ADDR64:
8889                       break;
8890
8891                     default:
8892                       continue;
8893                     }
8894
8895                   r_symndx = ELF64_R_SYM (rel->r_info);
8896                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8897                                   r_symndx, ibfd))
8898                     {
8899                       free (used);
8900                       goto error_ret;
8901                     }
8902
8903                   if (sym_sec != toc)
8904                     continue;
8905
8906                   if (h != NULL)
8907                     val = h->root.u.def.value;
8908                   else
8909                     val = sym->st_value;
8910                   val += rel->r_addend;
8911
8912                   if (val >= toc->size)
8913                     continue;
8914
8915                   if ((skip[val >> 3] & can_optimize) != 0)
8916                     {
8917                       bfd_vma off;
8918                       unsigned char opc;
8919
8920                       switch (r_type)
8921                         {
8922                         case R_PPC64_TOC16_HA:
8923                           break;
8924
8925                         case R_PPC64_TOC16_LO_DS:
8926                           off = rel->r_offset;
8927                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8928                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8929                                                          off, 1))
8930                             {
8931                               free (used);
8932                               goto error_ret;
8933                             }
8934                           if ((opc & (0x3f << 2)) == (58u << 2))
8935                             break;
8936                           /* Fall thru */
8937
8938                         default:
8939                           /* Wrong sort of reloc, or not a ld.  We may
8940                              as well clear ref_from_discarded too.  */
8941                           skip[val >> 3] = 0;
8942                         }
8943                     }
8944
8945                   if (sec != toc)
8946                     used[val >> 3] = 1;
8947                   /* For the toc section, we only mark as used if this
8948                      entry itself isn't unused.  */
8949                   else if ((used[rel->r_offset >> 3]
8950                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8951                            && !used[val >> 3])
8952                     {
8953                       /* Do all the relocs again, to catch reference
8954                          chains.  */
8955                       repeat = 1;
8956                       used[val >> 3] = 1;
8957                     }
8958                 }
8959             }
8960           while (repeat);
8961
8962           if (elf_section_data (sec)->relocs != relstart)
8963             free (relstart);
8964         }
8965
8966       /* Merge the used and skip arrays.  Assume that TOC
8967          doublewords not appearing as either used or unused belong
8968          to to an entry more than one doubleword in size.  */
8969       for (drop = skip, keep = used, last = 0, some_unused = 0;
8970            drop < skip + (toc->size + 7) / 8;
8971            ++drop, ++keep)
8972         {
8973           if (*keep)
8974             {
8975               *drop &= ~ref_from_discarded;
8976               if ((*drop & can_optimize) != 0)
8977                 some_unused = 1;
8978               last = 0;
8979             }
8980           else if ((*drop & ref_from_discarded) != 0)
8981             {
8982               some_unused = 1;
8983               last = ref_from_discarded;
8984             }
8985           else
8986             *drop = last;
8987         }
8988
8989       free (used);
8990
8991       if (some_unused)
8992         {
8993           bfd_byte *contents, *src;
8994           unsigned long off;
8995           Elf_Internal_Sym *sym;
8996           bfd_boolean local_toc_syms = FALSE;
8997
8998           /* Shuffle the toc contents, and at the same time convert the
8999              skip array from booleans into offsets.  */
9000           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9001             goto error_ret;
9002
9003           elf_section_data (toc)->this_hdr.contents = contents;
9004
9005           for (src = contents, off = 0, drop = skip;
9006                src < contents + toc->size;
9007                src += 8, ++drop)
9008             {
9009               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9010                 off += 8;
9011               else if (off != 0)
9012                 {
9013                   *drop = off;
9014                   memcpy (src - off, src, 8);
9015                 }
9016             }
9017           *drop = off;
9018           toc->rawsize = toc->size;
9019           toc->size = src - contents - off;
9020
9021           /* Adjust addends for relocs against the toc section sym,
9022              and optimize any accesses we can.  */
9023           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9024             {
9025               if (sec->reloc_count == 0
9026                   || discarded_section (sec))
9027                 continue;
9028
9029               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9030                                                     info->keep_memory);
9031               if (relstart == NULL)
9032                 goto error_ret;
9033
9034               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9035                 {
9036                   enum elf_ppc64_reloc_type r_type;
9037                   unsigned long r_symndx;
9038                   asection *sym_sec;
9039                   struct elf_link_hash_entry *h;
9040                   bfd_vma val;
9041
9042                   r_type = ELF64_R_TYPE (rel->r_info);
9043                   switch (r_type)
9044                     {
9045                     default:
9046                       continue;
9047
9048                     case R_PPC64_TOC16:
9049                     case R_PPC64_TOC16_LO:
9050                     case R_PPC64_TOC16_HI:
9051                     case R_PPC64_TOC16_HA:
9052                     case R_PPC64_TOC16_DS:
9053                     case R_PPC64_TOC16_LO_DS:
9054                     case R_PPC64_ADDR64:
9055                       break;
9056                     }
9057
9058                   r_symndx = ELF64_R_SYM (rel->r_info);
9059                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9060                                   r_symndx, ibfd))
9061                     goto error_ret;
9062
9063                   if (sym_sec != toc)
9064                     continue;
9065
9066                   if (h != NULL)
9067                     val = h->root.u.def.value;
9068                   else
9069                     {
9070                       val = sym->st_value;
9071                       if (val != 0)
9072                         local_toc_syms = TRUE;
9073                     }
9074
9075                   val += rel->r_addend;
9076
9077                   if (val > toc->rawsize)
9078                     val = toc->rawsize;
9079                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
9080                     continue;
9081                   else if ((skip[val >> 3] & can_optimize) != 0)
9082                     {
9083                       Elf_Internal_Rela *tocrel
9084                         = toc_relocs + (skip[val >> 3] >> 2);
9085                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9086
9087                       switch (r_type)
9088                         {
9089                         case R_PPC64_TOC16_HA:
9090                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9091                           break;
9092
9093                         case R_PPC64_TOC16_LO_DS:
9094                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9095                           break;
9096
9097                         default:
9098                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9099                             ppc_howto_init ();
9100                           info->callbacks->einfo
9101                             (_("%P: %H: %s references "
9102                                "optimized away TOC entry\n"),
9103                              ibfd, sec, rel->r_offset,
9104                              ppc64_elf_howto_table[r_type]->name);
9105                           bfd_set_error (bfd_error_bad_value);
9106                           goto error_ret;
9107                         }
9108                       rel->r_addend = tocrel->r_addend;
9109                       elf_section_data (sec)->relocs = relstart;
9110                       continue;
9111                     }
9112
9113                   if (h != NULL || sym->st_value != 0)
9114                     continue;
9115
9116                   rel->r_addend -= skip[val >> 3];
9117                   elf_section_data (sec)->relocs = relstart;
9118                 }
9119
9120               if (elf_section_data (sec)->relocs != relstart)
9121                 free (relstart);
9122             }
9123
9124           /* We shouldn't have local or global symbols defined in the TOC,
9125              but handle them anyway.  */
9126           if (local_syms != NULL)
9127             for (sym = local_syms;
9128                  sym < local_syms + symtab_hdr->sh_info;
9129                  ++sym)
9130               if (sym->st_value != 0
9131                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9132                 {
9133                   unsigned long i;
9134
9135                   if (sym->st_value > toc->rawsize)
9136                     i = toc->rawsize >> 3;
9137                   else
9138                     i = sym->st_value >> 3;
9139
9140                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9141                     {
9142                       if (local_toc_syms)
9143                         (*_bfd_error_handler)
9144                           (_("%s defined on removed toc entry"),
9145                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9146                       do
9147                         ++i;
9148                       while ((skip[i] & (ref_from_discarded | can_optimize)));
9149                       sym->st_value = (bfd_vma) i << 3;
9150                     }
9151
9152                   sym->st_value -= skip[i];
9153                   symtab_hdr->contents = (unsigned char *) local_syms;
9154                 }
9155
9156           /* Adjust any global syms defined in this toc input section.  */
9157           if (toc_inf.global_toc_syms)
9158             {
9159               toc_inf.toc = toc;
9160               toc_inf.skip = skip;
9161               toc_inf.global_toc_syms = FALSE;
9162               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9163                                       &toc_inf);
9164             }
9165
9166           if (toc->reloc_count != 0)
9167             {
9168               Elf_Internal_Shdr *rel_hdr;
9169               Elf_Internal_Rela *wrel;
9170               bfd_size_type sz;
9171
9172               /* Remove unused toc relocs, and adjust those we keep.  */
9173               if (toc_relocs == NULL)
9174                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9175                                                         info->keep_memory);
9176               if (toc_relocs == NULL)
9177                 goto error_ret;
9178
9179               wrel = toc_relocs;
9180               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9181                 if ((skip[rel->r_offset >> 3]
9182                      & (ref_from_discarded | can_optimize)) == 0)
9183                   {
9184                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9185                     wrel->r_info = rel->r_info;
9186                     wrel->r_addend = rel->r_addend;
9187                     ++wrel;
9188                   }
9189                 else if (!dec_dynrel_count (rel->r_info, toc, info,
9190                                             &local_syms, NULL, NULL))
9191                   goto error_ret;
9192
9193               elf_section_data (toc)->relocs = toc_relocs;
9194               toc->reloc_count = wrel - toc_relocs;
9195               rel_hdr = _bfd_elf_single_rel_hdr (toc);
9196               sz = rel_hdr->sh_entsize;
9197               rel_hdr->sh_size = toc->reloc_count * sz;
9198             }
9199         }
9200       else if (toc_relocs != NULL
9201                && elf_section_data (toc)->relocs != toc_relocs)
9202         free (toc_relocs);
9203
9204       if (local_syms != NULL
9205           && symtab_hdr->contents != (unsigned char *) local_syms)
9206         {
9207           if (!info->keep_memory)
9208             free (local_syms);
9209           else
9210             symtab_hdr->contents = (unsigned char *) local_syms;
9211         }
9212       free (skip);
9213     }
9214
9215   return TRUE;
9216 }
9217
9218 /* Return true iff input section I references the TOC using
9219    instructions limited to +/-32k offsets.  */
9220
9221 bfd_boolean
9222 ppc64_elf_has_small_toc_reloc (asection *i)
9223 {
9224   return (is_ppc64_elf (i->owner)
9225           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9226 }
9227
9228 /* Allocate space for one GOT entry.  */
9229
9230 static void
9231 allocate_got (struct elf_link_hash_entry *h,
9232               struct bfd_link_info *info,
9233               struct got_entry *gent)
9234 {
9235   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9236   bfd_boolean dyn;
9237   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9238   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9239                  ? 16 : 8);
9240   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9241                   ? 2 : 1) * sizeof (Elf64_External_Rela);
9242   asection *got = ppc64_elf_tdata (gent->owner)->got;
9243
9244   gent->got.offset = got->size;
9245   got->size += entsize;
9246
9247   dyn = htab->elf.dynamic_sections_created;
9248   if (h->type == STT_GNU_IFUNC)
9249     {
9250       htab->elf.irelplt->size += rentsize;
9251       htab->got_reli_size += rentsize;
9252     }
9253   else if ((info->shared
9254             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9255            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9256                || h->root.type != bfd_link_hash_undefweak))
9257     {
9258       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9259       relgot->size += rentsize;
9260     }
9261 }
9262
9263 /* This function merges got entries in the same toc group.  */
9264
9265 static void
9266 merge_got_entries (struct got_entry **pent)
9267 {
9268   struct got_entry *ent, *ent2;
9269
9270   for (ent = *pent; ent != NULL; ent = ent->next)
9271     if (!ent->is_indirect)
9272       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9273         if (!ent2->is_indirect
9274             && ent2->addend == ent->addend
9275             && ent2->tls_type == ent->tls_type
9276             && elf_gp (ent2->owner) == elf_gp (ent->owner))
9277           {
9278             ent2->is_indirect = TRUE;
9279             ent2->got.ent = ent;
9280           }
9281 }
9282
9283 /* Allocate space in .plt, .got and associated reloc sections for
9284    dynamic relocs.  */
9285
9286 static bfd_boolean
9287 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9288 {
9289   struct bfd_link_info *info;
9290   struct ppc_link_hash_table *htab;
9291   asection *s;
9292   struct ppc_link_hash_entry *eh;
9293   struct elf_dyn_relocs *p;
9294   struct got_entry **pgent, *gent;
9295
9296   if (h->root.type == bfd_link_hash_indirect)
9297     return TRUE;
9298
9299   info = (struct bfd_link_info *) inf;
9300   htab = ppc_hash_table (info);
9301   if (htab == NULL)
9302     return FALSE;
9303
9304   if ((htab->elf.dynamic_sections_created
9305        && h->dynindx != -1
9306        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9307       || h->type == STT_GNU_IFUNC)
9308     {
9309       struct plt_entry *pent;
9310       bfd_boolean doneone = FALSE;
9311       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9312         if (pent->plt.refcount > 0)
9313           {
9314             if (!htab->elf.dynamic_sections_created
9315                 || h->dynindx == -1)
9316               {
9317                 s = htab->elf.iplt;
9318                 pent->plt.offset = s->size;
9319                 s->size += PLT_ENTRY_SIZE (htab);
9320                 s = htab->elf.irelplt;
9321               }
9322             else
9323               {
9324                 /* If this is the first .plt entry, make room for the special
9325                    first entry.  */
9326                 s = htab->elf.splt;
9327                 if (s->size == 0)
9328                   s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9329
9330                 pent->plt.offset = s->size;
9331
9332                 /* Make room for this entry.  */
9333                 s->size += PLT_ENTRY_SIZE (htab);
9334
9335                 /* Make room for the .glink code.  */
9336                 s = htab->glink;
9337                 if (s->size == 0)
9338                   s->size += GLINK_CALL_STUB_SIZE;
9339                 if (htab->opd_abi)
9340                   {
9341                     /* We need bigger stubs past index 32767.  */
9342                     if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9343                       s->size += 4;
9344                     s->size += 2*4;
9345                   }
9346                 else
9347                   s->size += 4;
9348
9349                 /* We also need to make an entry in the .rela.plt section.  */
9350                 s = htab->elf.srelplt;
9351               }
9352             s->size += sizeof (Elf64_External_Rela);
9353             doneone = TRUE;
9354           }
9355         else
9356           pent->plt.offset = (bfd_vma) -1;
9357       if (!doneone)
9358         {
9359           h->plt.plist = NULL;
9360           h->needs_plt = 0;
9361         }
9362     }
9363   else
9364     {
9365       h->plt.plist = NULL;
9366       h->needs_plt = 0;
9367     }
9368
9369   eh = (struct ppc_link_hash_entry *) h;
9370   /* Run through the TLS GD got entries first if we're changing them
9371      to TPREL.  */
9372   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9373     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9374       if (gent->got.refcount > 0
9375           && (gent->tls_type & TLS_GD) != 0)
9376         {
9377           /* This was a GD entry that has been converted to TPREL.  If
9378              there happens to be a TPREL entry we can use that one.  */
9379           struct got_entry *ent;
9380           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9381             if (ent->got.refcount > 0
9382                 && (ent->tls_type & TLS_TPREL) != 0
9383                 && ent->addend == gent->addend
9384                 && ent->owner == gent->owner)
9385               {
9386                 gent->got.refcount = 0;
9387                 break;
9388               }
9389
9390           /* If not, then we'll be using our own TPREL entry.  */
9391           if (gent->got.refcount != 0)
9392             gent->tls_type = TLS_TLS | TLS_TPREL;
9393         }
9394
9395   /* Remove any list entry that won't generate a word in the GOT before
9396      we call merge_got_entries.  Otherwise we risk merging to empty
9397      entries.  */
9398   pgent = &h->got.glist;
9399   while ((gent = *pgent) != NULL)
9400     if (gent->got.refcount > 0)
9401       {
9402         if ((gent->tls_type & TLS_LD) != 0
9403             && !h->def_dynamic)
9404           {
9405             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9406             *pgent = gent->next;
9407           }
9408         else
9409           pgent = &gent->next;
9410       }
9411     else
9412       *pgent = gent->next;
9413
9414   if (!htab->do_multi_toc)
9415     merge_got_entries (&h->got.glist);
9416
9417   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9418     if (!gent->is_indirect)
9419       {
9420         /* Make sure this symbol is output as a dynamic symbol.
9421            Undefined weak syms won't yet be marked as dynamic,
9422            nor will all TLS symbols.  */
9423         if (h->dynindx == -1
9424             && !h->forced_local
9425             && h->type != STT_GNU_IFUNC
9426             && htab->elf.dynamic_sections_created)
9427           {
9428             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9429               return FALSE;
9430           }
9431
9432         if (!is_ppc64_elf (gent->owner))
9433           abort ();
9434
9435         allocate_got (h, info, gent);
9436       }
9437
9438   if (eh->dyn_relocs == NULL
9439       || (!htab->elf.dynamic_sections_created
9440           && h->type != STT_GNU_IFUNC))
9441     return TRUE;
9442
9443   /* In the shared -Bsymbolic case, discard space allocated for
9444      dynamic pc-relative relocs against symbols which turn out to be
9445      defined in regular objects.  For the normal shared case, discard
9446      space for relocs that have become local due to symbol visibility
9447      changes.  */
9448
9449   if (info->shared)
9450     {
9451       /* Relocs that use pc_count are those that appear on a call insn,
9452          or certain REL relocs (see must_be_dyn_reloc) that can be
9453          generated via assembly.  We want calls to protected symbols to
9454          resolve directly to the function rather than going via the plt.
9455          If people want function pointer comparisons to work as expected
9456          then they should avoid writing weird assembly.  */
9457       if (SYMBOL_CALLS_LOCAL (info, h))
9458         {
9459           struct elf_dyn_relocs **pp;
9460
9461           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9462             {
9463               p->count -= p->pc_count;
9464               p->pc_count = 0;
9465               if (p->count == 0)
9466                 *pp = p->next;
9467               else
9468                 pp = &p->next;
9469             }
9470         }
9471
9472       /* Also discard relocs on undefined weak syms with non-default
9473          visibility.  */
9474       if (eh->dyn_relocs != NULL
9475           && h->root.type == bfd_link_hash_undefweak)
9476         {
9477           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9478             eh->dyn_relocs = NULL;
9479
9480           /* Make sure this symbol is output as a dynamic symbol.
9481              Undefined weak syms won't yet be marked as dynamic.  */
9482           else if (h->dynindx == -1
9483                    && !h->forced_local)
9484             {
9485               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9486                 return FALSE;
9487             }
9488         }
9489     }
9490   else if (h->type == STT_GNU_IFUNC)
9491     {
9492       if (!h->non_got_ref)
9493         eh->dyn_relocs = NULL;
9494     }
9495   else if (ELIMINATE_COPY_RELOCS)
9496     {
9497       /* For the non-shared case, discard space for relocs against
9498          symbols which turn out to need copy relocs or are not
9499          dynamic.  */
9500
9501       if (!h->non_got_ref
9502           && !h->def_regular)
9503         {
9504           /* Make sure this symbol is output as a dynamic symbol.
9505              Undefined weak syms won't yet be marked as dynamic.  */
9506           if (h->dynindx == -1
9507               && !h->forced_local)
9508             {
9509               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9510                 return FALSE;
9511             }
9512
9513           /* If that succeeded, we know we'll be keeping all the
9514              relocs.  */
9515           if (h->dynindx != -1)
9516             goto keep;
9517         }
9518
9519       eh->dyn_relocs = NULL;
9520
9521     keep: ;
9522     }
9523
9524   /* Finally, allocate space.  */
9525   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9526     {
9527       asection *sreloc = elf_section_data (p->sec)->sreloc;
9528       if (eh->elf.type == STT_GNU_IFUNC)
9529         sreloc = htab->elf.irelplt;
9530       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9531     }
9532
9533   return TRUE;
9534 }
9535
9536 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9537    to set up space for global entry stubs.  These are put in glink,
9538    after the branch table.  */
9539
9540 static bfd_boolean
9541 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9542 {
9543   struct bfd_link_info *info;
9544   struct ppc_link_hash_table *htab;
9545   struct plt_entry *pent;
9546   asection *s;
9547
9548   if (h->root.type == bfd_link_hash_indirect)
9549     return TRUE;
9550
9551   if (!h->pointer_equality_needed)
9552     return TRUE;
9553
9554   if (h->def_regular)
9555     return TRUE;
9556
9557   info = inf;
9558   htab = ppc_hash_table (info);
9559   if (htab == NULL)
9560     return FALSE;
9561
9562   s = htab->glink;
9563   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9564     if (pent->plt.offset != (bfd_vma) -1
9565         && pent->addend == 0)
9566       {
9567         /* For ELFv2, if this symbol is not defined in a regular file
9568            and we are not generating a shared library or pie, then we
9569            need to define the symbol in the executable on a call stub.
9570            This is to avoid text relocations.  */
9571         s->size = (s->size + 15) & -16;
9572         h->root.u.def.section = s;
9573         h->root.u.def.value = s->size;
9574         s->size += 16;
9575         break;
9576       }
9577   return TRUE;
9578 }
9579
9580 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9581    read-only sections.  */
9582
9583 static bfd_boolean
9584 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9585 {
9586   if (h->root.type == bfd_link_hash_indirect)
9587     return TRUE;
9588
9589   if (readonly_dynrelocs (h))
9590     {
9591       ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9592
9593       /* Not an error, just cut short the traversal.  */
9594       return FALSE;
9595     }
9596   return TRUE;
9597 }
9598
9599 /* Set the sizes of the dynamic sections.  */
9600
9601 static bfd_boolean
9602 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9603                                  struct bfd_link_info *info)
9604 {
9605   struct ppc_link_hash_table *htab;
9606   bfd *dynobj;
9607   asection *s;
9608   bfd_boolean relocs;
9609   bfd *ibfd;
9610   struct got_entry *first_tlsld;
9611
9612   htab = ppc_hash_table (info);
9613   if (htab == NULL)
9614     return FALSE;
9615
9616   dynobj = htab->elf.dynobj;
9617   if (dynobj == NULL)
9618     abort ();
9619
9620   if (htab->elf.dynamic_sections_created)
9621     {
9622       /* Set the contents of the .interp section to the interpreter.  */
9623       if (info->executable)
9624         {
9625           s = bfd_get_linker_section (dynobj, ".interp");
9626           if (s == NULL)
9627             abort ();
9628           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9629           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9630         }
9631     }
9632
9633   /* Set up .got offsets for local syms, and space for local dynamic
9634      relocs.  */
9635   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9636     {
9637       struct got_entry **lgot_ents;
9638       struct got_entry **end_lgot_ents;
9639       struct plt_entry **local_plt;
9640       struct plt_entry **end_local_plt;
9641       unsigned char *lgot_masks;
9642       bfd_size_type locsymcount;
9643       Elf_Internal_Shdr *symtab_hdr;
9644
9645       if (!is_ppc64_elf (ibfd))
9646         continue;
9647
9648       for (s = ibfd->sections; s != NULL; s = s->next)
9649         {
9650           struct ppc_dyn_relocs *p;
9651
9652           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9653             {
9654               if (!bfd_is_abs_section (p->sec)
9655                   && bfd_is_abs_section (p->sec->output_section))
9656                 {
9657                   /* Input section has been discarded, either because
9658                      it is a copy of a linkonce section or due to
9659                      linker script /DISCARD/, so we'll be discarding
9660                      the relocs too.  */
9661                 }
9662               else if (p->count != 0)
9663                 {
9664                   asection *srel = elf_section_data (p->sec)->sreloc;
9665                   if (p->ifunc)
9666                     srel = htab->elf.irelplt;
9667                   srel->size += p->count * sizeof (Elf64_External_Rela);
9668                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9669                     info->flags |= DF_TEXTREL;
9670                 }
9671             }
9672         }
9673
9674       lgot_ents = elf_local_got_ents (ibfd);
9675       if (!lgot_ents)
9676         continue;
9677
9678       symtab_hdr = &elf_symtab_hdr (ibfd);
9679       locsymcount = symtab_hdr->sh_info;
9680       end_lgot_ents = lgot_ents + locsymcount;
9681       local_plt = (struct plt_entry **) end_lgot_ents;
9682       end_local_plt = local_plt + locsymcount;
9683       lgot_masks = (unsigned char *) end_local_plt;
9684       s = ppc64_elf_tdata (ibfd)->got;
9685       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9686         {
9687           struct got_entry **pent, *ent;
9688
9689           pent = lgot_ents;
9690           while ((ent = *pent) != NULL)
9691             if (ent->got.refcount > 0)
9692               {
9693                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9694                   {
9695                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9696                     *pent = ent->next;
9697                   }
9698                 else
9699                   {
9700                     unsigned int ent_size = 8;
9701                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9702
9703                     ent->got.offset = s->size;
9704                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9705                       {
9706                         ent_size *= 2;
9707                         rel_size *= 2;
9708                       }
9709                     s->size += ent_size;
9710                     if ((*lgot_masks & PLT_IFUNC) != 0)
9711                       {
9712                         htab->elf.irelplt->size += rel_size;
9713                         htab->got_reli_size += rel_size;
9714                       }
9715                     else if (info->shared)
9716                       {
9717                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9718                         srel->size += rel_size;
9719                       }
9720                     pent = &ent->next;
9721                   }
9722               }
9723             else
9724               *pent = ent->next;
9725         }
9726
9727       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9728       for (; local_plt < end_local_plt; ++local_plt)
9729         {
9730           struct plt_entry *ent;
9731
9732           for (ent = *local_plt; ent != NULL; ent = ent->next)
9733             if (ent->plt.refcount > 0)
9734               {
9735                 s = htab->elf.iplt;
9736                 ent->plt.offset = s->size;
9737                 s->size += PLT_ENTRY_SIZE (htab);
9738
9739                 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9740               }
9741             else
9742               ent->plt.offset = (bfd_vma) -1;
9743         }
9744     }
9745
9746   /* Allocate global sym .plt and .got entries, and space for global
9747      sym dynamic relocs.  */
9748   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9749   /* Stash the end of glink branch table.  */
9750   if (htab->glink != NULL)
9751     htab->glink->rawsize = htab->glink->size;
9752
9753   if (!htab->opd_abi && !info->shared)
9754     elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9755
9756   first_tlsld = NULL;
9757   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9758     {
9759       struct got_entry *ent;
9760
9761       if (!is_ppc64_elf (ibfd))
9762         continue;
9763
9764       ent = ppc64_tlsld_got (ibfd);
9765       if (ent->got.refcount > 0)
9766         {
9767           if (!htab->do_multi_toc && first_tlsld != NULL)
9768             {
9769               ent->is_indirect = TRUE;
9770               ent->got.ent = first_tlsld;
9771             }
9772           else
9773             {
9774               if (first_tlsld == NULL)
9775                 first_tlsld = ent;
9776               s = ppc64_elf_tdata (ibfd)->got;
9777               ent->got.offset = s->size;
9778               ent->owner = ibfd;
9779               s->size += 16;
9780               if (info->shared)
9781                 {
9782                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9783                   srel->size += sizeof (Elf64_External_Rela);
9784                 }
9785             }
9786         }
9787       else
9788         ent->got.offset = (bfd_vma) -1;
9789     }
9790
9791   /* We now have determined the sizes of the various dynamic sections.
9792      Allocate memory for them.  */
9793   relocs = FALSE;
9794   for (s = dynobj->sections; s != NULL; s = s->next)
9795     {
9796       if ((s->flags & SEC_LINKER_CREATED) == 0)
9797         continue;
9798
9799       if (s == htab->brlt || s == htab->relbrlt)
9800         /* These haven't been allocated yet;  don't strip.  */
9801         continue;
9802       else if (s == htab->elf.sgot
9803                || s == htab->elf.splt
9804                || s == htab->elf.iplt
9805                || s == htab->glink
9806                || s == htab->dynbss)
9807         {
9808           /* Strip this section if we don't need it; see the
9809              comment below.  */
9810         }
9811       else if (s == htab->glink_eh_frame)
9812         {
9813           if (!bfd_is_abs_section (s->output_section))
9814             /* Not sized yet.  */
9815             continue;
9816         }
9817       else if (CONST_STRNEQ (s->name, ".rela"))
9818         {
9819           if (s->size != 0)
9820             {
9821               if (s != htab->elf.srelplt)
9822                 relocs = TRUE;
9823
9824               /* We use the reloc_count field as a counter if we need
9825                  to copy relocs into the output file.  */
9826               s->reloc_count = 0;
9827             }
9828         }
9829       else
9830         {
9831           /* It's not one of our sections, so don't allocate space.  */
9832           continue;
9833         }
9834
9835       if (s->size == 0)
9836         {
9837           /* If we don't need this section, strip it from the
9838              output file.  This is mostly to handle .rela.bss and
9839              .rela.plt.  We must create both sections in
9840              create_dynamic_sections, because they must be created
9841              before the linker maps input sections to output
9842              sections.  The linker does that before
9843              adjust_dynamic_symbol is called, and it is that
9844              function which decides whether anything needs to go
9845              into these sections.  */
9846           s->flags |= SEC_EXCLUDE;
9847           continue;
9848         }
9849
9850       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9851         continue;
9852
9853       /* Allocate memory for the section contents.  We use bfd_zalloc
9854          here in case unused entries are not reclaimed before the
9855          section's contents are written out.  This should not happen,
9856          but this way if it does we get a R_PPC64_NONE reloc in .rela
9857          sections instead of garbage.
9858          We also rely on the section contents being zero when writing
9859          the GOT.  */
9860       s->contents = bfd_zalloc (dynobj, s->size);
9861       if (s->contents == NULL)
9862         return FALSE;
9863     }
9864
9865   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9866     {
9867       if (!is_ppc64_elf (ibfd))
9868         continue;
9869
9870       s = ppc64_elf_tdata (ibfd)->got;
9871       if (s != NULL && s != htab->elf.sgot)
9872         {
9873           if (s->size == 0)
9874             s->flags |= SEC_EXCLUDE;
9875           else
9876             {
9877               s->contents = bfd_zalloc (ibfd, s->size);
9878               if (s->contents == NULL)
9879                 return FALSE;
9880             }
9881         }
9882       s = ppc64_elf_tdata (ibfd)->relgot;
9883       if (s != NULL)
9884         {
9885           if (s->size == 0)
9886             s->flags |= SEC_EXCLUDE;
9887           else
9888             {
9889               s->contents = bfd_zalloc (ibfd, s->size);
9890               if (s->contents == NULL)
9891                 return FALSE;
9892               relocs = TRUE;
9893               s->reloc_count = 0;
9894             }
9895         }
9896     }
9897
9898   if (htab->elf.dynamic_sections_created)
9899     {
9900       bfd_boolean tls_opt;
9901
9902       /* Add some entries to the .dynamic section.  We fill in the
9903          values later, in ppc64_elf_finish_dynamic_sections, but we
9904          must add the entries now so that we get the correct size for
9905          the .dynamic section.  The DT_DEBUG entry is filled in by the
9906          dynamic linker and used by the debugger.  */
9907 #define add_dynamic_entry(TAG, VAL) \
9908   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9909
9910       if (info->executable)
9911         {
9912           if (!add_dynamic_entry (DT_DEBUG, 0))
9913             return FALSE;
9914         }
9915
9916       if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9917         {
9918           if (!add_dynamic_entry (DT_PLTGOT, 0)
9919               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9920               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9921               || !add_dynamic_entry (DT_JMPREL, 0)
9922               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9923             return FALSE;
9924         }
9925
9926       if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9927         {
9928           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9929               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9930             return FALSE;
9931         }
9932
9933       tls_opt = (!htab->no_tls_get_addr_opt
9934                  && htab->tls_get_addr_fd != NULL
9935                  && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9936       if (tls_opt || !htab->opd_abi)
9937         {
9938           if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9939             return FALSE;
9940         }
9941
9942       if (relocs)
9943         {
9944           if (!add_dynamic_entry (DT_RELA, 0)
9945               || !add_dynamic_entry (DT_RELASZ, 0)
9946               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9947             return FALSE;
9948
9949           /* If any dynamic relocs apply to a read-only section,
9950              then we need a DT_TEXTREL entry.  */
9951           if ((info->flags & DF_TEXTREL) == 0)
9952             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9953
9954           if ((info->flags & DF_TEXTREL) != 0)
9955             {
9956               if (!add_dynamic_entry (DT_TEXTREL, 0))
9957                 return FALSE;
9958             }
9959         }
9960     }
9961 #undef add_dynamic_entry
9962
9963   return TRUE;
9964 }
9965
9966 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
9967
9968 static bfd_boolean
9969 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9970 {
9971   if (h->plt.plist != NULL
9972       && !h->def_regular
9973       && !h->pointer_equality_needed)
9974     return FALSE;
9975
9976   return _bfd_elf_hash_symbol (h);
9977 }
9978
9979 /* Determine the type of stub needed, if any, for a call.  */
9980
9981 static inline enum ppc_stub_type
9982 ppc_type_of_stub (asection *input_sec,
9983                   const Elf_Internal_Rela *rel,
9984                   struct ppc_link_hash_entry **hash,
9985                   struct plt_entry **plt_ent,
9986                   bfd_vma destination,
9987                   unsigned long local_off)
9988 {
9989   struct ppc_link_hash_entry *h = *hash;
9990   bfd_vma location;
9991   bfd_vma branch_offset;
9992   bfd_vma max_branch_offset;
9993   enum elf_ppc64_reloc_type r_type;
9994
9995   if (h != NULL)
9996     {
9997       struct plt_entry *ent;
9998       struct ppc_link_hash_entry *fdh = h;
9999       if (h->oh != NULL
10000           && h->oh->is_func_descriptor)
10001         {
10002           fdh = ppc_follow_link (h->oh);
10003           *hash = fdh;
10004         }
10005
10006       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10007         if (ent->addend == rel->r_addend
10008             && ent->plt.offset != (bfd_vma) -1)
10009           {
10010             *plt_ent = ent;
10011             return ppc_stub_plt_call;
10012           }
10013
10014       /* Here, we know we don't have a plt entry.  If we don't have a
10015          either a defined function descriptor or a defined entry symbol
10016          in a regular object file, then it is pointless trying to make
10017          any other type of stub.  */
10018       if (!is_static_defined (&fdh->elf)
10019           && !is_static_defined (&h->elf))
10020         return ppc_stub_none;
10021     }
10022   else if (elf_local_got_ents (input_sec->owner) != NULL)
10023     {
10024       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10025       struct plt_entry **local_plt = (struct plt_entry **)
10026         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10027       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10028
10029       if (local_plt[r_symndx] != NULL)
10030         {
10031           struct plt_entry *ent;
10032
10033           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10034             if (ent->addend == rel->r_addend
10035                 && ent->plt.offset != (bfd_vma) -1)
10036               {
10037                 *plt_ent = ent;
10038                 return ppc_stub_plt_call;
10039               }
10040         }
10041     }
10042
10043   /* Determine where the call point is.  */
10044   location = (input_sec->output_offset
10045               + input_sec->output_section->vma
10046               + rel->r_offset);
10047
10048   branch_offset = destination - location;
10049   r_type = ELF64_R_TYPE (rel->r_info);
10050
10051   /* Determine if a long branch stub is needed.  */
10052   max_branch_offset = 1 << 25;
10053   if (r_type != R_PPC64_REL24)
10054     max_branch_offset = 1 << 15;
10055
10056   if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10057     /* We need a stub.  Figure out whether a long_branch or plt_branch
10058        is needed later.  */
10059     return ppc_stub_long_branch;
10060
10061   return ppc_stub_none;
10062 }
10063
10064 /* With power7 weakly ordered memory model, it is possible for ld.so
10065    to update a plt entry in one thread and have another thread see a
10066    stale zero toc entry.  To avoid this we need some sort of acquire
10067    barrier in the call stub.  One solution is to make the load of the
10068    toc word seem to appear to depend on the load of the function entry
10069    word.  Another solution is to test for r2 being zero, and branch to
10070    the appropriate glink entry if so.
10071
10072    .    fake dep barrier        compare
10073    .    ld 12,xxx(2)            ld 12,xxx(2)
10074    .    mtctr 12                mtctr 12
10075    .    xor 11,12,12            ld 2,xxx+8(2)
10076    .    add 2,2,11              cmpldi 2,0
10077    .    ld 2,xxx+8(2)           bnectr+
10078    .    bctr                    b <glink_entry>
10079
10080    The solution involving the compare turns out to be faster, so
10081    that's what we use unless the branch won't reach.  */
10082
10083 #define ALWAYS_USE_FAKE_DEP 0
10084 #define ALWAYS_EMIT_R2SAVE 0
10085
10086 #define PPC_LO(v) ((v) & 0xffff)
10087 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10088 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10089
10090 static inline unsigned int
10091 plt_stub_size (struct ppc_link_hash_table *htab,
10092                struct ppc_stub_hash_entry *stub_entry,
10093                bfd_vma off)
10094 {
10095   unsigned size = 12;
10096
10097   if (ALWAYS_EMIT_R2SAVE
10098       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10099     size += 4;
10100   if (PPC_HA (off) != 0)
10101     size += 4;
10102   if (htab->opd_abi)
10103     {
10104       size += 4;
10105       if (htab->plt_static_chain)
10106         size += 4;
10107       if (htab->plt_thread_safe)
10108         size += 8;
10109       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10110         size += 4;
10111     }
10112   if (stub_entry->h != NULL
10113       && (stub_entry->h == htab->tls_get_addr_fd
10114           || stub_entry->h == htab->tls_get_addr)
10115       && !htab->no_tls_get_addr_opt)
10116     size += 13 * 4;
10117   return size;
10118 }
10119
10120 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10121    then return the padding needed to do so.  */
10122 static inline unsigned int
10123 plt_stub_pad (struct ppc_link_hash_table *htab,
10124               struct ppc_stub_hash_entry *stub_entry,
10125               bfd_vma plt_off)
10126 {
10127   int stub_align = 1 << htab->plt_stub_align;
10128   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10129   bfd_vma stub_off = stub_entry->stub_sec->size;
10130
10131   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10132       > (stub_size & -stub_align))
10133     return stub_align - (stub_off & (stub_align - 1));
10134   return 0;
10135 }
10136
10137 /* Build a .plt call stub.  */
10138
10139 static inline bfd_byte *
10140 build_plt_stub (struct ppc_link_hash_table *htab,
10141                 struct ppc_stub_hash_entry *stub_entry,
10142                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10143 {
10144   bfd *obfd = htab->stub_bfd;
10145   bfd_boolean plt_load_toc = htab->opd_abi;
10146   bfd_boolean plt_static_chain = htab->plt_static_chain;
10147   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10148   bfd_boolean use_fake_dep = plt_thread_safe;
10149   bfd_vma cmp_branch_off = 0;
10150
10151   if (!ALWAYS_USE_FAKE_DEP
10152       && plt_load_toc
10153       && plt_thread_safe
10154       && !(stub_entry->h != NULL
10155            && (stub_entry->h == htab->tls_get_addr_fd
10156                || stub_entry->h == htab->tls_get_addr)
10157            && !htab->no_tls_get_addr_opt))
10158     {
10159       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10160       bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10161                           / PLT_ENTRY_SIZE (htab));
10162       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10163       bfd_vma to, from;
10164
10165       if (pltindex > 32768)
10166         glinkoff += (pltindex - 32768) * 4;
10167       to = (glinkoff
10168             + htab->glink->output_offset
10169             + htab->glink->output_section->vma);
10170       from = (p - stub_entry->stub_sec->contents
10171               + 4 * (ALWAYS_EMIT_R2SAVE
10172                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10173               + 4 * (PPC_HA (offset) != 0)
10174               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10175                      != PPC_HA (offset))
10176               + 4 * (plt_static_chain != 0)
10177               + 20
10178               + stub_entry->stub_sec->output_offset
10179               + stub_entry->stub_sec->output_section->vma);
10180       cmp_branch_off = to - from;
10181       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10182     }
10183
10184   if (PPC_HA (offset) != 0)
10185     {
10186       if (r != NULL)
10187         {
10188           if (ALWAYS_EMIT_R2SAVE
10189               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10190             r[0].r_offset += 4;
10191           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10192           r[1].r_offset = r[0].r_offset + 4;
10193           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10194           r[1].r_addend = r[0].r_addend;
10195           if (plt_load_toc)
10196             {
10197               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10198                 {
10199                   r[2].r_offset = r[1].r_offset + 4;
10200                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10201                   r[2].r_addend = r[0].r_addend;
10202                 }
10203               else
10204                 {
10205                   r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10206                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10207                   r[2].r_addend = r[0].r_addend + 8;
10208                   if (plt_static_chain)
10209                     {
10210                       r[3].r_offset = r[2].r_offset + 4;
10211                       r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10212                       r[3].r_addend = r[0].r_addend + 16;
10213                     }
10214                 }
10215             }
10216         }
10217       if (ALWAYS_EMIT_R2SAVE
10218           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10219         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10220       bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p),     p += 4;
10221       bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p),      p += 4;
10222       if (plt_load_toc
10223           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10224         {
10225           bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10226           offset = 0;
10227         }
10228       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10229       if (plt_load_toc)
10230         {
10231           if (use_fake_dep)
10232             {
10233               bfd_put_32 (obfd, XOR_R2_R12_R12, p),             p += 4;
10234               bfd_put_32 (obfd, ADD_R11_R11_R2, p),             p += 4;
10235             }
10236           bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10237           if (plt_static_chain)
10238             bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10239         }
10240     }
10241   else
10242     {
10243       if (r != NULL)
10244         {
10245           if (ALWAYS_EMIT_R2SAVE
10246               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10247             r[0].r_offset += 4;
10248           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10249           if (plt_load_toc)
10250             {
10251               if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10252                 {
10253                   r[1].r_offset = r[0].r_offset + 4;
10254                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10255                   r[1].r_addend = r[0].r_addend;
10256                 }
10257               else
10258                 {
10259                   r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10260                   r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10261                   r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10262                   if (plt_static_chain)
10263                     {
10264                       r[2].r_offset = r[1].r_offset + 4;
10265                       r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10266                       r[2].r_addend = r[0].r_addend + 8;
10267                     }
10268                 }
10269             }
10270         }
10271       if (ALWAYS_EMIT_R2SAVE
10272           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10273         bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p),      p += 4;
10274       bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p),       p += 4;
10275       if (plt_load_toc
10276           && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10277         {
10278           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
10279           offset = 0;
10280         }
10281       bfd_put_32 (obfd, MTCTR_R12, p),                          p += 4;
10282       if (plt_load_toc)
10283         {
10284           if (use_fake_dep)
10285             {
10286               bfd_put_32 (obfd, XOR_R11_R12_R12, p),            p += 4;
10287               bfd_put_32 (obfd, ADD_R2_R2_R11, p),              p += 4;
10288             }
10289           if (plt_static_chain)
10290             bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10291           bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10292         }
10293     }
10294   if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10295     {
10296       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
10297       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
10298       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10299     }
10300   else
10301     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
10302   return p;
10303 }
10304
10305 /* Build a special .plt call stub for __tls_get_addr.  */
10306
10307 #define LD_R11_0R3      0xe9630000
10308 #define LD_R12_0R3      0xe9830000
10309 #define MR_R0_R3        0x7c601b78
10310 #define CMPDI_R11_0     0x2c2b0000
10311 #define ADD_R3_R12_R13  0x7c6c6a14
10312 #define BEQLR           0x4d820020
10313 #define MR_R3_R0        0x7c030378
10314 #define STD_R11_0R1     0xf9610000
10315 #define BCTRL           0x4e800421
10316 #define LD_R11_0R1      0xe9610000
10317 #define MTLR_R11        0x7d6803a6
10318
10319 static inline bfd_byte *
10320 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10321                          struct ppc_stub_hash_entry *stub_entry,
10322                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10323 {
10324   bfd *obfd = htab->stub_bfd;
10325
10326   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
10327   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
10328   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
10329   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
10330   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
10331   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
10332   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
10333   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
10334   bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10335
10336   if (r != NULL)
10337     r[0].r_offset += 9 * 4;
10338   p = build_plt_stub (htab, stub_entry, p, offset, r);
10339   bfd_put_32 (obfd, BCTRL, p - 4);
10340
10341   bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10342   bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p),     p += 4;
10343   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
10344   bfd_put_32 (obfd, BLR, p),                    p += 4;
10345
10346   return p;
10347 }
10348
10349 static Elf_Internal_Rela *
10350 get_relocs (asection *sec, int count)
10351 {
10352   Elf_Internal_Rela *relocs;
10353   struct bfd_elf_section_data *elfsec_data;
10354
10355   elfsec_data = elf_section_data (sec);
10356   relocs = elfsec_data->relocs;
10357   if (relocs == NULL)
10358     {
10359       bfd_size_type relsize;
10360       relsize = sec->reloc_count * sizeof (*relocs);
10361       relocs = bfd_alloc (sec->owner, relsize);
10362       if (relocs == NULL)
10363         return NULL;
10364       elfsec_data->relocs = relocs;
10365       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10366                                           sizeof (Elf_Internal_Shdr));
10367       if (elfsec_data->rela.hdr == NULL)
10368         return NULL;
10369       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10370                                         * sizeof (Elf64_External_Rela));
10371       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10372       sec->reloc_count = 0;
10373     }
10374   relocs += sec->reloc_count;
10375   sec->reloc_count += count;
10376   return relocs;
10377 }
10378
10379 static bfd_vma
10380 get_r2off (struct bfd_link_info *info,
10381            struct ppc_stub_hash_entry *stub_entry)
10382 {
10383   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10384   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10385
10386   if (r2off == 0)
10387     {
10388       /* Support linking -R objects.  Get the toc pointer from the
10389          opd entry.  */
10390       char buf[8];
10391       if (!htab->opd_abi)
10392         return r2off;
10393       asection *opd = stub_entry->h->elf.root.u.def.section;
10394       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10395
10396       if (strcmp (opd->name, ".opd") != 0
10397           || opd->reloc_count != 0)
10398         {
10399           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10400                                   stub_entry->h->elf.root.root.string);
10401           bfd_set_error (bfd_error_bad_value);
10402           return 0;
10403         }
10404       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10405         return 0;
10406       r2off = bfd_get_64 (opd->owner, buf);
10407       r2off -= elf_gp (info->output_bfd);
10408     }
10409   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10410   return r2off;
10411 }
10412
10413 static bfd_boolean
10414 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10415 {
10416   struct ppc_stub_hash_entry *stub_entry;
10417   struct ppc_branch_hash_entry *br_entry;
10418   struct bfd_link_info *info;
10419   struct ppc_link_hash_table *htab;
10420   bfd_byte *loc;
10421   bfd_byte *p;
10422   bfd_vma dest, off;
10423   int size;
10424   Elf_Internal_Rela *r;
10425   asection *plt;
10426
10427   /* Massage our args to the form they really have.  */
10428   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10429   info = in_arg;
10430
10431   htab = ppc_hash_table (info);
10432   if (htab == NULL)
10433     return FALSE;
10434
10435   /* Make a note of the offset within the stubs for this entry.  */
10436   stub_entry->stub_offset = stub_entry->stub_sec->size;
10437   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10438
10439   htab->stub_count[stub_entry->stub_type - 1] += 1;
10440   switch (stub_entry->stub_type)
10441     {
10442     case ppc_stub_long_branch:
10443     case ppc_stub_long_branch_r2off:
10444       /* Branches are relative.  This is where we are going to.  */
10445       dest = (stub_entry->target_value
10446               + stub_entry->target_section->output_offset
10447               + stub_entry->target_section->output_section->vma);
10448       dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10449       off = dest;
10450
10451       /* And this is where we are coming from.  */
10452       off -= (stub_entry->stub_offset
10453               + stub_entry->stub_sec->output_offset
10454               + stub_entry->stub_sec->output_section->vma);
10455
10456       size = 4;
10457       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10458         {
10459           bfd_vma r2off = get_r2off (info, stub_entry);
10460
10461           if (r2off == 0)
10462             {
10463               htab->stub_error = TRUE;
10464               return FALSE;
10465             }
10466           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10467           loc += 4;
10468           size = 12;
10469           if (PPC_HA (r2off) != 0)
10470             {
10471               size = 16;
10472               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10473               loc += 4;
10474             }
10475           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10476           loc += 4;
10477           off -= size - 4;
10478         }
10479       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10480
10481       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10482         {
10483           info->callbacks->einfo
10484             (_("%P: long branch stub `%s' offset overflow\n"),
10485              stub_entry->root.string);
10486           htab->stub_error = TRUE;
10487           return FALSE;
10488         }
10489
10490       if (info->emitrelocations)
10491         {
10492           r = get_relocs (stub_entry->stub_sec, 1);
10493           if (r == NULL)
10494             return FALSE;
10495           r->r_offset = loc - stub_entry->stub_sec->contents;
10496           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10497           r->r_addend = dest;
10498           if (stub_entry->h != NULL)
10499             {
10500               struct elf_link_hash_entry **hashes;
10501               unsigned long symndx;
10502               struct ppc_link_hash_entry *h;
10503
10504               hashes = elf_sym_hashes (htab->stub_bfd);
10505               if (hashes == NULL)
10506                 {
10507                   bfd_size_type hsize;
10508
10509                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10510                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10511                   if (hashes == NULL)
10512                     return FALSE;
10513                   elf_sym_hashes (htab->stub_bfd) = hashes;
10514                   htab->stub_globals = 1;
10515                 }
10516               symndx = htab->stub_globals++;
10517               h = stub_entry->h;
10518               hashes[symndx] = &h->elf;
10519               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10520               if (h->oh != NULL && h->oh->is_func)
10521                 h = ppc_follow_link (h->oh);
10522               if (h->elf.root.u.def.section != stub_entry->target_section)
10523                 /* H is an opd symbol.  The addend must be zero.  */
10524                 r->r_addend = 0;
10525               else
10526                 {
10527                   off = (h->elf.root.u.def.value
10528                          + h->elf.root.u.def.section->output_offset
10529                          + h->elf.root.u.def.section->output_section->vma);
10530                   r->r_addend -= off;
10531                 }
10532             }
10533         }
10534       break;
10535
10536     case ppc_stub_plt_branch:
10537     case ppc_stub_plt_branch_r2off:
10538       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10539                                          stub_entry->root.string + 9,
10540                                          FALSE, FALSE);
10541       if (br_entry == NULL)
10542         {
10543           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10544                                   stub_entry->root.string);
10545           htab->stub_error = TRUE;
10546           return FALSE;
10547         }
10548
10549       dest = (stub_entry->target_value
10550               + stub_entry->target_section->output_offset
10551               + stub_entry->target_section->output_section->vma);
10552       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10553         dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10554
10555       bfd_put_64 (htab->brlt->owner, dest,
10556                   htab->brlt->contents + br_entry->offset);
10557
10558       if (br_entry->iter == htab->stub_iteration)
10559         {
10560           br_entry->iter = 0;
10561
10562           if (htab->relbrlt != NULL)
10563             {
10564               /* Create a reloc for the branch lookup table entry.  */
10565               Elf_Internal_Rela rela;
10566               bfd_byte *rl;
10567
10568               rela.r_offset = (br_entry->offset
10569                                + htab->brlt->output_offset
10570                                + htab->brlt->output_section->vma);
10571               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10572               rela.r_addend = dest;
10573
10574               rl = htab->relbrlt->contents;
10575               rl += (htab->relbrlt->reloc_count++
10576                      * sizeof (Elf64_External_Rela));
10577               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10578             }
10579           else if (info->emitrelocations)
10580             {
10581               r = get_relocs (htab->brlt, 1);
10582               if (r == NULL)
10583                 return FALSE;
10584               /* brlt, being SEC_LINKER_CREATED does not go through the
10585                  normal reloc processing.  Symbols and offsets are not
10586                  translated from input file to output file form, so
10587                  set up the offset per the output file.  */
10588               r->r_offset = (br_entry->offset
10589                              + htab->brlt->output_offset
10590                              + htab->brlt->output_section->vma);
10591               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10592               r->r_addend = dest;
10593             }
10594         }
10595
10596       dest = (br_entry->offset
10597               + htab->brlt->output_offset
10598               + htab->brlt->output_section->vma);
10599
10600       off = (dest
10601              - elf_gp (htab->brlt->output_section->owner)
10602              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10603
10604       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10605         {
10606           info->callbacks->einfo
10607             (_("%P: linkage table error against `%T'\n"),
10608              stub_entry->root.string);
10609           bfd_set_error (bfd_error_bad_value);
10610           htab->stub_error = TRUE;
10611           return FALSE;
10612         }
10613
10614       if (info->emitrelocations)
10615         {
10616           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10617           if (r == NULL)
10618             return FALSE;
10619           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10620           if (bfd_big_endian (info->output_bfd))
10621             r[0].r_offset += 2;
10622           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10623             r[0].r_offset += 4;
10624           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10625           r[0].r_addend = dest;
10626           if (PPC_HA (off) != 0)
10627             {
10628               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10629               r[1].r_offset = r[0].r_offset + 4;
10630               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10631               r[1].r_addend = r[0].r_addend;
10632             }
10633         }
10634
10635       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10636         {
10637           if (PPC_HA (off) != 0)
10638             {
10639               size = 16;
10640               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10641               loc += 4;
10642               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10643             }
10644           else
10645             {
10646               size = 12;
10647               bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10648             }
10649         }
10650       else
10651         {
10652           bfd_vma r2off = get_r2off (info, stub_entry);
10653
10654           if (r2off == 0 && htab->opd_abi)
10655             {
10656               htab->stub_error = TRUE;
10657               return FALSE;
10658             }
10659
10660           bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10661           loc += 4;
10662           size = 16;
10663           if (PPC_HA (off) != 0)
10664             {
10665               size += 4;
10666               bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10667               loc += 4;
10668               bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10669             }
10670           else
10671             bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10672
10673           if (PPC_HA (r2off) != 0)
10674             {
10675               size += 4;
10676               loc += 4;
10677               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10678             }
10679           if (PPC_LO (r2off) != 0)
10680             {
10681               size += 4;
10682               loc += 4;
10683               bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10684             }
10685         }
10686       loc += 4;
10687       bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10688       loc += 4;
10689       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10690       break;
10691
10692     case ppc_stub_plt_call:
10693     case ppc_stub_plt_call_r2save:
10694       if (stub_entry->h != NULL
10695           && stub_entry->h->is_func_descriptor
10696           && stub_entry->h->oh != NULL)
10697         {
10698           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10699
10700           /* If the old-ABI "dot-symbol" is undefined make it weak so
10701              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10702              FIXME: We used to define the symbol on one of the call
10703              stubs instead, which is why we test symbol section id
10704              against htab->top_id in various places.  Likely all
10705              these checks could now disappear.  */
10706           if (fh->elf.root.type == bfd_link_hash_undefined)
10707             fh->elf.root.type = bfd_link_hash_undefweak;
10708           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10709           fh->was_undefined = 0;
10710         }
10711
10712       /* Now build the stub.  */
10713       dest = stub_entry->plt_ent->plt.offset & ~1;
10714       if (dest >= (bfd_vma) -2)
10715         abort ();
10716
10717       plt = htab->elf.splt;
10718       if (!htab->elf.dynamic_sections_created
10719           || stub_entry->h == NULL
10720           || stub_entry->h->elf.dynindx == -1)
10721         plt = htab->elf.iplt;
10722
10723       dest += plt->output_offset + plt->output_section->vma;
10724
10725       if (stub_entry->h == NULL
10726           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10727         {
10728           Elf_Internal_Rela rela;
10729           bfd_byte *rl;
10730
10731           rela.r_offset = dest;
10732           if (htab->opd_abi)
10733             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10734           else
10735             rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10736           rela.r_addend = (stub_entry->target_value
10737                            + stub_entry->target_section->output_offset
10738                            + stub_entry->target_section->output_section->vma);
10739
10740           rl = (htab->elf.irelplt->contents
10741                 + (htab->elf.irelplt->reloc_count++
10742                    * sizeof (Elf64_External_Rela)));
10743           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10744           stub_entry->plt_ent->plt.offset |= 1;
10745         }
10746
10747       off = (dest
10748              - elf_gp (plt->output_section->owner)
10749              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10750
10751       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10752         {
10753           info->callbacks->einfo
10754             (_("%P: linkage table error against `%T'\n"),
10755              stub_entry->h != NULL
10756              ? stub_entry->h->elf.root.root.string
10757              : "<local sym>");
10758           bfd_set_error (bfd_error_bad_value);
10759           htab->stub_error = TRUE;
10760           return FALSE;
10761         }
10762
10763       if (htab->plt_stub_align != 0)
10764         {
10765           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10766
10767           stub_entry->stub_sec->size += pad;
10768           stub_entry->stub_offset = stub_entry->stub_sec->size;
10769           loc += pad;
10770         }
10771
10772       r = NULL;
10773       if (info->emitrelocations)
10774         {
10775           r = get_relocs (stub_entry->stub_sec,
10776                           ((PPC_HA (off) != 0)
10777                            + (htab->opd_abi
10778                               ? 2 + (htab->plt_static_chain
10779                                      && PPC_HA (off + 16) == PPC_HA (off))
10780                               : 1)));
10781           if (r == NULL)
10782             return FALSE;
10783           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10784           if (bfd_big_endian (info->output_bfd))
10785             r[0].r_offset += 2;
10786           r[0].r_addend = dest;
10787         }
10788       if (stub_entry->h != NULL
10789           && (stub_entry->h == htab->tls_get_addr_fd
10790               || stub_entry->h == htab->tls_get_addr)
10791           && !htab->no_tls_get_addr_opt)
10792         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10793       else
10794         p = build_plt_stub (htab, stub_entry, loc, off, r);
10795       size = p - loc;
10796       break;
10797
10798     default:
10799       BFD_FAIL ();
10800       return FALSE;
10801     }
10802
10803   stub_entry->stub_sec->size += size;
10804
10805   if (htab->emit_stub_syms)
10806     {
10807       struct elf_link_hash_entry *h;
10808       size_t len1, len2;
10809       char *name;
10810       const char *const stub_str[] = { "long_branch",
10811                                        "long_branch_r2off",
10812                                        "plt_branch",
10813                                        "plt_branch_r2off",
10814                                        "plt_call",
10815                                        "plt_call" };
10816
10817       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10818       len2 = strlen (stub_entry->root.string);
10819       name = bfd_malloc (len1 + len2 + 2);
10820       if (name == NULL)
10821         return FALSE;
10822       memcpy (name, stub_entry->root.string, 9);
10823       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10824       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10825       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10826       if (h == NULL)
10827         return FALSE;
10828       if (h->root.type == bfd_link_hash_new)
10829         {
10830           h->root.type = bfd_link_hash_defined;
10831           h->root.u.def.section = stub_entry->stub_sec;
10832           h->root.u.def.value = stub_entry->stub_offset;
10833           h->ref_regular = 1;
10834           h->def_regular = 1;
10835           h->ref_regular_nonweak = 1;
10836           h->forced_local = 1;
10837           h->non_elf = 0;
10838         }
10839     }
10840
10841   return TRUE;
10842 }
10843
10844 /* As above, but don't actually build the stub.  Just bump offset so
10845    we know stub section sizes, and select plt_branch stubs where
10846    long_branch stubs won't do.  */
10847
10848 static bfd_boolean
10849 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10850 {
10851   struct ppc_stub_hash_entry *stub_entry;
10852   struct bfd_link_info *info;
10853   struct ppc_link_hash_table *htab;
10854   bfd_vma off;
10855   int size;
10856
10857   /* Massage our args to the form they really have.  */
10858   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10859   info = in_arg;
10860
10861   htab = ppc_hash_table (info);
10862   if (htab == NULL)
10863     return FALSE;
10864
10865   if (stub_entry->stub_type == ppc_stub_plt_call
10866       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10867     {
10868       asection *plt;
10869       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10870       if (off >= (bfd_vma) -2)
10871         abort ();
10872       plt = htab->elf.splt;
10873       if (!htab->elf.dynamic_sections_created
10874           || stub_entry->h == NULL
10875           || stub_entry->h->elf.dynindx == -1)
10876         plt = htab->elf.iplt;
10877       off += (plt->output_offset
10878               + plt->output_section->vma
10879               - elf_gp (plt->output_section->owner)
10880               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10881
10882       size = plt_stub_size (htab, stub_entry, off);
10883       if (htab->plt_stub_align)
10884         size += plt_stub_pad (htab, stub_entry, off);
10885       if (info->emitrelocations)
10886         {
10887           stub_entry->stub_sec->reloc_count
10888             += ((PPC_HA (off) != 0)
10889                 + (htab->opd_abi
10890                    ? 2 + (htab->plt_static_chain
10891                           && PPC_HA (off + 16) == PPC_HA (off))
10892                    : 1));
10893           stub_entry->stub_sec->flags |= SEC_RELOC;
10894         }
10895     }
10896   else
10897     {
10898       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10899          variants.  */
10900       bfd_vma r2off = 0;
10901       bfd_vma local_off = 0;
10902
10903       off = (stub_entry->target_value
10904              + stub_entry->target_section->output_offset
10905              + stub_entry->target_section->output_section->vma);
10906       off -= (stub_entry->stub_sec->size
10907               + stub_entry->stub_sec->output_offset
10908               + stub_entry->stub_sec->output_section->vma);
10909
10910       /* Reset the stub type from the plt variant in case we now
10911          can reach with a shorter stub.  */
10912       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10913         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10914
10915       size = 4;
10916       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10917         {
10918           r2off = get_r2off (info, stub_entry);
10919           if (r2off == 0 && htab->opd_abi)
10920             {
10921               htab->stub_error = TRUE;
10922               return FALSE;
10923             }
10924           size = 12;
10925           if (PPC_HA (r2off) != 0)
10926             size = 16;
10927           off -= size - 4;
10928         }
10929
10930       local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10931
10932       /* If the branch offset if too big, use a ppc_stub_plt_branch.
10933          Do the same for -R objects without function descriptors.  */
10934       if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10935           || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10936               && r2off == 0))
10937         {
10938           struct ppc_branch_hash_entry *br_entry;
10939
10940           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10941                                              stub_entry->root.string + 9,
10942                                              TRUE, FALSE);
10943           if (br_entry == NULL)
10944             {
10945               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10946                                       stub_entry->root.string);
10947               htab->stub_error = TRUE;
10948               return FALSE;
10949             }
10950
10951           if (br_entry->iter != htab->stub_iteration)
10952             {
10953               br_entry->iter = htab->stub_iteration;
10954               br_entry->offset = htab->brlt->size;
10955               htab->brlt->size += 8;
10956
10957               if (htab->relbrlt != NULL)
10958                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10959               else if (info->emitrelocations)
10960                 {
10961                   htab->brlt->reloc_count += 1;
10962                   htab->brlt->flags |= SEC_RELOC;
10963                 }
10964             }
10965
10966           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10967           off = (br_entry->offset
10968                  + htab->brlt->output_offset
10969                  + htab->brlt->output_section->vma
10970                  - elf_gp (htab->brlt->output_section->owner)
10971                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10972
10973           if (info->emitrelocations)
10974             {
10975               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10976               stub_entry->stub_sec->flags |= SEC_RELOC;
10977             }
10978
10979           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10980             {
10981               size = 12;
10982               if (PPC_HA (off) != 0)
10983                 size = 16;
10984             }
10985           else
10986             {
10987               size = 16;
10988               if (PPC_HA (off) != 0)
10989                 size += 4;
10990
10991               if (PPC_HA (r2off) != 0)
10992                 size += 4;
10993               if (PPC_LO (r2off) != 0)
10994                 size += 4;
10995             }
10996         }
10997       else if (info->emitrelocations)
10998         {
10999           stub_entry->stub_sec->reloc_count += 1;
11000           stub_entry->stub_sec->flags |= SEC_RELOC;
11001         }
11002     }
11003
11004   stub_entry->stub_sec->size += size;
11005   return TRUE;
11006 }
11007
11008 /* Set up various things so that we can make a list of input sections
11009    for each output section included in the link.  Returns -1 on error,
11010    0 when no stubs will be needed, and 1 on success.  */
11011
11012 int
11013 ppc64_elf_setup_section_lists
11014   (struct bfd_link_info *info,
11015    asection *(*add_stub_section) (const char *, asection *),
11016    void (*layout_sections_again) (void))
11017 {
11018   bfd *input_bfd;
11019   int top_id, top_index, id;
11020   asection *section;
11021   asection **input_list;
11022   bfd_size_type amt;
11023   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11024
11025   if (htab == NULL)
11026     return -1;
11027   /* Stash our params away.  */
11028   htab->add_stub_section = add_stub_section;
11029   htab->layout_sections_again = layout_sections_again;
11030
11031   /* Find the top input section id.  */
11032   for (input_bfd = info->input_bfds, top_id = 3;
11033        input_bfd != NULL;
11034        input_bfd = input_bfd->link_next)
11035     {
11036       for (section = input_bfd->sections;
11037            section != NULL;
11038            section = section->next)
11039         {
11040           if (top_id < section->id)
11041             top_id = section->id;
11042         }
11043     }
11044
11045   htab->top_id = top_id;
11046   amt = sizeof (struct map_stub) * (top_id + 1);
11047   htab->stub_group = bfd_zmalloc (amt);
11048   if (htab->stub_group == NULL)
11049     return -1;
11050
11051   /* Set toc_off for com, und, abs and ind sections.  */
11052   for (id = 0; id < 3; id++)
11053     htab->stub_group[id].toc_off = TOC_BASE_OFF;
11054
11055   /* We can't use output_bfd->section_count here to find the top output
11056      section index as some sections may have been removed, and
11057      strip_excluded_output_sections doesn't renumber the indices.  */
11058   for (section = info->output_bfd->sections, top_index = 0;
11059        section != NULL;
11060        section = section->next)
11061     {
11062       if (top_index < section->index)
11063         top_index = section->index;
11064     }
11065
11066   htab->top_index = top_index;
11067   amt = sizeof (asection *) * (top_index + 1);
11068   input_list = bfd_zmalloc (amt);
11069   htab->input_list = input_list;
11070   if (input_list == NULL)
11071     return -1;
11072
11073   return 1;
11074 }
11075
11076 /* Set up for first pass at multitoc partitioning.  */
11077
11078 void
11079 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11080 {
11081   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11082
11083   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11084   htab->toc_bfd = NULL;
11085   htab->toc_first_sec = NULL;
11086 }
11087
11088 /* The linker repeatedly calls this function for each TOC input section
11089    and linker generated GOT section.  Group input bfds such that the toc
11090    within a group is less than 64k in size.  */
11091
11092 bfd_boolean
11093 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11094 {
11095   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11096   bfd_vma addr, off, limit;
11097
11098   if (htab == NULL)
11099     return FALSE;
11100
11101   if (!htab->second_toc_pass)
11102     {
11103       /* Keep track of the first .toc or .got section for this input bfd.  */
11104       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11105
11106       if (new_bfd)
11107         {
11108           htab->toc_bfd = isec->owner;
11109           htab->toc_first_sec = isec;
11110         }
11111
11112       addr = isec->output_offset + isec->output_section->vma;
11113       off = addr - htab->toc_curr;
11114       limit = 0x80008000;
11115       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11116         limit = 0x10000;
11117       if (off + isec->size > limit)
11118         {
11119           addr = (htab->toc_first_sec->output_offset
11120                   + htab->toc_first_sec->output_section->vma);
11121           htab->toc_curr = addr;
11122         }
11123
11124       /* toc_curr is the base address of this toc group.  Set elf_gp
11125          for the input section to be the offset relative to the
11126          output toc base plus 0x8000.  Making the input elf_gp an
11127          offset allows us to move the toc as a whole without
11128          recalculating input elf_gp.  */
11129       off = htab->toc_curr - elf_gp (isec->output_section->owner);
11130       off += TOC_BASE_OFF;
11131
11132       /* Die if someone uses a linker script that doesn't keep input
11133          file .toc and .got together.  */
11134       if (new_bfd
11135           && elf_gp (isec->owner) != 0
11136           && elf_gp (isec->owner) != off)
11137         return FALSE;
11138
11139       elf_gp (isec->owner) = off;
11140       return TRUE;
11141     }
11142
11143   /* During the second pass toc_first_sec points to the start of
11144      a toc group, and toc_curr is used to track the old elf_gp.
11145      We use toc_bfd to ensure we only look at each bfd once.  */
11146   if (htab->toc_bfd == isec->owner)
11147     return TRUE;
11148   htab->toc_bfd = isec->owner;
11149
11150   if (htab->toc_first_sec == NULL
11151       || htab->toc_curr != elf_gp (isec->owner))
11152     {
11153       htab->toc_curr = elf_gp (isec->owner);
11154       htab->toc_first_sec = isec;
11155     }
11156   addr = (htab->toc_first_sec->output_offset
11157           + htab->toc_first_sec->output_section->vma);
11158   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11159   elf_gp (isec->owner) = off;
11160
11161   return TRUE;
11162 }
11163
11164 /* Called via elf_link_hash_traverse to merge GOT entries for global
11165    symbol H.  */
11166
11167 static bfd_boolean
11168 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11169 {
11170   if (h->root.type == bfd_link_hash_indirect)
11171     return TRUE;
11172
11173   merge_got_entries (&h->got.glist);
11174
11175   return TRUE;
11176 }
11177
11178 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11179    symbol H.  */
11180
11181 static bfd_boolean
11182 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11183 {
11184   struct got_entry *gent;
11185
11186   if (h->root.type == bfd_link_hash_indirect)
11187     return TRUE;
11188
11189   for (gent = h->got.glist; gent != NULL; gent = gent->next)
11190     if (!gent->is_indirect)
11191       allocate_got (h, (struct bfd_link_info *) inf, gent);
11192   return TRUE;
11193 }
11194
11195 /* Called on the first multitoc pass after the last call to
11196    ppc64_elf_next_toc_section.  This function removes duplicate GOT
11197    entries.  */
11198
11199 bfd_boolean
11200 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11201 {
11202   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11203   struct bfd *ibfd, *ibfd2;
11204   bfd_boolean done_something;
11205
11206   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11207
11208   if (!htab->do_multi_toc)
11209     return FALSE;
11210
11211   /* Merge global sym got entries within a toc group.  */
11212   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11213
11214   /* And tlsld_got.  */
11215   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11216     {
11217       struct got_entry *ent, *ent2;
11218
11219       if (!is_ppc64_elf (ibfd))
11220         continue;
11221
11222       ent = ppc64_tlsld_got (ibfd);
11223       if (!ent->is_indirect
11224           && ent->got.offset != (bfd_vma) -1)
11225         {
11226           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11227             {
11228               if (!is_ppc64_elf (ibfd2))
11229                 continue;
11230
11231               ent2 = ppc64_tlsld_got (ibfd2);
11232               if (!ent2->is_indirect
11233                   && ent2->got.offset != (bfd_vma) -1
11234                   && elf_gp (ibfd2) == elf_gp (ibfd))
11235                 {
11236                   ent2->is_indirect = TRUE;
11237                   ent2->got.ent = ent;
11238                 }
11239             }
11240         }
11241     }
11242
11243   /* Zap sizes of got sections.  */
11244   htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11245   htab->elf.irelplt->size -= htab->got_reli_size;
11246   htab->got_reli_size = 0;
11247
11248   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11249     {
11250       asection *got, *relgot;
11251
11252       if (!is_ppc64_elf (ibfd))
11253         continue;
11254
11255       got = ppc64_elf_tdata (ibfd)->got;
11256       if (got != NULL)
11257         {
11258           got->rawsize = got->size;
11259           got->size = 0;
11260           relgot = ppc64_elf_tdata (ibfd)->relgot;
11261           relgot->rawsize = relgot->size;
11262           relgot->size = 0;
11263         }
11264     }
11265
11266   /* Now reallocate the got, local syms first.  We don't need to
11267      allocate section contents again since we never increase size.  */
11268   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11269     {
11270       struct got_entry **lgot_ents;
11271       struct got_entry **end_lgot_ents;
11272       struct plt_entry **local_plt;
11273       struct plt_entry **end_local_plt;
11274       unsigned char *lgot_masks;
11275       bfd_size_type locsymcount;
11276       Elf_Internal_Shdr *symtab_hdr;
11277       asection *s;
11278
11279       if (!is_ppc64_elf (ibfd))
11280         continue;
11281
11282       lgot_ents = elf_local_got_ents (ibfd);
11283       if (!lgot_ents)
11284         continue;
11285
11286       symtab_hdr = &elf_symtab_hdr (ibfd);
11287       locsymcount = symtab_hdr->sh_info;
11288       end_lgot_ents = lgot_ents + locsymcount;
11289       local_plt = (struct plt_entry **) end_lgot_ents;
11290       end_local_plt = local_plt + locsymcount;
11291       lgot_masks = (unsigned char *) end_local_plt;
11292       s = ppc64_elf_tdata (ibfd)->got;
11293       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11294         {
11295           struct got_entry *ent;
11296
11297           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11298             {
11299               unsigned int ent_size = 8;
11300               unsigned int rel_size = sizeof (Elf64_External_Rela);
11301
11302               ent->got.offset = s->size;
11303               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11304                 {
11305                   ent_size *= 2;
11306                   rel_size *= 2;
11307                 }
11308               s->size += ent_size;
11309               if ((*lgot_masks & PLT_IFUNC) != 0)
11310                 {
11311                   htab->elf.irelplt->size += rel_size;
11312                   htab->got_reli_size += rel_size;
11313                 }
11314               else if (info->shared)
11315                 {
11316                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11317                   srel->size += rel_size;
11318                 }
11319             }
11320         }
11321     }
11322
11323   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11324
11325   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11326     {
11327       struct got_entry *ent;
11328
11329       if (!is_ppc64_elf (ibfd))
11330         continue;
11331
11332       ent = ppc64_tlsld_got (ibfd);
11333       if (!ent->is_indirect
11334           && ent->got.offset != (bfd_vma) -1)
11335         {
11336           asection *s = ppc64_elf_tdata (ibfd)->got;
11337           ent->got.offset = s->size;
11338           s->size += 16;
11339           if (info->shared)
11340             {
11341               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11342               srel->size += sizeof (Elf64_External_Rela);
11343             }
11344         }
11345     }
11346
11347   done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11348   if (!done_something)
11349     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11350       {
11351         asection *got;
11352
11353         if (!is_ppc64_elf (ibfd))
11354           continue;
11355
11356         got = ppc64_elf_tdata (ibfd)->got;
11357         if (got != NULL)
11358           {
11359             done_something = got->rawsize != got->size;
11360             if (done_something)
11361               break;
11362           }
11363       }
11364
11365   if (done_something)
11366     (*htab->layout_sections_again) ();
11367
11368   /* Set up for second pass over toc sections to recalculate elf_gp
11369      on input sections.  */
11370   htab->toc_bfd = NULL;
11371   htab->toc_first_sec = NULL;
11372   htab->second_toc_pass = TRUE;
11373   return done_something;
11374 }
11375
11376 /* Called after second pass of multitoc partitioning.  */
11377
11378 void
11379 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11380 {
11381   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11382
11383   /* After the second pass, toc_curr tracks the TOC offset used
11384      for code sections below in ppc64_elf_next_input_section.  */
11385   htab->toc_curr = TOC_BASE_OFF;
11386 }
11387
11388 /* No toc references were found in ISEC.  If the code in ISEC makes no
11389    calls, then there's no need to use toc adjusting stubs when branching
11390    into ISEC.  Actually, indirect calls from ISEC are OK as they will
11391    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
11392    needed, and 2 if a cyclical call-graph was found but no other reason
11393    for a stub was detected.  If called from the top level, a return of
11394    2 means the same as a return of 0.  */
11395
11396 static int
11397 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11398 {
11399   int ret;
11400
11401   /* Mark this section as checked.  */
11402   isec->call_check_done = 1;
11403
11404   /* We know none of our code bearing sections will need toc stubs.  */
11405   if ((isec->flags & SEC_LINKER_CREATED) != 0)
11406     return 0;
11407
11408   if (isec->size == 0)
11409     return 0;
11410
11411   if (isec->output_section == NULL)
11412     return 0;
11413
11414   ret = 0;
11415   if (isec->reloc_count != 0)
11416     {
11417       Elf_Internal_Rela *relstart, *rel;
11418       Elf_Internal_Sym *local_syms;
11419       struct ppc_link_hash_table *htab;
11420
11421       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11422                                             info->keep_memory);
11423       if (relstart == NULL)
11424         return -1;
11425
11426       /* Look for branches to outside of this section.  */
11427       local_syms = NULL;
11428       htab = ppc_hash_table (info);
11429       if (htab == NULL)
11430         return -1;
11431
11432       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11433         {
11434           enum elf_ppc64_reloc_type r_type;
11435           unsigned long r_symndx;
11436           struct elf_link_hash_entry *h;
11437           struct ppc_link_hash_entry *eh;
11438           Elf_Internal_Sym *sym;
11439           asection *sym_sec;
11440           struct _opd_sec_data *opd;
11441           bfd_vma sym_value;
11442           bfd_vma dest;
11443
11444           r_type = ELF64_R_TYPE (rel->r_info);
11445           if (r_type != R_PPC64_REL24
11446               && r_type != R_PPC64_REL14
11447               && r_type != R_PPC64_REL14_BRTAKEN
11448               && r_type != R_PPC64_REL14_BRNTAKEN)
11449             continue;
11450
11451           r_symndx = ELF64_R_SYM (rel->r_info);
11452           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11453                           isec->owner))
11454             {
11455               ret = -1;
11456               break;
11457             }
11458
11459           /* Calls to dynamic lib functions go through a plt call stub
11460              that uses r2.  */
11461           eh = (struct ppc_link_hash_entry *) h;
11462           if (eh != NULL
11463               && (eh->elf.plt.plist != NULL
11464                   || (eh->oh != NULL
11465                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11466             {
11467               ret = 1;
11468               break;
11469             }
11470
11471           if (sym_sec == NULL)
11472             /* Ignore other undefined symbols.  */
11473             continue;
11474
11475           /* Assume branches to other sections not included in the
11476              link need stubs too, to cover -R and absolute syms.  */
11477           if (sym_sec->output_section == NULL)
11478             {
11479               ret = 1;
11480               break;
11481             }
11482
11483           if (h == NULL)
11484             sym_value = sym->st_value;
11485           else
11486             {
11487               if (h->root.type != bfd_link_hash_defined
11488                   && h->root.type != bfd_link_hash_defweak)
11489                 abort ();
11490               sym_value = h->root.u.def.value;
11491             }
11492           sym_value += rel->r_addend;
11493
11494           /* If this branch reloc uses an opd sym, find the code section.  */
11495           opd = get_opd_info (sym_sec);
11496           if (opd != NULL)
11497             {
11498               if (h == NULL && opd->adjust != NULL)
11499                 {
11500                   long adjust;
11501
11502                   adjust = opd->adjust[sym->st_value / 8];
11503                   if (adjust == -1)
11504                     /* Assume deleted functions won't ever be called.  */
11505                     continue;
11506                   sym_value += adjust;
11507                 }
11508
11509               dest = opd_entry_value (sym_sec, sym_value,
11510                                       &sym_sec, NULL, FALSE);
11511               if (dest == (bfd_vma) -1)
11512                 continue;
11513             }
11514           else
11515             dest = (sym_value
11516                     + sym_sec->output_offset
11517                     + sym_sec->output_section->vma);
11518
11519           /* Ignore branch to self.  */
11520           if (sym_sec == isec)
11521             continue;
11522
11523           /* If the called function uses the toc, we need a stub.  */
11524           if (sym_sec->has_toc_reloc
11525               || sym_sec->makes_toc_func_call)
11526             {
11527               ret = 1;
11528               break;
11529             }
11530
11531           /* Assume any branch that needs a long branch stub might in fact
11532              need a plt_branch stub.  A plt_branch stub uses r2.  */
11533           else if (dest - (isec->output_offset
11534                            + isec->output_section->vma
11535                            + rel->r_offset) + (1 << 25)
11536                    >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11537                                                              ? h->other
11538                                                              : sym->st_other))
11539             {
11540               ret = 1;
11541               break;
11542             }
11543
11544           /* If calling back to a section in the process of being
11545              tested, we can't say for sure that no toc adjusting stubs
11546              are needed, so don't return zero.  */
11547           else if (sym_sec->call_check_in_progress)
11548             ret = 2;
11549
11550           /* Branches to another section that itself doesn't have any TOC
11551              references are OK.  Recursively call ourselves to check.  */
11552           else if (!sym_sec->call_check_done)
11553             {
11554               int recur;
11555
11556               /* Mark current section as indeterminate, so that other
11557                  sections that call back to current won't be marked as
11558                  known.  */
11559               isec->call_check_in_progress = 1;
11560               recur = toc_adjusting_stub_needed (info, sym_sec);
11561               isec->call_check_in_progress = 0;
11562
11563               if (recur != 0)
11564                 {
11565                   ret = recur;
11566                   if (recur != 2)
11567                     break;
11568                 }
11569             }
11570         }
11571
11572       if (local_syms != NULL
11573           && (elf_symtab_hdr (isec->owner).contents
11574               != (unsigned char *) local_syms))
11575         free (local_syms);
11576       if (elf_section_data (isec)->relocs != relstart)
11577         free (relstart);
11578     }
11579
11580   if ((ret & 1) == 0
11581       && isec->map_head.s != NULL
11582       && (strcmp (isec->output_section->name, ".init") == 0
11583           || strcmp (isec->output_section->name, ".fini") == 0))
11584     {
11585       if (isec->map_head.s->has_toc_reloc
11586           || isec->map_head.s->makes_toc_func_call)
11587         ret = 1;
11588       else if (!isec->map_head.s->call_check_done)
11589         {
11590           int recur;
11591           isec->call_check_in_progress = 1;
11592           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11593           isec->call_check_in_progress = 0;
11594           if (recur != 0)
11595             ret = recur;
11596         }
11597     }
11598
11599   if (ret == 1)
11600     isec->makes_toc_func_call = 1;
11601
11602   return ret;
11603 }
11604
11605 /* The linker repeatedly calls this function for each input section,
11606    in the order that input sections are linked into output sections.
11607    Build lists of input sections to determine groupings between which
11608    we may insert linker stubs.  */
11609
11610 bfd_boolean
11611 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11612 {
11613   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11614
11615   if (htab == NULL)
11616     return FALSE;
11617
11618   if ((isec->output_section->flags & SEC_CODE) != 0
11619       && isec->output_section->index <= htab->top_index)
11620     {
11621       asection **list = htab->input_list + isec->output_section->index;
11622       /* Steal the link_sec pointer for our list.  */
11623 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11624       /* This happens to make the list in reverse order,
11625          which is what we want.  */
11626       PREV_SEC (isec) = *list;
11627       *list = isec;
11628     }
11629
11630   if (htab->multi_toc_needed)
11631     {
11632       /* Analyse sections that aren't already flagged as needing a
11633          valid toc pointer.  Exclude .fixup for the linux kernel.
11634          .fixup contains branches, but only back to the function that
11635          hit an exception.  */
11636       if (!(isec->has_toc_reloc
11637             || (isec->flags & SEC_CODE) == 0
11638             || strcmp (isec->name, ".fixup") == 0
11639             || isec->call_check_done))
11640         {
11641           if (toc_adjusting_stub_needed (info, isec) < 0)
11642             return FALSE;
11643         }
11644       /* Make all sections use the TOC assigned for this object file.
11645          This will be wrong for pasted sections;  We fix that in
11646          check_pasted_section().  */
11647       if (elf_gp (isec->owner) != 0)
11648         htab->toc_curr = elf_gp (isec->owner);
11649     }
11650
11651   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11652   return TRUE;
11653 }
11654
11655 /* Check that all .init and .fini sections use the same toc, if they
11656    have toc relocs.  */
11657
11658 static bfd_boolean
11659 check_pasted_section (struct bfd_link_info *info, const char *name)
11660 {
11661   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11662
11663   if (o != NULL)
11664     {
11665       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11666       bfd_vma toc_off = 0;
11667       asection *i;
11668
11669       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11670         if (i->has_toc_reloc)
11671           {
11672             if (toc_off == 0)
11673               toc_off = htab->stub_group[i->id].toc_off;
11674             else if (toc_off != htab->stub_group[i->id].toc_off)
11675               return FALSE;
11676           }
11677
11678       if (toc_off == 0)
11679         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11680           if (i->makes_toc_func_call)
11681             {
11682               toc_off = htab->stub_group[i->id].toc_off;
11683               break;
11684             }
11685
11686       /* Make sure the whole pasted function uses the same toc offset.  */
11687       if (toc_off != 0)
11688         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11689           htab->stub_group[i->id].toc_off = toc_off;
11690     }
11691   return TRUE;
11692 }
11693
11694 bfd_boolean
11695 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11696 {
11697   return (check_pasted_section (info, ".init")
11698           & check_pasted_section (info, ".fini"));
11699 }
11700
11701 /* See whether we can group stub sections together.  Grouping stub
11702    sections may result in fewer stubs.  More importantly, we need to
11703    put all .init* and .fini* stubs at the beginning of the .init or
11704    .fini output sections respectively, because glibc splits the
11705    _init and _fini functions into multiple parts.  Putting a stub in
11706    the middle of a function is not a good idea.  */
11707
11708 static void
11709 group_sections (struct ppc_link_hash_table *htab,
11710                 bfd_size_type stub_group_size,
11711                 bfd_boolean stubs_always_before_branch)
11712 {
11713   asection **list;
11714   bfd_size_type stub14_group_size;
11715   bfd_boolean suppress_size_errors;
11716
11717   suppress_size_errors = FALSE;
11718   stub14_group_size = stub_group_size;
11719   if (stub_group_size == 1)
11720     {
11721       /* Default values.  */
11722       if (stubs_always_before_branch)
11723         {
11724           stub_group_size = 0x1e00000;
11725           stub14_group_size = 0x7800;
11726         }
11727       else
11728         {
11729           stub_group_size = 0x1c00000;
11730           stub14_group_size = 0x7000;
11731         }
11732       suppress_size_errors = TRUE;
11733     }
11734
11735   list = htab->input_list + htab->top_index;
11736   do
11737     {
11738       asection *tail = *list;
11739       while (tail != NULL)
11740         {
11741           asection *curr;
11742           asection *prev;
11743           bfd_size_type total;
11744           bfd_boolean big_sec;
11745           bfd_vma curr_toc;
11746
11747           curr = tail;
11748           total = tail->size;
11749           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11750                              && ppc64_elf_section_data (tail)->has_14bit_branch
11751                              ? stub14_group_size : stub_group_size);
11752           if (big_sec && !suppress_size_errors)
11753             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11754                                      tail->owner, tail);
11755           curr_toc = htab->stub_group[tail->id].toc_off;
11756
11757           while ((prev = PREV_SEC (curr)) != NULL
11758                  && ((total += curr->output_offset - prev->output_offset)
11759                      < (ppc64_elf_section_data (prev) != NULL
11760                         && ppc64_elf_section_data (prev)->has_14bit_branch
11761                         ? stub14_group_size : stub_group_size))
11762                  && htab->stub_group[prev->id].toc_off == curr_toc)
11763             curr = prev;
11764
11765           /* OK, the size from the start of CURR to the end is less
11766              than stub_group_size and thus can be handled by one stub
11767              section.  (or the tail section is itself larger than
11768              stub_group_size, in which case we may be toast.)  We
11769              should really be keeping track of the total size of stubs
11770              added here, as stubs contribute to the final output
11771              section size.  That's a little tricky, and this way will
11772              only break if stubs added make the total size more than
11773              2^25, ie. for the default stub_group_size, if stubs total
11774              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11775           do
11776             {
11777               prev = PREV_SEC (tail);
11778               /* Set up this stub group.  */
11779               htab->stub_group[tail->id].link_sec = curr;
11780             }
11781           while (tail != curr && (tail = prev) != NULL);
11782
11783           /* But wait, there's more!  Input sections up to stub_group_size
11784              bytes before the stub section can be handled by it too.
11785              Don't do this if we have a really large section after the
11786              stubs, as adding more stubs increases the chance that
11787              branches may not reach into the stub section.  */
11788           if (!stubs_always_before_branch && !big_sec)
11789             {
11790               total = 0;
11791               while (prev != NULL
11792                      && ((total += tail->output_offset - prev->output_offset)
11793                          < (ppc64_elf_section_data (prev) != NULL
11794                             && ppc64_elf_section_data (prev)->has_14bit_branch
11795                             ? stub14_group_size : stub_group_size))
11796                      && htab->stub_group[prev->id].toc_off == curr_toc)
11797                 {
11798                   tail = prev;
11799                   prev = PREV_SEC (tail);
11800                   htab->stub_group[tail->id].link_sec = curr;
11801                 }
11802             }
11803           tail = prev;
11804         }
11805     }
11806   while (list-- != htab->input_list);
11807   free (htab->input_list);
11808 #undef PREV_SEC
11809 }
11810
11811 static const unsigned char glink_eh_frame_cie[] =
11812 {
11813   0, 0, 0, 16,                          /* length.  */
11814   0, 0, 0, 0,                           /* id.  */
11815   1,                                    /* CIE version.  */
11816   'z', 'R', 0,                          /* Augmentation string.  */
11817   4,                                    /* Code alignment.  */
11818   0x78,                                 /* Data alignment.  */
11819   65,                                   /* RA reg.  */
11820   1,                                    /* Augmentation size.  */
11821   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11822   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11823 };
11824
11825 /* Stripping output sections is normally done before dynamic section
11826    symbols have been allocated.  This function is called later, and
11827    handles cases like htab->brlt which is mapped to its own output
11828    section.  */
11829
11830 static void
11831 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11832 {
11833   if (isec->size == 0
11834       && isec->output_section->size == 0
11835       && !(isec->output_section->flags & SEC_KEEP)
11836       && !bfd_section_removed_from_list (info->output_bfd,
11837                                          isec->output_section)
11838       && elf_section_data (isec->output_section)->dynindx == 0)
11839     {
11840       isec->output_section->flags |= SEC_EXCLUDE;
11841       bfd_section_list_remove (info->output_bfd, isec->output_section);
11842       info->output_bfd->section_count--;
11843     }
11844 }
11845
11846 /* Determine and set the size of the stub section for a final link.
11847
11848    The basic idea here is to examine all the relocations looking for
11849    PC-relative calls to a target that is unreachable with a "bl"
11850    instruction.  */
11851
11852 bfd_boolean
11853 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11854                       bfd_boolean plt_static_chain, int plt_thread_safe,
11855                       int plt_stub_align)
11856 {
11857   bfd_size_type stub_group_size;
11858   bfd_boolean stubs_always_before_branch;
11859   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11860
11861   if (htab == NULL)
11862     return FALSE;
11863
11864   htab->plt_static_chain = plt_static_chain;
11865   htab->plt_stub_align = plt_stub_align;
11866   if (plt_thread_safe == -1 && !info->executable)
11867     plt_thread_safe = 1;
11868   if (!htab->opd_abi)
11869     plt_thread_safe = 0;
11870   else if (plt_thread_safe == -1)
11871     {
11872       static const char *const thread_starter[] =
11873         {
11874           "pthread_create",
11875           /* libstdc++ */
11876           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11877           /* librt */
11878           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11879           "mq_notify", "create_timer",
11880           /* libanl */
11881           "getaddrinfo_a",
11882           /* libgomp */
11883           "GOMP_parallel_start",
11884           "GOMP_parallel_loop_static_start",
11885           "GOMP_parallel_loop_dynamic_start",
11886           "GOMP_parallel_loop_guided_start",
11887           "GOMP_parallel_loop_runtime_start",
11888           "GOMP_parallel_sections_start",
11889         };
11890       unsigned i;
11891
11892       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11893         {
11894           struct elf_link_hash_entry *h;
11895           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11896                                     FALSE, FALSE, TRUE);
11897           plt_thread_safe = h != NULL && h->ref_regular;
11898           if (plt_thread_safe)
11899             break;
11900         }
11901     }
11902   htab->plt_thread_safe = plt_thread_safe;
11903   stubs_always_before_branch = group_size < 0;
11904   if (group_size < 0)
11905     stub_group_size = -group_size;
11906   else
11907     stub_group_size = group_size;
11908
11909   group_sections (htab, stub_group_size, stubs_always_before_branch);
11910
11911   while (1)
11912     {
11913       bfd *input_bfd;
11914       unsigned int bfd_indx;
11915       asection *stub_sec;
11916
11917       htab->stub_iteration += 1;
11918
11919       for (input_bfd = info->input_bfds, bfd_indx = 0;
11920            input_bfd != NULL;
11921            input_bfd = input_bfd->link_next, bfd_indx++)
11922         {
11923           Elf_Internal_Shdr *symtab_hdr;
11924           asection *section;
11925           Elf_Internal_Sym *local_syms = NULL;
11926
11927           if (!is_ppc64_elf (input_bfd))
11928             continue;
11929
11930           /* We'll need the symbol table in a second.  */
11931           symtab_hdr = &elf_symtab_hdr (input_bfd);
11932           if (symtab_hdr->sh_info == 0)
11933             continue;
11934
11935           /* Walk over each section attached to the input bfd.  */
11936           for (section = input_bfd->sections;
11937                section != NULL;
11938                section = section->next)
11939             {
11940               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11941
11942               /* If there aren't any relocs, then there's nothing more
11943                  to do.  */
11944               if ((section->flags & SEC_RELOC) == 0
11945                   || (section->flags & SEC_ALLOC) == 0
11946                   || (section->flags & SEC_LOAD) == 0
11947                   || (section->flags & SEC_CODE) == 0
11948                   || section->reloc_count == 0)
11949                 continue;
11950
11951               /* If this section is a link-once section that will be
11952                  discarded, then don't create any stubs.  */
11953               if (section->output_section == NULL
11954                   || section->output_section->owner != info->output_bfd)
11955                 continue;
11956
11957               /* Get the relocs.  */
11958               internal_relocs
11959                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11960                                              info->keep_memory);
11961               if (internal_relocs == NULL)
11962                 goto error_ret_free_local;
11963
11964               /* Now examine each relocation.  */
11965               irela = internal_relocs;
11966               irelaend = irela + section->reloc_count;
11967               for (; irela < irelaend; irela++)
11968                 {
11969                   enum elf_ppc64_reloc_type r_type;
11970                   unsigned int r_indx;
11971                   enum ppc_stub_type stub_type;
11972                   struct ppc_stub_hash_entry *stub_entry;
11973                   asection *sym_sec, *code_sec;
11974                   bfd_vma sym_value, code_value;
11975                   bfd_vma destination;
11976                   unsigned long local_off;
11977                   bfd_boolean ok_dest;
11978                   struct ppc_link_hash_entry *hash;
11979                   struct ppc_link_hash_entry *fdh;
11980                   struct elf_link_hash_entry *h;
11981                   Elf_Internal_Sym *sym;
11982                   char *stub_name;
11983                   const asection *id_sec;
11984                   struct _opd_sec_data *opd;
11985                   struct plt_entry *plt_ent;
11986
11987                   r_type = ELF64_R_TYPE (irela->r_info);
11988                   r_indx = ELF64_R_SYM (irela->r_info);
11989
11990                   if (r_type >= R_PPC64_max)
11991                     {
11992                       bfd_set_error (bfd_error_bad_value);
11993                       goto error_ret_free_internal;
11994                     }
11995
11996                   /* Only look for stubs on branch instructions.  */
11997                   if (r_type != R_PPC64_REL24
11998                       && r_type != R_PPC64_REL14
11999                       && r_type != R_PPC64_REL14_BRTAKEN
12000                       && r_type != R_PPC64_REL14_BRNTAKEN)
12001                     continue;
12002
12003                   /* Now determine the call target, its name, value,
12004                      section.  */
12005                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12006                                   r_indx, input_bfd))
12007                     goto error_ret_free_internal;
12008                   hash = (struct ppc_link_hash_entry *) h;
12009
12010                   ok_dest = FALSE;
12011                   fdh = NULL;
12012                   sym_value = 0;
12013                   if (hash == NULL)
12014                     {
12015                       sym_value = sym->st_value;
12016                       ok_dest = TRUE;
12017                     }
12018                   else if (hash->elf.root.type == bfd_link_hash_defined
12019                            || hash->elf.root.type == bfd_link_hash_defweak)
12020                     {
12021                       sym_value = hash->elf.root.u.def.value;
12022                       if (sym_sec->output_section != NULL)
12023                         ok_dest = TRUE;
12024                     }
12025                   else if (hash->elf.root.type == bfd_link_hash_undefweak
12026                            || hash->elf.root.type == bfd_link_hash_undefined)
12027                     {
12028                       /* Recognise an old ABI func code entry sym, and
12029                          use the func descriptor sym instead if it is
12030                          defined.  */
12031                       if (hash->elf.root.root.string[0] == '.'
12032                           && (fdh = lookup_fdh (hash, htab)) != NULL)
12033                         {
12034                           if (fdh->elf.root.type == bfd_link_hash_defined
12035                               || fdh->elf.root.type == bfd_link_hash_defweak)
12036                             {
12037                               sym_sec = fdh->elf.root.u.def.section;
12038                               sym_value = fdh->elf.root.u.def.value;
12039                               if (sym_sec->output_section != NULL)
12040                                 ok_dest = TRUE;
12041                             }
12042                           else
12043                             fdh = NULL;
12044                         }
12045                     }
12046                   else
12047                     {
12048                       bfd_set_error (bfd_error_bad_value);
12049                       goto error_ret_free_internal;
12050                     }
12051
12052                   destination = 0;
12053                   local_off = 0;
12054                   if (ok_dest)
12055                     {
12056                       sym_value += irela->r_addend;
12057                       destination = (sym_value
12058                                      + sym_sec->output_offset
12059                                      + sym_sec->output_section->vma);
12060                       local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12061                                                             ? hash->elf.other
12062                                                             : sym->st_other);
12063                     }
12064
12065                   code_sec = sym_sec;
12066                   code_value = sym_value;
12067                   opd = get_opd_info (sym_sec);
12068                   if (opd != NULL)
12069                     {
12070                       bfd_vma dest;
12071
12072                       if (hash == NULL && opd->adjust != NULL)
12073                         {
12074                           long adjust = opd->adjust[sym_value / 8];
12075                           if (adjust == -1)
12076                             continue;
12077                           code_value += adjust;
12078                           sym_value += adjust;
12079                         }
12080                       dest = opd_entry_value (sym_sec, sym_value,
12081                                               &code_sec, &code_value, FALSE);
12082                       if (dest != (bfd_vma) -1)
12083                         {
12084                           destination = dest;
12085                           if (fdh != NULL)
12086                             {
12087                               /* Fixup old ABI sym to point at code
12088                                  entry.  */
12089                               hash->elf.root.type = bfd_link_hash_defweak;
12090                               hash->elf.root.u.def.section = code_sec;
12091                               hash->elf.root.u.def.value = code_value;
12092                             }
12093                         }
12094                     }
12095
12096                   /* Determine what (if any) linker stub is needed.  */
12097                   plt_ent = NULL;
12098                   stub_type = ppc_type_of_stub (section, irela, &hash,
12099                                                 &plt_ent, destination,
12100                                                 local_off);
12101
12102                   if (stub_type != ppc_stub_plt_call)
12103                     {
12104                       /* Check whether we need a TOC adjusting stub.
12105                          Since the linker pastes together pieces from
12106                          different object files when creating the
12107                          _init and _fini functions, it may be that a
12108                          call to what looks like a local sym is in
12109                          fact a call needing a TOC adjustment.  */
12110                       if (code_sec != NULL
12111                           && code_sec->output_section != NULL
12112                           && (htab->stub_group[code_sec->id].toc_off
12113                               != htab->stub_group[section->id].toc_off)
12114                           && (code_sec->has_toc_reloc
12115                               || code_sec->makes_toc_func_call))
12116                         stub_type = ppc_stub_long_branch_r2off;
12117                     }
12118
12119                   if (stub_type == ppc_stub_none)
12120                     continue;
12121
12122                   /* __tls_get_addr calls might be eliminated.  */
12123                   if (stub_type != ppc_stub_plt_call
12124                       && hash != NULL
12125                       && (hash == htab->tls_get_addr
12126                           || hash == htab->tls_get_addr_fd)
12127                       && section->has_tls_reloc
12128                       && irela != internal_relocs)
12129                     {
12130                       /* Get tls info.  */
12131                       unsigned char *tls_mask;
12132
12133                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12134                                          irela - 1, input_bfd))
12135                         goto error_ret_free_internal;
12136                       if (*tls_mask != 0)
12137                         continue;
12138                     }
12139
12140                   if (stub_type == ppc_stub_plt_call
12141                       && irela + 1 < irelaend
12142                       && irela[1].r_offset == irela->r_offset + 4
12143                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12144                     {
12145                       if (!tocsave_find (htab, INSERT,
12146                                          &local_syms, irela + 1, input_bfd))
12147                         goto error_ret_free_internal;
12148                     }
12149                   else if (stub_type == ppc_stub_plt_call)
12150                     stub_type = ppc_stub_plt_call_r2save;
12151
12152                   /* Support for grouping stub sections.  */
12153                   id_sec = htab->stub_group[section->id].link_sec;
12154
12155                   /* Get the name of this stub.  */
12156                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12157                   if (!stub_name)
12158                     goto error_ret_free_internal;
12159
12160                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12161                                                      stub_name, FALSE, FALSE);
12162                   if (stub_entry != NULL)
12163                     {
12164                       /* The proper stub has already been created.  */
12165                       free (stub_name);
12166                       if (stub_type == ppc_stub_plt_call_r2save)
12167                         stub_entry->stub_type = stub_type;
12168                       continue;
12169                     }
12170
12171                   stub_entry = ppc_add_stub (stub_name, section, info);
12172                   if (stub_entry == NULL)
12173                     {
12174                       free (stub_name);
12175                     error_ret_free_internal:
12176                       if (elf_section_data (section)->relocs == NULL)
12177                         free (internal_relocs);
12178                     error_ret_free_local:
12179                       if (local_syms != NULL
12180                           && (symtab_hdr->contents
12181                               != (unsigned char *) local_syms))
12182                         free (local_syms);
12183                       return FALSE;
12184                     }
12185
12186                   stub_entry->stub_type = stub_type;
12187                   if (stub_type != ppc_stub_plt_call
12188                       && stub_type != ppc_stub_plt_call_r2save)
12189                     {
12190                       stub_entry->target_value = code_value;
12191                       stub_entry->target_section = code_sec;
12192                     }
12193                   else
12194                     {
12195                       stub_entry->target_value = sym_value;
12196                       stub_entry->target_section = sym_sec;
12197                     }
12198                   stub_entry->h = hash;
12199                   stub_entry->plt_ent = plt_ent;
12200                   stub_entry->other = hash ? hash->elf.other : sym->st_other;
12201
12202                   if (stub_entry->h != NULL)
12203                     htab->stub_globals += 1;
12204                 }
12205
12206               /* We're done with the internal relocs, free them.  */
12207               if (elf_section_data (section)->relocs != internal_relocs)
12208                 free (internal_relocs);
12209             }
12210
12211           if (local_syms != NULL
12212               && symtab_hdr->contents != (unsigned char *) local_syms)
12213             {
12214               if (!info->keep_memory)
12215                 free (local_syms);
12216               else
12217                 symtab_hdr->contents = (unsigned char *) local_syms;
12218             }
12219         }
12220
12221       /* We may have added some stubs.  Find out the new size of the
12222          stub sections.  */
12223       for (stub_sec = htab->stub_bfd->sections;
12224            stub_sec != NULL;
12225            stub_sec = stub_sec->next)
12226         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12227           {
12228             stub_sec->rawsize = stub_sec->size;
12229             stub_sec->size = 0;
12230             stub_sec->reloc_count = 0;
12231             stub_sec->flags &= ~SEC_RELOC;
12232           }
12233
12234       htab->brlt->size = 0;
12235       htab->brlt->reloc_count = 0;
12236       htab->brlt->flags &= ~SEC_RELOC;
12237       if (htab->relbrlt != NULL)
12238         htab->relbrlt->size = 0;
12239
12240       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12241
12242       if (info->emitrelocations
12243           && htab->glink != NULL && htab->glink->size != 0)
12244         {
12245           htab->glink->reloc_count = 1;
12246           htab->glink->flags |= SEC_RELOC;
12247         }
12248
12249       if (htab->glink_eh_frame != NULL
12250           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12251           && htab->glink_eh_frame->output_section->size != 0)
12252         {
12253           size_t size = 0, align;
12254
12255           for (stub_sec = htab->stub_bfd->sections;
12256                stub_sec != NULL;
12257                stub_sec = stub_sec->next)
12258             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12259               size += 20;
12260           if (htab->glink != NULL && htab->glink->size != 0)
12261             size += 24;
12262           if (size != 0)
12263             size += sizeof (glink_eh_frame_cie);
12264           align = 1;
12265           align <<= htab->glink_eh_frame->output_section->alignment_power;
12266           align -= 1;
12267           size = (size + align) & ~align;
12268           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12269           htab->glink_eh_frame->size = size;
12270         }
12271
12272       if (htab->plt_stub_align != 0)
12273         for (stub_sec = htab->stub_bfd->sections;
12274              stub_sec != NULL;
12275              stub_sec = stub_sec->next)
12276           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12277             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12278                               & (-1 << htab->plt_stub_align));
12279
12280       for (stub_sec = htab->stub_bfd->sections;
12281            stub_sec != NULL;
12282            stub_sec = stub_sec->next)
12283         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12284             && stub_sec->rawsize != stub_sec->size)
12285           break;
12286
12287       /* Exit from this loop when no stubs have been added, and no stubs
12288          have changed size.  */
12289       if (stub_sec == NULL
12290           && (htab->glink_eh_frame == NULL
12291               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12292         break;
12293
12294       /* Ask the linker to do its stuff.  */
12295       (*htab->layout_sections_again) ();
12296     }
12297
12298   maybe_strip_output (info, htab->brlt);
12299   if (htab->glink_eh_frame != NULL)
12300     maybe_strip_output (info, htab->glink_eh_frame);
12301
12302   return TRUE;
12303 }
12304
12305 /* Called after we have determined section placement.  If sections
12306    move, we'll be called again.  Provide a value for TOCstart.  */
12307
12308 bfd_vma
12309 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12310 {
12311   asection *s;
12312   bfd_vma TOCstart;
12313
12314   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12315      order.  The TOC starts where the first of these sections starts.  */
12316   s = bfd_get_section_by_name (obfd, ".got");
12317   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12318     s = bfd_get_section_by_name (obfd, ".toc");
12319   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12320     s = bfd_get_section_by_name (obfd, ".tocbss");
12321   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12322     s = bfd_get_section_by_name (obfd, ".plt");
12323   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12324     {
12325       /* This may happen for
12326          o  references to TOC base (SYM@toc / TOC[tc0]) without a
12327          .toc directive
12328          o  bad linker script
12329          o --gc-sections and empty TOC sections
12330
12331          FIXME: Warn user?  */
12332
12333       /* Look for a likely section.  We probably won't even be
12334          using TOCstart.  */
12335       for (s = obfd->sections; s != NULL; s = s->next)
12336         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12337                          | SEC_EXCLUDE))
12338             == (SEC_ALLOC | SEC_SMALL_DATA))
12339           break;
12340       if (s == NULL)
12341         for (s = obfd->sections; s != NULL; s = s->next)
12342           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12343               == (SEC_ALLOC | SEC_SMALL_DATA))
12344             break;
12345       if (s == NULL)
12346         for (s = obfd->sections; s != NULL; s = s->next)
12347           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12348               == SEC_ALLOC)
12349             break;
12350       if (s == NULL)
12351         for (s = obfd->sections; s != NULL; s = s->next)
12352           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12353             break;
12354     }
12355
12356   TOCstart = 0;
12357   if (s != NULL)
12358     TOCstart = s->output_section->vma + s->output_offset;
12359
12360   _bfd_set_gp_value (obfd, TOCstart);
12361
12362   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12363     {
12364       struct ppc_link_hash_table *htab = ppc_hash_table (info);
12365
12366       if (htab != NULL
12367           && htab->elf.hgot != NULL)
12368         {
12369           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12370           htab->elf.hgot->root.u.def.section = s;
12371         }
12372     }
12373   return TOCstart;
12374 }
12375
12376 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12377    write out any global entry stubs.  */
12378
12379 static bfd_boolean
12380 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12381 {
12382   struct bfd_link_info *info;
12383   struct ppc_link_hash_table *htab;
12384   struct plt_entry *pent;
12385   asection *s;
12386
12387   if (h->root.type == bfd_link_hash_indirect)
12388     return TRUE;
12389
12390   if (!h->pointer_equality_needed)
12391     return TRUE;
12392
12393   if (h->def_regular)
12394     return TRUE;
12395
12396   info = inf;
12397   htab = ppc_hash_table (info);
12398   if (htab == NULL)
12399     return FALSE;
12400
12401   s = htab->glink;
12402   for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12403     if (pent->plt.offset != (bfd_vma) -1
12404         && pent->addend == 0)
12405       {
12406         bfd_byte *p;
12407         asection *plt;
12408         bfd_vma off;
12409
12410         p = s->contents + h->root.u.def.value;
12411         plt = htab->elf.splt;
12412         if (!htab->elf.dynamic_sections_created
12413             || h->dynindx == -1)
12414           plt = htab->elf.iplt;
12415         off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12416         off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12417
12418         if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12419           {
12420             info->callbacks->einfo
12421               (_("%P: linkage table error against `%T'\n"),
12422                h->root.root.string);
12423             bfd_set_error (bfd_error_bad_value);
12424             htab->stub_error = TRUE;
12425           }
12426
12427         if (PPC_HA (off) != 0)
12428           {
12429             bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12430             p += 4;
12431           }
12432         bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12433         p += 4;
12434         bfd_put_32 (s->owner, MTCTR_R12, p);
12435         p += 4;
12436         bfd_put_32 (s->owner, BCTR, p);
12437         break;
12438       }
12439   return TRUE;
12440 }
12441
12442 /* Build all the stubs associated with the current output file.
12443    The stubs are kept in a hash table attached to the main linker
12444    hash table.  This function is called via gldelf64ppc_finish.  */
12445
12446 bfd_boolean
12447 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12448                        struct bfd_link_info *info,
12449                        char **stats)
12450 {
12451   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12452   asection *stub_sec;
12453   bfd_byte *p;
12454   int stub_sec_count = 0;
12455
12456   if (htab == NULL)
12457     return FALSE;
12458
12459   htab->emit_stub_syms = emit_stub_syms;
12460
12461   /* Allocate memory to hold the linker stubs.  */
12462   for (stub_sec = htab->stub_bfd->sections;
12463        stub_sec != NULL;
12464        stub_sec = stub_sec->next)
12465     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12466         && stub_sec->size != 0)
12467       {
12468         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12469         if (stub_sec->contents == NULL)
12470           return FALSE;
12471         /* We want to check that built size is the same as calculated
12472            size.  rawsize is a convenient location to use.  */
12473         stub_sec->rawsize = stub_sec->size;
12474         stub_sec->size = 0;
12475       }
12476
12477   if (htab->glink != NULL && htab->glink->size != 0)
12478     {
12479       unsigned int indx;
12480       bfd_vma plt0;
12481
12482       /* Build the .glink plt call stub.  */
12483       if (htab->emit_stub_syms)
12484         {
12485           struct elf_link_hash_entry *h;
12486           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12487                                     TRUE, FALSE, FALSE);
12488           if (h == NULL)
12489             return FALSE;
12490           if (h->root.type == bfd_link_hash_new)
12491             {
12492               h->root.type = bfd_link_hash_defined;
12493               h->root.u.def.section = htab->glink;
12494               h->root.u.def.value = 8;
12495               h->ref_regular = 1;
12496               h->def_regular = 1;
12497               h->ref_regular_nonweak = 1;
12498               h->forced_local = 1;
12499               h->non_elf = 0;
12500             }
12501         }
12502       plt0 = (htab->elf.splt->output_section->vma
12503               + htab->elf.splt->output_offset
12504               - 16);
12505       if (info->emitrelocations)
12506         {
12507           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12508           if (r == NULL)
12509             return FALSE;
12510           r->r_offset = (htab->glink->output_offset
12511                          + htab->glink->output_section->vma);
12512           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12513           r->r_addend = plt0;
12514         }
12515       p = htab->glink->contents;
12516       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12517       bfd_put_64 (htab->glink->owner, plt0, p);
12518       p += 8;
12519       if (htab->opd_abi)
12520         {
12521           bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12522           p += 4;
12523           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12524           p += 4;
12525           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12526           p += 4;
12527           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12528           p += 4;
12529           bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12530           p += 4;
12531           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12532           p += 4;
12533           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12534           p += 4;
12535           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12536           p += 4;
12537           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12538           p += 4;
12539           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12540           p += 4;
12541         }
12542       else
12543         {
12544           bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12545           p += 4;
12546           bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12547           p += 4;
12548           bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12549           p += 4;
12550           bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12551           p += 4;
12552           bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12553           p += 4;
12554           bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12555           p += 4;
12556           bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12557           p += 4;
12558           bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12559           p += 4;
12560           bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12561           p += 4;
12562           bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12563           p += 4;
12564           bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12565           p += 4;
12566           bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12567           p += 4;
12568         }
12569       bfd_put_32 (htab->glink->owner, BCTR, p);
12570       p += 4;
12571       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12572         {
12573           bfd_put_32 (htab->glink->owner, NOP, p);
12574           p += 4;
12575         }
12576
12577       /* Build the .glink lazy link call stubs.  */
12578       indx = 0;
12579       while (p < htab->glink->contents + htab->glink->rawsize)
12580         {
12581           if (htab->opd_abi)
12582             {
12583               if (indx < 0x8000)
12584                 {
12585                   bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12586                   p += 4;
12587                 }
12588               else
12589                 {
12590                   bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12591                   p += 4;
12592                   bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12593                               p);
12594                   p += 4;
12595                 }
12596             }
12597           bfd_put_32 (htab->glink->owner,
12598                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12599           indx++;
12600           p += 4;
12601         }
12602
12603       /* Build .glink global entry stubs.  */
12604       if (htab->glink->size > htab->glink->rawsize)
12605         elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12606     }
12607
12608   if (htab->brlt->size != 0)
12609     {
12610       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12611                                          htab->brlt->size);
12612       if (htab->brlt->contents == NULL)
12613         return FALSE;
12614     }
12615   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12616     {
12617       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12618                                             htab->relbrlt->size);
12619       if (htab->relbrlt->contents == NULL)
12620         return FALSE;
12621     }
12622
12623   if (htab->glink_eh_frame != NULL
12624       && htab->glink_eh_frame->size != 0)
12625     {
12626       bfd_vma val;
12627       bfd_byte *last_fde;
12628       size_t last_fde_len, size, align, pad;
12629
12630       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12631       if (p == NULL)
12632         return FALSE;
12633       htab->glink_eh_frame->contents = p;
12634       last_fde = p;
12635
12636       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12637
12638       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12639       /* CIE length (rewrite in case little-endian).  */
12640       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12641       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12642       p += sizeof (glink_eh_frame_cie);
12643
12644       for (stub_sec = htab->stub_bfd->sections;
12645            stub_sec != NULL;
12646            stub_sec = stub_sec->next)
12647         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12648           {
12649             last_fde = p;
12650             last_fde_len = 16;
12651             /* FDE length.  */
12652             bfd_put_32 (htab->elf.dynobj, 16, p);
12653             p += 4;
12654             /* CIE pointer.  */
12655             val = p - htab->glink_eh_frame->contents;
12656             bfd_put_32 (htab->elf.dynobj, val, p);
12657             p += 4;
12658             /* Offset to stub section.  */
12659             val = (stub_sec->output_section->vma
12660                    + stub_sec->output_offset);
12661             val -= (htab->glink_eh_frame->output_section->vma
12662                     + htab->glink_eh_frame->output_offset);
12663             val -= p - htab->glink_eh_frame->contents;
12664             if (val + 0x80000000 > 0xffffffff)
12665               {
12666                 info->callbacks->einfo
12667                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12668                    stub_sec->name);
12669                 return FALSE;
12670               }
12671             bfd_put_32 (htab->elf.dynobj, val, p);
12672             p += 4;
12673             /* stub section size.  */
12674             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12675             p += 4;
12676             /* Augmentation.  */
12677             p += 1;
12678             /* Pad.  */
12679             p += 3;
12680           }
12681       if (htab->glink != NULL && htab->glink->size != 0)
12682         {
12683           last_fde = p;
12684           last_fde_len = 20;
12685           /* FDE length.  */
12686           bfd_put_32 (htab->elf.dynobj, 20, p);
12687           p += 4;
12688           /* CIE pointer.  */
12689           val = p - htab->glink_eh_frame->contents;
12690           bfd_put_32 (htab->elf.dynobj, val, p);
12691           p += 4;
12692           /* Offset to .glink.  */
12693           val = (htab->glink->output_section->vma
12694                  + htab->glink->output_offset
12695                  + 8);
12696           val -= (htab->glink_eh_frame->output_section->vma
12697                   + htab->glink_eh_frame->output_offset);
12698           val -= p - htab->glink_eh_frame->contents;
12699           if (val + 0x80000000 > 0xffffffff)
12700             {
12701               info->callbacks->einfo
12702                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12703                  htab->glink->name);
12704               return FALSE;
12705             }
12706           bfd_put_32 (htab->elf.dynobj, val, p);
12707           p += 4;
12708           /* .glink size.  */
12709           bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12710           p += 4;
12711           /* Augmentation.  */
12712           p += 1;
12713
12714           *p++ = DW_CFA_advance_loc + 1;
12715           *p++ = DW_CFA_register;
12716           *p++ = 65;
12717           *p++ = 12;
12718           *p++ = DW_CFA_advance_loc + 4;
12719           *p++ = DW_CFA_restore_extended;
12720           *p++ = 65;
12721         }
12722       /* Subsume any padding into the last FDE if user .eh_frame
12723          sections are aligned more than glink_eh_frame.  Otherwise any
12724          zero padding will be seen as a terminator.  */
12725       size = p - htab->glink_eh_frame->contents;
12726       align = 1;
12727       align <<= htab->glink_eh_frame->output_section->alignment_power;
12728       align -= 1;
12729       pad = ((size + align) & ~align) - size;
12730       htab->glink_eh_frame->size = size + pad;
12731       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12732     }
12733
12734   /* Build the stubs as directed by the stub hash table.  */
12735   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12736
12737   if (htab->relbrlt != NULL)
12738     htab->relbrlt->reloc_count = 0;
12739
12740   if (htab->plt_stub_align != 0)
12741     for (stub_sec = htab->stub_bfd->sections;
12742          stub_sec != NULL;
12743          stub_sec = stub_sec->next)
12744       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12745         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12746                           & (-1 << htab->plt_stub_align));
12747
12748   for (stub_sec = htab->stub_bfd->sections;
12749        stub_sec != NULL;
12750        stub_sec = stub_sec->next)
12751     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12752       {
12753         stub_sec_count += 1;
12754         if (stub_sec->rawsize != stub_sec->size)
12755           break;
12756       }
12757
12758   if (stub_sec != NULL
12759       || (htab->glink_eh_frame != NULL
12760           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12761     {
12762       htab->stub_error = TRUE;
12763       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12764     }
12765
12766   if (htab->stub_error)
12767     return FALSE;
12768
12769   if (stats != NULL)
12770     {
12771       *stats = bfd_malloc (500);
12772       if (*stats == NULL)
12773         return FALSE;
12774
12775       sprintf (*stats, _("linker stubs in %u group%s\n"
12776                          "  branch       %lu\n"
12777                          "  toc adjust   %lu\n"
12778                          "  long branch  %lu\n"
12779                          "  long toc adj %lu\n"
12780                          "  plt call     %lu\n"
12781                          "  plt call toc %lu"),
12782                stub_sec_count,
12783                stub_sec_count == 1 ? "" : "s",
12784                htab->stub_count[ppc_stub_long_branch - 1],
12785                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12786                htab->stub_count[ppc_stub_plt_branch - 1],
12787                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12788                htab->stub_count[ppc_stub_plt_call - 1],
12789                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12790     }
12791   return TRUE;
12792 }
12793
12794 /* This function undoes the changes made by add_symbol_adjust.  */
12795
12796 static bfd_boolean
12797 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12798 {
12799   struct ppc_link_hash_entry *eh;
12800
12801   if (h->root.type == bfd_link_hash_indirect)
12802     return TRUE;
12803
12804   eh = (struct ppc_link_hash_entry *) h;
12805   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12806     return TRUE;
12807
12808   eh->elf.root.type = bfd_link_hash_undefined;
12809   return TRUE;
12810 }
12811
12812 void
12813 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12814 {
12815   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12816
12817   if (htab != NULL)
12818     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12819 }
12820
12821 /* What to do when ld finds relocations against symbols defined in
12822    discarded sections.  */
12823
12824 static unsigned int
12825 ppc64_elf_action_discarded (asection *sec)
12826 {
12827   if (strcmp (".opd", sec->name) == 0)
12828     return 0;
12829
12830   if (strcmp (".toc", sec->name) == 0)
12831     return 0;
12832
12833   if (strcmp (".toc1", sec->name) == 0)
12834     return 0;
12835
12836   return _bfd_elf_default_action_discarded (sec);
12837 }
12838
12839 /* The RELOCATE_SECTION function is called by the ELF backend linker
12840    to handle the relocations for a section.
12841
12842    The relocs are always passed as Rela structures; if the section
12843    actually uses Rel structures, the r_addend field will always be
12844    zero.
12845
12846    This function is responsible for adjust the section contents as
12847    necessary, and (if using Rela relocs and generating a
12848    relocatable output file) adjusting the reloc addend as
12849    necessary.
12850
12851    This function does not have to worry about setting the reloc
12852    address or the reloc symbol index.
12853
12854    LOCAL_SYMS is a pointer to the swapped in local symbols.
12855
12856    LOCAL_SECTIONS is an array giving the section in the input file
12857    corresponding to the st_shndx field of each local symbol.
12858
12859    The global hash table entry for the global symbols can be found
12860    via elf_sym_hashes (input_bfd).
12861
12862    When generating relocatable output, this function must handle
12863    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12864    going to be the section symbol corresponding to the output
12865    section, which means that the addend must be adjusted
12866    accordingly.  */
12867
12868 static bfd_boolean
12869 ppc64_elf_relocate_section (bfd *output_bfd,
12870                             struct bfd_link_info *info,
12871                             bfd *input_bfd,
12872                             asection *input_section,
12873                             bfd_byte *contents,
12874                             Elf_Internal_Rela *relocs,
12875                             Elf_Internal_Sym *local_syms,
12876                             asection **local_sections)
12877 {
12878   struct ppc_link_hash_table *htab;
12879   Elf_Internal_Shdr *symtab_hdr;
12880   struct elf_link_hash_entry **sym_hashes;
12881   Elf_Internal_Rela *rel;
12882   Elf_Internal_Rela *relend;
12883   Elf_Internal_Rela outrel;
12884   bfd_byte *loc;
12885   struct got_entry **local_got_ents;
12886   bfd_vma TOCstart;
12887   bfd_boolean ret = TRUE;
12888   bfd_boolean is_opd;
12889   /* Assume 'at' branch hints.  */
12890   bfd_boolean is_isa_v2 = TRUE;
12891   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12892
12893   /* Initialize howto table if needed.  */
12894   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12895     ppc_howto_init ();
12896
12897   htab = ppc_hash_table (info);
12898   if (htab == NULL)
12899     return FALSE;
12900
12901   /* Don't relocate stub sections.  */
12902   if (input_section->owner == htab->stub_bfd)
12903     return TRUE;
12904
12905   BFD_ASSERT (is_ppc64_elf (input_bfd));
12906
12907   local_got_ents = elf_local_got_ents (input_bfd);
12908   TOCstart = elf_gp (output_bfd);
12909   symtab_hdr = &elf_symtab_hdr (input_bfd);
12910   sym_hashes = elf_sym_hashes (input_bfd);
12911   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12912
12913   rel = relocs;
12914   relend = relocs + input_section->reloc_count;
12915   for (; rel < relend; rel++)
12916     {
12917       enum elf_ppc64_reloc_type r_type;
12918       bfd_vma addend;
12919       bfd_reloc_status_type r;
12920       Elf_Internal_Sym *sym;
12921       asection *sec;
12922       struct elf_link_hash_entry *h_elf;
12923       struct ppc_link_hash_entry *h;
12924       struct ppc_link_hash_entry *fdh;
12925       const char *sym_name;
12926       unsigned long r_symndx, toc_symndx;
12927       bfd_vma toc_addend;
12928       unsigned char tls_mask, tls_gd, tls_type;
12929       unsigned char sym_type;
12930       bfd_vma relocation;
12931       bfd_boolean unresolved_reloc;
12932       bfd_boolean warned;
12933       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12934       unsigned int insn;
12935       unsigned int mask;
12936       struct ppc_stub_hash_entry *stub_entry;
12937       bfd_vma max_br_offset;
12938       bfd_vma from;
12939       const Elf_Internal_Rela orig_rel = *rel;
12940
12941       r_type = ELF64_R_TYPE (rel->r_info);
12942       r_symndx = ELF64_R_SYM (rel->r_info);
12943
12944       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12945          symbol of the previous ADDR64 reloc.  The symbol gives us the
12946          proper TOC base to use.  */
12947       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12948           && rel != relocs
12949           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12950           && is_opd)
12951         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12952
12953       sym = NULL;
12954       sec = NULL;
12955       h_elf = NULL;
12956       sym_name = NULL;
12957       unresolved_reloc = FALSE;
12958       warned = FALSE;
12959
12960       if (r_symndx < symtab_hdr->sh_info)
12961         {
12962           /* It's a local symbol.  */
12963           struct _opd_sec_data *opd;
12964
12965           sym = local_syms + r_symndx;
12966           sec = local_sections[r_symndx];
12967           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12968           sym_type = ELF64_ST_TYPE (sym->st_info);
12969           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12970           opd = get_opd_info (sec);
12971           if (opd != NULL && opd->adjust != NULL)
12972             {
12973               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12974               if (adjust == -1)
12975                 relocation = 0;
12976               else
12977                 {
12978                   /* If this is a relocation against the opd section sym
12979                      and we have edited .opd, adjust the reloc addend so
12980                      that ld -r and ld --emit-relocs output is correct.
12981                      If it is a reloc against some other .opd symbol,
12982                      then the symbol value will be adjusted later.  */
12983                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12984                     rel->r_addend += adjust;
12985                   else
12986                     relocation += adjust;
12987                 }
12988             }
12989         }
12990       else
12991         {
12992           bfd_boolean ignored;
12993
12994           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12995                                    r_symndx, symtab_hdr, sym_hashes,
12996                                    h_elf, sec, relocation,
12997                                    unresolved_reloc, warned, ignored);
12998           sym_name = h_elf->root.root.string;
12999           sym_type = h_elf->type;
13000           if (sec != NULL
13001               && sec->owner == output_bfd
13002               && strcmp (sec->name, ".opd") == 0)
13003             {
13004               /* This is a symbol defined in a linker script.  All
13005                  such are defined in output sections, even those
13006                  defined by simple assignment from a symbol defined in
13007                  an input section.  Transfer the symbol to an
13008                  appropriate input .opd section, so that a branch to
13009                  this symbol will be mapped to the location specified
13010                  by the opd entry.  */
13011               struct bfd_link_order *lo;
13012               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13013                 if (lo->type == bfd_indirect_link_order)
13014                   {
13015                     asection *isec = lo->u.indirect.section;
13016                     if (h_elf->root.u.def.value >= isec->output_offset
13017                         && h_elf->root.u.def.value < (isec->output_offset
13018                                                       + isec->size))
13019                       {
13020                         h_elf->root.u.def.value -= isec->output_offset;
13021                         h_elf->root.u.def.section = isec;
13022                         sec = isec;
13023                         break;
13024                       }
13025                   }
13026             }
13027         }
13028       h = (struct ppc_link_hash_entry *) h_elf;
13029
13030       if (sec != NULL && discarded_section (sec))
13031         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13032                                          rel, 1, relend,
13033                                          ppc64_elf_howto_table[r_type], 0,
13034                                          contents);
13035
13036       if (info->relocatable)
13037         continue;
13038
13039       if (h != NULL && &h->elf == htab->elf.hgot)
13040         {
13041           relocation = (TOCstart
13042                         + htab->stub_group[input_section->id].toc_off);
13043           sec = bfd_abs_section_ptr;
13044           unresolved_reloc = FALSE;
13045         }
13046
13047       /* TLS optimizations.  Replace instruction sequences and relocs
13048          based on information we collected in tls_optimize.  We edit
13049          RELOCS so that --emit-relocs will output something sensible
13050          for the final instruction stream.  */
13051       tls_mask = 0;
13052       tls_gd = 0;
13053       toc_symndx = 0;
13054       if (h != NULL)
13055         tls_mask = h->tls_mask;
13056       else if (local_got_ents != NULL)
13057         {
13058           struct plt_entry **local_plt = (struct plt_entry **)
13059             (local_got_ents + symtab_hdr->sh_info);
13060           unsigned char *lgot_masks = (unsigned char *)
13061             (local_plt + symtab_hdr->sh_info);
13062           tls_mask = lgot_masks[r_symndx];
13063         }
13064       if (tls_mask == 0
13065           && (r_type == R_PPC64_TLS
13066               || r_type == R_PPC64_TLSGD
13067               || r_type == R_PPC64_TLSLD))
13068         {
13069           /* Check for toc tls entries.  */
13070           unsigned char *toc_tls;
13071
13072           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13073                              &local_syms, rel, input_bfd))
13074             return FALSE;
13075
13076           if (toc_tls)
13077             tls_mask = *toc_tls;
13078         }
13079
13080       /* Check that tls relocs are used with tls syms, and non-tls
13081          relocs are used with non-tls syms.  */
13082       if (r_symndx != STN_UNDEF
13083           && r_type != R_PPC64_NONE
13084           && (h == NULL
13085               || h->elf.root.type == bfd_link_hash_defined
13086               || h->elf.root.type == bfd_link_hash_defweak)
13087           && (IS_PPC64_TLS_RELOC (r_type)
13088               != (sym_type == STT_TLS
13089                   || (sym_type == STT_SECTION
13090                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13091         {
13092           if (tls_mask != 0
13093               && (r_type == R_PPC64_TLS
13094                   || r_type == R_PPC64_TLSGD
13095                   || r_type == R_PPC64_TLSLD))
13096             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
13097             ;
13098           else
13099             info->callbacks->einfo
13100               (!IS_PPC64_TLS_RELOC (r_type)
13101                ? _("%P: %H: %s used with TLS symbol `%T'\n")
13102                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13103                input_bfd, input_section, rel->r_offset,
13104                ppc64_elf_howto_table[r_type]->name,
13105                sym_name);
13106         }
13107
13108       /* Ensure reloc mapping code below stays sane.  */
13109       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13110           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13111           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
13112           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13113           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13114           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13115           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
13116           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13117           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13118           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13119         abort ();
13120
13121       switch (r_type)
13122         {
13123         default:
13124           break;
13125
13126         case R_PPC64_LO_DS_OPT:
13127           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13128           if ((insn & (0x3f << 26)) != 58u << 26)
13129             abort ();
13130           insn += (14u << 26) - (58u << 26);
13131           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13132           r_type = R_PPC64_TOC16_LO;
13133           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13134           break;
13135
13136         case R_PPC64_TOC16:
13137         case R_PPC64_TOC16_LO:
13138         case R_PPC64_TOC16_DS:
13139         case R_PPC64_TOC16_LO_DS:
13140           {
13141             /* Check for toc tls entries.  */
13142             unsigned char *toc_tls;
13143             int retval;
13144
13145             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13146                                    &local_syms, rel, input_bfd);
13147             if (retval == 0)
13148               return FALSE;
13149
13150             if (toc_tls)
13151               {
13152                 tls_mask = *toc_tls;
13153                 if (r_type == R_PPC64_TOC16_DS
13154                     || r_type == R_PPC64_TOC16_LO_DS)
13155                   {
13156                     if (tls_mask != 0
13157                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13158                       goto toctprel;
13159                   }
13160                 else
13161                   {
13162                     /* If we found a GD reloc pair, then we might be
13163                        doing a GD->IE transition.  */
13164                     if (retval == 2)
13165                       {
13166                         tls_gd = TLS_TPRELGD;
13167                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13168                           goto tls_ldgd_opt;
13169                       }
13170                     else if (retval == 3)
13171                       {
13172                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13173                           goto tls_ldgd_opt;
13174                       }
13175                   }
13176               }
13177           }
13178           break;
13179
13180         case R_PPC64_GOT_TPREL16_HI:
13181         case R_PPC64_GOT_TPREL16_HA:
13182           if (tls_mask != 0
13183               && (tls_mask & TLS_TPREL) == 0)
13184             {
13185               rel->r_offset -= d_offset;
13186               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13187               r_type = R_PPC64_NONE;
13188               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13189             }
13190           break;
13191
13192         case R_PPC64_GOT_TPREL16_DS:
13193         case R_PPC64_GOT_TPREL16_LO_DS:
13194           if (tls_mask != 0
13195               && (tls_mask & TLS_TPREL) == 0)
13196             {
13197             toctprel:
13198               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13199               insn &= 31 << 21;
13200               insn |= 0x3c0d0000;       /* addis 0,13,0 */
13201               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13202               r_type = R_PPC64_TPREL16_HA;
13203               if (toc_symndx != 0)
13204                 {
13205                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13206                   rel->r_addend = toc_addend;
13207                   /* We changed the symbol.  Start over in order to
13208                      get h, sym, sec etc. right.  */
13209                   rel--;
13210                   continue;
13211                 }
13212               else
13213                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13214             }
13215           break;
13216
13217         case R_PPC64_TLS:
13218           if (tls_mask != 0
13219               && (tls_mask & TLS_TPREL) == 0)
13220             {
13221               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13222               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13223               if (insn == 0)
13224                 abort ();
13225               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13226               /* Was PPC64_TLS which sits on insn boundary, now
13227                  PPC64_TPREL16_LO which is at low-order half-word.  */
13228               rel->r_offset += d_offset;
13229               r_type = R_PPC64_TPREL16_LO;
13230               if (toc_symndx != 0)
13231                 {
13232                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13233                   rel->r_addend = toc_addend;
13234                   /* We changed the symbol.  Start over in order to
13235                      get h, sym, sec etc. right.  */
13236                   rel--;
13237                   continue;
13238                 }
13239               else
13240                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13241             }
13242           break;
13243
13244         case R_PPC64_GOT_TLSGD16_HI:
13245         case R_PPC64_GOT_TLSGD16_HA:
13246           tls_gd = TLS_TPRELGD;
13247           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13248             goto tls_gdld_hi;
13249           break;
13250
13251         case R_PPC64_GOT_TLSLD16_HI:
13252         case R_PPC64_GOT_TLSLD16_HA:
13253           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13254             {
13255             tls_gdld_hi:
13256               if ((tls_mask & tls_gd) != 0)
13257                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13258                           + R_PPC64_GOT_TPREL16_DS);
13259               else
13260                 {
13261                   rel->r_offset -= d_offset;
13262                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13263                   r_type = R_PPC64_NONE;
13264                 }
13265               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13266             }
13267           break;
13268
13269         case R_PPC64_GOT_TLSGD16:
13270         case R_PPC64_GOT_TLSGD16_LO:
13271           tls_gd = TLS_TPRELGD;
13272           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13273             goto tls_ldgd_opt;
13274           break;
13275
13276         case R_PPC64_GOT_TLSLD16:
13277         case R_PPC64_GOT_TLSLD16_LO:
13278           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13279             {
13280               unsigned int insn1, insn2, insn3;
13281               bfd_vma offset;
13282
13283             tls_ldgd_opt:
13284               offset = (bfd_vma) -1;
13285               /* If not using the newer R_PPC64_TLSGD/LD to mark
13286                  __tls_get_addr calls, we must trust that the call
13287                  stays with its arg setup insns, ie. that the next
13288                  reloc is the __tls_get_addr call associated with
13289                  the current reloc.  Edit both insns.  */
13290               if (input_section->has_tls_get_addr_call
13291                   && rel + 1 < relend
13292                   && branch_reloc_hash_match (input_bfd, rel + 1,
13293                                               htab->tls_get_addr,
13294                                               htab->tls_get_addr_fd))
13295                 offset = rel[1].r_offset;
13296               if ((tls_mask & tls_gd) != 0)
13297                 {
13298                   /* IE */
13299                   insn1 = bfd_get_32 (output_bfd,
13300                                       contents + rel->r_offset - d_offset);
13301                   insn1 &= (1 << 26) - (1 << 2);
13302                   insn1 |= 58 << 26;    /* ld */
13303                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13304                   if (offset != (bfd_vma) -1)
13305                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13306                   if ((tls_mask & TLS_EXPLICIT) == 0)
13307                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13308                               + R_PPC64_GOT_TPREL16_DS);
13309                   else
13310                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13311                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13312                 }
13313               else
13314                 {
13315                   /* LE */
13316                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
13317                   insn2 = 0x38630000;   /* addi 3,3,0 */
13318                   if (tls_gd == 0)
13319                     {
13320                       /* Was an LD reloc.  */
13321                       if (toc_symndx)
13322                         sec = local_sections[toc_symndx];
13323                       for (r_symndx = 0;
13324                            r_symndx < symtab_hdr->sh_info;
13325                            r_symndx++)
13326                         if (local_sections[r_symndx] == sec)
13327                           break;
13328                       if (r_symndx >= symtab_hdr->sh_info)
13329                         r_symndx = STN_UNDEF;
13330                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13331                       if (r_symndx != STN_UNDEF)
13332                         rel->r_addend -= (local_syms[r_symndx].st_value
13333                                           + sec->output_offset
13334                                           + sec->output_section->vma);
13335                     }
13336                   else if (toc_symndx != 0)
13337                     {
13338                       r_symndx = toc_symndx;
13339                       rel->r_addend = toc_addend;
13340                     }
13341                   r_type = R_PPC64_TPREL16_HA;
13342                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13343                   if (offset != (bfd_vma) -1)
13344                     {
13345                       rel[1].r_info = ELF64_R_INFO (r_symndx,
13346                                                     R_PPC64_TPREL16_LO);
13347                       rel[1].r_offset = offset + d_offset;
13348                       rel[1].r_addend = rel->r_addend;
13349                     }
13350                 }
13351               bfd_put_32 (output_bfd, insn1,
13352                           contents + rel->r_offset - d_offset);
13353               if (offset != (bfd_vma) -1)
13354                 {
13355                   insn3 = bfd_get_32 (output_bfd,
13356                                       contents + offset + 4);
13357                   if (insn3 == NOP
13358                       || insn3 == CROR_151515 || insn3 == CROR_313131)
13359                     {
13360                       rel[1].r_offset += 4;
13361                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13362                       insn2 = NOP;
13363                     }
13364                   bfd_put_32 (output_bfd, insn2, contents + offset);
13365                 }
13366               if ((tls_mask & tls_gd) == 0
13367                   && (tls_gd == 0 || toc_symndx != 0))
13368                 {
13369                   /* We changed the symbol.  Start over in order
13370                      to get h, sym, sec etc. right.  */
13371                   rel--;
13372                   continue;
13373                 }
13374             }
13375           break;
13376
13377         case R_PPC64_TLSGD:
13378           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13379             {
13380               unsigned int insn2, insn3;
13381               bfd_vma offset = rel->r_offset;
13382
13383               if ((tls_mask & TLS_TPRELGD) != 0)
13384                 {
13385                   /* IE */
13386                   r_type = R_PPC64_NONE;
13387                   insn2 = 0x7c636a14;   /* add 3,3,13 */
13388                 }
13389               else
13390                 {
13391                   /* LE */
13392                   if (toc_symndx != 0)
13393                     {
13394                       r_symndx = toc_symndx;
13395                       rel->r_addend = toc_addend;
13396                     }
13397                   r_type = R_PPC64_TPREL16_LO;
13398                   rel->r_offset = offset + d_offset;
13399                   insn2 = 0x38630000;   /* addi 3,3,0 */
13400                 }
13401               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13402               /* Zap the reloc on the _tls_get_addr call too.  */
13403               BFD_ASSERT (offset == rel[1].r_offset);
13404               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13405               insn3 = bfd_get_32 (output_bfd,
13406                                   contents + offset + 4);
13407               if (insn3 == NOP
13408                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13409                 {
13410                   rel->r_offset += 4;
13411                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13412                   insn2 = NOP;
13413                 }
13414               bfd_put_32 (output_bfd, insn2, contents + offset);
13415               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13416                 {
13417                   rel--;
13418                   continue;
13419                 }
13420             }
13421           break;
13422
13423         case R_PPC64_TLSLD:
13424           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13425             {
13426               unsigned int insn2, insn3;
13427               bfd_vma offset = rel->r_offset;
13428
13429               if (toc_symndx)
13430                 sec = local_sections[toc_symndx];
13431               for (r_symndx = 0;
13432                    r_symndx < symtab_hdr->sh_info;
13433                    r_symndx++)
13434                 if (local_sections[r_symndx] == sec)
13435                   break;
13436               if (r_symndx >= symtab_hdr->sh_info)
13437                 r_symndx = STN_UNDEF;
13438               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13439               if (r_symndx != STN_UNDEF)
13440                 rel->r_addend -= (local_syms[r_symndx].st_value
13441                                   + sec->output_offset
13442                                   + sec->output_section->vma);
13443
13444               r_type = R_PPC64_TPREL16_LO;
13445               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13446               rel->r_offset = offset + d_offset;
13447               /* Zap the reloc on the _tls_get_addr call too.  */
13448               BFD_ASSERT (offset == rel[1].r_offset);
13449               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13450               insn2 = 0x38630000;       /* addi 3,3,0 */
13451               insn3 = bfd_get_32 (output_bfd,
13452                                   contents + offset + 4);
13453               if (insn3 == NOP
13454                   || insn3 == CROR_151515 || insn3 == CROR_313131)
13455                 {
13456                   rel->r_offset += 4;
13457                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13458                   insn2 = NOP;
13459                 }
13460               bfd_put_32 (output_bfd, insn2, contents + offset);
13461               rel--;
13462               continue;
13463             }
13464           break;
13465
13466         case R_PPC64_DTPMOD64:
13467           if (rel + 1 < relend
13468               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13469               && rel[1].r_offset == rel->r_offset + 8)
13470             {
13471               if ((tls_mask & TLS_GD) == 0)
13472                 {
13473                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13474                   if ((tls_mask & TLS_TPRELGD) != 0)
13475                     r_type = R_PPC64_TPREL64;
13476                   else
13477                     {
13478                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13479                       r_type = R_PPC64_NONE;
13480                     }
13481                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13482                 }
13483             }
13484           else
13485             {
13486               if ((tls_mask & TLS_LD) == 0)
13487                 {
13488                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13489                   r_type = R_PPC64_NONE;
13490                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13491                 }
13492             }
13493           break;
13494
13495         case R_PPC64_TPREL64:
13496           if ((tls_mask & TLS_TPREL) == 0)
13497             {
13498               r_type = R_PPC64_NONE;
13499               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13500             }
13501           break;
13502
13503         case R_PPC64_REL16_HA:
13504           /* If we are generating a non-PIC executable, edit
13505              .  0:      addis 2,12,.TOC.-0b@ha
13506              .          addi 2,2,.TOC.-0b@l
13507              used by ELFv2 global entry points to set up r2, to
13508              .          lis 2,.TOC.@ha
13509              .          addi 2,2,.TOC.@l
13510              if .TOC. is in range.  */
13511           if (!info->shared
13512               && h != NULL && &h->elf == htab->elf.hgot
13513               && rel + 1 < relend
13514               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13515               && rel[1].r_offset == rel->r_offset + 4
13516               && rel[1].r_addend == rel->r_addend + 4
13517               && relocation + 0x80008000 <= 0xffffffff)
13518             {
13519               unsigned int insn1, insn2;
13520               bfd_vma offset = rel->r_offset - d_offset;
13521               insn1 = bfd_get_32 (output_bfd, contents + offset);
13522               insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13523               if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13524                   && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13525                 {
13526                   r_type = R_PPC64_ADDR16_HA;
13527                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13528                   rel->r_addend -= d_offset;
13529                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13530                   rel[1].r_addend -= d_offset + 4;
13531                   bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13532                 }
13533             }
13534           break;
13535         }
13536
13537       /* Handle other relocations that tweak non-addend part of insn.  */
13538       insn = 0;
13539       max_br_offset = 1 << 25;
13540       addend = rel->r_addend;
13541       reloc_dest = DEST_NORMAL;
13542       switch (r_type)
13543         {
13544         default:
13545           break;
13546
13547         case R_PPC64_TOCSAVE:
13548           if (relocation + addend == (rel->r_offset
13549                                       + input_section->output_offset
13550                                       + input_section->output_section->vma)
13551               && tocsave_find (htab, NO_INSERT,
13552                                &local_syms, rel, input_bfd))
13553             {
13554               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13555               if (insn == NOP
13556                   || insn == CROR_151515 || insn == CROR_313131)
13557                 bfd_put_32 (input_bfd,
13558                             STD_R2_0R1 + STK_TOC (htab),
13559                             contents + rel->r_offset);
13560             }
13561           break;
13562
13563           /* Branch taken prediction relocations.  */
13564         case R_PPC64_ADDR14_BRTAKEN:
13565         case R_PPC64_REL14_BRTAKEN:
13566           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
13567           /* Fall thru.  */
13568
13569           /* Branch not taken prediction relocations.  */
13570         case R_PPC64_ADDR14_BRNTAKEN:
13571         case R_PPC64_REL14_BRNTAKEN:
13572           insn |= bfd_get_32 (output_bfd,
13573                               contents + rel->r_offset) & ~(0x01 << 21);
13574           /* Fall thru.  */
13575
13576         case R_PPC64_REL14:
13577           max_br_offset = 1 << 15;
13578           /* Fall thru.  */
13579
13580         case R_PPC64_REL24:
13581           /* Calls to functions with a different TOC, such as calls to
13582              shared objects, need to alter the TOC pointer.  This is
13583              done using a linkage stub.  A REL24 branching to these
13584              linkage stubs needs to be followed by a nop, as the nop
13585              will be replaced with an instruction to restore the TOC
13586              base pointer.  */
13587           fdh = h;
13588           if (h != NULL
13589               && h->oh != NULL
13590               && h->oh->is_func_descriptor)
13591             fdh = ppc_follow_link (h->oh);
13592           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13593                                            htab);
13594           if (stub_entry != NULL
13595               && (stub_entry->stub_type == ppc_stub_plt_call
13596                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13597                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13598                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13599             {
13600               bfd_boolean can_plt_call = FALSE;
13601
13602               /* All of these stubs will modify r2, so there must be a
13603                  branch and link followed by a nop.  The nop is
13604                  replaced by an insn to restore r2.  */
13605               if (rel->r_offset + 8 <= input_section->size)
13606                 {
13607                   unsigned long br;
13608
13609                   br = bfd_get_32 (input_bfd,
13610                                    contents + rel->r_offset);
13611                   if ((br & 1) != 0)
13612                     {
13613                       unsigned long nop;
13614
13615                       nop = bfd_get_32 (input_bfd,
13616                                         contents + rel->r_offset + 4);
13617                       if (nop == NOP
13618                           || nop == CROR_151515 || nop == CROR_313131)
13619                         {
13620                           if (h != NULL
13621                               && (h == htab->tls_get_addr_fd
13622                                   || h == htab->tls_get_addr)
13623                               && !htab->no_tls_get_addr_opt)
13624                             {
13625                               /* Special stub used, leave nop alone.  */
13626                             }
13627                           else
13628                             bfd_put_32 (input_bfd,
13629                                         LD_R2_0R1 + STK_TOC (htab),
13630                                         contents + rel->r_offset + 4);
13631                           can_plt_call = TRUE;
13632                         }
13633                     }
13634                 }
13635
13636               if (!can_plt_call && h != NULL)
13637                 {
13638                   const char *name = h->elf.root.root.string;
13639
13640                   if (*name == '.')
13641                     ++name;
13642
13643                   if (strncmp (name, "__libc_start_main", 17) == 0
13644                       && (name[17] == 0 || name[17] == '@'))
13645                     {
13646                       /* Allow crt1 branch to go via a toc adjusting
13647                          stub.  Other calls that never return could do
13648                          the same, if we could detect such.  */
13649                       can_plt_call = TRUE;
13650                     }
13651                 }
13652
13653               if (!can_plt_call)
13654                 {
13655                   /* g++ as of 20130507 emits self-calls without a
13656                      following nop.  This is arguably wrong since we
13657                      have conflicting information.  On the one hand a
13658                      global symbol and on the other a local call
13659                      sequence, but don't error for this special case.
13660                      It isn't possible to cheaply verify we have
13661                      exactly such a call.  Allow all calls to the same
13662                      section.  */
13663                   asection *code_sec = sec;
13664
13665                   if (get_opd_info (sec) != NULL)
13666                     {
13667                       bfd_vma off = (relocation + addend
13668                                      - sec->output_section->vma
13669                                      - sec->output_offset);
13670
13671                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13672                     }
13673                   if (code_sec == input_section)
13674                     can_plt_call = TRUE;
13675                 }
13676
13677               if (!can_plt_call)
13678                 {
13679                   info->callbacks->einfo
13680                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13681                        "recompile with -fPIC\n"),
13682                      input_bfd, input_section, rel->r_offset, sym_name);
13683
13684                   bfd_set_error (bfd_error_bad_value);
13685                   ret = FALSE;
13686                 }
13687
13688               if (can_plt_call
13689                   && (stub_entry->stub_type == ppc_stub_plt_call
13690                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13691                 unresolved_reloc = FALSE;
13692             }
13693
13694           if ((stub_entry == NULL
13695                || stub_entry->stub_type == ppc_stub_long_branch
13696                || stub_entry->stub_type == ppc_stub_plt_branch)
13697               && get_opd_info (sec) != NULL)
13698             {
13699               /* The branch destination is the value of the opd entry. */
13700               bfd_vma off = (relocation + addend
13701                              - sec->output_section->vma
13702                              - sec->output_offset);
13703               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13704               if (dest != (bfd_vma) -1)
13705                 {
13706                   relocation = dest;
13707                   addend = 0;
13708                   reloc_dest = DEST_OPD;
13709                 }
13710             }
13711
13712           /* If the branch is out of reach we ought to have a long
13713              branch stub.  */
13714           from = (rel->r_offset
13715                   + input_section->output_offset
13716                   + input_section->output_section->vma);
13717
13718           relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13719                                                   ? fdh->elf.other
13720                                                   : sym->st_other);
13721
13722           if (stub_entry != NULL
13723               && (stub_entry->stub_type == ppc_stub_long_branch
13724                   || stub_entry->stub_type == ppc_stub_plt_branch)
13725               && (r_type == R_PPC64_ADDR14_BRTAKEN
13726                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13727                   || (relocation + addend - from + max_br_offset
13728                       < 2 * max_br_offset)))
13729             /* Don't use the stub if this branch is in range.  */
13730             stub_entry = NULL;
13731
13732           if (stub_entry != NULL)
13733             {
13734               /* Munge up the value and addend so that we call the stub
13735                  rather than the procedure directly.  */
13736               relocation = (stub_entry->stub_offset
13737                             + stub_entry->stub_sec->output_offset
13738                             + stub_entry->stub_sec->output_section->vma);
13739               addend = 0;
13740               reloc_dest = DEST_STUB;
13741
13742               if ((stub_entry->stub_type == ppc_stub_plt_call
13743                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13744                   && (ALWAYS_EMIT_R2SAVE
13745                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13746                   && rel + 1 < relend
13747                   && rel[1].r_offset == rel->r_offset + 4
13748                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13749                 relocation += 4;
13750             }
13751
13752           if (insn != 0)
13753             {
13754               if (is_isa_v2)
13755                 {
13756                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13757                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13758                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13759                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13760                     insn |= 0x02 << 21;
13761                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13762                     insn |= 0x08 << 21;
13763                   else
13764                     break;
13765                 }
13766               else
13767                 {
13768                   /* Invert 'y' bit if not the default.  */
13769                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13770                     insn ^= 0x01 << 21;
13771                 }
13772
13773               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13774             }
13775
13776           /* NOP out calls to undefined weak functions.
13777              We can thus call a weak function without first
13778              checking whether the function is defined.  */
13779           else if (h != NULL
13780                    && h->elf.root.type == bfd_link_hash_undefweak
13781                    && h->elf.dynindx == -1
13782                    && r_type == R_PPC64_REL24
13783                    && relocation == 0
13784                    && addend == 0)
13785             {
13786               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13787               continue;
13788             }
13789           break;
13790         }
13791
13792       /* Set `addend'.  */
13793       tls_type = 0;
13794       switch (r_type)
13795         {
13796         default:
13797           info->callbacks->einfo
13798             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13799              input_bfd, (int) r_type, sym_name);
13800
13801           bfd_set_error (bfd_error_bad_value);
13802           ret = FALSE;
13803           continue;
13804
13805         case R_PPC64_NONE:
13806         case R_PPC64_TLS:
13807         case R_PPC64_TLSGD:
13808         case R_PPC64_TLSLD:
13809         case R_PPC64_TOCSAVE:
13810         case R_PPC64_GNU_VTINHERIT:
13811         case R_PPC64_GNU_VTENTRY:
13812           continue;
13813
13814           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13815              address in the GOT as relocation value instead of the
13816              symbol's value itself.  Also, create a GOT entry for the
13817              symbol and put the symbol value there.  */
13818         case R_PPC64_GOT_TLSGD16:
13819         case R_PPC64_GOT_TLSGD16_LO:
13820         case R_PPC64_GOT_TLSGD16_HI:
13821         case R_PPC64_GOT_TLSGD16_HA:
13822           tls_type = TLS_TLS | TLS_GD;
13823           goto dogot;
13824
13825         case R_PPC64_GOT_TLSLD16:
13826         case R_PPC64_GOT_TLSLD16_LO:
13827         case R_PPC64_GOT_TLSLD16_HI:
13828         case R_PPC64_GOT_TLSLD16_HA:
13829           tls_type = TLS_TLS | TLS_LD;
13830           goto dogot;
13831
13832         case R_PPC64_GOT_TPREL16_DS:
13833         case R_PPC64_GOT_TPREL16_LO_DS:
13834         case R_PPC64_GOT_TPREL16_HI:
13835         case R_PPC64_GOT_TPREL16_HA:
13836           tls_type = TLS_TLS | TLS_TPREL;
13837           goto dogot;
13838
13839         case R_PPC64_GOT_DTPREL16_DS:
13840         case R_PPC64_GOT_DTPREL16_LO_DS:
13841         case R_PPC64_GOT_DTPREL16_HI:
13842         case R_PPC64_GOT_DTPREL16_HA:
13843           tls_type = TLS_TLS | TLS_DTPREL;
13844           goto dogot;
13845
13846         case R_PPC64_GOT16:
13847         case R_PPC64_GOT16_LO:
13848         case R_PPC64_GOT16_HI:
13849         case R_PPC64_GOT16_HA:
13850         case R_PPC64_GOT16_DS:
13851         case R_PPC64_GOT16_LO_DS:
13852         dogot:
13853           {
13854             /* Relocation is to the entry for this symbol in the global
13855                offset table.  */
13856             asection *got;
13857             bfd_vma *offp;
13858             bfd_vma off;
13859             unsigned long indx = 0;
13860             struct got_entry *ent;
13861
13862             if (tls_type == (TLS_TLS | TLS_LD)
13863                 && (h == NULL
13864                     || !h->elf.def_dynamic))
13865               ent = ppc64_tlsld_got (input_bfd);
13866             else
13867               {
13868
13869                 if (h != NULL)
13870                   {
13871                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13872                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13873                                                           &h->elf)
13874                         || (info->shared
13875                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13876                       /* This is actually a static link, or it is a
13877                          -Bsymbolic link and the symbol is defined
13878                          locally, or the symbol was forced to be local
13879                          because of a version file.  */
13880                       ;
13881                     else
13882                       {
13883                         BFD_ASSERT (h->elf.dynindx != -1);
13884                         indx = h->elf.dynindx;
13885                         unresolved_reloc = FALSE;
13886                       }
13887                     ent = h->elf.got.glist;
13888                   }
13889                 else
13890                   {
13891                     if (local_got_ents == NULL)
13892                       abort ();
13893                     ent = local_got_ents[r_symndx];
13894                   }
13895
13896                 for (; ent != NULL; ent = ent->next)
13897                   if (ent->addend == orig_rel.r_addend
13898                       && ent->owner == input_bfd
13899                       && ent->tls_type == tls_type)
13900                     break;
13901               }
13902
13903             if (ent == NULL)
13904               abort ();
13905             if (ent->is_indirect)
13906               ent = ent->got.ent;
13907             offp = &ent->got.offset;
13908             got = ppc64_elf_tdata (ent->owner)->got;
13909             if (got == NULL)
13910               abort ();
13911
13912             /* The offset must always be a multiple of 8.  We use the
13913                least significant bit to record whether we have already
13914                processed this entry.  */
13915             off = *offp;
13916             if ((off & 1) != 0)
13917               off &= ~1;
13918             else
13919               {
13920                 /* Generate relocs for the dynamic linker, except in
13921                    the case of TLSLD where we'll use one entry per
13922                    module.  */
13923                 asection *relgot;
13924                 bfd_boolean ifunc;
13925
13926                 *offp = off | 1;
13927                 relgot = NULL;
13928                 ifunc = (h != NULL
13929                          ? h->elf.type == STT_GNU_IFUNC
13930                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13931                 if (ifunc)
13932                   relgot = htab->elf.irelplt;
13933                 else if ((info->shared || indx != 0)
13934                          && (h == NULL
13935                              || (tls_type == (TLS_TLS | TLS_LD)
13936                                  && !h->elf.def_dynamic)
13937                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13938                              || h->elf.root.type != bfd_link_hash_undefweak))
13939                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13940                 if (relgot != NULL)
13941                   {
13942                     outrel.r_offset = (got->output_section->vma
13943                                        + got->output_offset
13944                                        + off);
13945                     outrel.r_addend = addend;
13946                     if (tls_type & (TLS_LD | TLS_GD))
13947                       {
13948                         outrel.r_addend = 0;
13949                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13950                         if (tls_type == (TLS_TLS | TLS_GD))
13951                           {
13952                             loc = relgot->contents;
13953                             loc += (relgot->reloc_count++
13954                                     * sizeof (Elf64_External_Rela));
13955                             bfd_elf64_swap_reloca_out (output_bfd,
13956                                                        &outrel, loc);
13957                             outrel.r_offset += 8;
13958                             outrel.r_addend = addend;
13959                             outrel.r_info
13960                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13961                           }
13962                       }
13963                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13964                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13965                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13966                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13967                     else if (indx != 0)
13968                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13969                     else
13970                       {
13971                         if (ifunc)
13972                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13973                         else
13974                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13975
13976                         /* Write the .got section contents for the sake
13977                            of prelink.  */
13978                         loc = got->contents + off;
13979                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13980                                     loc);
13981                       }
13982
13983                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13984                       {
13985                         outrel.r_addend += relocation;
13986                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13987                           outrel.r_addend -= htab->elf.tls_sec->vma;
13988                       }
13989                     loc = relgot->contents;
13990                     loc += (relgot->reloc_count++
13991                             * sizeof (Elf64_External_Rela));
13992                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13993                   }
13994
13995                 /* Init the .got section contents here if we're not
13996                    emitting a reloc.  */
13997                 else
13998                   {
13999                     relocation += addend;
14000                     if (tls_type == (TLS_TLS | TLS_LD))
14001                       relocation = 1;
14002                     else if (tls_type != 0)
14003                       {
14004                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14005                         if (tls_type == (TLS_TLS | TLS_TPREL))
14006                           relocation += DTP_OFFSET - TP_OFFSET;
14007
14008                         if (tls_type == (TLS_TLS | TLS_GD))
14009                           {
14010                             bfd_put_64 (output_bfd, relocation,
14011                                         got->contents + off + 8);
14012                             relocation = 1;
14013                           }
14014                       }
14015
14016                     bfd_put_64 (output_bfd, relocation,
14017                                 got->contents + off);
14018                   }
14019               }
14020
14021             if (off >= (bfd_vma) -2)
14022               abort ();
14023
14024             relocation = got->output_section->vma + got->output_offset + off;
14025             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14026           }
14027           break;
14028
14029         case R_PPC64_PLT16_HA:
14030         case R_PPC64_PLT16_HI:
14031         case R_PPC64_PLT16_LO:
14032         case R_PPC64_PLT32:
14033         case R_PPC64_PLT64:
14034           /* Relocation is to the entry for this symbol in the
14035              procedure linkage table.  */
14036
14037           /* Resolve a PLT reloc against a local symbol directly,
14038              without using the procedure linkage table.  */
14039           if (h == NULL)
14040             break;
14041
14042           /* It's possible that we didn't make a PLT entry for this
14043              symbol.  This happens when statically linking PIC code,
14044              or when using -Bsymbolic.  Go find a match if there is a
14045              PLT entry.  */
14046           if (htab->elf.splt != NULL)
14047             {
14048               struct plt_entry *ent;
14049               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14050                 if (ent->plt.offset != (bfd_vma) -1
14051                     && ent->addend == orig_rel.r_addend)
14052                   {
14053                     relocation = (htab->elf.splt->output_section->vma
14054                                   + htab->elf.splt->output_offset
14055                                   + ent->plt.offset);
14056                     unresolved_reloc = FALSE;
14057                     break;
14058                   }
14059             }
14060           break;
14061
14062         case R_PPC64_TOC:
14063           /* Relocation value is TOC base.  */
14064           relocation = TOCstart;
14065           if (r_symndx == STN_UNDEF)
14066             relocation += htab->stub_group[input_section->id].toc_off;
14067           else if (unresolved_reloc)
14068             ;
14069           else if (sec != NULL && sec->id <= htab->top_id)
14070             relocation += htab->stub_group[sec->id].toc_off;
14071           else
14072             unresolved_reloc = TRUE;
14073           goto dodyn;
14074
14075           /* TOC16 relocs.  We want the offset relative to the TOC base,
14076              which is the address of the start of the TOC plus 0x8000.
14077              The TOC consists of sections .got, .toc, .tocbss, and .plt,
14078              in this order.  */
14079         case R_PPC64_TOC16:
14080         case R_PPC64_TOC16_LO:
14081         case R_PPC64_TOC16_HI:
14082         case R_PPC64_TOC16_DS:
14083         case R_PPC64_TOC16_LO_DS:
14084         case R_PPC64_TOC16_HA:
14085           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14086           break;
14087
14088           /* Relocate against the beginning of the section.  */
14089         case R_PPC64_SECTOFF:
14090         case R_PPC64_SECTOFF_LO:
14091         case R_PPC64_SECTOFF_HI:
14092         case R_PPC64_SECTOFF_DS:
14093         case R_PPC64_SECTOFF_LO_DS:
14094         case R_PPC64_SECTOFF_HA:
14095           if (sec != NULL)
14096             addend -= sec->output_section->vma;
14097           break;
14098
14099         case R_PPC64_REL16:
14100         case R_PPC64_REL16_LO:
14101         case R_PPC64_REL16_HI:
14102         case R_PPC64_REL16_HA:
14103           break;
14104
14105         case R_PPC64_REL14:
14106         case R_PPC64_REL14_BRNTAKEN:
14107         case R_PPC64_REL14_BRTAKEN:
14108         case R_PPC64_REL24:
14109           break;
14110
14111         case R_PPC64_TPREL16:
14112         case R_PPC64_TPREL16_LO:
14113         case R_PPC64_TPREL16_HI:
14114         case R_PPC64_TPREL16_HA:
14115         case R_PPC64_TPREL16_DS:
14116         case R_PPC64_TPREL16_LO_DS:
14117         case R_PPC64_TPREL16_HIGH:
14118         case R_PPC64_TPREL16_HIGHA:
14119         case R_PPC64_TPREL16_HIGHER:
14120         case R_PPC64_TPREL16_HIGHERA:
14121         case R_PPC64_TPREL16_HIGHEST:
14122         case R_PPC64_TPREL16_HIGHESTA:
14123           if (h != NULL
14124               && h->elf.root.type == bfd_link_hash_undefweak
14125               && h->elf.dynindx == -1)
14126             {
14127               /* Make this relocation against an undefined weak symbol
14128                  resolve to zero.  This is really just a tweak, since
14129                  code using weak externs ought to check that they are
14130                  defined before using them.  */
14131               bfd_byte *p = contents + rel->r_offset - d_offset;
14132
14133               insn = bfd_get_32 (output_bfd, p);
14134               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14135               if (insn != 0)
14136                 bfd_put_32 (output_bfd, insn, p);
14137               break;
14138             }
14139           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14140           if (info->shared)
14141             /* The TPREL16 relocs shouldn't really be used in shared
14142                libs as they will result in DT_TEXTREL being set, but
14143                support them anyway.  */
14144             goto dodyn;
14145           break;
14146
14147         case R_PPC64_DTPREL16:
14148         case R_PPC64_DTPREL16_LO:
14149         case R_PPC64_DTPREL16_HI:
14150         case R_PPC64_DTPREL16_HA:
14151         case R_PPC64_DTPREL16_DS:
14152         case R_PPC64_DTPREL16_LO_DS:
14153         case R_PPC64_DTPREL16_HIGH:
14154         case R_PPC64_DTPREL16_HIGHA:
14155         case R_PPC64_DTPREL16_HIGHER:
14156         case R_PPC64_DTPREL16_HIGHERA:
14157         case R_PPC64_DTPREL16_HIGHEST:
14158         case R_PPC64_DTPREL16_HIGHESTA:
14159           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14160           break;
14161
14162         case R_PPC64_DTPMOD64:
14163           relocation = 1;
14164           addend = 0;
14165           goto dodyn;
14166
14167         case R_PPC64_TPREL64:
14168           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14169           goto dodyn;
14170
14171         case R_PPC64_DTPREL64:
14172           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14173           /* Fall thru */
14174
14175           /* Relocations that may need to be propagated if this is a
14176              dynamic object.  */
14177         case R_PPC64_REL30:
14178         case R_PPC64_REL32:
14179         case R_PPC64_REL64:
14180         case R_PPC64_ADDR14:
14181         case R_PPC64_ADDR14_BRNTAKEN:
14182         case R_PPC64_ADDR14_BRTAKEN:
14183         case R_PPC64_ADDR16:
14184         case R_PPC64_ADDR16_DS:
14185         case R_PPC64_ADDR16_HA:
14186         case R_PPC64_ADDR16_HI:
14187         case R_PPC64_ADDR16_HIGH:
14188         case R_PPC64_ADDR16_HIGHA:
14189         case R_PPC64_ADDR16_HIGHER:
14190         case R_PPC64_ADDR16_HIGHERA:
14191         case R_PPC64_ADDR16_HIGHEST:
14192         case R_PPC64_ADDR16_HIGHESTA:
14193         case R_PPC64_ADDR16_LO:
14194         case R_PPC64_ADDR16_LO_DS:
14195         case R_PPC64_ADDR24:
14196         case R_PPC64_ADDR32:
14197         case R_PPC64_ADDR64:
14198         case R_PPC64_UADDR16:
14199         case R_PPC64_UADDR32:
14200         case R_PPC64_UADDR64:
14201         dodyn:
14202           if ((input_section->flags & SEC_ALLOC) == 0)
14203             break;
14204
14205           if (NO_OPD_RELOCS && is_opd)
14206             break;
14207
14208           if ((info->shared
14209                && (h == NULL
14210                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14211                    || h->elf.root.type != bfd_link_hash_undefweak)
14212                && (must_be_dyn_reloc (info, r_type)
14213                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14214               || (ELIMINATE_COPY_RELOCS
14215                   && !info->shared
14216                   && h != NULL
14217                   && h->elf.dynindx != -1
14218                   && !h->elf.non_got_ref
14219                   && !h->elf.def_regular)
14220               || (!info->shared
14221                   && (h != NULL
14222                       ? h->elf.type == STT_GNU_IFUNC
14223                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14224             {
14225               bfd_boolean skip, relocate;
14226               asection *sreloc;
14227               bfd_vma out_off;
14228
14229               /* When generating a dynamic object, these relocations
14230                  are copied into the output file to be resolved at run
14231                  time.  */
14232
14233               skip = FALSE;
14234               relocate = FALSE;
14235
14236               out_off = _bfd_elf_section_offset (output_bfd, info,
14237                                                  input_section, rel->r_offset);
14238               if (out_off == (bfd_vma) -1)
14239                 skip = TRUE;
14240               else if (out_off == (bfd_vma) -2)
14241                 skip = TRUE, relocate = TRUE;
14242               out_off += (input_section->output_section->vma
14243                           + input_section->output_offset);
14244               outrel.r_offset = out_off;
14245               outrel.r_addend = rel->r_addend;
14246
14247               /* Optimize unaligned reloc use.  */
14248               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14249                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14250                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14251               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14252                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14253                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14254               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14255                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14256                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14257
14258               if (skip)
14259                 memset (&outrel, 0, sizeof outrel);
14260               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14261                        && !is_opd
14262                        && r_type != R_PPC64_TOC)
14263                 {
14264                   BFD_ASSERT (h->elf.dynindx != -1);
14265                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14266                 }
14267               else
14268                 {
14269                   /* This symbol is local, or marked to become local,
14270                      or this is an opd section reloc which must point
14271                      at a local function.  */
14272                   outrel.r_addend += relocation;
14273                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14274                     {
14275                       if (is_opd && h != NULL)
14276                         {
14277                           /* Lie about opd entries.  This case occurs
14278                              when building shared libraries and we
14279                              reference a function in another shared
14280                              lib.  The same thing happens for a weak
14281                              definition in an application that's
14282                              overridden by a strong definition in a
14283                              shared lib.  (I believe this is a generic
14284                              bug in binutils handling of weak syms.)
14285                              In these cases we won't use the opd
14286                              entry in this lib.  */
14287                           unresolved_reloc = FALSE;
14288                         }
14289                       if (!is_opd
14290                           && r_type == R_PPC64_ADDR64
14291                           && (h != NULL
14292                               ? h->elf.type == STT_GNU_IFUNC
14293                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14294                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14295                       else
14296                         {
14297                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14298
14299                           /* We need to relocate .opd contents for ld.so.
14300                              Prelink also wants simple and consistent rules
14301                              for relocs.  This make all RELATIVE relocs have
14302                              *r_offset equal to r_addend.  */
14303                           relocate = TRUE;
14304                         }
14305                     }
14306                   else
14307                     {
14308                       long indx = 0;
14309
14310                       if (h != NULL
14311                           ? h->elf.type == STT_GNU_IFUNC
14312                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14313                         {
14314                           info->callbacks->einfo
14315                             (_("%P: %H: %s for indirect "
14316                                "function `%T' unsupported\n"),
14317                              input_bfd, input_section, rel->r_offset,
14318                              ppc64_elf_howto_table[r_type]->name,
14319                              sym_name);
14320                           ret = FALSE;
14321                         }
14322                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14323                         ;
14324                       else if (sec == NULL || sec->owner == NULL)
14325                         {
14326                           bfd_set_error (bfd_error_bad_value);
14327                           return FALSE;
14328                         }
14329                       else
14330                         {
14331                           asection *osec;
14332
14333                           osec = sec->output_section;
14334                           indx = elf_section_data (osec)->dynindx;
14335
14336                           if (indx == 0)
14337                             {
14338                               if ((osec->flags & SEC_READONLY) == 0
14339                                   && htab->elf.data_index_section != NULL)
14340                                 osec = htab->elf.data_index_section;
14341                               else
14342                                 osec = htab->elf.text_index_section;
14343                               indx = elf_section_data (osec)->dynindx;
14344                             }
14345                           BFD_ASSERT (indx != 0);
14346
14347                           /* We are turning this relocation into one
14348                              against a section symbol, so subtract out
14349                              the output section's address but not the
14350                              offset of the input section in the output
14351                              section.  */
14352                           outrel.r_addend -= osec->vma;
14353                         }
14354
14355                       outrel.r_info = ELF64_R_INFO (indx, r_type);
14356                     }
14357                 }
14358
14359               sreloc = elf_section_data (input_section)->sreloc;
14360               if (h != NULL
14361                   ? h->elf.type == STT_GNU_IFUNC
14362                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14363                 sreloc = htab->elf.irelplt;
14364               if (sreloc == NULL)
14365                 abort ();
14366
14367               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14368                   >= sreloc->size)
14369                 abort ();
14370               loc = sreloc->contents;
14371               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14372               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14373
14374               /* If this reloc is against an external symbol, it will
14375                  be computed at runtime, so there's no need to do
14376                  anything now.  However, for the sake of prelink ensure
14377                  that the section contents are a known value.  */
14378               if (! relocate)
14379                 {
14380                   unresolved_reloc = FALSE;
14381                   /* The value chosen here is quite arbitrary as ld.so
14382                      ignores section contents except for the special
14383                      case of .opd where the contents might be accessed
14384                      before relocation.  Choose zero, as that won't
14385                      cause reloc overflow.  */
14386                   relocation = 0;
14387                   addend = 0;
14388                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14389                      to improve backward compatibility with older
14390                      versions of ld.  */
14391                   if (r_type == R_PPC64_ADDR64)
14392                     addend = outrel.r_addend;
14393                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
14394                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
14395                     addend = (input_section->output_section->vma
14396                               + input_section->output_offset
14397                               + rel->r_offset);
14398                 }
14399             }
14400           break;
14401
14402         case R_PPC64_COPY:
14403         case R_PPC64_GLOB_DAT:
14404         case R_PPC64_JMP_SLOT:
14405         case R_PPC64_JMP_IREL:
14406         case R_PPC64_RELATIVE:
14407           /* We shouldn't ever see these dynamic relocs in relocatable
14408              files.  */
14409           /* Fall through.  */
14410
14411         case R_PPC64_PLTGOT16:
14412         case R_PPC64_PLTGOT16_DS:
14413         case R_PPC64_PLTGOT16_HA:
14414         case R_PPC64_PLTGOT16_HI:
14415         case R_PPC64_PLTGOT16_LO:
14416         case R_PPC64_PLTGOT16_LO_DS:
14417         case R_PPC64_PLTREL32:
14418         case R_PPC64_PLTREL64:
14419           /* These ones haven't been implemented yet.  */
14420
14421           info->callbacks->einfo
14422             (_("%P: %B: %s is not supported for `%T'\n"),
14423              input_bfd,
14424              ppc64_elf_howto_table[r_type]->name, sym_name);
14425
14426           bfd_set_error (bfd_error_invalid_operation);
14427           ret = FALSE;
14428           continue;
14429         }
14430
14431       /* Multi-instruction sequences that access the TOC can be
14432          optimized, eg. addis ra,r2,0; addi rb,ra,x;
14433          to             nop;           addi rb,r2,x;  */
14434       switch (r_type)
14435         {
14436         default:
14437           break;
14438
14439         case R_PPC64_GOT_TLSLD16_HI:
14440         case R_PPC64_GOT_TLSGD16_HI:
14441         case R_PPC64_GOT_TPREL16_HI:
14442         case R_PPC64_GOT_DTPREL16_HI:
14443         case R_PPC64_GOT16_HI:
14444         case R_PPC64_TOC16_HI:
14445           /* These relocs would only be useful if building up an
14446              offset to later add to r2, perhaps in an indexed
14447              addressing mode instruction.  Don't try to optimize.
14448              Unfortunately, the possibility of someone building up an
14449              offset like this or even with the HA relocs, means that
14450              we need to check the high insn when optimizing the low
14451              insn.  */
14452           break;
14453
14454         case R_PPC64_GOT_TLSLD16_HA:
14455         case R_PPC64_GOT_TLSGD16_HA:
14456         case R_PPC64_GOT_TPREL16_HA:
14457         case R_PPC64_GOT_DTPREL16_HA:
14458         case R_PPC64_GOT16_HA:
14459         case R_PPC64_TOC16_HA:
14460           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14461               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14462             {
14463               bfd_byte *p = contents + (rel->r_offset & ~3);
14464               bfd_put_32 (input_bfd, NOP, p);
14465             }
14466           break;
14467
14468         case R_PPC64_GOT_TLSLD16_LO:
14469         case R_PPC64_GOT_TLSGD16_LO:
14470         case R_PPC64_GOT_TPREL16_LO_DS:
14471         case R_PPC64_GOT_DTPREL16_LO_DS:
14472         case R_PPC64_GOT16_LO:
14473         case R_PPC64_GOT16_LO_DS:
14474         case R_PPC64_TOC16_LO:
14475         case R_PPC64_TOC16_LO_DS:
14476           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14477               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14478             {
14479               bfd_byte *p = contents + (rel->r_offset & ~3);
14480               insn = bfd_get_32 (input_bfd, p);
14481               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14482                 {
14483                   /* Transform addic to addi when we change reg.  */
14484                   insn &= ~((0x3f << 26) | (0x1f << 16));
14485                   insn |= (14u << 26) | (2 << 16);
14486                 }
14487               else
14488                 {
14489                   insn &= ~(0x1f << 16);
14490                   insn |= 2 << 16;
14491                 }
14492               bfd_put_32 (input_bfd, insn, p);
14493             }
14494           break;
14495         }
14496
14497       /* Do any further special processing.  */
14498       switch (r_type)
14499         {
14500         default:
14501           break;
14502
14503         case R_PPC64_REL16_HA:
14504         case R_PPC64_ADDR16_HA:
14505         case R_PPC64_ADDR16_HIGHA:
14506         case R_PPC64_ADDR16_HIGHERA:
14507         case R_PPC64_ADDR16_HIGHESTA:
14508         case R_PPC64_TOC16_HA:
14509         case R_PPC64_SECTOFF_HA:
14510         case R_PPC64_TPREL16_HA:
14511         case R_PPC64_TPREL16_HIGHA:
14512         case R_PPC64_TPREL16_HIGHERA:
14513         case R_PPC64_TPREL16_HIGHESTA:
14514         case R_PPC64_DTPREL16_HA:
14515         case R_PPC64_DTPREL16_HIGHA:
14516         case R_PPC64_DTPREL16_HIGHERA:
14517         case R_PPC64_DTPREL16_HIGHESTA:
14518           /* It's just possible that this symbol is a weak symbol
14519              that's not actually defined anywhere. In that case,
14520              'sec' would be NULL, and we should leave the symbol
14521              alone (it will be set to zero elsewhere in the link).  */
14522           if (sec == NULL)
14523             break;
14524           /* Fall thru */
14525
14526         case R_PPC64_GOT16_HA:
14527         case R_PPC64_PLTGOT16_HA:
14528         case R_PPC64_PLT16_HA:
14529         case R_PPC64_GOT_TLSGD16_HA:
14530         case R_PPC64_GOT_TLSLD16_HA:
14531         case R_PPC64_GOT_TPREL16_HA:
14532         case R_PPC64_GOT_DTPREL16_HA:
14533           /* Add 0x10000 if sign bit in 0:15 is set.
14534              Bits 0:15 are not used.  */
14535           addend += 0x8000;
14536           break;
14537
14538         case R_PPC64_ADDR16_DS:
14539         case R_PPC64_ADDR16_LO_DS:
14540         case R_PPC64_GOT16_DS:
14541         case R_PPC64_GOT16_LO_DS:
14542         case R_PPC64_PLT16_LO_DS:
14543         case R_PPC64_SECTOFF_DS:
14544         case R_PPC64_SECTOFF_LO_DS:
14545         case R_PPC64_TOC16_DS:
14546         case R_PPC64_TOC16_LO_DS:
14547         case R_PPC64_PLTGOT16_DS:
14548         case R_PPC64_PLTGOT16_LO_DS:
14549         case R_PPC64_GOT_TPREL16_DS:
14550         case R_PPC64_GOT_TPREL16_LO_DS:
14551         case R_PPC64_GOT_DTPREL16_DS:
14552         case R_PPC64_GOT_DTPREL16_LO_DS:
14553         case R_PPC64_TPREL16_DS:
14554         case R_PPC64_TPREL16_LO_DS:
14555         case R_PPC64_DTPREL16_DS:
14556         case R_PPC64_DTPREL16_LO_DS:
14557           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14558           mask = 3;
14559           /* If this reloc is against an lq insn, then the value must be
14560              a multiple of 16.  This is somewhat of a hack, but the
14561              "correct" way to do this by defining _DQ forms of all the
14562              _DS relocs bloats all reloc switches in this file.  It
14563              doesn't seem to make much sense to use any of these relocs
14564              in data, so testing the insn should be safe.  */
14565           if ((insn & (0x3f << 26)) == (56u << 26))
14566             mask = 15;
14567           if (((relocation + addend) & mask) != 0)
14568             {
14569               info->callbacks->einfo
14570                 (_("%P: %H: error: %s not a multiple of %u\n"),
14571                  input_bfd, input_section, rel->r_offset,
14572                  ppc64_elf_howto_table[r_type]->name,
14573                  mask + 1);
14574               bfd_set_error (bfd_error_bad_value);
14575               ret = FALSE;
14576               continue;
14577             }
14578           break;
14579         }
14580
14581       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14582          because such sections are not SEC_ALLOC and thus ld.so will
14583          not process them.  */
14584       if (unresolved_reloc
14585           && !((input_section->flags & SEC_DEBUGGING) != 0
14586                && h->elf.def_dynamic)
14587           && _bfd_elf_section_offset (output_bfd, info, input_section,
14588                                       rel->r_offset) != (bfd_vma) -1)
14589         {
14590           info->callbacks->einfo
14591             (_("%P: %H: unresolvable %s against `%T'\n"),
14592              input_bfd, input_section, rel->r_offset,
14593              ppc64_elf_howto_table[(int) r_type]->name,
14594              h->elf.root.root.string);
14595           ret = FALSE;
14596         }
14597
14598       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14599                                     input_bfd,
14600                                     input_section,
14601                                     contents,
14602                                     rel->r_offset,
14603                                     relocation,
14604                                     addend);
14605
14606       if (r != bfd_reloc_ok)
14607         {
14608           char *more_info = NULL;
14609           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14610
14611           if (reloc_dest != DEST_NORMAL)
14612             {
14613               more_info = bfd_malloc (strlen (reloc_name) + 8);
14614               if (more_info != NULL)
14615                 {
14616                   strcpy (more_info, reloc_name);
14617                   strcat (more_info, (reloc_dest == DEST_OPD
14618                                       ? " (OPD)" : " (stub)"));
14619                   reloc_name = more_info;
14620                 }
14621             }
14622
14623           if (r == bfd_reloc_overflow)
14624             {
14625               if (warned)
14626                 continue;
14627               if (h != NULL
14628                   && h->elf.root.type == bfd_link_hash_undefweak
14629                   && ppc64_elf_howto_table[r_type]->pc_relative)
14630                 {
14631                   /* Assume this is a call protected by other code that
14632                      detects the symbol is undefined.  If this is the case,
14633                      we can safely ignore the overflow.  If not, the
14634                      program is hosed anyway, and a little warning isn't
14635                      going to help.  */
14636
14637                   continue;
14638                 }
14639
14640               if (!((*info->callbacks->reloc_overflow)
14641                     (info, &h->elf.root, sym_name,
14642                      reloc_name, orig_rel.r_addend,
14643                      input_bfd, input_section, rel->r_offset)))
14644                 return FALSE;
14645             }
14646           else
14647             {
14648               info->callbacks->einfo
14649                 (_("%P: %H: %s against `%T': error %d\n"),
14650                  input_bfd, input_section, rel->r_offset,
14651                  reloc_name, sym_name, (int) r);
14652               ret = FALSE;
14653             }
14654           if (more_info != NULL)
14655             free (more_info);
14656         }
14657     }
14658
14659   /* If we're emitting relocations, then shortly after this function
14660      returns, reloc offsets and addends for this section will be
14661      adjusted.  Worse, reloc symbol indices will be for the output
14662      file rather than the input.  Save a copy of the relocs for
14663      opd_entry_value.  */
14664   if (is_opd && (info->emitrelocations || info->relocatable))
14665     {
14666       bfd_size_type amt;
14667       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14668       rel = bfd_alloc (input_bfd, amt);
14669       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14670       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14671       if (rel == NULL)
14672         return FALSE;
14673       memcpy (rel, relocs, amt);
14674     }
14675   return ret;
14676 }
14677
14678 /* Adjust the value of any local symbols in opd sections.  */
14679
14680 static int
14681 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14682                               const char *name ATTRIBUTE_UNUSED,
14683                               Elf_Internal_Sym *elfsym,
14684                               asection *input_sec,
14685                               struct elf_link_hash_entry *h)
14686 {
14687   struct _opd_sec_data *opd;
14688   long adjust;
14689   bfd_vma value;
14690
14691   if (h != NULL)
14692     return 1;
14693
14694   opd = get_opd_info (input_sec);
14695   if (opd == NULL || opd->adjust == NULL)
14696     return 1;
14697
14698   value = elfsym->st_value - input_sec->output_offset;
14699   if (!info->relocatable)
14700     value -= input_sec->output_section->vma;
14701
14702   adjust = opd->adjust[value / 8];
14703   if (adjust == -1)
14704     return 2;
14705
14706   elfsym->st_value += adjust;
14707   return 1;
14708 }
14709
14710 /* Finish up dynamic symbol handling.  We set the contents of various
14711    dynamic sections here.  */
14712
14713 static bfd_boolean
14714 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14715                                  struct bfd_link_info *info,
14716                                  struct elf_link_hash_entry *h,
14717                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14718 {
14719   struct ppc_link_hash_table *htab;
14720   struct plt_entry *ent;
14721   Elf_Internal_Rela rela;
14722   bfd_byte *loc;
14723
14724   htab = ppc_hash_table (info);
14725   if (htab == NULL)
14726     return FALSE;
14727
14728   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14729     if (ent->plt.offset != (bfd_vma) -1)
14730       {
14731         /* This symbol has an entry in the procedure linkage
14732            table.  Set it up.  */
14733         if (!htab->elf.dynamic_sections_created
14734             || h->dynindx == -1)
14735           {
14736             BFD_ASSERT (h->type == STT_GNU_IFUNC
14737                         && h->def_regular
14738                         && (h->root.type == bfd_link_hash_defined
14739                             || h->root.type == bfd_link_hash_defweak));
14740             rela.r_offset = (htab->elf.iplt->output_section->vma
14741                              + htab->elf.iplt->output_offset
14742                              + ent->plt.offset);
14743             if (htab->opd_abi)
14744               rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14745             else
14746               rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14747             rela.r_addend = (h->root.u.def.value
14748                              + h->root.u.def.section->output_offset
14749                              + h->root.u.def.section->output_section->vma
14750                              + ent->addend);
14751             loc = (htab->elf.irelplt->contents
14752                    + (htab->elf.irelplt->reloc_count++
14753                       * sizeof (Elf64_External_Rela)));
14754           }
14755         else
14756           {
14757             rela.r_offset = (htab->elf.splt->output_section->vma
14758                              + htab->elf.splt->output_offset
14759                              + ent->plt.offset);
14760             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14761             rela.r_addend = ent->addend;
14762             loc = (htab->elf.srelplt->contents
14763                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14764                       / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14765           }
14766         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14767
14768         if (!htab->opd_abi)
14769           {
14770             if (!h->def_regular)
14771               {
14772                 /* Mark the symbol as undefined, rather than as
14773                    defined in glink.  Leave the value if there were
14774                    any relocations where pointer equality matters
14775                    (this is a clue for the dynamic linker, to make
14776                    function pointer comparisons work between an
14777                    application and shared library), otherwise set it
14778                    to zero.  */
14779                 sym->st_shndx = SHN_UNDEF;
14780                 if (!h->pointer_equality_needed)
14781                   sym->st_value = 0;
14782                 else if (!h->ref_regular_nonweak)
14783                   {
14784                     /* This breaks function pointer comparisons, but
14785                        that is better than breaking tests for a NULL
14786                        function pointer.  */
14787                     sym->st_value = 0;
14788                   }
14789               }
14790           }
14791       }
14792
14793   if (h->needs_copy)
14794     {
14795       /* This symbol needs a copy reloc.  Set it up.  */
14796
14797       if (h->dynindx == -1
14798           || (h->root.type != bfd_link_hash_defined
14799               && h->root.type != bfd_link_hash_defweak)
14800           || htab->relbss == NULL)
14801         abort ();
14802
14803       rela.r_offset = (h->root.u.def.value
14804                        + h->root.u.def.section->output_section->vma
14805                        + h->root.u.def.section->output_offset);
14806       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14807       rela.r_addend = 0;
14808       loc = htab->relbss->contents;
14809       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14810       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14811     }
14812
14813   return TRUE;
14814 }
14815
14816 /* Used to decide how to sort relocs in an optimal manner for the
14817    dynamic linker, before writing them out.  */
14818
14819 static enum elf_reloc_type_class
14820 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14821                             const asection *rel_sec,
14822                             const Elf_Internal_Rela *rela)
14823 {
14824   enum elf_ppc64_reloc_type r_type;
14825   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14826
14827   if (rel_sec == htab->elf.irelplt)
14828     return reloc_class_ifunc;
14829
14830   r_type = ELF64_R_TYPE (rela->r_info);
14831   switch (r_type)
14832     {
14833     case R_PPC64_RELATIVE:
14834       return reloc_class_relative;
14835     case R_PPC64_JMP_SLOT:
14836       return reloc_class_plt;
14837     case R_PPC64_COPY:
14838       return reloc_class_copy;
14839     default:
14840       return reloc_class_normal;
14841     }
14842 }
14843
14844 /* Finish up the dynamic sections.  */
14845
14846 static bfd_boolean
14847 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14848                                    struct bfd_link_info *info)
14849 {
14850   struct ppc_link_hash_table *htab;
14851   bfd *dynobj;
14852   asection *sdyn;
14853
14854   htab = ppc_hash_table (info);
14855   if (htab == NULL)
14856     return FALSE;
14857
14858   dynobj = htab->elf.dynobj;
14859   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14860
14861   if (htab->elf.dynamic_sections_created)
14862     {
14863       Elf64_External_Dyn *dyncon, *dynconend;
14864
14865       if (sdyn == NULL || htab->elf.sgot == NULL)
14866         abort ();
14867
14868       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14869       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14870       for (; dyncon < dynconend; dyncon++)
14871         {
14872           Elf_Internal_Dyn dyn;
14873           asection *s;
14874
14875           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14876
14877           switch (dyn.d_tag)
14878             {
14879             default:
14880               continue;
14881
14882             case DT_PPC64_GLINK:
14883               s = htab->glink;
14884               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14885               /* We stupidly defined DT_PPC64_GLINK to be the start
14886                  of glink rather than the first entry point, which is
14887                  what ld.so needs, and now have a bigger stub to
14888                  support automatic multiple TOCs.  */
14889               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14890               break;
14891
14892             case DT_PPC64_OPD:
14893               s = bfd_get_section_by_name (output_bfd, ".opd");
14894               if (s == NULL)
14895                 continue;
14896               dyn.d_un.d_ptr = s->vma;
14897               break;
14898
14899             case DT_PPC64_OPT:
14900               if (htab->do_multi_toc && htab->multi_toc_needed)
14901                 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14902               break;
14903
14904             case DT_PPC64_OPDSZ:
14905               s = bfd_get_section_by_name (output_bfd, ".opd");
14906               if (s == NULL)
14907                 continue;
14908               dyn.d_un.d_val = s->size;
14909               break;
14910
14911             case DT_PLTGOT:
14912               s = htab->elf.splt;
14913               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14914               break;
14915
14916             case DT_JMPREL:
14917               s = htab->elf.srelplt;
14918               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14919               break;
14920
14921             case DT_PLTRELSZ:
14922               dyn.d_un.d_val = htab->elf.srelplt->size;
14923               break;
14924
14925             case DT_RELASZ:
14926               /* Don't count procedure linkage table relocs in the
14927                  overall reloc count.  */
14928               s = htab->elf.srelplt;
14929               if (s == NULL)
14930                 continue;
14931               dyn.d_un.d_val -= s->size;
14932               break;
14933
14934             case DT_RELA:
14935               /* We may not be using the standard ELF linker script.
14936                  If .rela.plt is the first .rela section, we adjust
14937                  DT_RELA to not include it.  */
14938               s = htab->elf.srelplt;
14939               if (s == NULL)
14940                 continue;
14941               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14942                 continue;
14943               dyn.d_un.d_ptr += s->size;
14944               break;
14945             }
14946
14947           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14948         }
14949     }
14950
14951   if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14952     {
14953       /* Fill in the first entry in the global offset table.
14954          We use it to hold the link-time TOCbase.  */
14955       bfd_put_64 (output_bfd,
14956                   elf_gp (output_bfd) + TOC_BASE_OFF,
14957                   htab->elf.sgot->contents);
14958
14959       /* Set .got entry size.  */
14960       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14961     }
14962
14963   if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14964     {
14965       /* Set .plt entry size.  */
14966       elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14967         = PLT_ENTRY_SIZE (htab);
14968     }
14969
14970   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14971      brlt ourselves if emitrelocations.  */
14972   if (htab->brlt != NULL
14973       && htab->brlt->reloc_count != 0
14974       && !_bfd_elf_link_output_relocs (output_bfd,
14975                                        htab->brlt,
14976                                        elf_section_data (htab->brlt)->rela.hdr,
14977                                        elf_section_data (htab->brlt)->relocs,
14978                                        NULL))
14979     return FALSE;
14980
14981   if (htab->glink != NULL
14982       && htab->glink->reloc_count != 0
14983       && !_bfd_elf_link_output_relocs (output_bfd,
14984                                        htab->glink,
14985                                        elf_section_data (htab->glink)->rela.hdr,
14986                                        elf_section_data (htab->glink)->relocs,
14987                                        NULL))
14988     return FALSE;
14989
14990
14991   if (htab->glink_eh_frame != NULL
14992       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14993       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14994                                            htab->glink_eh_frame,
14995                                            htab->glink_eh_frame->contents))
14996     return FALSE;
14997
14998   /* We need to handle writing out multiple GOT sections ourselves,
14999      since we didn't add them to DYNOBJ.  We know dynobj is the first
15000      bfd.  */
15001   while ((dynobj = dynobj->link_next) != NULL)
15002     {
15003       asection *s;
15004
15005       if (!is_ppc64_elf (dynobj))
15006         continue;
15007
15008       s = ppc64_elf_tdata (dynobj)->got;
15009       if (s != NULL
15010           && s->size != 0
15011           && s->output_section != bfd_abs_section_ptr
15012           && !bfd_set_section_contents (output_bfd, s->output_section,
15013                                         s->contents, s->output_offset,
15014                                         s->size))
15015         return FALSE;
15016       s = ppc64_elf_tdata (dynobj)->relgot;
15017       if (s != NULL
15018           && s->size != 0
15019           && s->output_section != bfd_abs_section_ptr
15020           && !bfd_set_section_contents (output_bfd, s->output_section,
15021                                         s->contents, s->output_offset,
15022                                         s->size))
15023         return FALSE;
15024     }
15025
15026   return TRUE;
15027 }
15028
15029 #include "elf64-target.h"
15030
15031 /* FreeBSD support */
15032
15033 #undef  TARGET_LITTLE_SYM
15034 #undef  TARGET_LITTLE_NAME
15035
15036 #undef  TARGET_BIG_SYM
15037 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
15038 #undef  TARGET_BIG_NAME
15039 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15040
15041 #undef  ELF_OSABI
15042 #define ELF_OSABI       ELFOSABI_FREEBSD
15043
15044 #undef  elf64_bed
15045 #define elf64_bed       elf64_powerpc_fbsd_bed
15046
15047 #include "elf64-target.h"
15048