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  _bfd_generic_verify_endian_match
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  99 #define elf_backend_notice_as_needed          ppc64_elf_notice_as_needed
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 109 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 110 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE 24
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 130
 131 /* TOC base pointers offset from start of TOC.  */
 132 #define TOC_BASE_OFF    0x8000
 133
 134 /* Offset of tp and dtp pointers from start of TLS block.  */
 135 #define TP_OFFSET       0x7000
 136 #define DTP_OFFSET      0x8000
 137
 138 /* .plt call stub instructions.  The normal stub is like this, but
 139    sometimes the .plt entry crosses a 64k boundary and we need to
 140    insert an addi to adjust r12.  */
 141 #define PLT_CALL_STUB_SIZE (7*4)
 142 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 143 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 144 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 145 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 146 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 147                                         /* ld    %r11,xxx+16@l(%r12) */
 148 #define BCTR            0x4e800420      /* bctr                      */
 149
 150
 151 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 152 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 153 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 154 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 155
 156 #define XOR_R11_R11_R11 0x7d6b5a78      /* xor   %r11,%r11,%r11  */
 157 #define ADD_R12_R12_R11 0x7d8c5a14      /* add   %r12,%r12,%r11  */
 158 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 159 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 160 #define BNECTR          0x4ca20420      /* bnectr+               */
 161 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 162
 163 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 164 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 165
 166 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 167
 168 /* glink call stub instructions.  We enter with the index in R0.  */
 169 #define GLINK_CALL_STUB_SIZE (16*4)
 170                                         /* 0:                           */
 171                                         /*  .quad plt0-1f               */
 172                                         /* __glink:                     */
 173 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 174 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 175                                         /* 1:                           */
 176 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 177 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 178 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 179 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 180                                         /*  ld %11,0(%12)               */
 181                                         /*  ld %2,8(%12)                */
 182                                         /*  mtctr %11                   */
 183                                         /*  ld %11,16(%12)              */
 184                                         /*  bctr                        */
 185
 186 /* Pad with this.  */
 187 #define NOP             0x60000000
 188
 189 /* Some other nops.  */
 190 #define CROR_151515     0x4def7b82
 191 #define CROR_313131     0x4ffffb82
 192
 193 /* .glink entries for the first 32k functions are two instructions.  */
 194 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 195 #define B_DOT           0x48000000      /* b     .              */
 196
 197 /* After that, we need two instructions to load the index, followed by
 198    a branch.  */
 199 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 200 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 201
 202 /* Instructions used by the save and restore reg functions.  */
 203 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 204 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 205 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 206 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 207 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 208 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 209 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 210 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 211 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 212 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 213 #define BLR             0x4e800020      /* blr                  */
 214
 215 /* Since .opd is an array of descriptors and each entry will end up
 216    with identical R_PPC64_RELATIVE relocs, there is really no need to
 217    propagate .opd relocs;  The dynamic linker should be taught to
 218    relocate .opd without reloc entries.  */
 219 #ifndef NO_OPD_RELOCS
 220 #define NO_OPD_RELOCS 0
 221 #endif
 222 \f
 223 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 224
 225 /* Relocation HOWTO's.  */
 226 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 227
 228 static reloc_howto_type ppc64_elf_howto_raw[] = {
 229   /* This reloc does nothing.  */
 230   HOWTO (R_PPC64_NONE,          /* type */
 231          0,                     /* rightshift */
 232          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 233          32,                    /* bitsize */
 234          FALSE,                 /* pc_relative */
 235          0,                     /* bitpos */
 236          complain_overflow_dont, /* complain_on_overflow */
 237          bfd_elf_generic_reloc, /* special_function */
 238          "R_PPC64_NONE",        /* name */
 239          FALSE,                 /* partial_inplace */
 240          0,                     /* src_mask */
 241          0,                     /* dst_mask */
 242          FALSE),                /* pcrel_offset */
 243
 244   /* A standard 32 bit relocation.  */
 245   HOWTO (R_PPC64_ADDR32,        /* type */
 246          0,                     /* rightshift */
 247          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 248          32,                    /* bitsize */
 249          FALSE,                 /* pc_relative */
 250          0,                     /* bitpos */
 251          complain_overflow_bitfield, /* complain_on_overflow */
 252          bfd_elf_generic_reloc, /* special_function */
 253          "R_PPC64_ADDR32",      /* name */
 254          FALSE,                 /* partial_inplace */
 255          0,                     /* src_mask */
 256          0xffffffff,            /* dst_mask */
 257          FALSE),                /* pcrel_offset */
 258
 259   /* An absolute 26 bit branch; the lower two bits must be zero.
 260      FIXME: we don't check that, we just clear them.  */
 261   HOWTO (R_PPC64_ADDR24,        /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          26,                    /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_bitfield, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_PPC64_ADDR24",      /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0x03fffffc,            /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* A standard 16 bit relocation.  */
 276   HOWTO (R_PPC64_ADDR16,        /* type */
 277          0,                     /* rightshift */
 278          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          16,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_bitfield, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_PPC64_ADDR16",      /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0xffff,                /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* A 16 bit relocation without overflow.  */
 291   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 292          0,                     /* rightshift */
 293          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 294          16,                    /* bitsize */
 295          FALSE,                 /* pc_relative */
 296          0,                     /* bitpos */
 297          complain_overflow_dont,/* complain_on_overflow */
 298          bfd_elf_generic_reloc, /* special_function */
 299          "R_PPC64_ADDR16_LO",   /* name */
 300          FALSE,                 /* partial_inplace */
 301          0,                     /* src_mask */
 302          0xffff,                /* dst_mask */
 303          FALSE),                /* pcrel_offset */
 304
 305   /* Bits 16-31 of an address.  */
 306   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 307          16,                    /* rightshift */
 308          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 309          16,                    /* bitsize */
 310          FALSE,                 /* pc_relative */
 311          0,                     /* bitpos */
 312          complain_overflow_dont, /* complain_on_overflow */
 313          bfd_elf_generic_reloc, /* special_function */
 314          "R_PPC64_ADDR16_HI",   /* name */
 315          FALSE,                 /* partial_inplace */
 316          0,                     /* src_mask */
 317          0xffff,                /* dst_mask */
 318          FALSE),                /* pcrel_offset */
 319
 320   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 321      bits, treated as a signed number, is negative.  */
 322   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 323          16,                    /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_dont, /* complain_on_overflow */
 329          ppc64_elf_ha_reloc,    /* special_function */
 330          "R_PPC64_ADDR16_HA",   /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* An absolute 16 bit branch; the lower two bits must be zero.
 337      FIXME: we don't check that, we just clear them.  */
 338   HOWTO (R_PPC64_ADDR14,        /* type */
 339          0,                     /* rightshift */
 340          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield, /* complain_on_overflow */
 345          ppc64_elf_branch_reloc, /* special_function */
 346          "R_PPC64_ADDR14",      /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0x0000fffc,            /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* An absolute 16 bit branch, for which bit 10 should be set to
 353      indicate that the branch is expected to be taken.  The lower two
 354      bits must be zero.  */
 355   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* 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_brtaken_reloc, /* special_function */
 363          "R_PPC64_ADDR14_BRTAKEN",/* 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 not expected to be taken.  The lower
 371      two bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* 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_BRNTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* A relative 26 bit branch; the lower two bits must be zero.  */
 387   HOWTO (R_PPC64_REL24,         /* type */
 388          0,                     /* rightshift */
 389          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          26,                    /* bitsize */
 391          TRUE,                  /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_signed, /* complain_on_overflow */
 394          ppc64_elf_branch_reloc, /* special_function */
 395          "R_PPC64_REL24",       /* name */
 396          FALSE,                 /* partial_inplace */
 397          0,                     /* src_mask */
 398          0x03fffffc,            /* dst_mask */
 399          TRUE),                 /* pcrel_offset */
 400
 401   /* A relative 16 bit branch; the lower two bits must be zero.  */
 402   HOWTO (R_PPC64_REL14,         /* type */
 403          0,                     /* rightshift */
 404          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 405          16,                    /* bitsize */
 406          TRUE,                  /* pc_relative */
 407          0,                     /* bitpos */
 408          complain_overflow_signed, /* complain_on_overflow */
 409          ppc64_elf_branch_reloc, /* special_function */
 410          "R_PPC64_REL14",       /* name */
 411          FALSE,                 /* partial_inplace */
 412          0,                     /* src_mask */
 413          0x0000fffc,            /* dst_mask */
 414          TRUE),                 /* pcrel_offset */
 415
 416   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 417      the branch is expected to be taken.  The lower two bits must be
 418      zero.  */
 419   HOWTO (R_PPC64_REL14_BRTAKEN, /* 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_brtaken_reloc, /* special_function */
 427          "R_PPC64_REL14_BRTAKEN", /* 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 not expected to be taken.  The lower two bits must
 435      be zero.  */
 436   HOWTO (R_PPC64_REL14_BRNTAKEN, /* 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_BRNTAKEN",/* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 451      symbol.  */
 452   HOWTO (R_PPC64_GOT16,         /* type */
 453          0,                     /* rightshift */
 454          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          16,                    /* bitsize */
 456          FALSE,                 /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_signed, /* complain_on_overflow */
 459          ppc64_elf_unhandled_reloc, /* special_function */
 460          "R_PPC64_GOT16",       /* name */
 461          FALSE,                 /* partial_inplace */
 462          0,                     /* src_mask */
 463          0xffff,                /* dst_mask */
 464          FALSE),                /* pcrel_offset */
 465
 466   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 467      the symbol.  */
 468   HOWTO (R_PPC64_GOT16_LO,      /* type */
 469          0,                     /* rightshift */
 470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_dont, /* complain_on_overflow */
 475          ppc64_elf_unhandled_reloc, /* special_function */
 476          "R_PPC64_GOT16_LO",    /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0xffff,                /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 483      the symbol.  */
 484   HOWTO (R_PPC64_GOT16_HI,      /* type */
 485          16,                    /* rightshift */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont,/* complain_on_overflow */
 491          ppc64_elf_unhandled_reloc, /* special_function */
 492          "R_PPC64_GOT16_HI",    /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0xffff,                /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 499      the symbol.  */
 500   HOWTO (R_PPC64_GOT16_HA,      /* type */
 501          16,                    /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_dont,/* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16_HA",    /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* This is used only by the dynamic linker.  The symbol should exist
 515      both in the object being run and in some shared library.  The
 516      dynamic linker copies the data addressed by the symbol from the
 517      shared library into the object, because the object being
 518      run has to have the data at some particular address.  */
 519   HOWTO (R_PPC64_COPY,          /* type */
 520          0,                     /* rightshift */
 521          0,                     /* this one is variable size */
 522          0,                     /* bitsize */
 523          FALSE,                 /* pc_relative */
 524          0,                     /* bitpos */
 525          complain_overflow_dont, /* complain_on_overflow */
 526          ppc64_elf_unhandled_reloc, /* special_function */
 527          "R_PPC64_COPY",        /* name */
 528          FALSE,                 /* partial_inplace */
 529          0,                     /* src_mask */
 530          0,                     /* dst_mask */
 531          FALSE),                /* pcrel_offset */
 532
 533   /* Like R_PPC64_ADDR64, but used when setting global offset table
 534      entries.  */
 535   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 536          0,                     /* rightshift */
 537          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 538          64,                    /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_dont, /* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc,  /* special_function */
 543          "R_PPC64_GLOB_DAT",    /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          ONES (64),             /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* Created by the link editor.  Marks a procedure linkage table
 550      entry for a symbol.  */
 551   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 552          0,                     /* rightshift */
 553          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 554          0,                     /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont, /* complain_on_overflow */
 558          ppc64_elf_unhandled_reloc, /* special_function */
 559          "R_PPC64_JMP_SLOT",    /* name */
 560          FALSE,                 /* partial_inplace */
 561          0,                     /* src_mask */
 562          0,                     /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564
 565   /* Used only by the dynamic linker.  When the object is run, this
 566      doubleword64 is set to the load address of the object, plus the
 567      addend.  */
 568   HOWTO (R_PPC64_RELATIVE,      /* type */
 569          0,                     /* rightshift */
 570          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 571          64,                    /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          bfd_elf_generic_reloc, /* special_function */
 576          "R_PPC64_RELATIVE",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          ONES (64),             /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 583   HOWTO (R_PPC64_UADDR32,       /* type */
 584          0,                     /* rightshift */
 585          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 586          32,                    /* bitsize */
 587          FALSE,                 /* pc_relative */
 588          0,                     /* bitpos */
 589          complain_overflow_bitfield, /* complain_on_overflow */
 590          bfd_elf_generic_reloc, /* special_function */
 591          "R_PPC64_UADDR32",     /* name */
 592          FALSE,                 /* partial_inplace */
 593          0,                     /* src_mask */
 594          0xffffffff,            /* dst_mask */
 595          FALSE),                /* pcrel_offset */
 596
 597   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 598   HOWTO (R_PPC64_UADDR16,       /* type */
 599          0,                     /* rightshift */
 600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 601          16,                    /* bitsize */
 602          FALSE,                 /* pc_relative */
 603          0,                     /* bitpos */
 604          complain_overflow_bitfield, /* complain_on_overflow */
 605          bfd_elf_generic_reloc, /* special_function */
 606          "R_PPC64_UADDR16",     /* name */
 607          FALSE,                 /* partial_inplace */
 608          0,                     /* src_mask */
 609          0xffff,                /* dst_mask */
 610          FALSE),                /* pcrel_offset */
 611
 612   /* 32-bit PC relative.  */
 613   HOWTO (R_PPC64_REL32,         /* type */
 614          0,                     /* rightshift */
 615          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 616          32,                    /* bitsize */
 617          TRUE,                  /* pc_relative */
 618          0,                     /* bitpos */
 619          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 620          complain_overflow_signed, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_REL32",       /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffffffff,            /* dst_mask */
 626          TRUE),                 /* pcrel_offset */
 627
 628   /* 32-bit relocation to the symbol's procedure linkage table.  */
 629   HOWTO (R_PPC64_PLT32,         /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          FALSE,                 /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_bitfield, /* complain_on_overflow */
 636          ppc64_elf_unhandled_reloc, /* special_function */
 637          "R_PPC64_PLT32",       /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          FALSE),                /* pcrel_offset */
 642
 643   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 644      FIXME: R_PPC64_PLTREL32 not supported.  */
 645   HOWTO (R_PPC64_PLTREL32,      /* type */
 646          0,                     /* rightshift */
 647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          32,                    /* bitsize */
 649          TRUE,                  /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_signed, /* complain_on_overflow */
 652          bfd_elf_generic_reloc, /* special_function */
 653          "R_PPC64_PLTREL32",    /* name */
 654          FALSE,                 /* partial_inplace */
 655          0,                     /* src_mask */
 656          0xffffffff,            /* dst_mask */
 657          TRUE),                 /* pcrel_offset */
 658
 659   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 660      the symbol.  */
 661   HOWTO (R_PPC64_PLT16_LO,      /* type */
 662          0,                     /* rightshift */
 663          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          16,                    /* bitsize */
 665          FALSE,                 /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_dont, /* complain_on_overflow */
 668          ppc64_elf_unhandled_reloc, /* special_function */
 669          "R_PPC64_PLT16_LO",    /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffff,                /* dst_mask */
 673          FALSE),                /* pcrel_offset */
 674
 675   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 676      the symbol.  */
 677   HOWTO (R_PPC64_PLT16_HI,      /* type */
 678          16,                    /* rightshift */
 679          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          16,                    /* bitsize */
 681          FALSE,                 /* pc_relative */
 682          0,                     /* bitpos */
 683          complain_overflow_dont, /* complain_on_overflow */
 684          ppc64_elf_unhandled_reloc, /* special_function */
 685          "R_PPC64_PLT16_HI",    /* name */
 686          FALSE,                 /* partial_inplace */
 687          0,                     /* src_mask */
 688          0xffff,                /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 692      the symbol.  */
 693   HOWTO (R_PPC64_PLT16_HA,      /* type */
 694          16,                    /* rightshift */
 695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 696          16,                    /* bitsize */
 697          FALSE,                 /* pc_relative */
 698          0,                     /* bitpos */
 699          complain_overflow_dont, /* complain_on_overflow */
 700          ppc64_elf_unhandled_reloc, /* special_function */
 701          "R_PPC64_PLT16_HA",    /* name */
 702          FALSE,                 /* partial_inplace */
 703          0,                     /* src_mask */
 704          0xffff,                /* dst_mask */
 705          FALSE),                /* pcrel_offset */
 706
 707   /* 16-bit section relative relocation.  */
 708   HOWTO (R_PPC64_SECTOFF,       /* type */
 709          0,                     /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_bitfield, /* complain_on_overflow */
 715          ppc64_elf_sectoff_reloc, /* special_function */
 716          "R_PPC64_SECTOFF",     /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 723   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 724          0,                     /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_dont, /* complain_on_overflow */
 730          ppc64_elf_sectoff_reloc, /* special_function */
 731          "R_PPC64_SECTOFF_LO",  /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* 16-bit upper half section relative relocation.  */
 738   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 739          16,                    /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF_HI",  /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit upper half adjusted section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 754          16,                    /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_dont, /* complain_on_overflow */
 760          ppc64_elf_sectoff_ha_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_HA",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 768   HOWTO (R_PPC64_REL30,         /* type */
 769          2,                     /* rightshift */
 770          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          30,                    /* bitsize */
 772          TRUE,                  /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont, /* complain_on_overflow */
 775          bfd_elf_generic_reloc, /* special_function */
 776          "R_PPC64_REL30",       /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xfffffffc,            /* dst_mask */
 780          TRUE),                 /* pcrel_offset */
 781
 782   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 783
 784   /* A standard 64-bit relocation.  */
 785   HOWTO (R_PPC64_ADDR64,        /* type */
 786          0,                     /* rightshift */
 787          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 788          64,                    /* bitsize */
 789          FALSE,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_PPC64_ADDR64",      /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          ONES (64),             /* dst_mask */
 797          FALSE),                /* pcrel_offset */
 798
 799   /* The bits 32-47 of an address.  */
 800   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 801          32,                    /* rightshift */
 802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_PPC64_ADDR16_HIGHER", /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* The bits 32-47 of an address, plus 1 if the contents of the low
 815      16 bits, treated as a signed number, is negative.  */
 816   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 817          32,                    /* rightshift */
 818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          16,                    /* bitsize */
 820          FALSE,                 /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_dont, /* complain_on_overflow */
 823          ppc64_elf_ha_reloc,    /* special_function */
 824          "R_PPC64_ADDR16_HIGHERA", /* name */
 825          FALSE,                 /* partial_inplace */
 826          0,                     /* src_mask */
 827          0xffff,                /* dst_mask */
 828          FALSE),                /* pcrel_offset */
 829
 830   /* The bits 48-63 of an address.  */
 831   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 832          48,                    /* rightshift */
 833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 834          16,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          bfd_elf_generic_reloc, /* special_function */
 839          "R_PPC64_ADDR16_HIGHEST", /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          0xffff,                /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 48-63 of an address, plus 1 if the contents of the low
 846      16 bits, treated as a signed number, is negative.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 848          48,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          ppc64_elf_ha_reloc,    /* special_function */
 855          "R_PPC64_ADDR16_HIGHESTA", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* Like ADDR64, but may be unaligned.  */
 862   HOWTO (R_PPC64_UADDR64,       /* type */
 863          0,                     /* rightshift */
 864          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 865          64,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          bfd_elf_generic_reloc, /* special_function */
 870          "R_PPC64_UADDR64",     /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          ONES (64),             /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* 64-bit relative relocation.  */
 877   HOWTO (R_PPC64_REL64,         /* type */
 878          0,                     /* rightshift */
 879          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 880          64,                    /* bitsize */
 881          TRUE,                  /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_REL64",       /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          ONES (64),             /* dst_mask */
 889          TRUE),                 /* pcrel_offset */
 890
 891   /* 64-bit relocation to the symbol's procedure linkage table.  */
 892   HOWTO (R_PPC64_PLT64,         /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          ppc64_elf_unhandled_reloc, /* special_function */
 900          "R_PPC64_PLT64",       /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   /* 64-bit PC relative relocation to the symbol's procedure linkage
 907      table.  */
 908   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 909   HOWTO (R_PPC64_PLTREL64,      /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          TRUE,                  /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          ppc64_elf_unhandled_reloc, /* special_function */
 917          "R_PPC64_PLTREL64",    /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          TRUE),                 /* pcrel_offset */
 922
 923   /* 16 bit TOC-relative relocation.  */
 924
 925   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 926   HOWTO (R_PPC64_TOC16,         /* type */
 927          0,                     /* rightshift */
 928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 929          16,                    /* bitsize */
 930          FALSE,                 /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_signed, /* complain_on_overflow */
 933          ppc64_elf_toc_reloc,   /* special_function */
 934          "R_PPC64_TOC16",       /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          0xffff,                /* dst_mask */
 938          FALSE),                /* pcrel_offset */
 939
 940   /* 16 bit TOC-relative relocation without overflow.  */
 941
 942   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 943   HOWTO (R_PPC64_TOC16_LO,      /* 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_dont, /* complain_on_overflow */
 950          ppc64_elf_toc_reloc,   /* special_function */
 951          "R_PPC64_TOC16_LO",    /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          0xffff,                /* dst_mask */
 955          FALSE),                /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation, high 16 bits.  */
 958
 959   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 960   HOWTO (R_PPC64_TOC16_HI,      /* type */
 961          16,                    /* 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_HI",    /* 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, plus 1 if the
 975      contents of the low 16 bits, treated as a signed number, is
 976      negative.  */
 977
 978   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 979   HOWTO (R_PPC64_TOC16_HA,      /* type */
 980          16,                    /* rightshift */
 981          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 982          16,                    /* bitsize */
 983          FALSE,                 /* pc_relative */
 984          0,                     /* bitpos */
 985          complain_overflow_dont, /* complain_on_overflow */
 986          ppc64_elf_toc_ha_reloc, /* special_function */
 987          "R_PPC64_TOC16_HA",    /* name */
 988          FALSE,                 /* partial_inplace */
 989          0,                     /* src_mask */
 990          0xffff,                /* dst_mask */
 991          FALSE),                /* pcrel_offset */
 992
 993   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 994
 995   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 996   HOWTO (R_PPC64_TOC,           /* type */
 997          0,                     /* rightshift */
 998          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 999          64,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_bitfield, /* complain_on_overflow */
1003          ppc64_elf_toc64_reloc, /* special_function */
1004          "R_PPC64_TOC",         /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          ONES (64),             /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* Like R_PPC64_GOT16, but also informs the link editor that the
1011      value to relocate may (!) refer to a PLT entry which the link
1012      editor (a) may replace with the symbol value.  If the link editor
1013      is unable to fully resolve the symbol, it may (b) create a PLT
1014      entry and store the address to the new PLT entry in the GOT.
1015      This permits lazy resolution of function symbols at run time.
1016      The link editor may also skip all of this and just (c) emit a
1017      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1018   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1019     HOWTO (R_PPC64_PLTGOT16,    /* type */
1020          0,                     /* rightshift */
1021          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1022          16,                    /* bitsize */
1023          FALSE,                 /* pc_relative */
1024          0,                     /* bitpos */
1025          complain_overflow_signed, /* complain_on_overflow */
1026          ppc64_elf_unhandled_reloc, /* special_function */
1027          "R_PPC64_PLTGOT16",    /* name */
1028          FALSE,                 /* partial_inplace */
1029          0,                     /* src_mask */
1030          0xffff,                /* dst_mask */
1031          FALSE),                /* pcrel_offset */
1032
1033   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1034   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1035   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1036          0,                     /* rightshift */
1037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          16,                    /* bitsize */
1039          FALSE,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_dont, /* complain_on_overflow */
1042          ppc64_elf_unhandled_reloc, /* special_function */
1043          "R_PPC64_PLTGOT16_LO", /* name */
1044          FALSE,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          0xffff,                /* dst_mask */
1047          FALSE),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1050   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1051   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1052          16,                    /* rightshift */
1053          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1054          16,                    /* bitsize */
1055          FALSE,                 /* pc_relative */
1056          0,                     /* bitpos */
1057          complain_overflow_dont, /* complain_on_overflow */
1058          ppc64_elf_unhandled_reloc, /* special_function */
1059          "R_PPC64_PLTGOT16_HI", /* name */
1060          FALSE,                 /* partial_inplace */
1061          0,                     /* src_mask */
1062          0xffff,                /* dst_mask */
1063          FALSE),                /* pcrel_offset */
1064
1065   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1066      1 if the contents of the low 16 bits, treated as a signed number,
1067      is negative.  */
1068   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1069   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1070          16,                    /* rightshift */
1071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1072          16,                    /* bitsize */
1073          FALSE,                 /* pc_relative */
1074          0,                     /* bitpos */
1075          complain_overflow_dont,/* complain_on_overflow */
1076          ppc64_elf_unhandled_reloc, /* special_function */
1077          "R_PPC64_PLTGOT16_HA", /* name */
1078          FALSE,                 /* partial_inplace */
1079          0,                     /* src_mask */
1080          0xffff,                /* dst_mask */
1081          FALSE),                /* pcrel_offset */
1082
1083   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1084   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1085          0,                     /* rightshift */
1086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          16,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_bitfield, /* complain_on_overflow */
1091          bfd_elf_generic_reloc, /* special_function */
1092          "R_PPC64_ADDR16_DS",   /* name */
1093          FALSE,                 /* partial_inplace */
1094          0,                     /* src_mask */
1095          0xfffc,                /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1099   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1100          0,                     /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_dont,/* complain_on_overflow */
1106          bfd_elf_generic_reloc, /* special_function */
1107          "R_PPC64_ADDR16_LO_DS",/* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xfffc,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_GOT16_DS,      /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_signed, /* complain_on_overflow */
1121          ppc64_elf_unhandled_reloc, /* special_function */
1122          "R_PPC64_GOT16_DS",    /* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_dont, /* complain_on_overflow */
1136          ppc64_elf_unhandled_reloc, /* special_function */
1137          "R_PPC64_GOT16_LO_DS", /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_PLT16_LO_DS", /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_bitfield, /* complain_on_overflow */
1166          ppc64_elf_sectoff_reloc, /* special_function */
1167          "R_PPC64_SECTOFF_DS",  /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_dont, /* complain_on_overflow */
1181          ppc64_elf_sectoff_reloc, /* special_function */
1182          "R_PPC64_SECTOFF_LO_DS",/* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_TOC16_DS,      /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_signed, /* complain_on_overflow */
1196          ppc64_elf_toc_reloc,   /* special_function */
1197          "R_PPC64_TOC16_DS",    /* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_dont, /* complain_on_overflow */
1211          ppc64_elf_toc_reloc,   /* special_function */
1212          "R_PPC64_TOC16_LO_DS", /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1219   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1220   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1221          0,                     /* rightshift */
1222          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1223          16,                    /* bitsize */
1224          FALSE,                 /* pc_relative */
1225          0,                     /* bitpos */
1226          complain_overflow_signed, /* complain_on_overflow */
1227          ppc64_elf_unhandled_reloc, /* special_function */
1228          "R_PPC64_PLTGOT16_DS", /* name */
1229          FALSE,                 /* partial_inplace */
1230          0,                     /* src_mask */
1231          0xfffc,                /* dst_mask */
1232          FALSE),                /* pcrel_offset */
1233
1234   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1235   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1236   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_dont, /* complain_on_overflow */
1243          ppc64_elf_unhandled_reloc, /* special_function */
1244          "R_PPC64_PLTGOT16_LO_DS",/* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Marker relocs for TLS.  */
1251   HOWTO (R_PPC64_TLS,
1252          0,                     /* rightshift */
1253          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          32,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          bfd_elf_generic_reloc, /* special_function */
1259          "R_PPC64_TLS",         /* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0,                     /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   HOWTO (R_PPC64_TLSGD,
1266          0,                     /* rightshift */
1267          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1268          32,                    /* bitsize */
1269          FALSE,                 /* pc_relative */
1270          0,                     /* bitpos */
1271          complain_overflow_dont, /* complain_on_overflow */
1272          bfd_elf_generic_reloc, /* special_function */
1273          "R_PPC64_TLSGD",       /* name */
1274          FALSE,                 /* partial_inplace */
1275          0,                     /* src_mask */
1276          0,                     /* dst_mask */
1277          FALSE),                /* pcrel_offset */
1278
1279   HOWTO (R_PPC64_TLSLD,
1280          0,                     /* rightshift */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          32,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC64_TLSLD",       /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0,                     /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   HOWTO (R_PPC64_TOCSAVE,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TOCSAVE",     /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   /* Computes the load module index of the load module that contains the
1308      definition of its TLS sym.  */
1309   HOWTO (R_PPC64_DTPMOD64,
1310          0,                     /* rightshift */
1311          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1312          64,                    /* bitsize */
1313          FALSE,                 /* pc_relative */
1314          0,                     /* bitpos */
1315          complain_overflow_dont, /* complain_on_overflow */
1316          ppc64_elf_unhandled_reloc, /* special_function */
1317          "R_PPC64_DTPMOD64",    /* name */
1318          FALSE,                 /* partial_inplace */
1319          0,                     /* src_mask */
1320          ONES (64),             /* dst_mask */
1321          FALSE),                /* pcrel_offset */
1322
1323   /* Computes a dtv-relative displacement, the difference between the value
1324      of sym+add and the base address of the thread-local storage block that
1325      contains the definition of sym, minus 0x8000.  */
1326   HOWTO (R_PPC64_DTPREL64,
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_DTPREL64",    /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          ONES (64),             /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* A 16 bit dtprel reloc.  */
1341   HOWTO (R_PPC64_DTPREL16,
1342          0,                     /* rightshift */
1343          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          16,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_signed, /* complain_on_overflow */
1348          ppc64_elf_unhandled_reloc, /* special_function */
1349          "R_PPC64_DTPREL16",    /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          0xffff,                /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* Like DTPREL16, but no overflow.  */
1356   HOWTO (R_PPC64_DTPREL16_LO,
1357          0,                     /* rightshift */
1358          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          16,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_dont, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL16_LO", /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0xffff,                /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1371   HOWTO (R_PPC64_DTPREL16_HI,
1372          16,                    /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16_HI", /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1386   HOWTO (R_PPC64_DTPREL16_HA,
1387          16,                    /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_dont, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_HA", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HIGHER,
1402          32,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_dont, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HIGHER", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1417          32,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_dont, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HIGHERA", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1432          48,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHEST", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1447          48,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16, but for insns with a DS field.  */
1461   HOWTO (R_PPC64_DTPREL16_DS,
1462          0,                     /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_signed, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_DS", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xfffc,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16_DS, but no overflow.  */
1476   HOWTO (R_PPC64_DTPREL16_LO_DS,
1477          0,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_dont, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_LO_DS", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xfffc,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Computes a tp-relative displacement, the difference between the value of
1491      sym+add and the value of the thread pointer (r13).  */
1492   HOWTO (R_PPC64_TPREL64,
1493          0,                     /* rightshift */
1494          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          64,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          ppc64_elf_unhandled_reloc, /* special_function */
1500          "R_PPC64_TPREL64",     /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          ONES (64),             /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* A 16 bit tprel reloc.  */
1507   HOWTO (R_PPC64_TPREL16,
1508          0,                     /* rightshift */
1509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          16,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_signed, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_TPREL16",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          0xffff,                /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* Like TPREL16, but no overflow.  */
1522   HOWTO (R_PPC64_TPREL16_LO,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_dont, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL16_LO",  /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1537   HOWTO (R_PPC64_TPREL16_HI,
1538          16,                    /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16_HI",  /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1552   HOWTO (R_PPC64_TPREL16_HA,
1553          16,                    /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_dont, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_HA",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HIGHER,
1568          32,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_dont, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HIGHER",      /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HIGHERA,
1583          32,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_dont, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HIGHERA", /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHEST,
1598          48,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHEST", /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1613          48,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHESTA", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16, but for insns with a DS field.  */
1627   HOWTO (R_PPC64_TPREL16_DS,
1628          0,                     /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_signed, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_DS",  /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xfffc,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16_DS, but no overflow.  */
1642   HOWTO (R_PPC64_TPREL16_LO_DS,
1643          0,                     /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_dont, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_LO_DS", /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xfffc,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1657      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1658      to the first entry relative to the TOC base (r2).  */
1659   HOWTO (R_PPC64_GOT_TLSGD16,
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_signed, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_GOT_TLSGD16", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xffff,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Like GOT_TLSGD16, but no overflow.  */
1674   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1675          0,                     /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_dont, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_GOT_TLSGD16_LO", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1689   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1690          16,                    /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16_HI", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1705          16,                    /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_dont, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_HA", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1719      with values (sym+add)@dtpmod and zero, and computes the offset to the
1720      first entry relative to the TOC base (r2).  */
1721   HOWTO (R_PPC64_GOT_TLSLD16,
1722          0,                     /* 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_TLSLD16", /* name */
1730          FALSE,                 /* partial_inplace */
1731          0,                     /* src_mask */
1732          0xffff,                /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* Like GOT_TLSLD16, but no overflow.  */
1736   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_dont, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSLD16_LO", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1751   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1752          16,                    /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16_HI", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1767          16,                    /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_dont, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_HA", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1781      the offset to the entry relative to the TOC base (r2).  */
1782   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1783          0,                     /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_DTPREL16_DS", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xfffc,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Like GOT_DTPREL16_DS, but no overflow.  */
1797   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1798          0,                     /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_dont, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xfffc,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1813          16,                    /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_dont, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_HI", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xffff,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1828          16,                    /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_dont, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_HA", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xffff,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1842      offset to the entry relative to the TOC base (r2).  */
1843   HOWTO (R_PPC64_GOT_TPREL16_DS,
1844          0,                     /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_TPREL16_DS", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xfffc,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Like GOT_TPREL16_DS, but no overflow.  */
1858   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1859          0,                     /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_dont, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xfffc,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1873   HOWTO (R_PPC64_GOT_TPREL16_HI,
1874          16,                    /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_dont, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_HI", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xffff,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_HA,
1889          16,                    /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_dont, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_HA", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xffff,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   HOWTO (R_PPC64_JMP_IREL,      /* type */
1903          0,                     /* rightshift */
1904          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1905          0,                     /* bitsize */
1906          FALSE,                 /* pc_relative */
1907          0,                     /* bitpos */
1908          complain_overflow_dont, /* complain_on_overflow */
1909          ppc64_elf_unhandled_reloc, /* special_function */
1910          "R_PPC64_JMP_IREL",    /* name */
1911          FALSE,                 /* partial_inplace */
1912          0,                     /* src_mask */
1913          0,                     /* dst_mask */
1914          FALSE),                /* pcrel_offset */
1915
1916   HOWTO (R_PPC64_IRELATIVE,     /* type */
1917          0,                     /* rightshift */
1918          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1919          64,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_dont, /* complain_on_overflow */
1923          bfd_elf_generic_reloc, /* special_function */
1924          "R_PPC64_IRELATIVE",   /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          ONES (64),             /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* A 16 bit relative relocation.  */
1931   HOWTO (R_PPC64_REL16,         /* type */
1932          0,                     /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          TRUE,                  /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_bitfield, /* complain_on_overflow */
1938          bfd_elf_generic_reloc, /* special_function */
1939          "R_PPC64_REL16",       /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          TRUE),                 /* pcrel_offset */
1944
1945   /* A 16 bit relative relocation without overflow.  */
1946   HOWTO (R_PPC64_REL16_LO,      /* type */
1947          0,                     /* rightshift */
1948          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1949          16,                    /* bitsize */
1950          TRUE,                  /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_dont,/* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_REL16_LO",    /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          0xffff,                /* dst_mask */
1958          TRUE),                 /* pcrel_offset */
1959
1960   /* The high order 16 bits of a relative address.  */
1961   HOWTO (R_PPC64_REL16_HI,      /* type */
1962          16,                    /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont, /* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16_HI",    /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* The high order 16 bits of a relative address, plus 1 if the contents of
1976      the low 16 bits, treated as a signed number, is negative.  */
1977   HOWTO (R_PPC64_REL16_HA,      /* type */
1978          16,                    /* rightshift */
1979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1980          16,                    /* bitsize */
1981          TRUE,                  /* pc_relative */
1982          0,                     /* bitpos */
1983          complain_overflow_dont, /* complain_on_overflow */
1984          ppc64_elf_ha_reloc,    /* special_function */
1985          "R_PPC64_REL16_HA",    /* name */
1986          FALSE,                 /* partial_inplace */
1987          0,                     /* src_mask */
1988          0xffff,                /* dst_mask */
1989          TRUE),                 /* pcrel_offset */
1990
1991   /* GNU extension to record C++ vtable hierarchy.  */
1992   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1993          0,                     /* rightshift */
1994          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          0,                     /* bitsize */
1996          FALSE,                 /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_dont, /* complain_on_overflow */
1999          NULL,                  /* special_function */
2000          "R_PPC64_GNU_VTINHERIT", /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0,                     /* dst_mask */
2004          FALSE),                /* pcrel_offset */
2005
2006   /* GNU extension to record C++ vtable member usage.  */
2007   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2008          0,                     /* rightshift */
2009          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          0,                     /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont, /* complain_on_overflow */
2014          NULL,                  /* special_function */
2015          "R_PPC64_GNU_VTENTRY", /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0,                     /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020 };
2021
2022 \f
2023 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2024    be done.  */
2025
2026 static void
2027 ppc_howto_init (void)
2028 {
2029   unsigned int i, type;
2030
2031   for (i = 0;
2032        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2033        i++)
2034     {
2035       type = ppc64_elf_howto_raw[i].type;
2036       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2037                           / sizeof (ppc64_elf_howto_table[0])));
2038       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2039     }
2040 }
2041
2042 static reloc_howto_type *
2043 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2044                              bfd_reloc_code_real_type code)
2045 {
2046   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2047
2048   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2049     /* Initialize howto table if needed.  */
2050     ppc_howto_init ();
2051
2052   switch (code)
2053     {
2054     default:
2055       return NULL;
2056
2057     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2058       break;
2059     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2060       break;
2061     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2062       break;
2063     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2064       break;
2065     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2066       break;
2067     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2068       break;
2069     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2070       break;
2071     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2072       break;
2073     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2074       break;
2075     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2076       break;
2077     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2078       break;
2079     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2080       break;
2081     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2082       break;
2083     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2084       break;
2085     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2086       break;
2087     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2088       break;
2089     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2090       break;
2091     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2092       break;
2093     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2094       break;
2095     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2096       break;
2097     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2098       break;
2099     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2100       break;
2101     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2102       break;
2103     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2104       break;
2105     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2106       break;
2107     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2108       break;
2109     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2110       break;
2111     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2112       break;
2113     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2114       break;
2115     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2116       break;
2117     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2118       break;
2119     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2120       break;
2121     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2122       break;
2123     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2124       break;
2125     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2126       break;
2127     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2128       break;
2129     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2130       break;
2131     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2132       break;
2133     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2134       break;
2135     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2136       break;
2137     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2138       break;
2139     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2140       break;
2141     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2142       break;
2143     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2144       break;
2145     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2146       break;
2147     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2148       break;
2149     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2150       break;
2151     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2152       break;
2153     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2154       break;
2155     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2156       break;
2157     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2158       break;
2159     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2160       break;
2161     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2162       break;
2163     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2164       break;
2165     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2166       break;
2167     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2168       break;
2169     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2170       break;
2171     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2172       break;
2173     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2174       break;
2175     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2176       break;
2177     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2178       break;
2179     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2180       break;
2181     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2182       break;
2183     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2184       break;
2185     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2186       break;
2187     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2188       break;
2189     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2190       break;
2191     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2192       break;
2193     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2194       break;
2195     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2196       break;
2197     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2198       break;
2199     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2200       break;
2201     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2204       break;
2205     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2206       break;
2207     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2208       break;
2209     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2210       break;
2211     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2212       break;
2213     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2214       break;
2215     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2216       break;
2217     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2218       break;
2219     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2220       break;
2221     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2222       break;
2223     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2224       break;
2225     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2226       break;
2227     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2228       break;
2229     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2230       break;
2231     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2232       break;
2233     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2234       break;
2235     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2236       break;
2237     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2238       break;
2239     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2240       break;
2241     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2242       break;
2243     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2244       break;
2245     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2246       break;
2247     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2248       break;
2249     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2250       break;
2251     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2252       break;
2253     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2254       break;
2255     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2256       break;
2257     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2258       break;
2259     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2260       break;
2261     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2262       break;
2263     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2266       break;
2267     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2268       break;
2269     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2270       break;
2271     }
2272
2273   return ppc64_elf_howto_table[r];
2274 };
2275
2276 static reloc_howto_type *
2277 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2278                              const char *r_name)
2279 {
2280   unsigned int i;
2281
2282   for (i = 0;
2283        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2284        i++)
2285     if (ppc64_elf_howto_raw[i].name != NULL
2286         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2287       return &ppc64_elf_howto_raw[i];
2288
2289   return NULL;
2290 }
2291
2292 /* Set the howto pointer for a PowerPC ELF reloc.  */
2293
2294 static void
2295 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2296                          Elf_Internal_Rela *dst)
2297 {
2298   unsigned int type;
2299
2300   /* Initialize howto table if needed.  */
2301   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2302     ppc_howto_init ();
2303
2304   type = ELF64_R_TYPE (dst->r_info);
2305   if (type >= (sizeof (ppc64_elf_howto_table)
2306                / sizeof (ppc64_elf_howto_table[0])))
2307     {
2308       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2309                              abfd, (int) type);
2310       type = R_PPC64_NONE;
2311     }
2312   cache_ptr->howto = ppc64_elf_howto_table[type];
2313 }
2314
2315 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2316
2317 static bfd_reloc_status_type
2318 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2319                     void *data, asection *input_section,
2320                     bfd *output_bfd, char **error_message)
2321 {
2322   /* If this is a relocatable link (output_bfd test tells us), just
2323      call the generic function.  Any adjustment will be done at final
2324      link time.  */
2325   if (output_bfd != NULL)
2326     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2327                                   input_section, output_bfd, error_message);
2328
2329   /* Adjust the addend for sign extension of the low 16 bits.
2330      We won't actually be using the low 16 bits, so trashing them
2331      doesn't matter.  */
2332   reloc_entry->addend += 0x8000;
2333   return bfd_reloc_continue;
2334 }
2335
2336 static bfd_reloc_status_type
2337 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2338                         void *data, asection *input_section,
2339                         bfd *output_bfd, char **error_message)
2340 {
2341   if (output_bfd != NULL)
2342     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2343                                   input_section, output_bfd, error_message);
2344
2345   if (strcmp (symbol->section->name, ".opd") == 0
2346       && (symbol->section->owner->flags & DYNAMIC) == 0)
2347     {
2348       bfd_vma dest = opd_entry_value (symbol->section,
2349                                       symbol->value + reloc_entry->addend,
2350                                       NULL, NULL, FALSE);
2351       if (dest != (bfd_vma) -1)
2352         reloc_entry->addend = dest - (symbol->value
2353                                       + symbol->section->output_section->vma
2354                                       + symbol->section->output_offset);
2355     }
2356   return bfd_reloc_continue;
2357 }
2358
2359 static bfd_reloc_status_type
2360 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2361                          void *data, asection *input_section,
2362                          bfd *output_bfd, char **error_message)
2363 {
2364   long insn;
2365   enum elf_ppc64_reloc_type r_type;
2366   bfd_size_type octets;
2367   /* Assume 'at' branch hints.  */
2368   bfd_boolean is_isa_v2 = TRUE;
2369
2370   /* If this is a relocatable link (output_bfd test tells us), just
2371      call the generic function.  Any adjustment will be done at final
2372      link time.  */
2373   if (output_bfd != NULL)
2374     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2375                                   input_section, output_bfd, error_message);
2376
2377   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2378   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2379   insn &= ~(0x01 << 21);
2380   r_type = reloc_entry->howto->type;
2381   if (r_type == R_PPC64_ADDR14_BRTAKEN
2382       || r_type == R_PPC64_REL14_BRTAKEN)
2383     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2384
2385   if (is_isa_v2)
2386     {
2387       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2388          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2389          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2390       if ((insn & (0x14 << 21)) == (0x04 << 21))
2391         insn |= 0x02 << 21;
2392       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2393         insn |= 0x08 << 21;
2394       else
2395         goto out;
2396     }
2397   else
2398     {
2399       bfd_vma target = 0;
2400       bfd_vma from;
2401
2402       if (!bfd_is_com_section (symbol->section))
2403         target = symbol->value;
2404       target += symbol->section->output_section->vma;
2405       target += symbol->section->output_offset;
2406       target += reloc_entry->addend;
2407
2408       from = (reloc_entry->address
2409               + input_section->output_offset
2410               + input_section->output_section->vma);
2411
2412       /* Invert 'y' bit if not the default.  */
2413       if ((bfd_signed_vma) (target - from) < 0)
2414         insn ^= 0x01 << 21;
2415     }
2416   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2417  out:
2418   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2419                                  input_section, output_bfd, error_message);
2420 }
2421
2422 static bfd_reloc_status_type
2423 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2424                          void *data, asection *input_section,
2425                          bfd *output_bfd, char **error_message)
2426 {
2427   /* If this is a relocatable link (output_bfd test tells us), just
2428      call the generic function.  Any adjustment will be done at final
2429      link time.  */
2430   if (output_bfd != NULL)
2431     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2432                                   input_section, output_bfd, error_message);
2433
2434   /* Subtract the symbol section base address.  */
2435   reloc_entry->addend -= symbol->section->output_section->vma;
2436   return bfd_reloc_continue;
2437 }
2438
2439 static bfd_reloc_status_type
2440 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2441                             void *data, asection *input_section,
2442                             bfd *output_bfd, char **error_message)
2443 {
2444   /* If this is a relocatable link (output_bfd test tells us), just
2445      call the generic function.  Any adjustment will be done at final
2446      link time.  */
2447   if (output_bfd != NULL)
2448     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2449                                   input_section, output_bfd, error_message);
2450
2451   /* Subtract the symbol section base address.  */
2452   reloc_entry->addend -= symbol->section->output_section->vma;
2453
2454   /* Adjust the addend for sign extension of the low 16 bits.  */
2455   reloc_entry->addend += 0x8000;
2456   return bfd_reloc_continue;
2457 }
2458
2459 static bfd_reloc_status_type
2460 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2461                      void *data, asection *input_section,
2462                      bfd *output_bfd, char **error_message)
2463 {
2464   bfd_vma TOCstart;
2465
2466   /* If this is a relocatable link (output_bfd test tells us), just
2467      call the generic function.  Any adjustment will be done at final
2468      link time.  */
2469   if (output_bfd != NULL)
2470     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2471                                   input_section, output_bfd, error_message);
2472
2473   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2474   if (TOCstart == 0)
2475     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2476
2477   /* Subtract the TOC base address.  */
2478   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2479   return bfd_reloc_continue;
2480 }
2481
2482 static bfd_reloc_status_type
2483 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2484                         void *data, asection *input_section,
2485                         bfd *output_bfd, char **error_message)
2486 {
2487   bfd_vma TOCstart;
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   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2497   if (TOCstart == 0)
2498     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2499
2500   /* Subtract the TOC base address.  */
2501   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2502
2503   /* Adjust the addend for sign extension of the low 16 bits.  */
2504   reloc_entry->addend += 0x8000;
2505   return bfd_reloc_continue;
2506 }
2507
2508 static bfd_reloc_status_type
2509 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2510                        void *data, asection *input_section,
2511                        bfd *output_bfd, char **error_message)
2512 {
2513   bfd_vma TOCstart;
2514   bfd_size_type octets;
2515
2516   /* If this is a relocatable link (output_bfd test tells us), just
2517      call the generic function.  Any adjustment will be done at final
2518      link time.  */
2519   if (output_bfd != NULL)
2520     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2521                                   input_section, output_bfd, error_message);
2522
2523   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2524   if (TOCstart == 0)
2525     TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2526
2527   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2528   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2529   return bfd_reloc_ok;
2530 }
2531
2532 static bfd_reloc_status_type
2533 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2534                            void *data, asection *input_section,
2535                            bfd *output_bfd, char **error_message)
2536 {
2537   /* If this is a relocatable link (output_bfd test tells us), just
2538      call the generic function.  Any adjustment will be done at final
2539      link time.  */
2540   if (output_bfd != NULL)
2541     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2542                                   input_section, output_bfd, error_message);
2543
2544   if (error_message != NULL)
2545     {
2546       static char buf[60];
2547       sprintf (buf, "generic linker can't handle %s",
2548                reloc_entry->howto->name);
2549       *error_message = buf;
2550     }
2551   return bfd_reloc_dangerous;
2552 }
2553
2554 /* Track GOT entries needed for a given symbol.  We might need more
2555    than one got entry per symbol.  */
2556 struct got_entry
2557 {
2558   struct got_entry *next;
2559
2560   /* The symbol addend that we'll be placing in the GOT.  */
2561   bfd_vma addend;
2562
2563   /* Unlike other ELF targets, we use separate GOT entries for the same
2564      symbol referenced from different input files.  This is to support
2565      automatic multiple TOC/GOT sections, where the TOC base can vary
2566      from one input file to another.  After partitioning into TOC groups
2567      we merge entries within the group.
2568
2569      Point to the BFD owning this GOT entry.  */
2570   bfd *owner;
2571
2572   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2573      TLS_TPREL or TLS_DTPREL for tls entries.  */
2574   unsigned char tls_type;
2575
2576   /* Non-zero if got.ent points to real entry.  */
2577   unsigned char is_indirect;
2578
2579   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2580   union
2581     {
2582       bfd_signed_vma refcount;
2583       bfd_vma offset;
2584       struct got_entry *ent;
2585     } got;
2586 };
2587
2588 /* The same for PLT.  */
2589 struct plt_entry
2590 {
2591   struct plt_entry *next;
2592
2593   bfd_vma addend;
2594
2595   union
2596     {
2597       bfd_signed_vma refcount;
2598       bfd_vma offset;
2599     } plt;
2600 };
2601
2602 struct ppc64_elf_obj_tdata
2603 {
2604   struct elf_obj_tdata elf;
2605
2606   /* Shortcuts to dynamic linker sections.  */
2607   asection *got;
2608   asection *relgot;
2609
2610   /* Used during garbage collection.  We attach global symbols defined
2611      on removed .opd entries to this section so that the sym is removed.  */
2612   asection *deleted_section;
2613
2614   /* TLS local dynamic got entry handling.  Support for multiple GOT
2615      sections means we potentially need one of these for each input bfd.  */
2616   struct got_entry tlsld_got;
2617
2618   union {
2619     /* A copy of relocs before they are modified for --emit-relocs.  */
2620     Elf_Internal_Rela *relocs;
2621
2622     /* Section contents.  */
2623     bfd_byte *contents;
2624   } opd;
2625
2626   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2627      the reloc to be in the range -32768 to 32767.  */
2628   unsigned int has_small_toc_reloc : 1;
2629
2630   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2631      instruction not one we handle.  */
2632   unsigned int unexpected_toc_insn : 1;
2633 };
2634
2635 #define ppc64_elf_tdata(bfd) \
2636   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2637
2638 #define ppc64_tlsld_got(bfd) \
2639   (&ppc64_elf_tdata (bfd)->tlsld_got)
2640
2641 #define is_ppc64_elf(bfd) \
2642   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2643    && elf_object_id (bfd) == PPC64_ELF_DATA)
2644
2645 /* Override the generic function because we store some extras.  */
2646
2647 static bfd_boolean
2648 ppc64_elf_mkobject (bfd *abfd)
2649 {
2650   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2651                                   PPC64_ELF_DATA);
2652 }
2653
2654 /* Fix bad default arch selected for a 64 bit input bfd when the
2655    default is 32 bit.  */
2656
2657 static bfd_boolean
2658 ppc64_elf_object_p (bfd *abfd)
2659 {
2660   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2661     {
2662       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2663
2664       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2665         {
2666           /* Relies on arch after 32 bit default being 64 bit default.  */
2667           abfd->arch_info = abfd->arch_info->next;
2668           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2669         }
2670     }
2671   return TRUE;
2672 }
2673
2674 /* Support for core dump NOTE sections.  */
2675
2676 static bfd_boolean
2677 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2678 {
2679   size_t offset, size;
2680
2681   if (note->descsz != 504)
2682     return FALSE;
2683
2684   /* pr_cursig */
2685   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2686
2687   /* pr_pid */
2688   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2689
2690   /* pr_reg */
2691   offset = 112;
2692   size = 384;
2693
2694   /* Make a ".reg/999" section.  */
2695   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2696                                           size, note->descpos + offset);
2697 }
2698
2699 static bfd_boolean
2700 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2701 {
2702   if (note->descsz != 136)
2703     return FALSE;
2704
2705   elf_tdata (abfd)->core->pid
2706     = bfd_get_32 (abfd, note->descdata + 24);
2707   elf_tdata (abfd)->core->program
2708     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2709   elf_tdata (abfd)->core->command
2710     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2711
2712   return TRUE;
2713 }
2714
2715 static char *
2716 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2717                            ...)
2718 {
2719   switch (note_type)
2720     {
2721     default:
2722       return NULL;
2723
2724     case NT_PRPSINFO:
2725       {
2726         char data[136];
2727         va_list ap;
2728
2729         va_start (ap, note_type);
2730         memset (data, 0, sizeof (data));
2731         strncpy (data + 40, va_arg (ap, const char *), 16);
2732         strncpy (data + 56, va_arg (ap, const char *), 80);
2733         va_end (ap);
2734         return elfcore_write_note (abfd, buf, bufsiz,
2735                                    "CORE", note_type, data, sizeof (data));
2736       }
2737
2738     case NT_PRSTATUS:
2739       {
2740         char data[504];
2741         va_list ap;
2742         long pid;
2743         int cursig;
2744         const void *greg;
2745
2746         va_start (ap, note_type);
2747         memset (data, 0, 112);
2748         pid = va_arg (ap, long);
2749         bfd_put_32 (abfd, pid, data + 32);
2750         cursig = va_arg (ap, int);
2751         bfd_put_16 (abfd, cursig, data + 12);
2752         greg = va_arg (ap, const void *);
2753         memcpy (data + 112, greg, 384);
2754         memset (data + 496, 0, 8);
2755         va_end (ap);
2756         return elfcore_write_note (abfd, buf, bufsiz,
2757                                    "CORE", note_type, data, sizeof (data));
2758       }
2759     }
2760 }
2761
2762 /* Add extra PPC sections.  */
2763
2764 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2765 {
2766   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2767   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2768   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2769   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2770   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2771   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2772   { NULL,                     0,  0, 0,            0 }
2773 };
2774
2775 enum _ppc64_sec_type {
2776   sec_normal = 0,
2777   sec_opd = 1,
2778   sec_toc = 2
2779 };
2780
2781 struct _ppc64_elf_section_data
2782 {
2783   struct bfd_elf_section_data elf;
2784
2785   union
2786   {
2787     /* An array with one entry for each opd function descriptor.  */
2788     struct _opd_sec_data
2789     {
2790       /* Points to the function code section for local opd entries.  */
2791       asection **func_sec;
2792
2793       /* After editing .opd, adjust references to opd local syms.  */
2794       long *adjust;
2795     } opd;
2796
2797     /* An array for toc sections, indexed by offset/8.  */
2798     struct _toc_sec_data
2799     {
2800       /* Specifies the relocation symbol index used at a given toc offset.  */
2801       unsigned *symndx;
2802
2803       /* And the relocation addend.  */
2804       bfd_vma *add;
2805     } toc;
2806   } u;
2807
2808   enum _ppc64_sec_type sec_type:2;
2809
2810   /* Flag set when small branches are detected.  Used to
2811      select suitable defaults for the stub group size.  */
2812   unsigned int has_14bit_branch:1;
2813 };
2814
2815 #define ppc64_elf_section_data(sec) \
2816   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2817
2818 static bfd_boolean
2819 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2820 {
2821   if (!sec->used_by_bfd)
2822     {
2823       struct _ppc64_elf_section_data *sdata;
2824       bfd_size_type amt = sizeof (*sdata);
2825
2826       sdata = bfd_zalloc (abfd, amt);
2827       if (sdata == NULL)
2828         return FALSE;
2829       sec->used_by_bfd = sdata;
2830     }
2831
2832   return _bfd_elf_new_section_hook (abfd, sec);
2833 }
2834
2835 static struct _opd_sec_data *
2836 get_opd_info (asection * sec)
2837 {
2838   if (sec != NULL
2839       && ppc64_elf_section_data (sec) != NULL
2840       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2841     return &ppc64_elf_section_data (sec)->u.opd;
2842   return NULL;
2843 }
2844 \f
2845 /* Parameters for the qsort hook.  */
2846 static bfd_boolean synthetic_relocatable;
2847
2848 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2849
2850 static int
2851 compare_symbols (const void *ap, const void *bp)
2852 {
2853   const asymbol *a = * (const asymbol **) ap;
2854   const asymbol *b = * (const asymbol **) bp;
2855
2856   /* Section symbols first.  */
2857   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2858     return -1;
2859   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2860     return 1;
2861
2862   /* then .opd symbols.  */
2863   if (strcmp (a->section->name, ".opd") == 0
2864       && strcmp (b->section->name, ".opd") != 0)
2865     return -1;
2866   if (strcmp (a->section->name, ".opd") != 0
2867       && strcmp (b->section->name, ".opd") == 0)
2868     return 1;
2869
2870   /* then other code symbols.  */
2871   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2872       == (SEC_CODE | SEC_ALLOC)
2873       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2874          != (SEC_CODE | SEC_ALLOC))
2875     return -1;
2876
2877   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2878       != (SEC_CODE | SEC_ALLOC)
2879       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2880          == (SEC_CODE | SEC_ALLOC))
2881     return 1;
2882
2883   if (synthetic_relocatable)
2884     {
2885       if (a->section->id < b->section->id)
2886         return -1;
2887
2888       if (a->section->id > b->section->id)
2889         return 1;
2890     }
2891
2892   if (a->value + a->section->vma < b->value + b->section->vma)
2893     return -1;
2894
2895   if (a->value + a->section->vma > b->value + b->section->vma)
2896     return 1;
2897
2898   /* For syms with the same value, prefer strong dynamic global function
2899      syms over other syms.  */
2900   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2901     return -1;
2902
2903   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2904     return 1;
2905
2906   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2907     return -1;
2908
2909   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2910     return 1;
2911
2912   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2913     return -1;
2914
2915   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2916     return 1;
2917
2918   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2919     return -1;
2920
2921   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2922     return 1;
2923
2924   return 0;
2925 }
2926
2927 /* Search SYMS for a symbol of the given VALUE.  */
2928
2929 static asymbol *
2930 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2931 {
2932   long mid;
2933
2934   if (id == -1)
2935     {
2936       while (lo < hi)
2937         {
2938           mid = (lo + hi) >> 1;
2939           if (syms[mid]->value + syms[mid]->section->vma < value)
2940             lo = mid + 1;
2941           else if (syms[mid]->value + syms[mid]->section->vma > value)
2942             hi = mid;
2943           else
2944             return syms[mid];
2945         }
2946     }
2947   else
2948     {
2949       while (lo < hi)
2950         {
2951           mid = (lo + hi) >> 1;
2952           if (syms[mid]->section->id < id)
2953             lo = mid + 1;
2954           else if (syms[mid]->section->id > id)
2955             hi = mid;
2956           else if (syms[mid]->value < value)
2957             lo = mid + 1;
2958           else if (syms[mid]->value > value)
2959             hi = mid;
2960           else
2961             return syms[mid];
2962         }
2963     }
2964   return NULL;
2965 }
2966
2967 static bfd_boolean
2968 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2969 {
2970   bfd_vma vma = *(bfd_vma *) ptr;
2971   return ((section->flags & SEC_ALLOC) != 0
2972           && section->vma <= vma
2973           && vma < section->vma + section->size);
2974 }
2975
2976 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2977    entry syms.  Also generate @plt symbols for the glink branch table.  */
2978
2979 static long
2980 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2981                                 long static_count, asymbol **static_syms,
2982                                 long dyn_count, asymbol **dyn_syms,
2983                                 asymbol **ret)
2984 {
2985   asymbol *s;
2986   long i;
2987   long count;
2988   char *names;
2989   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2990   asection *opd;
2991   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2992   asymbol **syms;
2993
2994   *ret = NULL;
2995
2996   opd = bfd_get_section_by_name (abfd, ".opd");
2997   if (opd == NULL)
2998     return 0;
2999
3000   symcount = static_count;
3001   if (!relocatable)
3002     symcount += dyn_count;
3003   if (symcount == 0)
3004     return 0;
3005
3006   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3007   if (syms == NULL)
3008     return -1;
3009
3010   if (!relocatable && static_count != 0 && dyn_count != 0)
3011     {
3012       /* Use both symbol tables.  */
3013       memcpy (syms, static_syms, static_count * sizeof (*syms));
3014       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3015     }
3016   else if (!relocatable && static_count == 0)
3017     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3018   else
3019     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3020
3021   synthetic_relocatable = relocatable;
3022   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3023
3024   if (!relocatable && symcount > 1)
3025     {
3026       long j;
3027       /* Trim duplicate syms, since we may have merged the normal and
3028          dynamic symbols.  Actually, we only care about syms that have
3029          different values, so trim any with the same value.  */
3030       for (i = 1, j = 1; i < symcount; ++i)
3031         if (syms[i - 1]->value + syms[i - 1]->section->vma
3032             != syms[i]->value + syms[i]->section->vma)
3033           syms[j++] = syms[i];
3034       symcount = j;
3035     }
3036
3037   i = 0;
3038   if (strcmp (syms[i]->section->name, ".opd") == 0)
3039     ++i;
3040   codesecsym = i;
3041
3042   for (; i < symcount; ++i)
3043     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044          != (SEC_CODE | SEC_ALLOC))
3045         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3046       break;
3047   codesecsymend = i;
3048
3049   for (; i < symcount; ++i)
3050     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3051       break;
3052   secsymend = i;
3053
3054   for (; i < symcount; ++i)
3055     if (strcmp (syms[i]->section->name, ".opd") != 0)
3056       break;
3057   opdsymend = i;
3058
3059   for (; i < symcount; ++i)
3060     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3061         != (SEC_CODE | SEC_ALLOC))
3062       break;
3063   symcount = i;
3064
3065   count = 0;
3066
3067   if (relocatable)
3068     {
3069       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3070       arelent *r;
3071       size_t size;
3072       long relcount;
3073
3074       if (opdsymend == secsymend)
3075         goto done;
3076
3077       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3078       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3079       if (relcount == 0)
3080         goto done;
3081
3082       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3083         {
3084           count = -1;
3085           goto done;
3086         }
3087
3088       size = 0;
3089       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3090         {
3091           asymbol *sym;
3092
3093           while (r < opd->relocation + relcount
3094                  && r->address < syms[i]->value + opd->vma)
3095             ++r;
3096
3097           if (r == opd->relocation + relcount)
3098             break;
3099
3100           if (r->address != syms[i]->value + opd->vma)
3101             continue;
3102
3103           if (r->howto->type != R_PPC64_ADDR64)
3104             continue;
3105
3106           sym = *r->sym_ptr_ptr;
3107           if (!sym_exists_at (syms, opdsymend, symcount,
3108                               sym->section->id, sym->value + r->addend))
3109             {
3110               ++count;
3111               size += sizeof (asymbol);
3112               size += strlen (syms[i]->name) + 2;
3113             }
3114         }
3115
3116       s = *ret = bfd_malloc (size);
3117       if (s == NULL)
3118         {
3119           count = -1;
3120           goto done;
3121         }
3122
3123       names = (char *) (s + count);
3124
3125       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3126         {
3127           asymbol *sym;
3128
3129           while (r < opd->relocation + relcount
3130                  && r->address < syms[i]->value + opd->vma)
3131             ++r;
3132
3133           if (r == opd->relocation + relcount)
3134             break;
3135
3136           if (r->address != syms[i]->value + opd->vma)
3137             continue;
3138
3139           if (r->howto->type != R_PPC64_ADDR64)
3140             continue;
3141
3142           sym = *r->sym_ptr_ptr;
3143           if (!sym_exists_at (syms, opdsymend, symcount,
3144                               sym->section->id, sym->value + r->addend))
3145             {
3146               size_t len;
3147
3148               *s = *syms[i];
3149               s->flags |= BSF_SYNTHETIC;
3150               s->section = sym->section;
3151               s->value = sym->value + r->addend;
3152               s->name = names;
3153               *names++ = '.';
3154               len = strlen (syms[i]->name);
3155               memcpy (names, syms[i]->name, len + 1);
3156               names += len + 1;
3157               /* Have udata.p point back to the original symbol this
3158                  synthetic symbol was derived from.  */
3159               s->udata.p = syms[i];
3160               s++;
3161             }
3162         }
3163     }
3164   else
3165     {
3166       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3167       bfd_byte *contents;
3168       size_t size;
3169       long plt_count = 0;
3170       bfd_vma glink_vma = 0, resolv_vma = 0;
3171       asection *dynamic, *glink = NULL, *relplt = NULL;
3172       arelent *p;
3173
3174       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3175         {
3176           if (contents)
3177             {
3178             free_contents_and_exit:
3179               free (contents);
3180             }
3181           count = -1;
3182           goto done;
3183         }
3184
3185       size = 0;
3186       for (i = secsymend; i < opdsymend; ++i)
3187         {
3188           bfd_vma ent;
3189
3190           /* Ignore bogus symbols.  */
3191           if (syms[i]->value > opd->size - 8)
3192             continue;
3193
3194           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3195           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3196             {
3197               ++count;
3198               size += sizeof (asymbol);
3199               size += strlen (syms[i]->name) + 2;
3200             }
3201         }
3202
3203       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3204       if (dyn_count != 0
3205           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3206         {
3207           bfd_byte *dynbuf, *extdyn, *extdynend;
3208           size_t extdynsize;
3209           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3210
3211           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3212             goto free_contents_and_exit;
3213
3214           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3215           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3216
3217           extdyn = dynbuf;
3218           extdynend = extdyn + dynamic->size;
3219           for (; extdyn < extdynend; extdyn += extdynsize)
3220             {
3221               Elf_Internal_Dyn dyn;
3222               (*swap_dyn_in) (abfd, extdyn, &dyn);
3223
3224               if (dyn.d_tag == DT_NULL)
3225                 break;
3226
3227               if (dyn.d_tag == DT_PPC64_GLINK)
3228                 {
3229                   /* The first glink stub starts at offset 32; see comment in
3230                      ppc64_elf_finish_dynamic_sections. */
3231                   glink_vma = dyn.d_un.d_val + 32;
3232                   /* The .glink section usually does not survive the final
3233                      link; search for the section (usually .text) where the
3234                      glink stubs now reside.  */
3235                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3236                                                 &glink_vma);
3237                   break;
3238                 }
3239             }
3240
3241           free (dynbuf);
3242         }
3243
3244       if (glink != NULL)
3245         {
3246           /* Determine __glink trampoline by reading the relative branch
3247              from the first glink stub.  */
3248           bfd_byte buf[4];
3249           if (bfd_get_section_contents (abfd, glink, buf,
3250                                         glink_vma + 4 - glink->vma, 4))
3251             {
3252               unsigned int insn = bfd_get_32 (abfd, buf);
3253               insn ^= B_DOT;
3254               if ((insn & ~0x3fffffc) == 0)
3255                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3256             }
3257
3258           if (resolv_vma)
3259             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3260
3261           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3262           if (relplt != NULL)
3263             {
3264               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3265               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3266                 goto free_contents_and_exit;
3267
3268               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3269               size += plt_count * sizeof (asymbol);
3270
3271               p = relplt->relocation;
3272               for (i = 0; i < plt_count; i++, p++)
3273                 {
3274                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3275                   if (p->addend != 0)
3276                     size += sizeof ("+0x") - 1 + 16;
3277                 }
3278             }
3279         }
3280
3281       s = *ret = bfd_malloc (size);
3282       if (s == NULL)
3283         goto free_contents_and_exit;
3284
3285       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3286
3287       for (i = secsymend; i < opdsymend; ++i)
3288         {
3289           bfd_vma ent;
3290
3291           if (syms[i]->value > opd->size - 8)
3292             continue;
3293
3294           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3295           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3296             {
3297               long lo, hi;
3298               size_t len;
3299               asection *sec = abfd->sections;
3300
3301               *s = *syms[i];
3302               lo = codesecsym;
3303               hi = codesecsymend;
3304               while (lo < hi)
3305                 {
3306                   long mid = (lo + hi) >> 1;
3307                   if (syms[mid]->section->vma < ent)
3308                     lo = mid + 1;
3309                   else if (syms[mid]->section->vma > ent)
3310                     hi = mid;
3311                   else
3312                     {
3313                       sec = syms[mid]->section;
3314                       break;
3315                     }
3316                 }
3317
3318               if (lo >= hi && lo > codesecsym)
3319                 sec = syms[lo - 1]->section;
3320
3321               for (; sec != NULL; sec = sec->next)
3322                 {
3323                   if (sec->vma > ent)
3324                     break;
3325                   /* SEC_LOAD may not be set if SEC is from a separate debug
3326                      info file.  */
3327                   if ((sec->flags & SEC_ALLOC) == 0)
3328                     break;
3329                   if ((sec->flags & SEC_CODE) != 0)
3330                     s->section = sec;
3331                 }
3332               s->flags |= BSF_SYNTHETIC;
3333               s->value = ent - s->section->vma;
3334               s->name = names;
3335               *names++ = '.';
3336               len = strlen (syms[i]->name);
3337               memcpy (names, syms[i]->name, len + 1);
3338               names += len + 1;
3339               /* Have udata.p point back to the original symbol this
3340                  synthetic symbol was derived from.  */
3341               s->udata.p = syms[i];
3342               s++;
3343             }
3344         }
3345       free (contents);
3346
3347       if (glink != NULL && relplt != NULL)
3348         {
3349           if (resolv_vma)
3350             {
3351               /* Add a symbol for the main glink trampoline.  */
3352               memset (s, 0, sizeof *s);
3353               s->the_bfd = abfd;
3354               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3355               s->section = glink;
3356               s->value = resolv_vma - glink->vma;
3357               s->name = names;
3358               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3359               names += sizeof ("__glink_PLTresolve");
3360               s++;
3361               count++;
3362             }
3363
3364           /* FIXME: It would be very much nicer to put sym@plt on the
3365              stub rather than on the glink branch table entry.  The
3366              objdump disassembler would then use a sensible symbol
3367              name on plt calls.  The difficulty in doing so is
3368              a) finding the stubs, and,
3369              b) matching stubs against plt entries, and,
3370              c) there can be multiple stubs for a given plt entry.
3371
3372              Solving (a) could be done by code scanning, but older
3373              ppc64 binaries used different stubs to current code.
3374              (b) is the tricky one since you need to known the toc
3375              pointer for at least one function that uses a pic stub to
3376              be able to calculate the plt address referenced.
3377              (c) means gdb would need to set multiple breakpoints (or
3378              find the glink branch itself) when setting breakpoints
3379              for pending shared library loads.  */
3380           p = relplt->relocation;
3381           for (i = 0; i < plt_count; i++, p++)
3382             {
3383               size_t len;
3384
3385               *s = **p->sym_ptr_ptr;
3386               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3387                  we are defining a symbol, ensure one of them is set.  */
3388               if ((s->flags & BSF_LOCAL) == 0)
3389                 s->flags |= BSF_GLOBAL;
3390               s->flags |= BSF_SYNTHETIC;
3391               s->section = glink;
3392               s->value = glink_vma - glink->vma;
3393               s->name = names;
3394               s->udata.p = NULL;
3395               len = strlen ((*p->sym_ptr_ptr)->name);
3396               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3397               names += len;
3398               if (p->addend != 0)
3399                 {
3400                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3401                   names += sizeof ("+0x") - 1;
3402                   bfd_sprintf_vma (abfd, names, p->addend);
3403                   names += strlen (names);
3404                 }
3405               memcpy (names, "@plt", sizeof ("@plt"));
3406               names += sizeof ("@plt");
3407               s++;
3408               glink_vma += 8;
3409               if (i >= 0x8000)
3410                 glink_vma += 4;
3411             }
3412           count += plt_count;
3413         }
3414     }
3415
3416  done:
3417   free (syms);
3418   return count;
3419 }
3420 \f
3421 /* The following functions are specific to the ELF linker, while
3422    functions above are used generally.  Those named ppc64_elf_* are
3423    called by the main ELF linker code.  They appear in this file more
3424    or less in the order in which they are called.  eg.
3425    ppc64_elf_check_relocs is called early in the link process,
3426    ppc64_elf_finish_dynamic_sections is one of the last functions
3427    called.
3428
3429    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3430    functions have both a function code symbol and a function descriptor
3431    symbol.  A call to foo in a relocatable object file looks like:
3432
3433    .            .text
3434    .    x:
3435    .            bl      .foo
3436    .            nop
3437
3438    The function definition in another object file might be:
3439
3440    .            .section .opd
3441    .    foo:    .quad   .foo
3442    .            .quad   .TOC.@tocbase
3443    .            .quad   0
3444    .
3445    .            .text
3446    .    .foo:   blr
3447
3448    When the linker resolves the call during a static link, the branch
3449    unsurprisingly just goes to .foo and the .opd information is unused.
3450    If the function definition is in a shared library, things are a little
3451    different:  The call goes via a plt call stub, the opd information gets
3452    copied to the plt, and the linker patches the nop.
3453
3454    .    x:
3455    .            bl      .foo_stub
3456    .            ld      2,40(1)
3457    .
3458    .
3459    .    .foo_stub:
3460    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3461    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3462    .            std     2,40(1)                 # this is the general idea
3463    .            ld      11,0(12)
3464    .            ld      2,8(12)
3465    .            mtctr   11
3466    .            ld      11,16(12)
3467    .            bctr
3468    .
3469    .            .section .plt
3470    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3471
3472    The "reloc ()" notation is supposed to indicate that the linker emits
3473    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3474    copying.
3475
3476    What are the difficulties here?  Well, firstly, the relocations
3477    examined by the linker in check_relocs are against the function code
3478    sym .foo, while the dynamic relocation in the plt is emitted against
3479    the function descriptor symbol, foo.  Somewhere along the line, we need
3480    to carefully copy dynamic link information from one symbol to the other.
3481    Secondly, the generic part of the elf linker will make .foo a dynamic
3482    symbol as is normal for most other backends.  We need foo dynamic
3483    instead, at least for an application final link.  However, when
3484    creating a shared library containing foo, we need to have both symbols
3485    dynamic so that references to .foo are satisfied during the early
3486    stages of linking.  Otherwise the linker might decide to pull in a
3487    definition from some other object, eg. a static library.
3488
3489    Update: As of August 2004, we support a new convention.  Function
3490    calls may use the function descriptor symbol, ie. "bl foo".  This
3491    behaves exactly as "bl .foo".  */
3492
3493 /* Of those relocs that might be copied as dynamic relocs, this function
3494    selects those that must be copied when linking a shared library,
3495    even when the symbol is local.  */
3496
3497 static int
3498 must_be_dyn_reloc (struct bfd_link_info *info,
3499                    enum elf_ppc64_reloc_type r_type)
3500 {
3501   switch (r_type)
3502     {
3503     default:
3504       return 1;
3505
3506     case R_PPC64_REL32:
3507     case R_PPC64_REL64:
3508     case R_PPC64_REL30:
3509       return 0;
3510
3511     case R_PPC64_TPREL16:
3512     case R_PPC64_TPREL16_LO:
3513     case R_PPC64_TPREL16_HI:
3514     case R_PPC64_TPREL16_HA:
3515     case R_PPC64_TPREL16_DS:
3516     case R_PPC64_TPREL16_LO_DS:
3517     case R_PPC64_TPREL16_HIGHER:
3518     case R_PPC64_TPREL16_HIGHERA:
3519     case R_PPC64_TPREL16_HIGHEST:
3520     case R_PPC64_TPREL16_HIGHESTA:
3521     case R_PPC64_TPREL64:
3522       return !info->executable;
3523     }
3524 }
3525
3526 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3527    copying dynamic variables from a shared lib into an app's dynbss
3528    section, and instead use a dynamic relocation to point into the
3529    shared lib.  With code that gcc generates, it's vital that this be
3530    enabled;  In the PowerPC64 ABI, the address of a function is actually
3531    the address of a function descriptor, which resides in the .opd
3532    section.  gcc uses the descriptor directly rather than going via the
3533    GOT as some other ABI's do, which means that initialized function
3534    pointers must reference the descriptor.  Thus, a function pointer
3535    initialized to the address of a function in a shared library will
3536    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3537    redefines the function descriptor symbol to point to the copy.  This
3538    presents a problem as a plt entry for that function is also
3539    initialized from the function descriptor symbol and the copy reloc
3540    may not be initialized first.  */
3541 #define ELIMINATE_COPY_RELOCS 1
3542
3543 /* Section name for stubs is the associated section name plus this
3544    string.  */
3545 #define STUB_SUFFIX ".stub"
3546
3547 /* Linker stubs.
3548    ppc_stub_long_branch:
3549    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3550    destination, but a 24 bit branch in a stub section will reach.
3551    .    b       dest
3552
3553    ppc_stub_plt_branch:
3554    Similar to the above, but a 24 bit branch in the stub section won't
3555    reach its destination.
3556    .    addis   %r12,%r2,xxx@toc@ha
3557    .    ld      %r11,xxx@toc@l(%r12)
3558    .    mtctr   %r11
3559    .    bctr
3560
3561    ppc_stub_plt_call:
3562    Used to call a function in a shared library.  If it so happens that
3563    the plt entry referenced crosses a 64k boundary, then an extra
3564    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3565    .    addis   %r12,%r2,xxx@toc@ha
3566    .    std     %r2,40(%r1)
3567    .    ld      %r11,xxx+0@toc@l(%r12)
3568    .    mtctr   %r11
3569    .    ld      %r2,xxx+8@toc@l(%r12)
3570    .    ld      %r11,xxx+16@toc@l(%r12)
3571    .    bctr
3572
3573    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3574    code to adjust the value and save r2 to support multiple toc sections.
3575    A ppc_stub_long_branch with an r2 offset looks like:
3576    .    std     %r2,40(%r1)
3577    .    addis   %r2,%r2,off@ha
3578    .    addi    %r2,%r2,off@l
3579    .    b       dest
3580
3581    A ppc_stub_plt_branch with an r2 offset looks like:
3582    .    std     %r2,40(%r1)
3583    .    addis   %r12,%r2,xxx@toc@ha
3584    .    ld      %r11,xxx@toc@l(%r12)
3585    .    addis   %r2,%r2,off@ha
3586    .    addi    %r2,%r2,off@l
3587    .    mtctr   %r11
3588    .    bctr
3589
3590    In cases where the "addis" instruction would add zero, the "addis" is
3591    omitted and following instructions modified slightly in some cases.
3592 */
3593
3594 enum ppc_stub_type {
3595   ppc_stub_none,
3596   ppc_stub_long_branch,
3597   ppc_stub_long_branch_r2off,
3598   ppc_stub_plt_branch,
3599   ppc_stub_plt_branch_r2off,
3600   ppc_stub_plt_call,
3601   ppc_stub_plt_call_r2save
3602 };
3603
3604 struct ppc_stub_hash_entry {
3605
3606   /* Base hash table entry structure.  */
3607   struct bfd_hash_entry root;
3608
3609   enum ppc_stub_type stub_type;
3610
3611   /* The stub section.  */
3612   asection *stub_sec;
3613
3614   /* Offset within stub_sec of the beginning of this stub.  */
3615   bfd_vma stub_offset;
3616
3617   /* Given the symbol's value and its section we can determine its final
3618      value when building the stubs (so the stub knows where to jump.  */
3619   bfd_vma target_value;
3620   asection *target_section;
3621
3622   /* The symbol table entry, if any, that this was derived from.  */
3623   struct ppc_link_hash_entry *h;
3624   struct plt_entry *plt_ent;
3625
3626   /* Where this stub is being called from, or, in the case of combined
3627      stub sections, the first input section in the group.  */
3628   asection *id_sec;
3629 };
3630
3631 struct ppc_branch_hash_entry {
3632
3633   /* Base hash table entry structure.  */
3634   struct bfd_hash_entry root;
3635
3636   /* Offset within branch lookup table.  */
3637   unsigned int offset;
3638
3639   /* Generation marker.  */
3640   unsigned int iter;
3641 };
3642
3643 /* Used to track dynamic relocations for local symbols.  */
3644 struct ppc_dyn_relocs
3645 {
3646   struct ppc_dyn_relocs *next;
3647
3648   /* The input section of the reloc.  */
3649   asection *sec;
3650
3651   /* Total number of relocs copied for the input section.  */
3652   unsigned int count : 31;
3653
3654   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3655   unsigned int ifunc : 1;
3656 };
3657
3658 struct ppc_link_hash_entry
3659 {
3660   struct elf_link_hash_entry elf;
3661
3662   union {
3663     /* A pointer to the most recently used stub hash entry against this
3664        symbol.  */
3665     struct ppc_stub_hash_entry *stub_cache;
3666
3667     /* A pointer to the next symbol starting with a '.'  */
3668     struct ppc_link_hash_entry *next_dot_sym;
3669   } u;
3670
3671   /* Track dynamic relocs copied for this symbol.  */
3672   struct elf_dyn_relocs *dyn_relocs;
3673
3674   /* Link between function code and descriptor symbols.  */
3675   struct ppc_link_hash_entry *oh;
3676
3677   /* Flag function code and descriptor symbols.  */
3678   unsigned int is_func:1;
3679   unsigned int is_func_descriptor:1;
3680   unsigned int fake:1;
3681
3682   /* Whether global opd/toc sym has been adjusted or not.
3683      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3684      should be set for all globals defined in any opd/toc section.  */
3685   unsigned int adjust_done:1;
3686
3687   /* Set if we twiddled this symbol to weak at some stage.  */
3688   unsigned int was_undefined:1;
3689
3690   /* Contexts in which symbol is used in the GOT (or TOC).
3691      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3692      corresponding relocs are encountered during check_relocs.
3693      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3694      indicate the corresponding GOT entry type is not needed.
3695      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3696      a TPREL one.  We use a separate flag rather than setting TPREL
3697      just for convenience in distinguishing the two cases.  */
3698 #define TLS_GD           1      /* GD reloc. */
3699 #define TLS_LD           2      /* LD reloc. */
3700 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3701 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3702 #define TLS_TLS         16      /* Any TLS reloc.  */
3703 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3704 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3705 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3706   unsigned char tls_mask;
3707 };
3708
3709 /* ppc64 ELF linker hash table.  */
3710
3711 struct ppc_link_hash_table
3712 {
3713   struct elf_link_hash_table elf;
3714
3715   /* The stub hash table.  */
3716   struct bfd_hash_table stub_hash_table;
3717
3718   /* Another hash table for plt_branch stubs.  */
3719   struct bfd_hash_table branch_hash_table;
3720
3721   /* Hash table for function prologue tocsave.  */
3722   htab_t tocsave_htab;
3723
3724   /* Linker stub bfd.  */
3725   bfd *stub_bfd;
3726
3727   /* Linker call-backs.  */
3728   asection * (*add_stub_section) (const char *, asection *);
3729   void (*layout_sections_again) (void);
3730
3731   /* Array to keep track of which stub sections have been created, and
3732      information on stub grouping.  */
3733   struct map_stub {
3734     /* This is the section to which stubs in the group will be attached.  */
3735     asection *link_sec;
3736     /* The stub section.  */
3737     asection *stub_sec;
3738     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3739     bfd_vma toc_off;
3740   } *stub_group;
3741
3742   /* Temp used when calculating TOC pointers.  */
3743   bfd_vma toc_curr;
3744   bfd *toc_bfd;
3745   asection *toc_first_sec;
3746
3747   /* Highest input section id.  */
3748   int top_id;
3749
3750   /* Highest output section index.  */
3751   int top_index;
3752
3753   /* Used when adding symbols.  */
3754   struct ppc_link_hash_entry *dot_syms;
3755
3756   /* List of input sections for each output section.  */
3757   asection **input_list;
3758
3759   /* Short-cuts to get to dynamic linker sections.  */
3760   asection *got;
3761   asection *plt;
3762   asection *relplt;
3763   asection *iplt;
3764   asection *reliplt;
3765   asection *dynbss;
3766   asection *relbss;
3767   asection *glink;
3768   asection *sfpr;
3769   asection *brlt;
3770   asection *relbrlt;
3771   asection *glink_eh_frame;
3772
3773   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3774   struct ppc_link_hash_entry *tls_get_addr;
3775   struct ppc_link_hash_entry *tls_get_addr_fd;
3776
3777   /* The size of reliplt used by got entry relocs.  */
3778   bfd_size_type got_reli_size;
3779
3780   /* Statistics.  */
3781   unsigned long stub_count[ppc_stub_plt_call_r2save];
3782
3783   /* Number of stubs against global syms.  */
3784   unsigned long stub_globals;
3785
3786   /* Alignment of PLT call stubs.  */
3787   unsigned int plt_stub_align:4;
3788
3789   /* Set if PLT call stubs should load r11.  */
3790   unsigned int plt_static_chain:1;
3791
3792   /* Set if PLT call stubs need a read-read barrier.  */
3793   unsigned int plt_thread_safe:1;
3794
3795   /* Set if we should emit symbols for stubs.  */
3796   unsigned int emit_stub_syms:1;
3797
3798   /* Set if __tls_get_addr optimization should not be done.  */
3799   unsigned int no_tls_get_addr_opt:1;
3800
3801   /* Support for multiple toc sections.  */
3802   unsigned int do_multi_toc:1;
3803   unsigned int multi_toc_needed:1;
3804   unsigned int second_toc_pass:1;
3805   unsigned int do_toc_opt:1;
3806
3807   /* Set on error.  */
3808   unsigned int stub_error:1;
3809
3810   /* Temp used by ppc64_elf_process_dot_syms.  */
3811   unsigned int twiddled_syms:1;
3812
3813   /* Incremented every time we size stubs.  */
3814   unsigned int stub_iteration;
3815
3816   /* Small local sym cache.  */
3817   struct sym_cache sym_cache;
3818 };
3819
3820 /* Rename some of the generic section flags to better document how they
3821    are used here.  */
3822
3823 /* Nonzero if this section has TLS related relocations.  */
3824 #define has_tls_reloc sec_flg0
3825
3826 /* Nonzero if this section has a call to __tls_get_addr.  */
3827 #define has_tls_get_addr_call sec_flg1
3828
3829 /* Nonzero if this section has any toc or got relocs.  */
3830 #define has_toc_reloc sec_flg2
3831
3832 /* Nonzero if this section has a call to another section that uses
3833    the toc or got.  */
3834 #define makes_toc_func_call sec_flg3
3835
3836 /* Recursion protection when determining above flag.  */
3837 #define call_check_in_progress sec_flg4
3838 #define call_check_done sec_flg5
3839
3840 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3841
3842 #define ppc_hash_table(p) \
3843   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3844   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3845
3846 #define ppc_stub_hash_lookup(table, string, create, copy) \
3847   ((struct ppc_stub_hash_entry *) \
3848    bfd_hash_lookup ((table), (string), (create), (copy)))
3849
3850 #define ppc_branch_hash_lookup(table, string, create, copy) \
3851   ((struct ppc_branch_hash_entry *) \
3852    bfd_hash_lookup ((table), (string), (create), (copy)))
3853
3854 /* Create an entry in the stub hash table.  */
3855
3856 static struct bfd_hash_entry *
3857 stub_hash_newfunc (struct bfd_hash_entry *entry,
3858                    struct bfd_hash_table *table,
3859                    const char *string)
3860 {
3861   /* Allocate the structure if it has not already been allocated by a
3862      subclass.  */
3863   if (entry == NULL)
3864     {
3865       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3866       if (entry == NULL)
3867         return entry;
3868     }
3869
3870   /* Call the allocation method of the superclass.  */
3871   entry = bfd_hash_newfunc (entry, table, string);
3872   if (entry != NULL)
3873     {
3874       struct ppc_stub_hash_entry *eh;
3875
3876       /* Initialize the local fields.  */
3877       eh = (struct ppc_stub_hash_entry *) entry;
3878       eh->stub_type = ppc_stub_none;
3879       eh->stub_sec = NULL;
3880       eh->stub_offset = 0;
3881       eh->target_value = 0;
3882       eh->target_section = NULL;
3883       eh->h = NULL;
3884       eh->id_sec = NULL;
3885     }
3886
3887   return entry;
3888 }
3889
3890 /* Create an entry in the branch hash table.  */
3891
3892 static struct bfd_hash_entry *
3893 branch_hash_newfunc (struct bfd_hash_entry *entry,
3894                      struct bfd_hash_table *table,
3895                      const char *string)
3896 {
3897   /* Allocate the structure if it has not already been allocated by a
3898      subclass.  */
3899   if (entry == NULL)
3900     {
3901       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3902       if (entry == NULL)
3903         return entry;
3904     }
3905
3906   /* Call the allocation method of the superclass.  */
3907   entry = bfd_hash_newfunc (entry, table, string);
3908   if (entry != NULL)
3909     {
3910       struct ppc_branch_hash_entry *eh;
3911
3912       /* Initialize the local fields.  */
3913       eh = (struct ppc_branch_hash_entry *) entry;
3914       eh->offset = 0;
3915       eh->iter = 0;
3916     }
3917
3918   return entry;
3919 }
3920
3921 /* Create an entry in a ppc64 ELF linker hash table.  */
3922
3923 static struct bfd_hash_entry *
3924 link_hash_newfunc (struct bfd_hash_entry *entry,
3925                    struct bfd_hash_table *table,
3926                    const char *string)
3927 {
3928   /* Allocate the structure if it has not already been allocated by a
3929      subclass.  */
3930   if (entry == NULL)
3931     {
3932       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3933       if (entry == NULL)
3934         return entry;
3935     }
3936
3937   /* Call the allocation method of the superclass.  */
3938   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3939   if (entry != NULL)
3940     {
3941       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3942
3943       memset (&eh->u.stub_cache, 0,
3944               (sizeof (struct ppc_link_hash_entry)
3945                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3946
3947       /* When making function calls, old ABI code references function entry
3948          points (dot symbols), while new ABI code references the function
3949          descriptor symbol.  We need to make any combination of reference and
3950          definition work together, without breaking archive linking.
3951
3952          For a defined function "foo" and an undefined call to "bar":
3953          An old object defines "foo" and ".foo", references ".bar" (possibly
3954          "bar" too).
3955          A new object defines "foo" and references "bar".
3956
3957          A new object thus has no problem with its undefined symbols being
3958          satisfied by definitions in an old object.  On the other hand, the
3959          old object won't have ".bar" satisfied by a new object.
3960
3961          Keep a list of newly added dot-symbols.  */
3962
3963       if (string[0] == '.')
3964         {
3965           struct ppc_link_hash_table *htab;
3966
3967           htab = (struct ppc_link_hash_table *) table;
3968           eh->u.next_dot_sym = htab->dot_syms;
3969           htab->dot_syms = eh;
3970         }
3971     }
3972
3973   return entry;
3974 }
3975
3976 struct tocsave_entry {
3977   asection *sec;
3978   bfd_vma offset;
3979 };
3980
3981 static hashval_t
3982 tocsave_htab_hash (const void *p)
3983 {
3984   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3985   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
3986 }
3987
3988 static int
3989 tocsave_htab_eq (const void *p1, const void *p2)
3990 {
3991   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3992   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3993   return e1->sec == e2->sec && e1->offset == e2->offset;
3994 }
3995
3996 /* Create a ppc64 ELF linker hash table.  */
3997
3998 static struct bfd_link_hash_table *
3999 ppc64_elf_link_hash_table_create (bfd *abfd)
4000 {
4001   struct ppc_link_hash_table *htab;
4002   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4003
4004   htab = bfd_zmalloc (amt);
4005   if (htab == NULL)
4006     return NULL;
4007
4008   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4009                                       sizeof (struct ppc_link_hash_entry),
4010                                       PPC64_ELF_DATA))
4011     {
4012       free (htab);
4013       return NULL;
4014     }
4015
4016   /* Init the stub hash table too.  */
4017   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4018                             sizeof (struct ppc_stub_hash_entry)))
4019     return NULL;
4020
4021   /* And the branch hash table.  */
4022   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4023                             sizeof (struct ppc_branch_hash_entry)))
4024     return NULL;
4025
4026   htab->tocsave_htab = htab_try_create (1024,
4027                                         tocsave_htab_hash,
4028                                         tocsave_htab_eq,
4029                                         NULL);
4030   if (htab->tocsave_htab == NULL)
4031     return NULL;
4032
4033   /* Initializing two fields of the union is just cosmetic.  We really
4034      only care about glist, but when compiled on a 32-bit host the
4035      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4036      debugger inspection of these fields look nicer.  */
4037   htab->elf.init_got_refcount.refcount = 0;
4038   htab->elf.init_got_refcount.glist = NULL;
4039   htab->elf.init_plt_refcount.refcount = 0;
4040   htab->elf.init_plt_refcount.glist = NULL;
4041   htab->elf.init_got_offset.offset = 0;
4042   htab->elf.init_got_offset.glist = NULL;
4043   htab->elf.init_plt_offset.offset = 0;
4044   htab->elf.init_plt_offset.glist = NULL;
4045
4046   return &htab->elf.root;
4047 }
4048
4049 /* Free the derived linker hash table.  */
4050
4051 static void
4052 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4053 {
4054   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4055
4056   bfd_hash_table_free (&htab->stub_hash_table);
4057   bfd_hash_table_free (&htab->branch_hash_table);
4058   if (htab->tocsave_htab)
4059     htab_delete (htab->tocsave_htab);
4060   _bfd_elf_link_hash_table_free (hash);
4061 }
4062
4063 /* Create sections for linker generated code.  */
4064
4065 static bfd_boolean
4066 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4067 {
4068   struct ppc_link_hash_table *htab;
4069   flagword flags;
4070
4071   htab = ppc_hash_table (info);
4072
4073   /* Create .sfpr for code to save and restore fp regs.  */
4074   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4075            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4076   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4077                                                    flags);
4078   if (htab->sfpr == NULL
4079       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4080     return FALSE;
4081
4082   /* Create .glink for lazy dynamic linking support.  */
4083   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4084                                                     flags);
4085   if (htab->glink == NULL
4086       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4087     return FALSE;
4088
4089   if (!info->no_ld_generated_unwind_info)
4090     {
4091       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4092                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4093       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4094                                                                  ".eh_frame",
4095                                                                  flags);
4096       if (htab->glink_eh_frame == NULL
4097           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4098         return FALSE;
4099     }
4100
4101   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4102   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4103   if (htab->iplt == NULL
4104       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4105     return FALSE;
4106
4107   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4108            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4109   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4110                                                       ".rela.iplt",
4111                                                       flags);
4112   if (htab->reliplt == NULL
4113       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4114     return FALSE;
4115
4116   /* Create branch lookup table for plt_branch stubs.  */
4117   flags = (SEC_ALLOC | SEC_LOAD
4118            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4119   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4120                                                    flags);
4121   if (htab->brlt == NULL
4122       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4123     return FALSE;
4124
4125   if (!info->shared)
4126     return TRUE;
4127
4128   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4129            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4130   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4131                                                       ".rela.branch_lt",
4132                                                       flags);
4133   if (htab->relbrlt == NULL
4134       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4135     return FALSE;
4136
4137   return TRUE;
4138 }
4139
4140 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4141
4142 bfd_boolean
4143 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4144 {
4145   struct ppc_link_hash_table *htab;
4146
4147   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4148
4149 /* Always hook our dynamic sections into the first bfd, which is the
4150    linker created stub bfd.  This ensures that the GOT header is at
4151    the start of the output TOC section.  */
4152   htab = ppc_hash_table (info);
4153   if (htab == NULL)
4154     return FALSE;
4155   htab->stub_bfd = abfd;
4156   htab->elf.dynobj = abfd;
4157
4158   if (info->relocatable)
4159     return TRUE;
4160
4161   return create_linkage_sections (htab->elf.dynobj, info);
4162 }
4163
4164 /* Build a name for an entry in the stub hash table.  */
4165
4166 static char *
4167 ppc_stub_name (const asection *input_section,
4168                const asection *sym_sec,
4169                const struct ppc_link_hash_entry *h,
4170                const Elf_Internal_Rela *rel)
4171 {
4172   char *stub_name;
4173   ssize_t len;
4174
4175   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4176      offsets from a sym as a branch target?  In fact, we could
4177      probably assume the addend is always zero.  */
4178   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4179
4180   if (h)
4181     {
4182       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4183       stub_name = bfd_malloc (len);
4184       if (stub_name == NULL)
4185         return stub_name;
4186
4187       len = sprintf (stub_name, "%08x.%s+%x",
4188                      input_section->id & 0xffffffff,
4189                      h->elf.root.root.string,
4190                      (int) rel->r_addend & 0xffffffff);
4191     }
4192   else
4193     {
4194       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4195       stub_name = bfd_malloc (len);
4196       if (stub_name == NULL)
4197         return stub_name;
4198
4199       len = sprintf (stub_name, "%08x.%x:%x+%x",
4200                      input_section->id & 0xffffffff,
4201                      sym_sec->id & 0xffffffff,
4202                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4203                      (int) rel->r_addend & 0xffffffff);
4204     }
4205   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4206     stub_name[len - 2] = 0;
4207   return stub_name;
4208 }
4209
4210 /* Look up an entry in the stub hash.  Stub entries are cached because
4211    creating the stub name takes a bit of time.  */
4212
4213 static struct ppc_stub_hash_entry *
4214 ppc_get_stub_entry (const asection *input_section,
4215                     const asection *sym_sec,
4216                     struct ppc_link_hash_entry *h,
4217                     const Elf_Internal_Rela *rel,
4218                     struct ppc_link_hash_table *htab)
4219 {
4220   struct ppc_stub_hash_entry *stub_entry;
4221   const asection *id_sec;
4222
4223   /* If this input section is part of a group of sections sharing one
4224      stub section, then use the id of the first section in the group.
4225      Stub names need to include a section id, as there may well be
4226      more than one stub used to reach say, printf, and we need to
4227      distinguish between them.  */
4228   id_sec = htab->stub_group[input_section->id].link_sec;
4229
4230   if (h != NULL && h->u.stub_cache != NULL
4231       && h->u.stub_cache->h == h
4232       && h->u.stub_cache->id_sec == id_sec)
4233     {
4234       stub_entry = h->u.stub_cache;
4235     }
4236   else
4237     {
4238       char *stub_name;
4239
4240       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4241       if (stub_name == NULL)
4242         return NULL;
4243
4244       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4245                                          stub_name, FALSE, FALSE);
4246       if (h != NULL)
4247         h->u.stub_cache = stub_entry;
4248
4249       free (stub_name);
4250     }
4251
4252   return stub_entry;
4253 }
4254
4255 /* Add a new stub entry to the stub hash.  Not all fields of the new
4256    stub entry are initialised.  */
4257
4258 static struct ppc_stub_hash_entry *
4259 ppc_add_stub (const char *stub_name,
4260               asection *section,
4261               struct bfd_link_info *info)
4262 {
4263   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4264   asection *link_sec;
4265   asection *stub_sec;
4266   struct ppc_stub_hash_entry *stub_entry;
4267
4268   link_sec = htab->stub_group[section->id].link_sec;
4269   stub_sec = htab->stub_group[section->id].stub_sec;
4270   if (stub_sec == NULL)
4271     {
4272       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4273       if (stub_sec == NULL)
4274         {
4275           size_t namelen;
4276           bfd_size_type len;
4277           char *s_name;
4278
4279           namelen = strlen (link_sec->name);
4280           len = namelen + sizeof (STUB_SUFFIX);
4281           s_name = bfd_alloc (htab->stub_bfd, len);
4282           if (s_name == NULL)
4283             return NULL;
4284
4285           memcpy (s_name, link_sec->name, namelen);
4286           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4287           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4288           if (stub_sec == NULL)
4289             return NULL;
4290           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4291         }
4292       htab->stub_group[section->id].stub_sec = stub_sec;
4293     }
4294
4295   /* Enter this entry into the linker stub hash table.  */
4296   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4297                                      TRUE, FALSE);
4298   if (stub_entry == NULL)
4299     {
4300       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4301                               section->owner, stub_name);
4302       return NULL;
4303     }
4304
4305   stub_entry->stub_sec = stub_sec;
4306   stub_entry->stub_offset = 0;
4307   stub_entry->id_sec = link_sec;
4308   return stub_entry;
4309 }
4310
4311 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4312    not already done.  */
4313
4314 static bfd_boolean
4315 create_got_section (bfd *abfd, struct bfd_link_info *info)
4316 {
4317   asection *got, *relgot;
4318   flagword flags;
4319   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4320
4321   if (!is_ppc64_elf (abfd))
4322     return FALSE;
4323   if (htab == NULL)
4324     return FALSE;
4325
4326   if (!htab->got)
4327     {
4328       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4329         return FALSE;
4330
4331       htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4332       if (!htab->got)
4333         abort ();
4334     }
4335
4336   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4337            | SEC_LINKER_CREATED);
4338
4339   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4340   if (!got
4341       || !bfd_set_section_alignment (abfd, got, 3))
4342     return FALSE;
4343
4344   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4345                                                flags | SEC_READONLY);
4346   if (!relgot
4347       || ! bfd_set_section_alignment (abfd, relgot, 3))
4348     return FALSE;
4349
4350   ppc64_elf_tdata (abfd)->got = got;
4351   ppc64_elf_tdata (abfd)->relgot = relgot;
4352   return TRUE;
4353 }
4354
4355 /* Create the dynamic sections, and set up shortcuts.  */
4356
4357 static bfd_boolean
4358 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4359 {
4360   struct ppc_link_hash_table *htab;
4361
4362   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4363     return FALSE;
4364
4365   htab = ppc_hash_table (info);
4366   if (htab == NULL)
4367     return FALSE;
4368
4369   if (!htab->got)
4370     htab->got = bfd_get_linker_section (dynobj, ".got");
4371   htab->plt = bfd_get_linker_section (dynobj, ".plt");
4372   htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4373   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4374   if (!info->shared)
4375     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4376
4377   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4378       || (!info->shared && !htab->relbss))
4379     abort ();
4380
4381   return TRUE;
4382 }
4383
4384 /* Follow indirect and warning symbol links.  */
4385
4386 static inline struct bfd_link_hash_entry *
4387 follow_link (struct bfd_link_hash_entry *h)
4388 {
4389   while (h->type == bfd_link_hash_indirect
4390          || h->type == bfd_link_hash_warning)
4391     h = h->u.i.link;
4392   return h;
4393 }
4394
4395 static inline struct elf_link_hash_entry *
4396 elf_follow_link (struct elf_link_hash_entry *h)
4397 {
4398   return (struct elf_link_hash_entry *) follow_link (&h->root);
4399 }
4400
4401 static inline struct ppc_link_hash_entry *
4402 ppc_follow_link (struct ppc_link_hash_entry *h)
4403 {
4404   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4405 }
4406
4407 /* Merge PLT info on FROM with that on TO.  */
4408
4409 static void
4410 move_plt_plist (struct ppc_link_hash_entry *from,
4411                 struct ppc_link_hash_entry *to)
4412 {
4413   if (from->elf.plt.plist != NULL)
4414     {
4415       if (to->elf.plt.plist != NULL)
4416         {
4417           struct plt_entry **entp;
4418           struct plt_entry *ent;
4419
4420           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4421             {
4422               struct plt_entry *dent;
4423
4424               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4425                 if (dent->addend == ent->addend)
4426                   {
4427                     dent->plt.refcount += ent->plt.refcount;
4428                     *entp = ent->next;
4429                     break;
4430                   }
4431               if (dent == NULL)
4432                 entp = &ent->next;
4433             }
4434           *entp = to->elf.plt.plist;
4435         }
4436
4437       to->elf.plt.plist = from->elf.plt.plist;
4438       from->elf.plt.plist = NULL;
4439     }
4440 }
4441
4442 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4443
4444 static void
4445 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4446                                 struct elf_link_hash_entry *dir,
4447                                 struct elf_link_hash_entry *ind)
4448 {
4449   struct ppc_link_hash_entry *edir, *eind;
4450
4451   edir = (struct ppc_link_hash_entry *) dir;
4452   eind = (struct ppc_link_hash_entry *) ind;
4453
4454   edir->is_func |= eind->is_func;
4455   edir->is_func_descriptor |= eind->is_func_descriptor;
4456   edir->tls_mask |= eind->tls_mask;
4457   if (eind->oh != NULL)
4458     edir->oh = ppc_follow_link (eind->oh);
4459
4460   /* If called to transfer flags for a weakdef during processing
4461      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4462      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4463   if (!(ELIMINATE_COPY_RELOCS
4464         && eind->elf.root.type != bfd_link_hash_indirect
4465         && edir->elf.dynamic_adjusted))
4466     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4467
4468   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4469   edir->elf.ref_regular |= eind->elf.ref_regular;
4470   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4471   edir->elf.needs_plt |= eind->elf.needs_plt;
4472
4473   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4474   if (eind->dyn_relocs != NULL)
4475     {
4476       if (edir->dyn_relocs != NULL)
4477         {
4478           struct elf_dyn_relocs **pp;
4479           struct elf_dyn_relocs *p;
4480
4481           /* Add reloc counts against the indirect sym to the direct sym
4482              list.  Merge any entries against the same section.  */
4483           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4484             {
4485               struct elf_dyn_relocs *q;
4486
4487               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4488                 if (q->sec == p->sec)
4489                   {
4490                     q->pc_count += p->pc_count;
4491                     q->count += p->count;
4492                     *pp = p->next;
4493                     break;
4494                   }
4495               if (q == NULL)
4496                 pp = &p->next;
4497             }
4498           *pp = edir->dyn_relocs;
4499         }
4500
4501       edir->dyn_relocs = eind->dyn_relocs;
4502       eind->dyn_relocs = NULL;
4503     }
4504
4505   /* If we were called to copy over info for a weak sym, that's all.
4506      You might think dyn_relocs need not be copied over;  After all,
4507      both syms will be dynamic or both non-dynamic so we're just
4508      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4509      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4510      dyn_relocs in read-only sections, and it does so on what is the
4511      DIR sym here.  */
4512   if (eind->elf.root.type != bfd_link_hash_indirect)
4513     return;
4514
4515   /* Copy over got entries that we may have already seen to the
4516      symbol which just became indirect.  */
4517   if (eind->elf.got.glist != NULL)
4518     {
4519       if (edir->elf.got.glist != NULL)
4520         {
4521           struct got_entry **entp;
4522           struct got_entry *ent;
4523
4524           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4525             {
4526               struct got_entry *dent;
4527
4528               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4529                 if (dent->addend == ent->addend
4530                     && dent->owner == ent->owner
4531                     && dent->tls_type == ent->tls_type)
4532                   {
4533                     dent->got.refcount += ent->got.refcount;
4534                     *entp = ent->next;
4535                     break;
4536                   }
4537               if (dent == NULL)
4538                 entp = &ent->next;
4539             }
4540           *entp = edir->elf.got.glist;
4541         }
4542
4543       edir->elf.got.glist = eind->elf.got.glist;
4544       eind->elf.got.glist = NULL;
4545     }
4546
4547   /* And plt entries.  */
4548   move_plt_plist (eind, edir);
4549
4550   if (eind->elf.dynindx != -1)
4551     {
4552       if (edir->elf.dynindx != -1)
4553         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4554                                 edir->elf.dynstr_index);
4555       edir->elf.dynindx = eind->elf.dynindx;
4556       edir->elf.dynstr_index = eind->elf.dynstr_index;
4557       eind->elf.dynindx = -1;
4558       eind->elf.dynstr_index = 0;
4559     }
4560 }
4561
4562 /* Find the function descriptor hash entry from the given function code
4563    hash entry FH.  Link the entries via their OH fields.  */
4564
4565 static struct ppc_link_hash_entry *
4566 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4567 {
4568   struct ppc_link_hash_entry *fdh = fh->oh;
4569
4570   if (fdh == NULL)
4571     {
4572       const char *fd_name = fh->elf.root.root.string + 1;
4573
4574       fdh = (struct ppc_link_hash_entry *)
4575         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4576       if (fdh == NULL)
4577         return fdh;
4578
4579       fdh->is_func_descriptor = 1;
4580       fdh->oh = fh;
4581       fh->is_func = 1;
4582       fh->oh = fdh;
4583     }
4584
4585   return ppc_follow_link (fdh);
4586 }
4587
4588 /* Make a fake function descriptor sym for the code sym FH.  */
4589
4590 static struct ppc_link_hash_entry *
4591 make_fdh (struct bfd_link_info *info,
4592           struct ppc_link_hash_entry *fh)
4593 {
4594   bfd *abfd;
4595   asymbol *newsym;
4596   struct bfd_link_hash_entry *bh;
4597   struct ppc_link_hash_entry *fdh;
4598
4599   abfd = fh->elf.root.u.undef.abfd;
4600   newsym = bfd_make_empty_symbol (abfd);
4601   newsym->name = fh->elf.root.root.string + 1;
4602   newsym->section = bfd_und_section_ptr;
4603   newsym->value = 0;
4604   newsym->flags = BSF_WEAK;
4605
4606   bh = NULL;
4607   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4608                                          newsym->flags, newsym->section,
4609                                          newsym->value, NULL, FALSE, FALSE,
4610                                          &bh))
4611     return NULL;
4612
4613   fdh = (struct ppc_link_hash_entry *) bh;
4614   fdh->elf.non_elf = 0;
4615   fdh->fake = 1;
4616   fdh->is_func_descriptor = 1;
4617   fdh->oh = fh;
4618   fh->is_func = 1;
4619   fh->oh = fdh;
4620   return fdh;
4621 }
4622
4623 /* Fix function descriptor symbols defined in .opd sections to be
4624    function type.  */
4625
4626 static bfd_boolean
4627 ppc64_elf_add_symbol_hook (bfd *ibfd,
4628                            struct bfd_link_info *info,
4629                            Elf_Internal_Sym *isym,
4630                            const char **name ATTRIBUTE_UNUSED,
4631                            flagword *flags ATTRIBUTE_UNUSED,
4632                            asection **sec,
4633                            bfd_vma *value ATTRIBUTE_UNUSED)
4634 {
4635   if ((ibfd->flags & DYNAMIC) == 0
4636       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4637     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4638
4639   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4640     {
4641       if ((ibfd->flags & DYNAMIC) == 0)
4642         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4643     }
4644   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4645     ;
4646   else if (*sec != NULL
4647            && strcmp ((*sec)->name, ".opd") == 0)
4648     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4649
4650   return TRUE;
4651 }
4652
4653 /* This function makes an old ABI object reference to ".bar" cause the
4654    inclusion of a new ABI object archive that defines "bar".
4655    NAME is a symbol defined in an archive.  Return a symbol in the hash
4656    table that might be satisfied by the archive symbols.  */
4657
4658 static struct elf_link_hash_entry *
4659 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4660                                  struct bfd_link_info *info,
4661                                  const char *name)
4662 {
4663   struct elf_link_hash_entry *h;
4664   char *dot_name;
4665   size_t len;
4666
4667   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4668   if (h != NULL
4669       /* Don't return this sym if it is a fake function descriptor
4670          created by add_symbol_adjust.  */
4671       && !(h->root.type == bfd_link_hash_undefweak
4672            && ((struct ppc_link_hash_entry *) h)->fake))
4673     return h;
4674
4675   if (name[0] == '.')
4676     return h;
4677
4678   len = strlen (name);
4679   dot_name = bfd_alloc (abfd, len + 2);
4680   if (dot_name == NULL)
4681     return (struct elf_link_hash_entry *) 0 - 1;
4682   dot_name[0] = '.';
4683   memcpy (dot_name + 1, name, len + 1);
4684   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4685   bfd_release (abfd, dot_name);
4686   return h;
4687 }
4688
4689 /* This function satisfies all old ABI object references to ".bar" if a
4690    new ABI object defines "bar".  Well, at least, undefined dot symbols
4691    are made weak.  This stops later archive searches from including an
4692    object if we already have a function descriptor definition.  It also
4693    prevents the linker complaining about undefined symbols.
4694    We also check and correct mismatched symbol visibility here.  The
4695    most restrictive visibility of the function descriptor and the
4696    function entry symbol is used.  */
4697
4698 static bfd_boolean
4699 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4700 {
4701   struct ppc_link_hash_table *htab;
4702   struct ppc_link_hash_entry *fdh;
4703
4704   if (eh->elf.root.type == bfd_link_hash_indirect)
4705     return TRUE;
4706
4707   if (eh->elf.root.type == bfd_link_hash_warning)
4708     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4709
4710   if (eh->elf.root.root.string[0] != '.')
4711     abort ();
4712
4713   htab = ppc_hash_table (info);
4714   if (htab == NULL)
4715     return FALSE;
4716
4717   fdh = lookup_fdh (eh, htab);
4718   if (fdh == NULL)
4719     {
4720       if (!info->relocatable
4721           && (eh->elf.root.type == bfd_link_hash_undefined
4722               || eh->elf.root.type == bfd_link_hash_undefweak)
4723           && eh->elf.ref_regular)
4724         {
4725           /* Make an undefweak function descriptor sym, which is enough to
4726              pull in an --as-needed shared lib, but won't cause link
4727              errors.  Archives are handled elsewhere.  */
4728           fdh = make_fdh (info, eh);
4729           if (fdh == NULL)
4730             return FALSE;
4731           fdh->elf.ref_regular = 1;
4732         }
4733     }
4734   else
4735     {
4736       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4737       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4738       if (entry_vis < descr_vis)
4739         fdh->elf.other += entry_vis - descr_vis;
4740       else if (entry_vis > descr_vis)
4741         eh->elf.other += descr_vis - entry_vis;
4742
4743       if ((fdh->elf.root.type == bfd_link_hash_defined
4744            || fdh->elf.root.type == bfd_link_hash_defweak)
4745           && eh->elf.root.type == bfd_link_hash_undefined)
4746         {
4747           eh->elf.root.type = bfd_link_hash_undefweak;
4748           eh->was_undefined = 1;
4749           htab->twiddled_syms = 1;
4750         }
4751     }
4752
4753   return TRUE;
4754 }
4755
4756 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4757
4758 static bfd_boolean
4759 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4760 {
4761   struct ppc_link_hash_table *htab;
4762   struct ppc_link_hash_entry **p, *eh;
4763
4764   if (!is_ppc64_elf (info->output_bfd))
4765     return TRUE;
4766   htab = ppc_hash_table (info);
4767   if (htab == NULL)
4768     return FALSE;
4769
4770   if (is_ppc64_elf (ibfd))
4771     {
4772       p = &htab->dot_syms;
4773       while ((eh = *p) != NULL)
4774         {
4775           *p = NULL;
4776           if (&eh->elf == htab->elf.hgot)
4777             ;
4778           else if (htab->elf.hgot == NULL
4779                    && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4780             htab->elf.hgot = &eh->elf;
4781           else if (!add_symbol_adjust (eh, info))
4782             return FALSE;
4783           p = &eh->u.next_dot_sym;
4784         }
4785     }
4786
4787   /* Clear the list for non-ppc64 input files.  */
4788   p = &htab->dot_syms;
4789   while ((eh = *p) != NULL)
4790     {
4791       *p = NULL;
4792       p = &eh->u.next_dot_sym;
4793     }
4794
4795   /* We need to fix the undefs list for any syms we have twiddled to
4796      undef_weak.  */
4797   if (htab->twiddled_syms)
4798     {
4799       bfd_link_repair_undef_list (&htab->elf.root);
4800       htab->twiddled_syms = 0;
4801     }
4802   return TRUE;
4803 }
4804
4805 /* Undo hash table changes when an --as-needed input file is determined
4806    not to be needed.  */
4807
4808 static bfd_boolean
4809 ppc64_elf_notice_as_needed (bfd *ibfd,
4810                             struct bfd_link_info *info,
4811                             enum notice_asneeded_action act)
4812 {
4813   if (act == notice_not_needed)
4814     {
4815       struct ppc_link_hash_table *htab = ppc_hash_table (info);
4816
4817       if (htab == NULL)
4818         return FALSE;
4819
4820       htab->dot_syms = NULL;
4821     }
4822   return _bfd_elf_notice_as_needed (ibfd, info, act);
4823 }
4824
4825 /* If --just-symbols against a final linked binary, then assume we need
4826    toc adjusting stubs when calling functions defined there.  */
4827
4828 static void
4829 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4830 {
4831   if ((sec->flags & SEC_CODE) != 0
4832       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4833       && is_ppc64_elf (sec->owner))
4834     {
4835       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4836       if (got != NULL
4837           && got->size >= elf_backend_got_header_size
4838           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4839         sec->has_toc_reloc = 1;
4840     }
4841   _bfd_elf_link_just_syms (sec, info);
4842 }
4843
4844 static struct plt_entry **
4845 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4846                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4847 {
4848   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4849   struct plt_entry **local_plt;
4850   unsigned char *local_got_tls_masks;
4851
4852   if (local_got_ents == NULL)
4853     {
4854       bfd_size_type size = symtab_hdr->sh_info;
4855
4856       size *= (sizeof (*local_got_ents)
4857                + sizeof (*local_plt)
4858                + sizeof (*local_got_tls_masks));
4859       local_got_ents = bfd_zalloc (abfd, size);
4860       if (local_got_ents == NULL)
4861         return NULL;
4862       elf_local_got_ents (abfd) = local_got_ents;
4863     }
4864
4865   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4866     {
4867       struct got_entry *ent;
4868
4869       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4870         if (ent->addend == r_addend
4871             && ent->owner == abfd
4872             && ent->tls_type == tls_type)
4873           break;
4874       if (ent == NULL)
4875         {
4876           bfd_size_type amt = sizeof (*ent);
4877           ent = bfd_alloc (abfd, amt);
4878           if (ent == NULL)
4879             return FALSE;
4880           ent->next = local_got_ents[r_symndx];
4881           ent->addend = r_addend;
4882           ent->owner = abfd;
4883           ent->tls_type = tls_type;
4884           ent->is_indirect = FALSE;
4885           ent->got.refcount = 0;
4886           local_got_ents[r_symndx] = ent;
4887         }
4888       ent->got.refcount += 1;
4889     }
4890
4891   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4892   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4893   local_got_tls_masks[r_symndx] |= tls_type;
4894
4895   return local_plt + r_symndx;
4896 }
4897
4898 static bfd_boolean
4899 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4900 {
4901   struct plt_entry *ent;
4902
4903   for (ent = *plist; ent != NULL; ent = ent->next)
4904     if (ent->addend == addend)
4905       break;
4906   if (ent == NULL)
4907     {
4908       bfd_size_type amt = sizeof (*ent);
4909       ent = bfd_alloc (abfd, amt);
4910       if (ent == NULL)
4911         return FALSE;
4912       ent->next = *plist;
4913       ent->addend = addend;
4914       ent->plt.refcount = 0;
4915       *plist = ent;
4916     }
4917   ent->plt.refcount += 1;
4918   return TRUE;
4919 }
4920
4921 static bfd_boolean
4922 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4923 {
4924   return (r_type == R_PPC64_REL24
4925           || r_type == R_PPC64_REL14
4926           || r_type == R_PPC64_REL14_BRTAKEN
4927           || r_type == R_PPC64_REL14_BRNTAKEN
4928           || r_type == R_PPC64_ADDR24
4929           || r_type == R_PPC64_ADDR14
4930           || r_type == R_PPC64_ADDR14_BRTAKEN
4931           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4932 }
4933
4934 /* Look through the relocs for a section during the first phase, and
4935    calculate needed space in the global offset table, procedure
4936    linkage table, and dynamic reloc sections.  */
4937
4938 static bfd_boolean
4939 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4940                         asection *sec, const Elf_Internal_Rela *relocs)
4941 {
4942   struct ppc_link_hash_table *htab;
4943   Elf_Internal_Shdr *symtab_hdr;
4944   struct elf_link_hash_entry **sym_hashes;
4945   const Elf_Internal_Rela *rel;
4946   const Elf_Internal_Rela *rel_end;
4947   asection *sreloc;
4948   asection **opd_sym_map;
4949   struct elf_link_hash_entry *tga, *dottga;
4950
4951   if (info->relocatable)
4952     return TRUE;
4953
4954   /* Don't do anything special with non-loaded, non-alloced sections.
4955      In particular, any relocs in such sections should not affect GOT
4956      and PLT reference counting (ie. we don't allow them to create GOT
4957      or PLT entries), there's no possibility or desire to optimize TLS
4958      relocs, and there's not much point in propagating relocs to shared
4959      libs that the dynamic linker won't relocate.  */
4960   if ((sec->flags & SEC_ALLOC) == 0)
4961     return TRUE;
4962
4963   BFD_ASSERT (is_ppc64_elf (abfd));
4964
4965   htab = ppc_hash_table (info);
4966   if (htab == NULL)
4967     return FALSE;
4968
4969   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4970                               FALSE, FALSE, TRUE);
4971   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4972                                  FALSE, FALSE, TRUE);
4973   symtab_hdr = &elf_symtab_hdr (abfd);
4974   sym_hashes = elf_sym_hashes (abfd);
4975   sreloc = NULL;
4976   opd_sym_map = NULL;
4977   if (strcmp (sec->name, ".opd") == 0)
4978     {
4979       /* Garbage collection needs some extra help with .opd sections.
4980          We don't want to necessarily keep everything referenced by
4981          relocs in .opd, as that would keep all functions.  Instead,
4982          if we reference an .opd symbol (a function descriptor), we
4983          want to keep the function code symbol's section.  This is
4984          easy for global symbols, but for local syms we need to keep
4985          information about the associated function section.  */
4986       bfd_size_type amt;
4987
4988       amt = sec->size * sizeof (*opd_sym_map) / 8;
4989       opd_sym_map = bfd_zalloc (abfd, amt);
4990       if (opd_sym_map == NULL)
4991         return FALSE;
4992       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4993       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4994       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4995     }
4996
4997   rel_end = relocs + sec->reloc_count;
4998   for (rel = relocs; rel < rel_end; rel++)
4999     {
5000       unsigned long r_symndx;
5001       struct elf_link_hash_entry *h;
5002       enum elf_ppc64_reloc_type r_type;
5003       int tls_type;
5004       struct _ppc64_elf_section_data *ppc64_sec;
5005       struct plt_entry **ifunc;
5006
5007       r_symndx = ELF64_R_SYM (rel->r_info);
5008       if (r_symndx < symtab_hdr->sh_info)
5009         h = NULL;
5010       else
5011         {
5012           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5013           h = elf_follow_link (h);
5014
5015           /* PR15323, ref flags aren't set for references in the same
5016              object.  */
5017           h->root.non_ir_ref = 1;
5018
5019           if (h == htab->elf.hgot)
5020             sec->has_toc_reloc = 1;
5021         }
5022
5023       tls_type = 0;
5024       ifunc = NULL;
5025       if (h != NULL)
5026         {
5027           if (h->type == STT_GNU_IFUNC)
5028             {
5029               h->needs_plt = 1;
5030               ifunc = &h->plt.plist;
5031             }
5032         }
5033       else
5034         {
5035           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5036                                                           abfd, r_symndx);
5037           if (isym == NULL)
5038             return FALSE;
5039
5040           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5041             {
5042               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5043                                              rel->r_addend, PLT_IFUNC);
5044               if (ifunc == NULL)
5045                 return FALSE;
5046             }
5047         }
5048       r_type = ELF64_R_TYPE (rel->r_info);
5049       if (is_branch_reloc (r_type))
5050         {
5051           if (h != NULL && (h == tga || h == dottga))
5052             {
5053               if (rel != relocs
5054                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5055                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5056                 /* We have a new-style __tls_get_addr call with a marker
5057                    reloc.  */
5058                 ;
5059               else
5060                 /* Mark this section as having an old-style call.  */
5061                 sec->has_tls_get_addr_call = 1;
5062             }
5063
5064           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5065           if (ifunc != NULL
5066               && !update_plt_info (abfd, ifunc, rel->r_addend))
5067             return FALSE;
5068         }
5069
5070       switch (r_type)
5071         {
5072         case R_PPC64_TLSGD:
5073         case R_PPC64_TLSLD:
5074           /* These special tls relocs tie a call to __tls_get_addr with
5075              its parameter symbol.  */
5076           break;
5077
5078         case R_PPC64_GOT_TLSLD16:
5079         case R_PPC64_GOT_TLSLD16_LO:
5080         case R_PPC64_GOT_TLSLD16_HI:
5081         case R_PPC64_GOT_TLSLD16_HA:
5082           tls_type = TLS_TLS | TLS_LD;
5083           goto dogottls;
5084
5085         case R_PPC64_GOT_TLSGD16:
5086         case R_PPC64_GOT_TLSGD16_LO:
5087         case R_PPC64_GOT_TLSGD16_HI:
5088         case R_PPC64_GOT_TLSGD16_HA:
5089           tls_type = TLS_TLS | TLS_GD;
5090           goto dogottls;
5091
5092         case R_PPC64_GOT_TPREL16_DS:
5093         case R_PPC64_GOT_TPREL16_LO_DS:
5094         case R_PPC64_GOT_TPREL16_HI:
5095         case R_PPC64_GOT_TPREL16_HA:
5096           if (!info->executable)
5097             info->flags |= DF_STATIC_TLS;
5098           tls_type = TLS_TLS | TLS_TPREL;
5099           goto dogottls;
5100
5101         case R_PPC64_GOT_DTPREL16_DS:
5102         case R_PPC64_GOT_DTPREL16_LO_DS:
5103         case R_PPC64_GOT_DTPREL16_HI:
5104         case R_PPC64_GOT_DTPREL16_HA:
5105           tls_type = TLS_TLS | TLS_DTPREL;
5106         dogottls:
5107           sec->has_tls_reloc = 1;
5108           /* Fall thru */
5109
5110         case R_PPC64_GOT16:
5111         case R_PPC64_GOT16_DS:
5112         case R_PPC64_GOT16_HA:
5113         case R_PPC64_GOT16_HI:
5114         case R_PPC64_GOT16_LO:
5115         case R_PPC64_GOT16_LO_DS:
5116           /* This symbol requires a global offset table entry.  */
5117           sec->has_toc_reloc = 1;
5118           if (r_type == R_PPC64_GOT_TLSLD16
5119               || r_type == R_PPC64_GOT_TLSGD16
5120               || r_type == R_PPC64_GOT_TPREL16_DS
5121               || r_type == R_PPC64_GOT_DTPREL16_DS
5122               || r_type == R_PPC64_GOT16
5123               || r_type == R_PPC64_GOT16_DS)
5124             {
5125               htab->do_multi_toc = 1;
5126               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5127             }
5128
5129           if (ppc64_elf_tdata (abfd)->got == NULL
5130               && !create_got_section (abfd, info))
5131             return FALSE;
5132
5133           if (h != NULL)
5134             {
5135               struct ppc_link_hash_entry *eh;
5136               struct got_entry *ent;
5137
5138               eh = (struct ppc_link_hash_entry *) h;
5139               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5140                 if (ent->addend == rel->r_addend
5141                     && ent->owner == abfd
5142                     && ent->tls_type == tls_type)
5143                   break;
5144               if (ent == NULL)
5145                 {
5146                   bfd_size_type amt = sizeof (*ent);
5147                   ent = bfd_alloc (abfd, amt);
5148                   if (ent == NULL)
5149                     return FALSE;
5150                   ent->next = eh->elf.got.glist;
5151                   ent->addend = rel->r_addend;
5152                   ent->owner = abfd;
5153                   ent->tls_type = tls_type;
5154                   ent->is_indirect = FALSE;
5155                   ent->got.refcount = 0;
5156                   eh->elf.got.glist = ent;
5157                 }
5158               ent->got.refcount += 1;
5159               eh->tls_mask |= tls_type;
5160             }
5161           else
5162             /* This is a global offset table entry for a local symbol.  */
5163             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5164                                         rel->r_addend, tls_type))
5165               return FALSE;
5166           break;
5167
5168         case R_PPC64_PLT16_HA:
5169         case R_PPC64_PLT16_HI:
5170         case R_PPC64_PLT16_LO:
5171         case R_PPC64_PLT32:
5172         case R_PPC64_PLT64:
5173           /* This symbol requires a procedure linkage table entry.  We
5174              actually build the entry in adjust_dynamic_symbol,
5175              because this might be a case of linking PIC code without
5176              linking in any dynamic objects, in which case we don't
5177              need to generate a procedure linkage table after all.  */
5178           if (h == NULL)
5179             {
5180               /* It does not make sense to have a procedure linkage
5181                  table entry for a local symbol.  */
5182               bfd_set_error (bfd_error_bad_value);
5183               return FALSE;
5184             }
5185           else
5186             {
5187               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5188                 return FALSE;
5189               h->needs_plt = 1;
5190               if (h->root.root.string[0] == '.'
5191                   && h->root.root.string[1] != '\0')
5192                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5193             }
5194           break;
5195
5196           /* The following relocations don't need to propagate the
5197              relocation if linking a shared object since they are
5198              section relative.  */
5199         case R_PPC64_SECTOFF:
5200         case R_PPC64_SECTOFF_LO:
5201         case R_PPC64_SECTOFF_HI:
5202         case R_PPC64_SECTOFF_HA:
5203         case R_PPC64_SECTOFF_DS:
5204         case R_PPC64_SECTOFF_LO_DS:
5205         case R_PPC64_DTPREL16:
5206         case R_PPC64_DTPREL16_LO:
5207         case R_PPC64_DTPREL16_HI:
5208         case R_PPC64_DTPREL16_HA:
5209         case R_PPC64_DTPREL16_DS:
5210         case R_PPC64_DTPREL16_LO_DS:
5211         case R_PPC64_DTPREL16_HIGHER:
5212         case R_PPC64_DTPREL16_HIGHERA:
5213         case R_PPC64_DTPREL16_HIGHEST:
5214         case R_PPC64_DTPREL16_HIGHESTA:
5215           break;
5216
5217           /* Nor do these.  */
5218         case R_PPC64_REL16:
5219         case R_PPC64_REL16_LO:
5220         case R_PPC64_REL16_HI:
5221         case R_PPC64_REL16_HA:
5222           break;
5223
5224         case R_PPC64_TOC16:
5225         case R_PPC64_TOC16_DS:
5226           htab->do_multi_toc = 1;
5227           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5228         case R_PPC64_TOC16_LO:
5229         case R_PPC64_TOC16_HI:
5230         case R_PPC64_TOC16_HA:
5231         case R_PPC64_TOC16_LO_DS:
5232           sec->has_toc_reloc = 1;
5233           break;
5234
5235           /* This relocation describes the C++ object vtable hierarchy.
5236              Reconstruct it for later use during GC.  */
5237         case R_PPC64_GNU_VTINHERIT:
5238           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5239             return FALSE;
5240           break;
5241
5242           /* This relocation describes which C++ vtable entries are actually
5243              used.  Record for later use during GC.  */
5244         case R_PPC64_GNU_VTENTRY:
5245           BFD_ASSERT (h != NULL);
5246           if (h != NULL
5247               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5248             return FALSE;
5249           break;
5250
5251         case R_PPC64_REL14:
5252         case R_PPC64_REL14_BRTAKEN:
5253         case R_PPC64_REL14_BRNTAKEN:
5254           {
5255             asection *dest = NULL;
5256
5257             /* Heuristic: If jumping outside our section, chances are
5258                we are going to need a stub.  */
5259             if (h != NULL)
5260               {
5261                 /* If the sym is weak it may be overridden later, so
5262                    don't assume we know where a weak sym lives.  */
5263                 if (h->root.type == bfd_link_hash_defined)
5264                   dest = h->root.u.def.section;
5265               }
5266             else
5267               {
5268                 Elf_Internal_Sym *isym;
5269
5270                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5271                                               abfd, r_symndx);
5272                 if (isym == NULL)
5273                   return FALSE;
5274
5275                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5276               }
5277
5278             if (dest != sec)
5279               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5280           }
5281           /* Fall through.  */
5282
5283         case R_PPC64_REL24:
5284           if (h != NULL && ifunc == NULL)
5285             {
5286               /* We may need a .plt entry if the function this reloc
5287                  refers to is in a shared lib.  */
5288               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5289                 return FALSE;
5290               h->needs_plt = 1;
5291               if (h->root.root.string[0] == '.'
5292                   && h->root.root.string[1] != '\0')
5293                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5294               if (h == tga || h == dottga)
5295                 sec->has_tls_reloc = 1;
5296             }
5297           break;
5298
5299         case R_PPC64_TPREL64:
5300           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5301           if (!info->executable)
5302             info->flags |= DF_STATIC_TLS;
5303           goto dotlstoc;
5304
5305         case R_PPC64_DTPMOD64:
5306           if (rel + 1 < rel_end
5307               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5308               && rel[1].r_offset == rel->r_offset + 8)
5309             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5310           else
5311             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5312           goto dotlstoc;
5313
5314         case R_PPC64_DTPREL64:
5315           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5316           if (rel != relocs
5317               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5318               && rel[-1].r_offset == rel->r_offset - 8)
5319             /* This is the second reloc of a dtpmod, dtprel pair.
5320                Don't mark with TLS_DTPREL.  */
5321             goto dodyn;
5322
5323         dotlstoc:
5324           sec->has_tls_reloc = 1;
5325           if (h != NULL)
5326             {
5327               struct ppc_link_hash_entry *eh;
5328               eh = (struct ppc_link_hash_entry *) h;
5329               eh->tls_mask |= tls_type;
5330             }
5331           else
5332             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5333                                         rel->r_addend, tls_type))
5334               return FALSE;
5335
5336           ppc64_sec = ppc64_elf_section_data (sec);
5337           if (ppc64_sec->sec_type != sec_toc)
5338             {
5339               bfd_size_type amt;
5340
5341               /* One extra to simplify get_tls_mask.  */
5342               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5343               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5344               if (ppc64_sec->u.toc.symndx == NULL)
5345                 return FALSE;
5346               amt = sec->size * sizeof (bfd_vma) / 8;
5347               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5348               if (ppc64_sec->u.toc.add == NULL)
5349                 return FALSE;
5350               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5351               ppc64_sec->sec_type = sec_toc;
5352             }
5353           BFD_ASSERT (rel->r_offset % 8 == 0);
5354           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5355           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5356
5357           /* Mark the second slot of a GD or LD entry.
5358              -1 to indicate GD and -2 to indicate LD.  */
5359           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5360             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5361           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5362             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5363           goto dodyn;
5364
5365         case R_PPC64_TPREL16:
5366         case R_PPC64_TPREL16_LO:
5367         case R_PPC64_TPREL16_HI:
5368         case R_PPC64_TPREL16_HA:
5369         case R_PPC64_TPREL16_DS:
5370         case R_PPC64_TPREL16_LO_DS:
5371         case R_PPC64_TPREL16_HIGHER:
5372         case R_PPC64_TPREL16_HIGHERA:
5373         case R_PPC64_TPREL16_HIGHEST:
5374         case R_PPC64_TPREL16_HIGHESTA:
5375           if (info->shared)
5376             {
5377               if (!info->executable)
5378                 info->flags |= DF_STATIC_TLS;
5379               goto dodyn;
5380             }
5381           break;
5382
5383         case R_PPC64_ADDR64:
5384           if (opd_sym_map != NULL
5385               && rel + 1 < rel_end
5386               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5387             {
5388               if (h != NULL)
5389                 {
5390                   if (h->root.root.string[0] == '.'
5391                       && h->root.root.string[1] != 0
5392                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5393                     ;
5394                   else
5395                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5396                 }
5397               else
5398                 {
5399                   asection *s;
5400                   Elf_Internal_Sym *isym;
5401
5402                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5403                                                 abfd, r_symndx);
5404                   if (isym == NULL)
5405                     return FALSE;
5406
5407                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5408                   if (s != NULL && s != sec)
5409                     opd_sym_map[rel->r_offset / 8] = s;
5410                 }
5411             }
5412           /* Fall through.  */
5413
5414         case R_PPC64_REL30:
5415         case R_PPC64_REL32:
5416         case R_PPC64_REL64:
5417         case R_PPC64_ADDR14:
5418         case R_PPC64_ADDR14_BRNTAKEN:
5419         case R_PPC64_ADDR14_BRTAKEN:
5420         case R_PPC64_ADDR16:
5421         case R_PPC64_ADDR16_DS:
5422         case R_PPC64_ADDR16_HA:
5423         case R_PPC64_ADDR16_HI:
5424         case R_PPC64_ADDR16_HIGHER:
5425         case R_PPC64_ADDR16_HIGHERA:
5426         case R_PPC64_ADDR16_HIGHEST:
5427         case R_PPC64_ADDR16_HIGHESTA:
5428         case R_PPC64_ADDR16_LO:
5429         case R_PPC64_ADDR16_LO_DS:
5430         case R_PPC64_ADDR24:
5431         case R_PPC64_ADDR32:
5432         case R_PPC64_UADDR16:
5433         case R_PPC64_UADDR32:
5434         case R_PPC64_UADDR64:
5435         case R_PPC64_TOC:
5436           if (h != NULL && !info->shared)
5437             /* We may need a copy reloc.  */
5438             h->non_got_ref = 1;
5439
5440           /* Don't propagate .opd relocs.  */
5441           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5442             break;
5443
5444           /* If we are creating a shared library, and this is a reloc
5445              against a global symbol, or a non PC relative reloc
5446              against a local symbol, then we need to copy the reloc
5447              into the shared library.  However, if we are linking with
5448              -Bsymbolic, we do not need to copy a reloc against a
5449              global symbol which is defined in an object we are
5450              including in the link (i.e., DEF_REGULAR is set).  At
5451              this point we have not seen all the input files, so it is
5452              possible that DEF_REGULAR is not set now but will be set
5453              later (it is never cleared).  In case of a weak definition,
5454              DEF_REGULAR may be cleared later by a strong definition in
5455              a shared library.  We account for that possibility below by
5456              storing information in the dyn_relocs field of the hash
5457              table entry.  A similar situation occurs when creating
5458              shared libraries and symbol visibility changes render the
5459              symbol local.
5460
5461              If on the other hand, we are creating an executable, we
5462              may need to keep relocations for symbols satisfied by a
5463              dynamic library if we manage to avoid copy relocs for the
5464              symbol.  */
5465         dodyn:
5466           if ((info->shared
5467                && (must_be_dyn_reloc (info, r_type)
5468                    || (h != NULL
5469                        && (!SYMBOLIC_BIND (info, h)
5470                            || h->root.type == bfd_link_hash_defweak
5471                            || !h->def_regular))))
5472               || (ELIMINATE_COPY_RELOCS
5473                   && !info->shared
5474                   && h != NULL
5475                   && (h->root.type == bfd_link_hash_defweak
5476                       || !h->def_regular))
5477               || (!info->shared
5478                   && ifunc != NULL))
5479             {
5480               /* We must copy these reloc types into the output file.
5481                  Create a reloc section in dynobj and make room for
5482                  this reloc.  */
5483               if (sreloc == NULL)
5484                 {
5485                   sreloc = _bfd_elf_make_dynamic_reloc_section
5486                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5487
5488                   if (sreloc == NULL)
5489                     return FALSE;
5490                 }
5491
5492               /* If this is a global symbol, we count the number of
5493                  relocations we need for this symbol.  */
5494               if (h != NULL)
5495                 {
5496                   struct elf_dyn_relocs *p;
5497                   struct elf_dyn_relocs **head;
5498
5499                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5500                   p = *head;
5501                   if (p == NULL || p->sec != sec)
5502                     {
5503                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5504                       if (p == NULL)
5505                         return FALSE;
5506                       p->next = *head;
5507                       *head = p;
5508                       p->sec = sec;
5509                       p->count = 0;
5510                       p->pc_count = 0;
5511                     }
5512                   p->count += 1;
5513                   if (!must_be_dyn_reloc (info, r_type))
5514                     p->pc_count += 1;
5515                 }
5516               else
5517                 {
5518                   /* Track dynamic relocs needed for local syms too.
5519                      We really need local syms available to do this
5520                      easily.  Oh well.  */
5521                   struct ppc_dyn_relocs *p;
5522                   struct ppc_dyn_relocs **head;
5523                   bfd_boolean is_ifunc;
5524                   asection *s;
5525                   void *vpp;
5526                   Elf_Internal_Sym *isym;
5527
5528                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5529                                                 abfd, r_symndx);
5530                   if (isym == NULL)
5531                     return FALSE;
5532
5533                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5534                   if (s == NULL)
5535                     s = sec;
5536
5537                   vpp = &elf_section_data (s)->local_dynrel;
5538                   head = (struct ppc_dyn_relocs **) vpp;
5539                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5540                   p = *head;
5541                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5542                     p = p->next;
5543                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5544                     {
5545                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5546                       if (p == NULL)
5547                         return FALSE;
5548                       p->next = *head;
5549                       *head = p;
5550                       p->sec = sec;
5551                       p->ifunc = is_ifunc;
5552                       p->count = 0;
5553                     }
5554                   p->count += 1;
5555                 }
5556             }
5557           break;
5558
5559         default:
5560           break;
5561         }
5562     }
5563
5564   return TRUE;
5565 }
5566
5567 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5568    of the code entry point, and its section.  */
5569
5570 static bfd_vma
5571 opd_entry_value (asection *opd_sec,
5572                  bfd_vma offset,
5573                  asection **code_sec,
5574                  bfd_vma *code_off,
5575                  bfd_boolean in_code_sec)
5576 {
5577   bfd *opd_bfd = opd_sec->owner;
5578   Elf_Internal_Rela *relocs;
5579   Elf_Internal_Rela *lo, *hi, *look;
5580   bfd_vma val;
5581
5582   /* No relocs implies we are linking a --just-symbols object, or looking
5583      at a final linked executable with addr2line or somesuch.  */
5584   if (opd_sec->reloc_count == 0)
5585     {
5586       bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5587
5588       if (contents == NULL)
5589         {
5590           if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5591             return (bfd_vma) -1;
5592           ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5593         }
5594
5595       val = bfd_get_64 (opd_bfd, contents + offset);
5596       if (code_sec != NULL)
5597         {
5598           asection *sec, *likely = NULL;
5599
5600           if (in_code_sec)
5601             {
5602               sec = *code_sec;
5603               if (sec->vma <= val
5604                   && val < sec->vma + sec->size)
5605                 likely = sec;
5606               else
5607                 val = -1;
5608             }
5609           else
5610             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5611               if (sec->vma <= val
5612                   && (sec->flags & SEC_LOAD) != 0
5613                   && (sec->flags & SEC_ALLOC) != 0)
5614                 likely = sec;
5615           if (likely != NULL)
5616             {
5617               *code_sec = likely;
5618               if (code_off != NULL)
5619                 *code_off = val - likely->vma;
5620             }
5621         }
5622       return val;
5623     }
5624
5625   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5626
5627   relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5628   if (relocs == NULL)
5629     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5630
5631   /* Go find the opd reloc at the sym address.  */
5632   lo = relocs;
5633   BFD_ASSERT (lo != NULL);
5634   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5635   val = (bfd_vma) -1;
5636   while (lo < hi)
5637     {
5638       look = lo + (hi - lo) / 2;
5639       if (look->r_offset < offset)
5640         lo = look + 1;
5641       else if (look->r_offset > offset)
5642         hi = look;
5643       else
5644         {
5645           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5646
5647           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5648               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5649             {
5650               unsigned long symndx = ELF64_R_SYM (look->r_info);
5651               asection *sec;
5652
5653               if (symndx < symtab_hdr->sh_info
5654                   || elf_sym_hashes (opd_bfd) == NULL)
5655                 {
5656                   Elf_Internal_Sym *sym;
5657
5658                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5659                   if (sym == NULL)
5660                     {
5661                       size_t symcnt = symtab_hdr->sh_info;
5662                       if (elf_sym_hashes (opd_bfd) == NULL)
5663                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5664                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5665                                                   0, NULL, NULL, NULL);
5666                       if (sym == NULL)
5667                         break;
5668                       symtab_hdr->contents = (bfd_byte *) sym;
5669                     }
5670
5671                   sym += symndx;
5672                   val = sym->st_value;
5673                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5674                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5675                 }
5676               else
5677                 {
5678                   struct elf_link_hash_entry **sym_hashes;
5679                   struct elf_link_hash_entry *rh;
5680
5681                   sym_hashes = elf_sym_hashes (opd_bfd);
5682                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5683                   if (rh != NULL)
5684                     {
5685                       rh = elf_follow_link (rh);
5686                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5687                                   || rh->root.type == bfd_link_hash_defweak);
5688                       val = rh->root.u.def.value;
5689                       sec = rh->root.u.def.section;
5690                     }
5691                   else
5692                     {
5693                       /* Handle the odd case where we can be called
5694                          during bfd_elf_link_add_symbols before the
5695                          symbol hashes have been fully populated.  */
5696                       Elf_Internal_Sym *sym;
5697
5698                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5699                                                   symndx, NULL, NULL, NULL);
5700                       if (sym == NULL)
5701                         break;
5702
5703                       val = sym->st_value;
5704                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5705                       free (sym);
5706                     }
5707                 }
5708               val += look->r_addend;
5709               if (code_off != NULL)
5710                 *code_off = val;
5711               if (code_sec != NULL)
5712                 {
5713                   if (in_code_sec && *code_sec != sec)
5714                     return -1;
5715                   else
5716                     *code_sec = sec;
5717                 }
5718               if (sec != NULL && sec->output_section != NULL)
5719                 val += sec->output_section->vma + sec->output_offset;
5720             }
5721           break;
5722         }
5723     }
5724
5725   return val;
5726 }
5727
5728 /* If the ELF symbol SYM might be a function in SEC, return the
5729    function size and set *CODE_OFF to the function's entry point,
5730    otherwise return zero.  */
5731
5732 static bfd_size_type
5733 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5734                               bfd_vma *code_off)
5735 {
5736   bfd_size_type size;
5737
5738   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5739                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5740     return 0;
5741
5742   size = 0;
5743   if (!(sym->flags & BSF_SYNTHETIC))
5744     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5745
5746   if (strcmp (sym->section->name, ".opd") == 0)
5747     {
5748       if (opd_entry_value (sym->section, sym->value,
5749                            &sec, code_off, TRUE) == (bfd_vma) -1)
5750         return 0;
5751       /* An old ABI binary with dot-syms has a size of 24 on the .opd
5752          symbol.  This size has nothing to do with the code size of the
5753          function, which is what we're supposed to return, but the
5754          code size isn't available without looking up the dot-sym.
5755          However, doing that would be a waste of time particularly
5756          since elf_find_function will look at the dot-sym anyway.
5757          Now, elf_find_function will keep the largest size of any
5758          function sym found at the code address of interest, so return
5759          1 here to avoid it incorrectly caching a larger function size
5760          for a small function.  This does mean we return the wrong
5761          size for a new-ABI function of size 24, but all that does is
5762          disable caching for such functions.  */
5763       if (size == 24)
5764         size = 1;
5765     }
5766   else
5767     {
5768       if (sym->section != sec)
5769         return 0;
5770       *code_off = sym->value;
5771     }
5772   if (size == 0)
5773     size = 1;
5774   return size;
5775 }
5776
5777 /* Return true if symbol is defined in a regular object file.  */
5778
5779 static bfd_boolean
5780 is_static_defined (struct elf_link_hash_entry *h)
5781 {
5782   return ((h->root.type == bfd_link_hash_defined
5783            || h->root.type == bfd_link_hash_defweak)
5784           && h->root.u.def.section != NULL
5785           && h->root.u.def.section->output_section != NULL);
5786 }
5787
5788 /* If FDH is a function descriptor symbol, return the associated code
5789    entry symbol if it is defined.  Return NULL otherwise.  */
5790
5791 static struct ppc_link_hash_entry *
5792 defined_code_entry (struct ppc_link_hash_entry *fdh)
5793 {
5794   if (fdh->is_func_descriptor)
5795     {
5796       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5797       if (fh->elf.root.type == bfd_link_hash_defined
5798           || fh->elf.root.type == bfd_link_hash_defweak)
5799         return fh;
5800     }
5801   return NULL;
5802 }
5803
5804 /* If FH is a function code entry symbol, return the associated
5805    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5806
5807 static struct ppc_link_hash_entry *
5808 defined_func_desc (struct ppc_link_hash_entry *fh)
5809 {
5810   if (fh->oh != NULL
5811       && fh->oh->is_func_descriptor)
5812     {
5813       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5814       if (fdh->elf.root.type == bfd_link_hash_defined
5815           || fdh->elf.root.type == bfd_link_hash_defweak)
5816         return fdh;
5817     }
5818   return NULL;
5819 }
5820
5821 /* Mark all our entry sym sections, both opd and code section.  */
5822
5823 static void
5824 ppc64_elf_gc_keep (struct bfd_link_info *info)
5825 {
5826   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5827   struct bfd_sym_chain *sym;
5828
5829   if (htab == NULL)
5830     return;
5831
5832   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5833     {
5834       struct ppc_link_hash_entry *eh, *fh;
5835       asection *sec;
5836
5837       eh = (struct ppc_link_hash_entry *)
5838         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5839       if (eh == NULL)
5840         continue;
5841       if (eh->elf.root.type != bfd_link_hash_defined
5842           && eh->elf.root.type != bfd_link_hash_defweak)
5843         continue;
5844
5845       fh = defined_code_entry (eh);
5846       if (fh != NULL)
5847         {
5848           sec = fh->elf.root.u.def.section;
5849           sec->flags |= SEC_KEEP;
5850         }
5851       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5852                && opd_entry_value (eh->elf.root.u.def.section,
5853                                    eh->elf.root.u.def.value,
5854                                    &sec, NULL, FALSE) != (bfd_vma) -1)
5855         sec->flags |= SEC_KEEP;
5856
5857       sec = eh->elf.root.u.def.section;
5858       sec->flags |= SEC_KEEP;
5859     }
5860 }
5861
5862 /* Mark sections containing dynamically referenced symbols.  When
5863    building shared libraries, we must assume that any visible symbol is
5864    referenced.  */
5865
5866 static bfd_boolean
5867 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5868 {
5869   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5870   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5871   struct ppc_link_hash_entry *fdh;
5872
5873   /* Dynamic linking info is on the func descriptor sym.  */
5874   fdh = defined_func_desc (eh);
5875   if (fdh != NULL)
5876     eh = fdh;
5877
5878   if ((eh->elf.root.type == bfd_link_hash_defined
5879        || eh->elf.root.type == bfd_link_hash_defweak)
5880       && (eh->elf.ref_dynamic
5881           || (!info->executable
5882               && eh->elf.def_regular
5883               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5884               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5885               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5886                   || !bfd_hide_sym_by_version (info->version_info,
5887                                                eh->elf.root.root.string)))))
5888     {
5889       asection *code_sec;
5890       struct ppc_link_hash_entry *fh;
5891
5892       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5893
5894       /* Function descriptor syms cause the associated
5895          function code sym section to be marked.  */
5896       fh = defined_code_entry (eh);
5897       if (fh != NULL)
5898         {
5899           code_sec = fh->elf.root.u.def.section;
5900           code_sec->flags |= SEC_KEEP;
5901         }
5902       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5903                && opd_entry_value (eh->elf.root.u.def.section,
5904                                    eh->elf.root.u.def.value,
5905                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
5906         code_sec->flags |= SEC_KEEP;
5907     }
5908
5909   return TRUE;
5910 }
5911
5912 /* Return the section that should be marked against GC for a given
5913    relocation.  */
5914
5915 static asection *
5916 ppc64_elf_gc_mark_hook (asection *sec,
5917                         struct bfd_link_info *info,
5918                         Elf_Internal_Rela *rel,
5919                         struct elf_link_hash_entry *h,
5920                         Elf_Internal_Sym *sym)
5921 {
5922   asection *rsec;
5923
5924   /* Syms return NULL if we're marking .opd, so we avoid marking all
5925      function sections, as all functions are referenced in .opd.  */
5926   rsec = NULL;
5927   if (get_opd_info (sec) != NULL)
5928     return rsec;
5929
5930   if (h != NULL)
5931     {
5932       enum elf_ppc64_reloc_type r_type;
5933       struct ppc_link_hash_entry *eh, *fh, *fdh;
5934
5935       r_type = ELF64_R_TYPE (rel->r_info);
5936       switch (r_type)
5937         {
5938         case R_PPC64_GNU_VTINHERIT:
5939         case R_PPC64_GNU_VTENTRY:
5940           break;
5941
5942         default:
5943           switch (h->root.type)
5944             {
5945             case bfd_link_hash_defined:
5946             case bfd_link_hash_defweak:
5947               eh = (struct ppc_link_hash_entry *) h;
5948               fdh = defined_func_desc (eh);
5949               if (fdh != NULL)
5950                 eh = fdh;
5951
5952               /* Function descriptor syms cause the associated
5953                  function code sym section to be marked.  */
5954               fh = defined_code_entry (eh);
5955               if (fh != NULL)
5956                 {
5957                   /* They also mark their opd section.  */
5958                   eh->elf.root.u.def.section->gc_mark = 1;
5959
5960                   rsec = fh->elf.root.u.def.section;
5961                 }
5962               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5963                        && opd_entry_value (eh->elf.root.u.def.section,
5964                                            eh->elf.root.u.def.value,
5965                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
5966                 eh->elf.root.u.def.section->gc_mark = 1;
5967               else
5968                 rsec = h->root.u.def.section;
5969               break;
5970
5971             case bfd_link_hash_common:
5972               rsec = h->root.u.c.p->section;
5973               break;
5974
5975             default:
5976               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5977             }
5978         }
5979     }
5980   else
5981     {
5982       struct _opd_sec_data *opd;
5983
5984       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5985       opd = get_opd_info (rsec);
5986       if (opd != NULL && opd->func_sec != NULL)
5987         {
5988           rsec->gc_mark = 1;
5989
5990           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5991         }
5992     }
5993
5994   return rsec;
5995 }
5996
5997 /* Update the .got, .plt. and dynamic reloc reference counts for the
5998    section being removed.  */
5999
6000 static bfd_boolean
6001 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6002                          asection *sec, const Elf_Internal_Rela *relocs)
6003 {
6004   struct ppc_link_hash_table *htab;
6005   Elf_Internal_Shdr *symtab_hdr;
6006   struct elf_link_hash_entry **sym_hashes;
6007   struct got_entry **local_got_ents;
6008   const Elf_Internal_Rela *rel, *relend;
6009
6010   if (info->relocatable)
6011     return TRUE;
6012
6013   if ((sec->flags & SEC_ALLOC) == 0)
6014     return TRUE;
6015
6016   elf_section_data (sec)->local_dynrel = NULL;
6017
6018   htab = ppc_hash_table (info);
6019   if (htab == NULL)
6020     return FALSE;
6021
6022   symtab_hdr = &elf_symtab_hdr (abfd);
6023   sym_hashes = elf_sym_hashes (abfd);
6024   local_got_ents = elf_local_got_ents (abfd);
6025
6026   relend = relocs + sec->reloc_count;
6027   for (rel = relocs; rel < relend; rel++)
6028     {
6029       unsigned long r_symndx;
6030       enum elf_ppc64_reloc_type r_type;
6031       struct elf_link_hash_entry *h = NULL;
6032       unsigned char tls_type = 0;
6033
6034       r_symndx = ELF64_R_SYM (rel->r_info);
6035       r_type = ELF64_R_TYPE (rel->r_info);
6036       if (r_symndx >= symtab_hdr->sh_info)
6037         {
6038           struct ppc_link_hash_entry *eh;
6039           struct elf_dyn_relocs **pp;
6040           struct elf_dyn_relocs *p;
6041
6042           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6043           h = elf_follow_link (h);
6044           eh = (struct ppc_link_hash_entry *) h;
6045
6046           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6047             if (p->sec == sec)
6048               {
6049                 /* Everything must go for SEC.  */
6050                 *pp = p->next;
6051                 break;
6052               }
6053         }
6054
6055       if (is_branch_reloc (r_type))
6056         {
6057           struct plt_entry **ifunc = NULL;
6058           if (h != NULL)
6059             {
6060               if (h->type == STT_GNU_IFUNC)
6061                 ifunc = &h->plt.plist;
6062             }
6063           else if (local_got_ents != NULL)
6064             {
6065               struct plt_entry **local_plt = (struct plt_entry **)
6066                 (local_got_ents + symtab_hdr->sh_info);
6067               unsigned char *local_got_tls_masks = (unsigned char *)
6068                 (local_plt + symtab_hdr->sh_info);
6069               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6070                 ifunc = local_plt + r_symndx;
6071             }
6072           if (ifunc != NULL)
6073             {
6074               struct plt_entry *ent;
6075
6076               for (ent = *ifunc; ent != NULL; ent = ent->next)
6077                 if (ent->addend == rel->r_addend)
6078                   break;
6079               if (ent == NULL)
6080                 abort ();
6081               if (ent->plt.refcount > 0)
6082                 ent->plt.refcount -= 1;
6083               continue;
6084             }
6085         }
6086
6087       switch (r_type)
6088         {
6089         case R_PPC64_GOT_TLSLD16:
6090         case R_PPC64_GOT_TLSLD16_LO:
6091         case R_PPC64_GOT_TLSLD16_HI:
6092         case R_PPC64_GOT_TLSLD16_HA:
6093           tls_type = TLS_TLS | TLS_LD;
6094           goto dogot;
6095
6096         case R_PPC64_GOT_TLSGD16:
6097         case R_PPC64_GOT_TLSGD16_LO:
6098         case R_PPC64_GOT_TLSGD16_HI:
6099         case R_PPC64_GOT_TLSGD16_HA:
6100           tls_type = TLS_TLS | TLS_GD;
6101           goto dogot;
6102
6103         case R_PPC64_GOT_TPREL16_DS:
6104         case R_PPC64_GOT_TPREL16_LO_DS:
6105         case R_PPC64_GOT_TPREL16_HI:
6106         case R_PPC64_GOT_TPREL16_HA:
6107           tls_type = TLS_TLS | TLS_TPREL;
6108           goto dogot;
6109
6110         case R_PPC64_GOT_DTPREL16_DS:
6111         case R_PPC64_GOT_DTPREL16_LO_DS:
6112         case R_PPC64_GOT_DTPREL16_HI:
6113         case R_PPC64_GOT_DTPREL16_HA:
6114           tls_type = TLS_TLS | TLS_DTPREL;
6115           goto dogot;
6116
6117         case R_PPC64_GOT16:
6118         case R_PPC64_GOT16_DS:
6119         case R_PPC64_GOT16_HA:
6120         case R_PPC64_GOT16_HI:
6121         case R_PPC64_GOT16_LO:
6122         case R_PPC64_GOT16_LO_DS:
6123         dogot:
6124           {
6125             struct got_entry *ent;
6126
6127             if (h != NULL)
6128               ent = h->got.glist;
6129             else
6130               ent = local_got_ents[r_symndx];
6131
6132             for (; ent != NULL; ent = ent->next)
6133               if (ent->addend == rel->r_addend
6134                   && ent->owner == abfd
6135                   && ent->tls_type == tls_type)
6136                 break;
6137             if (ent == NULL)
6138               abort ();
6139             if (ent->got.refcount > 0)
6140               ent->got.refcount -= 1;
6141           }
6142           break;
6143
6144         case R_PPC64_PLT16_HA:
6145         case R_PPC64_PLT16_HI:
6146         case R_PPC64_PLT16_LO:
6147         case R_PPC64_PLT32:
6148         case R_PPC64_PLT64:
6149         case R_PPC64_REL14:
6150         case R_PPC64_REL14_BRNTAKEN:
6151         case R_PPC64_REL14_BRTAKEN:
6152         case R_PPC64_REL24:
6153           if (h != NULL)
6154             {
6155               struct plt_entry *ent;
6156
6157               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6158                 if (ent->addend == rel->r_addend)
6159                   break;
6160               if (ent != NULL && ent->plt.refcount > 0)
6161                 ent->plt.refcount -= 1;
6162             }
6163           break;
6164
6165         default:
6166           break;
6167         }
6168     }
6169   return TRUE;
6170 }
6171
6172 /* The maximum size of .sfpr.  */
6173 #define SFPR_MAX (218*4)
6174
6175 struct sfpr_def_parms
6176 {
6177   const char name[12];
6178   unsigned char lo, hi;
6179   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6180   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6181 };
6182
6183 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6184
6185 static bfd_boolean
6186 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6187 {
6188   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6189   unsigned int i;
6190   size_t len = strlen (parm->name);
6191   bfd_boolean writing = FALSE;
6192   char sym[16];
6193
6194   if (htab == NULL)
6195     return FALSE;
6196
6197   memcpy (sym, parm->name, len);
6198   sym[len + 2] = 0;
6199
6200   for (i = parm->lo; i <= parm->hi; i++)
6201     {
6202       struct elf_link_hash_entry *h;
6203
6204       sym[len + 0] = i / 10 + '0';
6205       sym[len + 1] = i % 10 + '0';
6206       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6207       if (h != NULL
6208           && !h->def_regular)
6209         {
6210           h->root.type = bfd_link_hash_defined;
6211           h->root.u.def.section = htab->sfpr;
6212           h->root.u.def.value = htab->sfpr->size;
6213           h->type = STT_FUNC;
6214           h->def_regular = 1;
6215           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6216           writing = TRUE;
6217           if (htab->sfpr->contents == NULL)
6218             {
6219               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6220               if (htab->sfpr->contents == NULL)
6221                 return FALSE;
6222             }
6223         }
6224       if (writing)
6225         {
6226           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6227           if (i != parm->hi)
6228             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6229           else
6230             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6231           htab->sfpr->size = p - htab->sfpr->contents;
6232         }
6233     }
6234
6235   return TRUE;
6236 }
6237
6238 static bfd_byte *
6239 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6240 {
6241   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6242   return p + 4;
6243 }
6244
6245 static bfd_byte *
6246 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6247 {
6248   p = savegpr0 (abfd, p, r);
6249   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6250   p = p + 4;
6251   bfd_put_32 (abfd, BLR, p);
6252   return p + 4;
6253 }
6254
6255 static bfd_byte *
6256 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6257 {
6258   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6259   return p + 4;
6260 }
6261
6262 static bfd_byte *
6263 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6264 {
6265   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6266   p = p + 4;
6267   p = restgpr0 (abfd, p, r);
6268   bfd_put_32 (abfd, MTLR_R0, p);
6269   p = p + 4;
6270   if (r == 29)
6271     {
6272       p = restgpr0 (abfd, p, 30);
6273       p = restgpr0 (abfd, p, 31);
6274     }
6275   bfd_put_32 (abfd, BLR, p);
6276   return p + 4;
6277 }
6278
6279 static bfd_byte *
6280 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6281 {
6282   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6283   return p + 4;
6284 }
6285
6286 static bfd_byte *
6287 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6288 {
6289   p = savegpr1 (abfd, p, r);
6290   bfd_put_32 (abfd, BLR, p);
6291   return p + 4;
6292 }
6293
6294 static bfd_byte *
6295 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6296 {
6297   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6298   return p + 4;
6299 }
6300
6301 static bfd_byte *
6302 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6303 {
6304   p = restgpr1 (abfd, p, r);
6305   bfd_put_32 (abfd, BLR, p);
6306   return p + 4;
6307 }
6308
6309 static bfd_byte *
6310 savefpr (bfd *abfd, bfd_byte *p, int r)
6311 {
6312   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6313   return p + 4;
6314 }
6315
6316 static bfd_byte *
6317 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6318 {
6319   p = savefpr (abfd, p, r);
6320   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6321   p = p + 4;
6322   bfd_put_32 (abfd, BLR, p);
6323   return p + 4;
6324 }
6325
6326 static bfd_byte *
6327 restfpr (bfd *abfd, bfd_byte *p, int r)
6328 {
6329   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6330   return p + 4;
6331 }
6332
6333 static bfd_byte *
6334 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6335 {
6336   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6337   p = p + 4;
6338   p = restfpr (abfd, p, r);
6339   bfd_put_32 (abfd, MTLR_R0, p);
6340   p = p + 4;
6341   if (r == 29)
6342     {
6343       p = restfpr (abfd, p, 30);
6344       p = restfpr (abfd, p, 31);
6345     }
6346   bfd_put_32 (abfd, BLR, p);
6347   return p + 4;
6348 }
6349
6350 static bfd_byte *
6351 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6352 {
6353   p = savefpr (abfd, p, r);
6354   bfd_put_32 (abfd, BLR, p);
6355   return p + 4;
6356 }
6357
6358 static bfd_byte *
6359 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6360 {
6361   p = restfpr (abfd, p, r);
6362   bfd_put_32 (abfd, BLR, p);
6363   return p + 4;
6364 }
6365
6366 static bfd_byte *
6367 savevr (bfd *abfd, bfd_byte *p, int r)
6368 {
6369   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6370   p = p + 4;
6371   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6372   return p + 4;
6373 }
6374
6375 static bfd_byte *
6376 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6377 {
6378   p = savevr (abfd, p, r);
6379   bfd_put_32 (abfd, BLR, p);
6380   return p + 4;
6381 }
6382
6383 static bfd_byte *
6384 restvr (bfd *abfd, bfd_byte *p, int r)
6385 {
6386   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6387   p = p + 4;
6388   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6389   return p + 4;
6390 }
6391
6392 static bfd_byte *
6393 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6394 {
6395   p = restvr (abfd, p, r);
6396   bfd_put_32 (abfd, BLR, p);
6397   return p + 4;
6398 }
6399
6400 /* Called via elf_link_hash_traverse to transfer dynamic linking
6401    information on function code symbol entries to their corresponding
6402    function descriptor symbol entries.  */
6403
6404 static bfd_boolean
6405 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6406 {
6407   struct bfd_link_info *info;
6408   struct ppc_link_hash_table *htab;
6409   struct plt_entry *ent;
6410   struct ppc_link_hash_entry *fh;
6411   struct ppc_link_hash_entry *fdh;
6412   bfd_boolean force_local;
6413
6414   fh = (struct ppc_link_hash_entry *) h;
6415   if (fh->elf.root.type == bfd_link_hash_indirect)
6416     return TRUE;
6417
6418   info = inf;
6419   htab = ppc_hash_table (info);
6420   if (htab == NULL)
6421     return FALSE;
6422
6423   /* Resolve undefined references to dot-symbols as the value
6424      in the function descriptor, if we have one in a regular object.
6425      This is to satisfy cases like ".quad .foo".  Calls to functions
6426      in dynamic objects are handled elsewhere.  */
6427   if (fh->elf.root.type == bfd_link_hash_undefweak
6428       && fh->was_undefined
6429       && (fdh = defined_func_desc (fh)) != NULL
6430       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6431       && opd_entry_value (fdh->elf.root.u.def.section,
6432                           fdh->elf.root.u.def.value,
6433                           &fh->elf.root.u.def.section,
6434                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6435     {
6436       fh->elf.root.type = fdh->elf.root.type;
6437       fh->elf.forced_local = 1;
6438       fh->elf.def_regular = fdh->elf.def_regular;
6439       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6440     }
6441
6442   /* If this is a function code symbol, transfer dynamic linking
6443      information to the function descriptor symbol.  */
6444   if (!fh->is_func)
6445     return TRUE;
6446
6447   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6448     if (ent->plt.refcount > 0)
6449       break;
6450   if (ent == NULL
6451       || fh->elf.root.root.string[0] != '.'
6452       || fh->elf.root.root.string[1] == '\0')
6453     return TRUE;
6454
6455   /* Find the corresponding function descriptor symbol.  Create it
6456      as undefined if necessary.  */
6457
6458   fdh = lookup_fdh (fh, htab);
6459   if (fdh == NULL
6460       && !info->executable
6461       && (fh->elf.root.type == bfd_link_hash_undefined
6462           || fh->elf.root.type == bfd_link_hash_undefweak))
6463     {
6464       fdh = make_fdh (info, fh);
6465       if (fdh == NULL)
6466         return FALSE;
6467     }
6468
6469   /* Fake function descriptors are made undefweak.  If the function
6470      code symbol is strong undefined, make the fake sym the same.
6471      If the function code symbol is defined, then force the fake
6472      descriptor local;  We can't support overriding of symbols in a
6473      shared library on a fake descriptor.  */
6474
6475   if (fdh != NULL
6476       && fdh->fake
6477       && fdh->elf.root.type == bfd_link_hash_undefweak)
6478     {
6479       if (fh->elf.root.type == bfd_link_hash_undefined)
6480         {
6481           fdh->elf.root.type = bfd_link_hash_undefined;
6482           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6483         }
6484       else if (fh->elf.root.type == bfd_link_hash_defined
6485                || fh->elf.root.type == bfd_link_hash_defweak)
6486         {
6487           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6488         }
6489     }
6490
6491   if (fdh != NULL
6492       && !fdh->elf.forced_local
6493       && (!info->executable
6494           || fdh->elf.def_dynamic
6495           || fdh->elf.ref_dynamic
6496           || (fdh->elf.root.type == bfd_link_hash_undefweak
6497               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6498     {
6499       if (fdh->elf.dynindx == -1)
6500         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6501           return FALSE;
6502       fdh->elf.ref_regular |= fh->elf.ref_regular;
6503       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6504       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6505       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6506       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6507         {
6508           move_plt_plist (fh, fdh);
6509           fdh->elf.needs_plt = 1;
6510         }
6511       fdh->is_func_descriptor = 1;
6512       fdh->oh = fh;
6513       fh->oh = fdh;
6514     }
6515
6516   /* Now that the info is on the function descriptor, clear the
6517      function code sym info.  Any function code syms for which we
6518      don't have a definition in a regular file, we force local.
6519      This prevents a shared library from exporting syms that have
6520      been imported from another library.  Function code syms that
6521      are really in the library we must leave global to prevent the
6522      linker dragging in a definition from a static library.  */
6523   force_local = (!fh->elf.def_regular
6524                  || fdh == NULL
6525                  || !fdh->elf.def_regular
6526                  || fdh->elf.forced_local);
6527   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6528
6529   return TRUE;
6530 }
6531
6532 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6533    this hook to a) provide some gcc support functions, and b) transfer
6534    dynamic linking information gathered so far on function code symbol
6535    entries, to their corresponding function descriptor symbol entries.  */
6536
6537 static bfd_boolean
6538 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6539                             struct bfd_link_info *info)
6540 {
6541   struct ppc_link_hash_table *htab;
6542   unsigned int i;
6543   static const struct sfpr_def_parms funcs[] =
6544     {
6545       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6546       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6547       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6548       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6549       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6550       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6551       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6552       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6553       { "._savef", 14, 31, savefpr, savefpr1_tail },
6554       { "._restf", 14, 31, restfpr, restfpr1_tail },
6555       { "_savevr_", 20, 31, savevr, savevr_tail },
6556       { "_restvr_", 20, 31, restvr, restvr_tail }
6557     };
6558
6559   htab = ppc_hash_table (info);
6560   if (htab == NULL)
6561     return FALSE;
6562
6563   if (!info->relocatable
6564       && htab->elf.hgot != NULL)
6565     _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6566
6567   if (htab->sfpr == NULL)
6568     /* We don't have any relocs.  */
6569     return TRUE;
6570
6571   /* Provide any missing _save* and _rest* functions.  */
6572   htab->sfpr->size = 0;
6573   if (!info->relocatable)
6574     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6575       if (!sfpr_define (info, &funcs[i]))
6576         return FALSE;
6577
6578   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6579
6580   if (htab->sfpr->size == 0)
6581     htab->sfpr->flags |= SEC_EXCLUDE;
6582
6583   return TRUE;
6584 }
6585
6586 /* Adjust a symbol defined by a dynamic object and referenced by a
6587    regular object.  The current definition is in some section of the
6588    dynamic object, but we're not including those sections.  We have to
6589    change the definition to something the rest of the link can
6590    understand.  */
6591
6592 static bfd_boolean
6593 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6594                                  struct elf_link_hash_entry *h)
6595 {
6596   struct ppc_link_hash_table *htab;
6597   asection *s;
6598
6599   htab = ppc_hash_table (info);
6600   if (htab == NULL)
6601     return FALSE;
6602
6603   /* Deal with function syms.  */
6604   if (h->type == STT_FUNC
6605       || h->type == STT_GNU_IFUNC
6606       || h->needs_plt)
6607     {
6608       /* Clear procedure linkage table information for any symbol that
6609          won't need a .plt entry.  */
6610       struct plt_entry *ent;
6611       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6612         if (ent->plt.refcount > 0)
6613           break;
6614       if (ent == NULL
6615           || (h->type != STT_GNU_IFUNC
6616               && (SYMBOL_CALLS_LOCAL (info, h)
6617                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6618                       && h->root.type == bfd_link_hash_undefweak))))
6619         {
6620           h->plt.plist = NULL;
6621           h->needs_plt = 0;
6622         }
6623     }
6624   else
6625     h->plt.plist = NULL;
6626
6627   /* If this is a weak symbol, and there is a real definition, the
6628      processor independent code will have arranged for us to see the
6629      real definition first, and we can just use the same value.  */
6630   if (h->u.weakdef != NULL)
6631     {
6632       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6633                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6634       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6635       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6636       if (ELIMINATE_COPY_RELOCS)
6637         h->non_got_ref = h->u.weakdef->non_got_ref;
6638       return TRUE;
6639     }
6640
6641   /* If we are creating a shared library, we must presume that the
6642      only references to the symbol are via the global offset table.
6643      For such cases we need not do anything here; the relocations will
6644      be handled correctly by relocate_section.  */
6645   if (info->shared)
6646     return TRUE;
6647
6648   /* If there are no references to this symbol that do not use the
6649      GOT, we don't need to generate a copy reloc.  */
6650   if (!h->non_got_ref)
6651     return TRUE;
6652
6653   /* Don't generate a copy reloc for symbols defined in the executable.  */
6654   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6655     return TRUE;
6656
6657   if (ELIMINATE_COPY_RELOCS)
6658     {
6659       struct ppc_link_hash_entry * eh;
6660       struct elf_dyn_relocs *p;
6661
6662       eh = (struct ppc_link_hash_entry *) h;
6663       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6664         {
6665           s = p->sec->output_section;
6666           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6667             break;
6668         }
6669
6670       /* If we didn't find any dynamic relocs in read-only sections, then
6671          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6672       if (p == NULL)
6673         {
6674           h->non_got_ref = 0;
6675           return TRUE;
6676         }
6677     }
6678
6679   if (h->plt.plist != NULL)
6680     {
6681       /* We should never get here, but unfortunately there are versions
6682          of gcc out there that improperly (for this ABI) put initialized
6683          function pointers, vtable refs and suchlike in read-only
6684          sections.  Allow them to proceed, but warn that this might
6685          break at runtime.  */
6686       info->callbacks->einfo
6687         (_("%P: copy reloc against `%T' requires lazy plt linking; "
6688            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6689          h->root.root.string);
6690     }
6691
6692   /* This is a reference to a symbol defined by a dynamic object which
6693      is not a function.  */
6694
6695   /* We must allocate the symbol in our .dynbss section, which will
6696      become part of the .bss section of the executable.  There will be
6697      an entry for this symbol in the .dynsym section.  The dynamic
6698      object will contain position independent code, so all references
6699      from the dynamic object to this symbol will go through the global
6700      offset table.  The dynamic linker will use the .dynsym entry to
6701      determine the address it must put in the global offset table, so
6702      both the dynamic object and the regular object will refer to the
6703      same memory location for the variable.  */
6704
6705   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6706      to copy the initial value out of the dynamic object and into the
6707      runtime process image.  We need to remember the offset into the
6708      .rela.bss section we are going to use.  */
6709   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6710     {
6711       htab->relbss->size += sizeof (Elf64_External_Rela);
6712       h->needs_copy = 1;
6713     }
6714
6715   s = htab->dynbss;
6716
6717   return _bfd_elf_adjust_dynamic_copy (h, s);
6718 }
6719
6720 /* If given a function descriptor symbol, hide both the function code
6721    sym and the descriptor.  */
6722 static void
6723 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6724                        struct elf_link_hash_entry *h,
6725                        bfd_boolean force_local)
6726 {
6727   struct ppc_link_hash_entry *eh;
6728   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6729
6730   eh = (struct ppc_link_hash_entry *) h;
6731   if (eh->is_func_descriptor)
6732     {
6733       struct ppc_link_hash_entry *fh = eh->oh;
6734
6735       if (fh == NULL)
6736         {
6737           const char *p, *q;
6738           struct ppc_link_hash_table *htab;
6739           char save;
6740
6741           /* We aren't supposed to use alloca in BFD because on
6742              systems which do not have alloca the version in libiberty
6743              calls xmalloc, which might cause the program to crash
6744              when it runs out of memory.  This function doesn't have a
6745              return status, so there's no way to gracefully return an
6746              error.  So cheat.  We know that string[-1] can be safely
6747              accessed;  It's either a string in an ELF string table,
6748              or allocated in an objalloc structure.  */
6749
6750           p = eh->elf.root.root.string - 1;
6751           save = *p;
6752           *(char *) p = '.';
6753           htab = ppc_hash_table (info);
6754           if (htab == NULL)
6755             return;
6756
6757           fh = (struct ppc_link_hash_entry *)
6758             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6759           *(char *) p = save;
6760
6761           /* Unfortunately, if it so happens that the string we were
6762              looking for was allocated immediately before this string,
6763              then we overwrote the string terminator.  That's the only
6764              reason the lookup should fail.  */
6765           if (fh == NULL)
6766             {
6767               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6768               while (q >= eh->elf.root.root.string && *q == *p)
6769                 --q, --p;
6770               if (q < eh->elf.root.root.string && *p == '.')
6771                 fh = (struct ppc_link_hash_entry *)
6772                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6773             }
6774           if (fh != NULL)
6775             {
6776               eh->oh = fh;
6777               fh->oh = eh;
6778             }
6779         }
6780       if (fh != NULL)
6781         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6782     }
6783 }
6784
6785 static bfd_boolean
6786 get_sym_h (struct elf_link_hash_entry **hp,
6787            Elf_Internal_Sym **symp,
6788            asection **symsecp,
6789            unsigned char **tls_maskp,
6790            Elf_Internal_Sym **locsymsp,
6791            unsigned long r_symndx,
6792            bfd *ibfd)
6793 {
6794   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6795
6796   if (r_symndx >= symtab_hdr->sh_info)
6797     {
6798       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6799       struct elf_link_hash_entry *h;
6800
6801       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6802       h = elf_follow_link (h);
6803
6804       if (hp != NULL)
6805         *hp = h;
6806
6807       if (symp != NULL)
6808         *symp = NULL;
6809
6810       if (symsecp != NULL)
6811         {
6812           asection *symsec = NULL;
6813           if (h->root.type == bfd_link_hash_defined
6814               || h->root.type == bfd_link_hash_defweak)
6815             symsec = h->root.u.def.section;
6816           *symsecp = symsec;
6817         }
6818
6819       if (tls_maskp != NULL)
6820         {
6821           struct ppc_link_hash_entry *eh;
6822
6823           eh = (struct ppc_link_hash_entry *) h;
6824           *tls_maskp = &eh->tls_mask;
6825         }
6826     }
6827   else
6828     {
6829       Elf_Internal_Sym *sym;
6830       Elf_Internal_Sym *locsyms = *locsymsp;
6831
6832       if (locsyms == NULL)
6833         {
6834           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6835           if (locsyms == NULL)
6836             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6837                                             symtab_hdr->sh_info,
6838                                             0, NULL, NULL, NULL);
6839           if (locsyms == NULL)
6840             return FALSE;
6841           *locsymsp = locsyms;
6842         }
6843       sym = locsyms + r_symndx;
6844
6845       if (hp != NULL)
6846         *hp = NULL;
6847
6848       if (symp != NULL)
6849         *symp = sym;
6850
6851       if (symsecp != NULL)
6852         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6853
6854       if (tls_maskp != NULL)
6855         {
6856           struct got_entry **lgot_ents;
6857           unsigned char *tls_mask;
6858
6859           tls_mask = NULL;
6860           lgot_ents = elf_local_got_ents (ibfd);
6861           if (lgot_ents != NULL)
6862             {
6863               struct plt_entry **local_plt = (struct plt_entry **)
6864                 (lgot_ents + symtab_hdr->sh_info);
6865               unsigned char *lgot_masks = (unsigned char *)
6866                 (local_plt + symtab_hdr->sh_info);
6867               tls_mask = &lgot_masks[r_symndx];
6868             }
6869           *tls_maskp = tls_mask;
6870         }
6871     }
6872   return TRUE;
6873 }
6874
6875 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6876    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6877    type suitable for optimization, and 1 otherwise.  */
6878
6879 static int
6880 get_tls_mask (unsigned char **tls_maskp,
6881               unsigned long *toc_symndx,
6882               bfd_vma *toc_addend,
6883               Elf_Internal_Sym **locsymsp,
6884               const Elf_Internal_Rela *rel,
6885               bfd *ibfd)
6886 {
6887   unsigned long r_symndx;
6888   int next_r;
6889   struct elf_link_hash_entry *h;
6890   Elf_Internal_Sym *sym;
6891   asection *sec;
6892   bfd_vma off;
6893
6894   r_symndx = ELF64_R_SYM (rel->r_info);
6895   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6896     return 0;
6897
6898   if ((*tls_maskp != NULL && **tls_maskp != 0)
6899       || sec == NULL
6900       || ppc64_elf_section_data (sec) == NULL
6901       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6902     return 1;
6903
6904   /* Look inside a TOC section too.  */
6905   if (h != NULL)
6906     {
6907       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6908       off = h->root.u.def.value;
6909     }
6910   else
6911     off = sym->st_value;
6912   off += rel->r_addend;
6913   BFD_ASSERT (off % 8 == 0);
6914   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6915   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6916   if (toc_symndx != NULL)
6917     *toc_symndx = r_symndx;
6918   if (toc_addend != NULL)
6919     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6920   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6921     return 0;
6922   if ((h == NULL || is_static_defined (h))
6923       && (next_r == -1 || next_r == -2))
6924     return 1 - next_r;
6925   return 1;
6926 }
6927
6928 /* Find (or create) an entry in the tocsave hash table.  */
6929
6930 static struct tocsave_entry *
6931 tocsave_find (struct ppc_link_hash_table *htab,
6932               enum insert_option insert,
6933               Elf_Internal_Sym **local_syms,
6934               const Elf_Internal_Rela *irela,
6935               bfd *ibfd)
6936 {
6937   unsigned long r_indx;
6938   struct elf_link_hash_entry *h;
6939   Elf_Internal_Sym *sym;
6940   struct tocsave_entry ent, *p;
6941   hashval_t hash;
6942   struct tocsave_entry **slot;
6943
6944   r_indx = ELF64_R_SYM (irela->r_info);
6945   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6946     return NULL;
6947   if (ent.sec == NULL || ent.sec->output_section == NULL)
6948     {
6949       (*_bfd_error_handler)
6950         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6951       return NULL;
6952     }
6953
6954   if (h != NULL)
6955     ent.offset = h->root.u.def.value;
6956   else
6957     ent.offset = sym->st_value;
6958   ent.offset += irela->r_addend;
6959
6960   hash = tocsave_htab_hash (&ent);
6961   slot = ((struct tocsave_entry **)
6962           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6963   if (slot == NULL)
6964     return NULL;
6965
6966   if (*slot == NULL)
6967     {
6968       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6969       if (p == NULL)
6970         return NULL;
6971       *p = ent;
6972       *slot = p;
6973     }
6974   return *slot;
6975 }
6976
6977 /* Adjust all global syms defined in opd sections.  In gcc generated
6978    code for the old ABI, these will already have been done.  */
6979
6980 static bfd_boolean
6981 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6982 {
6983   struct ppc_link_hash_entry *eh;
6984   asection *sym_sec;
6985   struct _opd_sec_data *opd;
6986
6987   if (h->root.type == bfd_link_hash_indirect)
6988     return TRUE;
6989
6990   if (h->root.type != bfd_link_hash_defined
6991       && h->root.type != bfd_link_hash_defweak)
6992     return TRUE;
6993
6994   eh = (struct ppc_link_hash_entry *) h;
6995   if (eh->adjust_done)
6996     return TRUE;
6997
6998   sym_sec = eh->elf.root.u.def.section;
6999   opd = get_opd_info (sym_sec);
7000   if (opd != NULL && opd->adjust != NULL)
7001     {
7002       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7003       if (adjust == -1)
7004         {
7005           /* This entry has been deleted.  */
7006           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7007           if (dsec == NULL)
7008             {
7009               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7010                 if (discarded_section (dsec))
7011                   {
7012                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7013                     break;
7014                   }
7015             }
7016           eh->elf.root.u.def.value = 0;
7017           eh->elf.root.u.def.section = dsec;
7018         }
7019       else
7020         eh->elf.root.u.def.value += adjust;
7021       eh->adjust_done = 1;
7022     }
7023   return TRUE;
7024 }
7025
7026 /* Handles decrementing dynamic reloc counts for the reloc specified by
7027    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7028    have already been determined.  */
7029
7030 static bfd_boolean
7031 dec_dynrel_count (bfd_vma r_info,
7032                   asection *sec,
7033                   struct bfd_link_info *info,
7034                   Elf_Internal_Sym **local_syms,
7035                   struct elf_link_hash_entry *h,
7036                   Elf_Internal_Sym *sym)
7037 {
7038   enum elf_ppc64_reloc_type r_type;
7039   asection *sym_sec = NULL;
7040
7041   /* Can this reloc be dynamic?  This switch, and later tests here
7042      should be kept in sync with the code in check_relocs.  */
7043   r_type = ELF64_R_TYPE (r_info);
7044   switch (r_type)
7045     {
7046     default:
7047       return TRUE;
7048
7049     case R_PPC64_TPREL16:
7050     case R_PPC64_TPREL16_LO:
7051     case R_PPC64_TPREL16_HI:
7052     case R_PPC64_TPREL16_HA:
7053     case R_PPC64_TPREL16_DS:
7054     case R_PPC64_TPREL16_LO_DS:
7055     case R_PPC64_TPREL16_HIGHER:
7056     case R_PPC64_TPREL16_HIGHERA:
7057     case R_PPC64_TPREL16_HIGHEST:
7058     case R_PPC64_TPREL16_HIGHESTA:
7059       if (!info->shared)
7060         return TRUE;
7061
7062     case R_PPC64_TPREL64:
7063     case R_PPC64_DTPMOD64:
7064     case R_PPC64_DTPREL64:
7065     case R_PPC64_ADDR64:
7066     case R_PPC64_REL30:
7067     case R_PPC64_REL32:
7068     case R_PPC64_REL64:
7069     case R_PPC64_ADDR14:
7070     case R_PPC64_ADDR14_BRNTAKEN:
7071     case R_PPC64_ADDR14_BRTAKEN:
7072     case R_PPC64_ADDR16:
7073     case R_PPC64_ADDR16_DS:
7074     case R_PPC64_ADDR16_HA:
7075     case R_PPC64_ADDR16_HI:
7076     case R_PPC64_ADDR16_HIGHER:
7077     case R_PPC64_ADDR16_HIGHERA:
7078     case R_PPC64_ADDR16_HIGHEST:
7079     case R_PPC64_ADDR16_HIGHESTA:
7080     case R_PPC64_ADDR16_LO:
7081     case R_PPC64_ADDR16_LO_DS:
7082     case R_PPC64_ADDR24:
7083     case R_PPC64_ADDR32:
7084     case R_PPC64_UADDR16:
7085     case R_PPC64_UADDR32:
7086     case R_PPC64_UADDR64:
7087     case R_PPC64_TOC:
7088       break;
7089     }
7090
7091   if (local_syms != NULL)
7092     {
7093       unsigned long r_symndx;
7094       bfd *ibfd = sec->owner;
7095
7096       r_symndx = ELF64_R_SYM (r_info);
7097       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7098         return FALSE;
7099     }
7100
7101   if ((info->shared
7102        && (must_be_dyn_reloc (info, r_type)
7103            || (h != NULL
7104                && (!SYMBOLIC_BIND (info, h)
7105                    || h->root.type == bfd_link_hash_defweak
7106                    || !h->def_regular))))
7107       || (ELIMINATE_COPY_RELOCS
7108           && !info->shared
7109           && h != NULL
7110           && (h->root.type == bfd_link_hash_defweak
7111               || !h->def_regular)))
7112     ;
7113   else
7114     return TRUE;
7115
7116   if (h != NULL)
7117     {
7118       struct elf_dyn_relocs *p;
7119       struct elf_dyn_relocs **pp;
7120       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7121
7122       /* elf_gc_sweep may have already removed all dyn relocs associated
7123          with local syms for a given section.  Also, symbol flags are
7124          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7125          report a dynreloc miscount.  */
7126       if (*pp == NULL && info->gc_sections)
7127         return TRUE;
7128
7129       while ((p = *pp) != NULL)
7130         {
7131           if (p->sec == sec)
7132             {
7133               if (!must_be_dyn_reloc (info, r_type))
7134                 p->pc_count -= 1;
7135               p->count -= 1;
7136               if (p->count == 0)
7137                 *pp = p->next;
7138               return TRUE;
7139             }
7140           pp = &p->next;
7141         }
7142     }
7143   else
7144     {
7145       struct ppc_dyn_relocs *p;
7146       struct ppc_dyn_relocs **pp;
7147       void *vpp;
7148       bfd_boolean is_ifunc;
7149
7150       if (local_syms == NULL)
7151         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7152       if (sym_sec == NULL)
7153         sym_sec = sec;
7154
7155       vpp = &elf_section_data (sym_sec)->local_dynrel;
7156       pp = (struct ppc_dyn_relocs **) vpp;
7157
7158       if (*pp == NULL && info->gc_sections)
7159         return TRUE;
7160
7161       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7162       while ((p = *pp) != NULL)
7163         {
7164           if (p->sec == sec && p->ifunc == is_ifunc)
7165             {
7166               p->count -= 1;
7167               if (p->count == 0)
7168                 *pp = p->next;
7169               return TRUE;
7170             }
7171           pp = &p->next;
7172         }
7173     }
7174
7175   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7176                           sec->owner, sec);
7177   bfd_set_error (bfd_error_bad_value);
7178   return FALSE;
7179 }
7180
7181 /* Remove unused Official Procedure Descriptor entries.  Currently we
7182    only remove those associated with functions in discarded link-once
7183    sections, or weakly defined functions that have been overridden.  It
7184    would be possible to remove many more entries for statically linked
7185    applications.  */
7186
7187 bfd_boolean
7188 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7189 {
7190   bfd *ibfd;
7191   bfd_boolean some_edited = FALSE;
7192   asection *need_pad = NULL;
7193
7194   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7195     {
7196       asection *sec;
7197       Elf_Internal_Rela *relstart, *rel, *relend;
7198       Elf_Internal_Shdr *symtab_hdr;
7199       Elf_Internal_Sym *local_syms;
7200       bfd_vma offset;
7201       struct _opd_sec_data *opd;
7202       bfd_boolean need_edit, add_aux_fields;
7203       bfd_size_type cnt_16b = 0;
7204
7205       if (!is_ppc64_elf (ibfd))
7206         continue;
7207
7208       sec = bfd_get_section_by_name (ibfd, ".opd");
7209       if (sec == NULL || sec->size == 0)
7210         continue;
7211
7212       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7213         continue;
7214
7215       if (sec->output_section == bfd_abs_section_ptr)
7216         continue;
7217
7218       /* Look through the section relocs.  */
7219       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7220         continue;
7221
7222       local_syms = NULL;
7223       symtab_hdr = &elf_symtab_hdr (ibfd);
7224
7225       /* Read the relocations.  */
7226       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7227                                             info->keep_memory);
7228       if (relstart == NULL)
7229         return FALSE;
7230
7231       /* First run through the relocs to check they are sane, and to
7232          determine whether we need to edit this opd section.  */
7233       need_edit = FALSE;
7234       need_pad = sec;
7235       offset = 0;
7236       relend = relstart + sec->reloc_count;
7237       for (rel = relstart; rel < relend; )
7238         {
7239           enum elf_ppc64_reloc_type r_type;
7240           unsigned long r_symndx;
7241           asection *sym_sec;
7242           struct elf_link_hash_entry *h;
7243           Elf_Internal_Sym *sym;
7244
7245           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7246              only interested in the reloc pointing to a function entry
7247              point.  */
7248           if (rel->r_offset != offset
7249               || rel + 1 >= relend
7250               || (rel + 1)->r_offset != offset + 8)
7251             {
7252               /* If someone messes with .opd alignment then after a
7253                  "ld -r" we might have padding in the middle of .opd.
7254                  Also, there's nothing to prevent someone putting
7255                  something silly in .opd with the assembler.  No .opd
7256                  optimization for them!  */
7257             broken_opd:
7258               (*_bfd_error_handler)
7259                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7260               need_edit = FALSE;
7261               break;
7262             }
7263
7264           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7265               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7266             {
7267               (*_bfd_error_handler)
7268                 (_("%B: unexpected reloc type %u in .opd section"),
7269                  ibfd, r_type);
7270               need_edit = FALSE;
7271               break;
7272             }
7273
7274           r_symndx = ELF64_R_SYM (rel->r_info);
7275           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7276                           r_symndx, ibfd))
7277             goto error_ret;
7278
7279           if (sym_sec == NULL || sym_sec->owner == NULL)
7280             {
7281               const char *sym_name;
7282               if (h != NULL)
7283                 sym_name = h->root.root.string;
7284               else
7285                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7286                                              sym_sec);
7287
7288               (*_bfd_error_handler)
7289                 (_("%B: undefined sym `%s' in .opd section"),
7290                  ibfd, sym_name);
7291               need_edit = FALSE;
7292               break;
7293             }
7294
7295           /* opd entries are always for functions defined in the
7296              current input bfd.  If the symbol isn't defined in the
7297              input bfd, then we won't be using the function in this
7298              bfd;  It must be defined in a linkonce section in another
7299              bfd, or is weak.  It's also possible that we are
7300              discarding the function due to a linker script /DISCARD/,
7301              which we test for via the output_section.  */
7302           if (sym_sec->owner != ibfd
7303               || sym_sec->output_section == bfd_abs_section_ptr)
7304             need_edit = TRUE;
7305
7306           rel += 2;
7307           if (rel == relend
7308               || (rel + 1 == relend && rel->r_offset == offset + 16))
7309             {
7310               if (sec->size == offset + 24)
7311                 {
7312                   need_pad = NULL;
7313                   break;
7314                 }
7315               if (rel == relend && sec->size == offset + 16)
7316                 {
7317                   cnt_16b++;
7318                   break;
7319                 }
7320               goto broken_opd;
7321             }
7322
7323           if (rel->r_offset == offset + 24)
7324             offset += 24;
7325           else if (rel->r_offset != offset + 16)
7326             goto broken_opd;
7327           else if (rel + 1 < relend
7328                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7329                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7330             {
7331               offset += 16;
7332               cnt_16b++;
7333             }
7334           else if (rel + 2 < relend
7335                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7336                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7337             {
7338               offset += 24;
7339               rel += 1;
7340             }
7341           else
7342             goto broken_opd;
7343         }
7344
7345       add_aux_fields = non_overlapping && cnt_16b > 0;
7346
7347       if (need_edit || add_aux_fields)
7348         {
7349           Elf_Internal_Rela *write_rel;
7350           Elf_Internal_Shdr *rel_hdr;
7351           bfd_byte *rptr, *wptr;
7352           bfd_byte *new_contents;
7353           bfd_boolean skip;
7354           long opd_ent_size;
7355           bfd_size_type amt;
7356
7357           new_contents = NULL;
7358           amt = sec->size * sizeof (long) / 8;
7359           opd = &ppc64_elf_section_data (sec)->u.opd;
7360           opd->adjust = bfd_zalloc (sec->owner, amt);
7361           if (opd->adjust == NULL)
7362             return FALSE;
7363           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7364
7365           /* This seems a waste of time as input .opd sections are all
7366              zeros as generated by gcc, but I suppose there's no reason
7367              this will always be so.  We might start putting something in
7368              the third word of .opd entries.  */
7369           if ((sec->flags & SEC_IN_MEMORY) == 0)
7370             {
7371               bfd_byte *loc;
7372               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7373                 {
7374                   if (loc != NULL)
7375                     free (loc);
7376                 error_ret:
7377                   if (local_syms != NULL
7378                       && symtab_hdr->contents != (unsigned char *) local_syms)
7379                     free (local_syms);
7380                   if (elf_section_data (sec)->relocs != relstart)
7381                     free (relstart);
7382                   return FALSE;
7383                 }
7384               sec->contents = loc;
7385               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7386             }
7387
7388           elf_section_data (sec)->relocs = relstart;
7389
7390           new_contents = sec->contents;
7391           if (add_aux_fields)
7392             {
7393               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7394               if (new_contents == NULL)
7395                 return FALSE;
7396               need_pad = FALSE;
7397             }
7398           wptr = new_contents;
7399           rptr = sec->contents;
7400
7401           write_rel = relstart;
7402           skip = FALSE;
7403           offset = 0;
7404           opd_ent_size = 0;
7405           for (rel = relstart; rel < relend; rel++)
7406             {
7407               unsigned long r_symndx;
7408               asection *sym_sec;
7409               struct elf_link_hash_entry *h;
7410               Elf_Internal_Sym *sym;
7411
7412               r_symndx = ELF64_R_SYM (rel->r_info);
7413               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7414                               r_symndx, ibfd))
7415                 goto error_ret;
7416
7417               if (rel->r_offset == offset)
7418                 {
7419                   struct ppc_link_hash_entry *fdh = NULL;
7420
7421                   /* See if the .opd entry is full 24 byte or
7422                      16 byte (with fd_aux entry overlapped with next
7423                      fd_func).  */
7424                   opd_ent_size = 24;
7425                   if ((rel + 2 == relend && sec->size == offset + 16)
7426                       || (rel + 3 < relend
7427                           && rel[2].r_offset == offset + 16
7428                           && rel[3].r_offset == offset + 24
7429                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7430                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7431                     opd_ent_size = 16;
7432
7433                   if (h != NULL
7434                       && h->root.root.string[0] == '.')
7435                     {
7436                       struct ppc_link_hash_table *htab;
7437
7438                       htab = ppc_hash_table (info);
7439                       if (htab != NULL)
7440                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7441                                           htab);
7442                       if (fdh != NULL
7443                           && fdh->elf.root.type != bfd_link_hash_defined
7444                           && fdh->elf.root.type != bfd_link_hash_defweak)
7445                         fdh = NULL;
7446                     }
7447
7448                   skip = (sym_sec->owner != ibfd
7449                           || sym_sec->output_section == bfd_abs_section_ptr);
7450                   if (skip)
7451                     {
7452                       if (fdh != NULL && sym_sec->owner == ibfd)
7453                         {
7454                           /* Arrange for the function descriptor sym
7455                              to be dropped.  */
7456                           fdh->elf.root.u.def.value = 0;
7457                           fdh->elf.root.u.def.section = sym_sec;
7458                         }
7459                       opd->adjust[rel->r_offset / 8] = -1;
7460                     }
7461                   else
7462                     {
7463                       /* We'll be keeping this opd entry.  */
7464
7465                       if (fdh != NULL)
7466                         {
7467                           /* Redefine the function descriptor symbol to
7468                              this location in the opd section.  It is
7469                              necessary to update the value here rather
7470                              than using an array of adjustments as we do
7471                              for local symbols, because various places
7472                              in the generic ELF code use the value
7473                              stored in u.def.value.  */
7474                           fdh->elf.root.u.def.value = wptr - new_contents;
7475                           fdh->adjust_done = 1;
7476                         }
7477
7478                       /* Local syms are a bit tricky.  We could
7479                          tweak them as they can be cached, but
7480                          we'd need to look through the local syms
7481                          for the function descriptor sym which we
7482                          don't have at the moment.  So keep an
7483                          array of adjustments.  */
7484                       opd->adjust[rel->r_offset / 8]
7485                         = (wptr - new_contents) - (rptr - sec->contents);
7486
7487                       if (wptr != rptr)
7488                         memcpy (wptr, rptr, opd_ent_size);
7489                       wptr += opd_ent_size;
7490                       if (add_aux_fields && opd_ent_size == 16)
7491                         {
7492                           memset (wptr, '\0', 8);
7493                           wptr += 8;
7494                         }
7495                     }
7496                   rptr += opd_ent_size;
7497                   offset += opd_ent_size;
7498                 }
7499
7500               if (skip)
7501                 {
7502                   if (!NO_OPD_RELOCS
7503                       && !info->relocatable
7504                       && !dec_dynrel_count (rel->r_info, sec, info,
7505                                             NULL, h, sym))
7506                     goto error_ret;
7507                 }
7508               else
7509                 {
7510                   /* We need to adjust any reloc offsets to point to the
7511                      new opd entries.  While we're at it, we may as well
7512                      remove redundant relocs.  */
7513                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7514                   if (write_rel != rel)
7515                     memcpy (write_rel, rel, sizeof (*rel));
7516                   ++write_rel;
7517                 }
7518             }
7519
7520           sec->size = wptr - new_contents;
7521           sec->reloc_count = write_rel - relstart;
7522           if (add_aux_fields)
7523             {
7524               free (sec->contents);
7525               sec->contents = new_contents;
7526             }
7527
7528           /* Fudge the header size too, as this is used later in
7529              elf_bfd_final_link if we are emitting relocs.  */
7530           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7531           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7532           some_edited = TRUE;
7533         }
7534       else if (elf_section_data (sec)->relocs != relstart)
7535         free (relstart);
7536
7537       if (local_syms != NULL
7538           && symtab_hdr->contents != (unsigned char *) local_syms)
7539         {
7540           if (!info->keep_memory)
7541             free (local_syms);
7542           else
7543             symtab_hdr->contents = (unsigned char *) local_syms;
7544         }
7545     }
7546
7547   if (some_edited)
7548     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7549
7550   /* If we are doing a final link and the last .opd entry is just 16 byte
7551      long, add a 8 byte padding after it.  */
7552   if (need_pad != NULL && !info->relocatable)
7553     {
7554       bfd_byte *p;
7555
7556       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7557         {
7558           BFD_ASSERT (need_pad->size > 0);
7559
7560           p = bfd_malloc (need_pad->size + 8);
7561           if (p == NULL)
7562             return FALSE;
7563
7564           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7565                                           p, 0, need_pad->size))
7566             return FALSE;
7567
7568           need_pad->contents = p;
7569           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7570         }
7571       else
7572         {
7573           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7574           if (p == NULL)
7575             return FALSE;
7576
7577           need_pad->contents = p;
7578         }
7579
7580       memset (need_pad->contents + need_pad->size, 0, 8);
7581       need_pad->size += 8;
7582     }
7583
7584   return TRUE;
7585 }
7586
7587 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7588
7589 asection *
7590 ppc64_elf_tls_setup (struct bfd_link_info *info,
7591                      int no_tls_get_addr_opt,
7592                      int *no_multi_toc)
7593 {
7594   struct ppc_link_hash_table *htab;
7595
7596   htab = ppc_hash_table (info);
7597   if (htab == NULL)
7598     return NULL;
7599
7600   if (*no_multi_toc)
7601     htab->do_multi_toc = 0;
7602   else if (!htab->do_multi_toc)
7603     *no_multi_toc = 1;
7604
7605   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7606                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7607                                               FALSE, FALSE, TRUE));
7608   /* Move dynamic linking info to the function descriptor sym.  */
7609   if (htab->tls_get_addr != NULL)
7610     func_desc_adjust (&htab->tls_get_addr->elf, info);
7611   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7612                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7613                                                  FALSE, FALSE, TRUE));
7614   if (!no_tls_get_addr_opt)
7615     {
7616       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7617
7618       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7619                                   FALSE, FALSE, TRUE);
7620       if (opt != NULL)
7621         func_desc_adjust (opt, info);
7622       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7623                                      FALSE, FALSE, TRUE);
7624       if (opt_fd != NULL
7625           && (opt_fd->root.type == bfd_link_hash_defined
7626               || opt_fd->root.type == bfd_link_hash_defweak))
7627         {
7628           /* If glibc supports an optimized __tls_get_addr call stub,
7629              signalled by the presence of __tls_get_addr_opt, and we'll
7630              be calling __tls_get_addr via a plt call stub, then
7631              make __tls_get_addr point to __tls_get_addr_opt.  */
7632           tga_fd = &htab->tls_get_addr_fd->elf;
7633           if (htab->elf.dynamic_sections_created
7634               && tga_fd != NULL
7635               && (tga_fd->type == STT_FUNC
7636                   || tga_fd->needs_plt)
7637               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7638                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7639                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7640             {
7641               struct plt_entry *ent;
7642
7643               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7644                 if (ent->plt.refcount > 0)
7645                   break;
7646               if (ent != NULL)
7647                 {
7648                   tga_fd->root.type = bfd_link_hash_indirect;
7649                   tga_fd->root.u.i.link = &opt_fd->root;
7650                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7651                   if (opt_fd->dynindx != -1)
7652                     {
7653                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7654                       opt_fd->dynindx = -1;
7655                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7656                                               opt_fd->dynstr_index);
7657                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7658                         return NULL;
7659                     }
7660                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7661                   tga = &htab->tls_get_addr->elf;
7662                   if (opt != NULL && tga != NULL)
7663                     {
7664                       tga->root.type = bfd_link_hash_indirect;
7665                       tga->root.u.i.link = &opt->root;
7666                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7667                       _bfd_elf_link_hash_hide_symbol (info, opt,
7668                                                       tga->forced_local);
7669                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7670                     }
7671                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7672                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7673                   if (htab->tls_get_addr != NULL)
7674                     {
7675                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7676                       htab->tls_get_addr->is_func = 1;
7677                     }
7678                 }
7679             }
7680         }
7681       else
7682         no_tls_get_addr_opt = TRUE;
7683     }
7684   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7685   return _bfd_elf_tls_setup (info->output_bfd, info);
7686 }
7687
7688 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7689    HASH1 or HASH2.  */
7690
7691 static bfd_boolean
7692 branch_reloc_hash_match (const bfd *ibfd,
7693                          const Elf_Internal_Rela *rel,
7694                          const struct ppc_link_hash_entry *hash1,
7695                          const struct ppc_link_hash_entry *hash2)
7696 {
7697   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7698   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7699   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7700
7701   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7702     {
7703       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7704       struct elf_link_hash_entry *h;
7705
7706       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7707       h = elf_follow_link (h);
7708       if (h == &hash1->elf || h == &hash2->elf)
7709         return TRUE;
7710     }
7711   return FALSE;
7712 }
7713
7714 /* Run through all the TLS relocs looking for optimization
7715    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7716    a preliminary section layout so that we know the TLS segment
7717    offsets.  We can't optimize earlier because some optimizations need
7718    to know the tp offset, and we need to optimize before allocating
7719    dynamic relocations.  */
7720
7721 bfd_boolean
7722 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7723 {
7724   bfd *ibfd;
7725   asection *sec;
7726   struct ppc_link_hash_table *htab;
7727   unsigned char *toc_ref;
7728   int pass;
7729
7730   if (info->relocatable || !info->executable)
7731     return TRUE;
7732
7733   htab = ppc_hash_table (info);
7734   if (htab == NULL)
7735     return FALSE;
7736
7737   /* Make two passes over the relocs.  On the first pass, mark toc
7738      entries involved with tls relocs, and check that tls relocs
7739      involved in setting up a tls_get_addr call are indeed followed by
7740      such a call.  If they are not, we can't do any tls optimization.
7741      On the second pass twiddle tls_mask flags to notify
7742      relocate_section that optimization can be done, and adjust got
7743      and plt refcounts.  */
7744   toc_ref = NULL;
7745   for (pass = 0; pass < 2; ++pass)
7746     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7747       {
7748         Elf_Internal_Sym *locsyms = NULL;
7749         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7750
7751         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7752           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7753             {
7754               Elf_Internal_Rela *relstart, *rel, *relend;
7755               bfd_boolean found_tls_get_addr_arg = 0;
7756
7757               /* Read the relocations.  */
7758               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7759                                                     info->keep_memory);
7760               if (relstart == NULL)
7761                 return FALSE;
7762
7763               relend = relstart + sec->reloc_count;
7764               for (rel = relstart; rel < relend; rel++)
7765                 {
7766                   enum elf_ppc64_reloc_type r_type;
7767                   unsigned long r_symndx;
7768                   struct elf_link_hash_entry *h;
7769                   Elf_Internal_Sym *sym;
7770                   asection *sym_sec;
7771                   unsigned char *tls_mask;
7772                   unsigned char tls_set, tls_clear, tls_type = 0;
7773                   bfd_vma value;
7774                   bfd_boolean ok_tprel, is_local;
7775                   long toc_ref_index = 0;
7776                   int expecting_tls_get_addr = 0;
7777                   bfd_boolean ret = FALSE;
7778
7779                   r_symndx = ELF64_R_SYM (rel->r_info);
7780                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7781                                   r_symndx, ibfd))
7782                     {
7783                     err_free_rel:
7784                       if (elf_section_data (sec)->relocs != relstart)
7785                         free (relstart);
7786                       if (toc_ref != NULL)
7787                         free (toc_ref);
7788                       if (locsyms != NULL
7789                           && (elf_symtab_hdr (ibfd).contents
7790                               != (unsigned char *) locsyms))
7791                         free (locsyms);
7792                       return ret;
7793                     }
7794
7795                   if (h != NULL)
7796                     {
7797                       if (h->root.type == bfd_link_hash_defined
7798                           || h->root.type == bfd_link_hash_defweak)
7799                         value = h->root.u.def.value;
7800                       else if (h->root.type == bfd_link_hash_undefweak)
7801                         value = 0;
7802                       else
7803                         {
7804                           found_tls_get_addr_arg = 0;
7805                           continue;
7806                         }
7807                     }
7808                   else
7809                     /* Symbols referenced by TLS relocs must be of type
7810                        STT_TLS.  So no need for .opd local sym adjust.  */
7811                     value = sym->st_value;
7812
7813                   ok_tprel = FALSE;
7814                   is_local = FALSE;
7815                   if (h == NULL
7816                       || !h->def_dynamic)
7817                     {
7818                       is_local = TRUE;
7819                       if (h != NULL
7820                           && h->root.type == bfd_link_hash_undefweak)
7821                         ok_tprel = TRUE;
7822                       else
7823                         {
7824                           value += sym_sec->output_offset;
7825                           value += sym_sec->output_section->vma;
7826                           value -= htab->elf.tls_sec->vma;
7827                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7828                                       < (bfd_vma) 1 << 32);
7829                         }
7830                     }
7831
7832                   r_type = ELF64_R_TYPE (rel->r_info);
7833                   /* If this section has old-style __tls_get_addr calls
7834                      without marker relocs, then check that each
7835                      __tls_get_addr call reloc is preceded by a reloc
7836                      that conceivably belongs to the __tls_get_addr arg
7837                      setup insn.  If we don't find matching arg setup
7838                      relocs, don't do any tls optimization.  */
7839                   if (pass == 0
7840                       && sec->has_tls_get_addr_call
7841                       && h != NULL
7842                       && (h == &htab->tls_get_addr->elf
7843                           || h == &htab->tls_get_addr_fd->elf)
7844                       && !found_tls_get_addr_arg
7845                       && is_branch_reloc (r_type))
7846                     {
7847                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7848                                                 "TLS optimization disabled\n"),
7849                                               ibfd, sec, rel->r_offset);
7850                       ret = TRUE;
7851                       goto err_free_rel;
7852                     }
7853
7854                   found_tls_get_addr_arg = 0;
7855                   switch (r_type)
7856                     {
7857                     case R_PPC64_GOT_TLSLD16:
7858                     case R_PPC64_GOT_TLSLD16_LO:
7859                       expecting_tls_get_addr = 1;
7860                       found_tls_get_addr_arg = 1;
7861                       /* Fall thru */
7862
7863                     case R_PPC64_GOT_TLSLD16_HI:
7864                     case R_PPC64_GOT_TLSLD16_HA:
7865                       /* These relocs should never be against a symbol
7866                          defined in a shared lib.  Leave them alone if
7867                          that turns out to be the case.  */
7868                       if (!is_local)
7869                         continue;
7870
7871                       /* LD -> LE */
7872                       tls_set = 0;
7873                       tls_clear = TLS_LD;
7874                       tls_type = TLS_TLS | TLS_LD;
7875                       break;
7876
7877                     case R_PPC64_GOT_TLSGD16:
7878                     case R_PPC64_GOT_TLSGD16_LO:
7879                       expecting_tls_get_addr = 1;
7880                       found_tls_get_addr_arg = 1;
7881                       /* Fall thru */
7882
7883                     case R_PPC64_GOT_TLSGD16_HI:
7884                     case R_PPC64_GOT_TLSGD16_HA:
7885                       if (ok_tprel)
7886                         /* GD -> LE */
7887                         tls_set = 0;
7888                       else
7889                         /* GD -> IE */
7890                         tls_set = TLS_TLS | TLS_TPRELGD;
7891                       tls_clear = TLS_GD;
7892                       tls_type = TLS_TLS | TLS_GD;
7893                       break;
7894
7895                     case R_PPC64_GOT_TPREL16_DS:
7896                     case R_PPC64_GOT_TPREL16_LO_DS:
7897                     case R_PPC64_GOT_TPREL16_HI:
7898                     case R_PPC64_GOT_TPREL16_HA:
7899                       if (ok_tprel)
7900                         {
7901                           /* IE -> LE */
7902                           tls_set = 0;
7903                           tls_clear = TLS_TPREL;
7904                           tls_type = TLS_TLS | TLS_TPREL;
7905                           break;
7906                         }
7907                       continue;
7908
7909                     case R_PPC64_TLSGD:
7910                     case R_PPC64_TLSLD:
7911                       found_tls_get_addr_arg = 1;
7912                       /* Fall thru */
7913
7914                     case R_PPC64_TLS:
7915                     case R_PPC64_TOC16:
7916                     case R_PPC64_TOC16_LO:
7917                       if (sym_sec == NULL || sym_sec != toc)
7918                         continue;
7919
7920                       /* Mark this toc entry as referenced by a TLS
7921                          code sequence.  We can do that now in the
7922                          case of R_PPC64_TLS, and after checking for
7923                          tls_get_addr for the TOC16 relocs.  */
7924                       if (toc_ref == NULL)
7925                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7926                       if (toc_ref == NULL)
7927                         goto err_free_rel;
7928
7929                       if (h != NULL)
7930                         value = h->root.u.def.value;
7931                       else
7932                         value = sym->st_value;
7933                       value += rel->r_addend;
7934                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7935                       toc_ref_index = (value + toc->output_offset) / 8;
7936                       if (r_type == R_PPC64_TLS
7937                           || r_type == R_PPC64_TLSGD
7938                           || r_type == R_PPC64_TLSLD)
7939                         {
7940                           toc_ref[toc_ref_index] = 1;
7941                           continue;
7942                         }
7943
7944                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7945                         continue;
7946
7947                       tls_set = 0;
7948                       tls_clear = 0;
7949                       expecting_tls_get_addr = 2;
7950                       break;
7951
7952                     case R_PPC64_TPREL64:
7953                       if (pass == 0
7954                           || sec != toc
7955                           || toc_ref == NULL
7956                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7957                         continue;
7958                       if (ok_tprel)
7959                         {
7960                           /* IE -> LE */
7961                           tls_set = TLS_EXPLICIT;
7962                           tls_clear = TLS_TPREL;
7963                           break;
7964                         }
7965                       continue;
7966
7967                     case R_PPC64_DTPMOD64:
7968                       if (pass == 0
7969                           || sec != toc
7970                           || toc_ref == NULL
7971                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7972                         continue;
7973                       if (rel + 1 < relend
7974                           && (rel[1].r_info
7975                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7976                           && rel[1].r_offset == rel->r_offset + 8)
7977                         {
7978                           if (ok_tprel)
7979                             /* GD -> LE */
7980                             tls_set = TLS_EXPLICIT | TLS_GD;
7981                           else
7982                             /* GD -> IE */
7983                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7984                           tls_clear = TLS_GD;
7985                         }
7986                       else
7987                         {
7988                           if (!is_local)
7989                             continue;
7990
7991                           /* LD -> LE */
7992                           tls_set = TLS_EXPLICIT;
7993                           tls_clear = TLS_LD;
7994                         }
7995                       break;
7996
7997                     default:
7998                       continue;
7999                     }
8000
8001                   if (pass == 0)
8002                     {
8003                       if (!expecting_tls_get_addr
8004                           || !sec->has_tls_get_addr_call)
8005                         continue;
8006
8007                       if (rel + 1 < relend
8008                           && branch_reloc_hash_match (ibfd, rel + 1,
8009                                                       htab->tls_get_addr,
8010                                                       htab->tls_get_addr_fd))
8011                         {
8012                           if (expecting_tls_get_addr == 2)
8013                             {
8014                               /* Check for toc tls entries.  */
8015                               unsigned char *toc_tls;
8016                               int retval;
8017
8018                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8019                                                      &locsyms,
8020                                                      rel, ibfd);
8021                               if (retval == 0)
8022                                 goto err_free_rel;
8023                               if (toc_tls != NULL)
8024                                 {
8025                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8026                                     found_tls_get_addr_arg = 1;
8027                                   if (retval > 1)
8028                                     toc_ref[toc_ref_index] = 1;
8029                                 }
8030                             }
8031                           continue;
8032                         }
8033
8034                       if (expecting_tls_get_addr != 1)
8035                         continue;
8036
8037                       /* Uh oh, we didn't find the expected call.  We
8038                          could just mark this symbol to exclude it
8039                          from tls optimization but it's safer to skip
8040                          the entire optimization.  */
8041                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8042                                                 "TLS optimization disabled\n"),
8043                                               ibfd, sec, rel->r_offset);
8044                       ret = TRUE;
8045                       goto err_free_rel;
8046                     }
8047
8048                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8049                     {
8050                       struct plt_entry *ent;
8051                       for (ent = htab->tls_get_addr->elf.plt.plist;
8052                            ent != NULL;
8053                            ent = ent->next)
8054                         if (ent->addend == 0)
8055                           {
8056                             if (ent->plt.refcount > 0)
8057                               {
8058                                 ent->plt.refcount -= 1;
8059                                 expecting_tls_get_addr = 0;
8060                               }
8061                             break;
8062                           }
8063                     }
8064
8065                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8066                     {
8067                       struct plt_entry *ent;
8068                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8069                            ent != NULL;
8070                            ent = ent->next)
8071                         if (ent->addend == 0)
8072                           {
8073                             if (ent->plt.refcount > 0)
8074                               ent->plt.refcount -= 1;
8075                             break;
8076                           }
8077                     }
8078
8079                   if (tls_clear == 0)
8080                     continue;
8081
8082                   if ((tls_set & TLS_EXPLICIT) == 0)
8083                     {
8084                       struct got_entry *ent;
8085
8086                       /* Adjust got entry for this reloc.  */
8087                       if (h != NULL)
8088                         ent = h->got.glist;
8089                       else
8090                         ent = elf_local_got_ents (ibfd)[r_symndx];
8091
8092                       for (; ent != NULL; ent = ent->next)
8093                         if (ent->addend == rel->r_addend
8094                             && ent->owner == ibfd
8095                             && ent->tls_type == tls_type)
8096                           break;
8097                       if (ent == NULL)
8098                         abort ();
8099
8100                       if (tls_set == 0)
8101                         {
8102                           /* We managed to get rid of a got entry.  */
8103                           if (ent->got.refcount > 0)
8104                             ent->got.refcount -= 1;
8105                         }
8106                     }
8107                   else
8108                     {
8109                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8110                          we'll lose one or two dyn relocs.  */
8111                       if (!dec_dynrel_count (rel->r_info, sec, info,
8112                                              NULL, h, sym))
8113                         return FALSE;
8114
8115                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8116                         {
8117                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8118                                                  NULL, h, sym))
8119                             return FALSE;
8120                         }
8121                     }
8122
8123                   *tls_mask |= tls_set;
8124                   *tls_mask &= ~tls_clear;
8125                 }
8126
8127               if (elf_section_data (sec)->relocs != relstart)
8128                 free (relstart);
8129             }
8130
8131         if (locsyms != NULL
8132             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8133           {
8134             if (!info->keep_memory)
8135               free (locsyms);
8136             else
8137               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8138           }
8139       }
8140
8141   if (toc_ref != NULL)
8142     free (toc_ref);
8143   return TRUE;
8144 }
8145
8146 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8147    the values of any global symbols in a toc section that has been
8148    edited.  Globals in toc sections should be a rarity, so this function
8149    sets a flag if any are found in toc sections other than the one just
8150    edited, so that futher hash table traversals can be avoided.  */
8151
8152 struct adjust_toc_info
8153 {
8154   asection *toc;
8155   unsigned long *skip;
8156   bfd_boolean global_toc_syms;
8157 };
8158
8159 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8160
8161 static bfd_boolean
8162 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8163 {
8164   struct ppc_link_hash_entry *eh;
8165   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8166   unsigned long i;
8167
8168   if (h->root.type != bfd_link_hash_defined
8169       && h->root.type != bfd_link_hash_defweak)
8170     return TRUE;
8171
8172   eh = (struct ppc_link_hash_entry *) h;
8173   if (eh->adjust_done)
8174     return TRUE;
8175
8176   if (eh->elf.root.u.def.section == toc_inf->toc)
8177     {
8178       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8179         i = toc_inf->toc->rawsize >> 3;
8180       else
8181         i = eh->elf.root.u.def.value >> 3;
8182
8183       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8184         {
8185           (*_bfd_error_handler)
8186             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8187           do
8188             ++i;
8189           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8190           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8191         }
8192
8193       eh->elf.root.u.def.value -= toc_inf->skip[i];
8194       eh->adjust_done = 1;
8195     }
8196   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8197     toc_inf->global_toc_syms = TRUE;
8198
8199   return TRUE;
8200 }
8201
8202 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8203
8204 static bfd_boolean
8205 ok_lo_toc_insn (unsigned int insn)
8206 {
8207   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8208           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8209           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8210           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8211           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8212           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8213           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8214           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8215           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8216           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8217           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8218           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8219           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8220           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8221           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8222               && (insn & 3) != 1)
8223           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8224               && ((insn & 3) == 0 || (insn & 3) == 3))
8225           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8226 }
8227
8228 /* Examine all relocs referencing .toc sections in order to remove
8229    unused .toc entries.  */
8230
8231 bfd_boolean
8232 ppc64_elf_edit_toc (struct bfd_link_info *info)
8233 {
8234   bfd *ibfd;
8235   struct adjust_toc_info toc_inf;
8236   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8237
8238   htab->do_toc_opt = 1;
8239   toc_inf.global_toc_syms = TRUE;
8240   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8241     {
8242       asection *toc, *sec;
8243       Elf_Internal_Shdr *symtab_hdr;
8244       Elf_Internal_Sym *local_syms;
8245       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8246       unsigned long *skip, *drop;
8247       unsigned char *used;
8248       unsigned char *keep, last, some_unused;
8249
8250       if (!is_ppc64_elf (ibfd))
8251         continue;
8252
8253       toc = bfd_get_section_by_name (ibfd, ".toc");
8254       if (toc == NULL
8255           || toc->size == 0
8256           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8257           || discarded_section (toc))
8258         continue;
8259
8260       toc_relocs = NULL;
8261       local_syms = NULL;
8262       symtab_hdr = &elf_symtab_hdr (ibfd);
8263
8264       /* Look at sections dropped from the final link.  */
8265       skip = NULL;
8266       relstart = NULL;
8267       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8268         {
8269           if (sec->reloc_count == 0
8270               || !discarded_section (sec)
8271               || get_opd_info (sec)
8272               || (sec->flags & SEC_ALLOC) == 0
8273               || (sec->flags & SEC_DEBUGGING) != 0)
8274             continue;
8275
8276           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8277           if (relstart == NULL)
8278             goto error_ret;
8279
8280           /* Run through the relocs to see which toc entries might be
8281              unused.  */
8282           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8283             {
8284               enum elf_ppc64_reloc_type r_type;
8285               unsigned long r_symndx;
8286               asection *sym_sec;
8287               struct elf_link_hash_entry *h;
8288               Elf_Internal_Sym *sym;
8289               bfd_vma val;
8290
8291               r_type = ELF64_R_TYPE (rel->r_info);
8292               switch (r_type)
8293                 {
8294                 default:
8295                   continue;
8296
8297                 case R_PPC64_TOC16:
8298                 case R_PPC64_TOC16_LO:
8299                 case R_PPC64_TOC16_HI:
8300                 case R_PPC64_TOC16_HA:
8301                 case R_PPC64_TOC16_DS:
8302                 case R_PPC64_TOC16_LO_DS:
8303                   break;
8304                 }
8305
8306               r_symndx = ELF64_R_SYM (rel->r_info);
8307               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8308                               r_symndx, ibfd))
8309                 goto error_ret;
8310
8311               if (sym_sec != toc)
8312                 continue;
8313
8314               if (h != NULL)
8315                 val = h->root.u.def.value;
8316               else
8317                 val = sym->st_value;
8318               val += rel->r_addend;
8319
8320               if (val >= toc->size)
8321                 continue;
8322
8323               /* Anything in the toc ought to be aligned to 8 bytes.
8324                  If not, don't mark as unused.  */
8325               if (val & 7)
8326                 continue;
8327
8328               if (skip == NULL)
8329                 {
8330                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8331                   if (skip == NULL)
8332                     goto error_ret;
8333                 }
8334
8335               skip[val >> 3] = ref_from_discarded;
8336             }
8337
8338           if (elf_section_data (sec)->relocs != relstart)
8339             free (relstart);
8340         }
8341
8342       /* For largetoc loads of address constants, we can convert
8343          .  addis rx,2,addr@got@ha
8344          .  ld ry,addr@got@l(rx)
8345          to
8346          .  addis rx,2,addr@toc@ha
8347          .  addi ry,rx,addr@toc@l
8348          when addr is within 2G of the toc pointer.  This then means
8349          that the word storing "addr" in the toc is no longer needed.  */
8350
8351       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8352           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8353           && toc->reloc_count != 0)
8354         {
8355           /* Read toc relocs.  */
8356           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8357                                                   info->keep_memory);
8358           if (toc_relocs == NULL)
8359             goto error_ret;
8360
8361           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8362             {
8363               enum elf_ppc64_reloc_type r_type;
8364               unsigned long r_symndx;
8365               asection *sym_sec;
8366               struct elf_link_hash_entry *h;
8367               Elf_Internal_Sym *sym;
8368               bfd_vma val, addr;
8369
8370               r_type = ELF64_R_TYPE (rel->r_info);
8371               if (r_type != R_PPC64_ADDR64)
8372                 continue;
8373
8374               r_symndx = ELF64_R_SYM (rel->r_info);
8375               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8376                               r_symndx, ibfd))
8377                 goto error_ret;
8378
8379               if (sym_sec == NULL
8380                   || discarded_section (sym_sec))
8381                 continue;
8382
8383               if (!SYMBOL_CALLS_LOCAL (info, h))
8384                 continue;
8385
8386               if (h != NULL)
8387                 {
8388                   if (h->type == STT_GNU_IFUNC)
8389                     continue;
8390                   val = h->root.u.def.value;
8391                 }
8392               else
8393                 {
8394                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8395                     continue;
8396                   val = sym->st_value;
8397                 }
8398               val += rel->r_addend;
8399               val += sym_sec->output_section->vma + sym_sec->output_offset;
8400
8401               /* We don't yet know the exact toc pointer value, but we
8402                  know it will be somewhere in the toc section.  Don't
8403                  optimize if the difference from any possible toc
8404                  pointer is outside [ff..f80008000, 7fff7fff].  */
8405               addr = toc->output_section->vma + TOC_BASE_OFF;
8406               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8407                 continue;
8408
8409               addr = toc->output_section->vma + toc->output_section->rawsize;
8410               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8411                 continue;
8412
8413               if (skip == NULL)
8414                 {
8415                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8416                   if (skip == NULL)
8417                     goto error_ret;
8418                 }
8419
8420               skip[rel->r_offset >> 3]
8421                 |= can_optimize | ((rel - toc_relocs) << 2);
8422             }
8423         }
8424
8425       if (skip == NULL)
8426         continue;
8427
8428       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8429       if (used == NULL)
8430         {
8431         error_ret:
8432           if (local_syms != NULL
8433               && symtab_hdr->contents != (unsigned char *) local_syms)
8434             free (local_syms);
8435           if (sec != NULL
8436               && relstart != NULL
8437               && elf_section_data (sec)->relocs != relstart)
8438             free (relstart);
8439           if (toc_relocs != NULL
8440               && elf_section_data (toc)->relocs != toc_relocs)
8441             free (toc_relocs);
8442           if (skip != NULL)
8443             free (skip);
8444           return FALSE;
8445         }
8446
8447       /* Now check all kept sections that might reference the toc.
8448          Check the toc itself last.  */
8449       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8450                   : ibfd->sections);
8451            sec != NULL;
8452            sec = (sec == toc ? NULL
8453                   : sec->next == NULL ? toc
8454                   : sec->next == toc && toc->next ? toc->next
8455                   : sec->next))
8456         {
8457           int repeat;
8458
8459           if (sec->reloc_count == 0
8460               || discarded_section (sec)
8461               || get_opd_info (sec)
8462               || (sec->flags & SEC_ALLOC) == 0
8463               || (sec->flags & SEC_DEBUGGING) != 0)
8464             continue;
8465
8466           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8467                                                 info->keep_memory);
8468           if (relstart == NULL)
8469             goto error_ret;
8470
8471           /* Mark toc entries referenced as used.  */
8472           do
8473             {
8474               repeat = 0;
8475               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8476                 {
8477                   enum elf_ppc64_reloc_type r_type;
8478                   unsigned long r_symndx;
8479                   asection *sym_sec;
8480                   struct elf_link_hash_entry *h;
8481                   Elf_Internal_Sym *sym;
8482                   bfd_vma val;
8483                   enum {no_check, check_lo, check_ha} insn_check;
8484
8485                   r_type = ELF64_R_TYPE (rel->r_info);
8486                   switch (r_type)
8487                     {
8488                     default:
8489                       insn_check = no_check;
8490                       break;
8491
8492                     case R_PPC64_GOT_TLSLD16_HA:
8493                     case R_PPC64_GOT_TLSGD16_HA:
8494                     case R_PPC64_GOT_TPREL16_HA:
8495                     case R_PPC64_GOT_DTPREL16_HA:
8496                     case R_PPC64_GOT16_HA:
8497                     case R_PPC64_TOC16_HA:
8498                       insn_check = check_ha;
8499                       break;
8500
8501                     case R_PPC64_GOT_TLSLD16_LO:
8502                     case R_PPC64_GOT_TLSGD16_LO:
8503                     case R_PPC64_GOT_TPREL16_LO_DS:
8504                     case R_PPC64_GOT_DTPREL16_LO_DS:
8505                     case R_PPC64_GOT16_LO:
8506                     case R_PPC64_GOT16_LO_DS:
8507                     case R_PPC64_TOC16_LO:
8508                     case R_PPC64_TOC16_LO_DS:
8509                       insn_check = check_lo;
8510                       break;
8511                     }
8512
8513                   if (insn_check != no_check)
8514                     {
8515                       bfd_vma off = rel->r_offset & ~3;
8516                       unsigned char buf[4];
8517                       unsigned int insn;
8518
8519                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8520                         {
8521                           free (used);
8522                           goto error_ret;
8523                         }
8524                       insn = bfd_get_32 (ibfd, buf);
8525                       if (insn_check == check_lo
8526                           ? !ok_lo_toc_insn (insn)
8527                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8528                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8529                         {
8530                           char str[12];
8531
8532                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8533                           sprintf (str, "%#08x", insn);
8534                           info->callbacks->einfo
8535                             (_("%P: %H: toc optimization is not supported for"
8536                                " %s instruction.\n"),
8537                              ibfd, sec, rel->r_offset & ~3, str);
8538                         }
8539                     }
8540
8541                   switch (r_type)
8542                     {
8543                     case R_PPC64_TOC16:
8544                     case R_PPC64_TOC16_LO:
8545                     case R_PPC64_TOC16_HI:
8546                     case R_PPC64_TOC16_HA:
8547                     case R_PPC64_TOC16_DS:
8548                     case R_PPC64_TOC16_LO_DS:
8549                       /* In case we're taking addresses of toc entries.  */
8550                     case R_PPC64_ADDR64:
8551                       break;
8552
8553                     default:
8554                       continue;
8555                     }
8556
8557                   r_symndx = ELF64_R_SYM (rel->r_info);
8558                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8559                                   r_symndx, ibfd))
8560                     {
8561                       free (used);
8562                       goto error_ret;
8563                     }
8564
8565                   if (sym_sec != toc)
8566                     continue;
8567
8568                   if (h != NULL)
8569                     val = h->root.u.def.value;
8570                   else
8571                     val = sym->st_value;
8572                   val += rel->r_addend;
8573
8574                   if (val >= toc->size)
8575                     continue;
8576
8577                   if ((skip[val >> 3] & can_optimize) != 0)
8578                     {
8579                       bfd_vma off;
8580                       unsigned char opc;
8581
8582                       switch (r_type)
8583                         {
8584                         case R_PPC64_TOC16_HA:
8585                           break;
8586
8587                         case R_PPC64_TOC16_LO_DS:
8588                           off = rel->r_offset;
8589                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8590                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8591                                                          off, 1))
8592                             {
8593                               free (used);
8594                               goto error_ret;
8595                             }
8596                           if ((opc & (0x3f << 2)) == (58u << 2))
8597                             break;
8598                           /* Fall thru */
8599
8600                         default:
8601                           /* Wrong sort of reloc, or not a ld.  We may
8602                              as well clear ref_from_discarded too.  */
8603                           skip[val >> 3] = 0;
8604                         }
8605                     }
8606
8607                   if (sec != toc)
8608                     used[val >> 3] = 1;
8609                   /* For the toc section, we only mark as used if this
8610                      entry itself isn't unused.  */
8611                   else if ((used[rel->r_offset >> 3]
8612                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8613                            && !used[val >> 3])
8614                     {
8615                       /* Do all the relocs again, to catch reference
8616                          chains.  */
8617                       repeat = 1;
8618                       used[val >> 3] = 1;
8619                     }
8620                 }
8621             }
8622           while (repeat);
8623
8624           if (elf_section_data (sec)->relocs != relstart)
8625             free (relstart);
8626         }
8627
8628       /* Merge the used and skip arrays.  Assume that TOC
8629          doublewords not appearing as either used or unused belong
8630          to to an entry more than one doubleword in size.  */
8631       for (drop = skip, keep = used, last = 0, some_unused = 0;
8632            drop < skip + (toc->size + 7) / 8;
8633            ++drop, ++keep)
8634         {
8635           if (*keep)
8636             {
8637               *drop &= ~ref_from_discarded;
8638               if ((*drop & can_optimize) != 0)
8639                 some_unused = 1;
8640               last = 0;
8641             }
8642           else if ((*drop & ref_from_discarded) != 0)
8643             {
8644               some_unused = 1;
8645               last = ref_from_discarded;
8646             }
8647           else
8648             *drop = last;
8649         }
8650
8651       free (used);
8652
8653       if (some_unused)
8654         {
8655           bfd_byte *contents, *src;
8656           unsigned long off;
8657           Elf_Internal_Sym *sym;
8658           bfd_boolean local_toc_syms = FALSE;
8659
8660           /* Shuffle the toc contents, and at the same time convert the
8661              skip array from booleans into offsets.  */
8662           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8663             goto error_ret;
8664
8665           elf_section_data (toc)->this_hdr.contents = contents;
8666
8667           for (src = contents, off = 0, drop = skip;
8668                src < contents + toc->size;
8669                src += 8, ++drop)
8670             {
8671               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8672                 off += 8;
8673               else if (off != 0)
8674                 {
8675                   *drop = off;
8676                   memcpy (src - off, src, 8);
8677                 }
8678             }
8679           *drop = off;
8680           toc->rawsize = toc->size;
8681           toc->size = src - contents - off;
8682
8683           /* Adjust addends for relocs against the toc section sym,
8684              and optimize any accesses we can.  */
8685           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8686             {
8687               if (sec->reloc_count == 0
8688                   || discarded_section (sec))
8689                 continue;
8690
8691               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8692                                                     info->keep_memory);
8693               if (relstart == NULL)
8694                 goto error_ret;
8695
8696               for (rel = relstart; rel < relstart + sec->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                   bfd_vma val;
8703
8704                   r_type = ELF64_R_TYPE (rel->r_info);
8705                   switch (r_type)
8706                     {
8707                     default:
8708                       continue;
8709
8710                     case R_PPC64_TOC16:
8711                     case R_PPC64_TOC16_LO:
8712                     case R_PPC64_TOC16_HI:
8713                     case R_PPC64_TOC16_HA:
8714                     case R_PPC64_TOC16_DS:
8715                     case R_PPC64_TOC16_LO_DS:
8716                     case R_PPC64_ADDR64:
8717                       break;
8718                     }
8719
8720                   r_symndx = ELF64_R_SYM (rel->r_info);
8721                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8722                                   r_symndx, ibfd))
8723                     goto error_ret;
8724
8725                   if (sym_sec != toc)
8726                     continue;
8727
8728                   if (h != NULL)
8729                     val = h->root.u.def.value;
8730                   else
8731                     {
8732                       val = sym->st_value;
8733                       if (val != 0)
8734                         local_toc_syms = TRUE;
8735                     }
8736
8737                   val += rel->r_addend;
8738
8739                   if (val > toc->rawsize)
8740                     val = toc->rawsize;
8741                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8742                     continue;
8743                   else if ((skip[val >> 3] & can_optimize) != 0)
8744                     {
8745                       Elf_Internal_Rela *tocrel
8746                         = toc_relocs + (skip[val >> 3] >> 2);
8747                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8748
8749                       switch (r_type)
8750                         {
8751                         case R_PPC64_TOC16_HA:
8752                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8753                           break;
8754
8755                         case R_PPC64_TOC16_LO_DS:
8756                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8757                           break;
8758
8759                         default:
8760                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8761                             ppc_howto_init ();
8762                           info->callbacks->einfo
8763                             (_("%P: %H: %s references "
8764                                "optimized away TOC entry\n"),
8765                              ibfd, sec, rel->r_offset,
8766                              ppc64_elf_howto_table[r_type]->name);
8767                           bfd_set_error (bfd_error_bad_value);
8768                           goto error_ret;
8769                         }
8770                       rel->r_addend = tocrel->r_addend;
8771                       elf_section_data (sec)->relocs = relstart;
8772                       continue;
8773                     }
8774
8775                   if (h != NULL || sym->st_value != 0)
8776                     continue;
8777
8778                   rel->r_addend -= skip[val >> 3];
8779                   elf_section_data (sec)->relocs = relstart;
8780                 }
8781
8782               if (elf_section_data (sec)->relocs != relstart)
8783                 free (relstart);
8784             }
8785
8786           /* We shouldn't have local or global symbols defined in the TOC,
8787              but handle them anyway.  */
8788           if (local_syms != NULL)
8789             for (sym = local_syms;
8790                  sym < local_syms + symtab_hdr->sh_info;
8791                  ++sym)
8792               if (sym->st_value != 0
8793                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8794                 {
8795                   unsigned long i;
8796
8797                   if (sym->st_value > toc->rawsize)
8798                     i = toc->rawsize >> 3;
8799                   else
8800                     i = sym->st_value >> 3;
8801
8802                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8803                     {
8804                       if (local_toc_syms)
8805                         (*_bfd_error_handler)
8806                           (_("%s defined on removed toc entry"),
8807                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8808                       do
8809                         ++i;
8810                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8811                       sym->st_value = (bfd_vma) i << 3;
8812                     }
8813
8814                   sym->st_value -= skip[i];
8815                   symtab_hdr->contents = (unsigned char *) local_syms;
8816                 }
8817
8818           /* Adjust any global syms defined in this toc input section.  */
8819           if (toc_inf.global_toc_syms)
8820             {
8821               toc_inf.toc = toc;
8822               toc_inf.skip = skip;
8823               toc_inf.global_toc_syms = FALSE;
8824               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8825                                       &toc_inf);
8826             }
8827
8828           if (toc->reloc_count != 0)
8829             {
8830               Elf_Internal_Shdr *rel_hdr;
8831               Elf_Internal_Rela *wrel;
8832               bfd_size_type sz;
8833
8834               /* Remove unused toc relocs, and adjust those we keep.  */
8835               if (toc_relocs == NULL)
8836                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8837                                                         info->keep_memory);
8838               if (toc_relocs == NULL)
8839                 goto error_ret;
8840
8841               wrel = toc_relocs;
8842               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8843                 if ((skip[rel->r_offset >> 3]
8844                      & (ref_from_discarded | can_optimize)) == 0)
8845                   {
8846                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8847                     wrel->r_info = rel->r_info;
8848                     wrel->r_addend = rel->r_addend;
8849                     ++wrel;
8850                   }
8851                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8852                                             &local_syms, NULL, NULL))
8853                   goto error_ret;
8854
8855               elf_section_data (toc)->relocs = toc_relocs;
8856               toc->reloc_count = wrel - toc_relocs;
8857               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8858               sz = rel_hdr->sh_entsize;
8859               rel_hdr->sh_size = toc->reloc_count * sz;
8860             }
8861         }
8862       else if (toc_relocs != NULL
8863                && elf_section_data (toc)->relocs != toc_relocs)
8864         free (toc_relocs);
8865
8866       if (local_syms != NULL
8867           && symtab_hdr->contents != (unsigned char *) local_syms)
8868         {
8869           if (!info->keep_memory)
8870             free (local_syms);
8871           else
8872             symtab_hdr->contents = (unsigned char *) local_syms;
8873         }
8874       free (skip);
8875     }
8876
8877   return TRUE;
8878 }
8879
8880 /* Return true iff input section I references the TOC using
8881    instructions limited to +/-32k offsets.  */
8882
8883 bfd_boolean
8884 ppc64_elf_has_small_toc_reloc (asection *i)
8885 {
8886   return (is_ppc64_elf (i->owner)
8887           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8888 }
8889
8890 /* Allocate space for one GOT entry.  */
8891
8892 static void
8893 allocate_got (struct elf_link_hash_entry *h,
8894               struct bfd_link_info *info,
8895               struct got_entry *gent)
8896 {
8897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8898   bfd_boolean dyn;
8899   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8900   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8901                  ? 16 : 8);
8902   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8903                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8904   asection *got = ppc64_elf_tdata (gent->owner)->got;
8905
8906   gent->got.offset = got->size;
8907   got->size += entsize;
8908
8909   dyn = htab->elf.dynamic_sections_created;
8910   if (h->type == STT_GNU_IFUNC)
8911     {
8912       htab->reliplt->size += rentsize;
8913       htab->got_reli_size += rentsize;
8914     }
8915   else if ((info->shared
8916             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8917            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8918                || h->root.type != bfd_link_hash_undefweak))
8919     {
8920       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8921       relgot->size += rentsize;
8922     }
8923 }
8924
8925 /* This function merges got entries in the same toc group.  */
8926
8927 static void
8928 merge_got_entries (struct got_entry **pent)
8929 {
8930   struct got_entry *ent, *ent2;
8931
8932   for (ent = *pent; ent != NULL; ent = ent->next)
8933     if (!ent->is_indirect)
8934       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8935         if (!ent2->is_indirect
8936             && ent2->addend == ent->addend
8937             && ent2->tls_type == ent->tls_type
8938             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8939           {
8940             ent2->is_indirect = TRUE;
8941             ent2->got.ent = ent;
8942           }
8943 }
8944
8945 /* Allocate space in .plt, .got and associated reloc sections for
8946    dynamic relocs.  */
8947
8948 static bfd_boolean
8949 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8950 {
8951   struct bfd_link_info *info;
8952   struct ppc_link_hash_table *htab;
8953   asection *s;
8954   struct ppc_link_hash_entry *eh;
8955   struct elf_dyn_relocs *p;
8956   struct got_entry **pgent, *gent;
8957
8958   if (h->root.type == bfd_link_hash_indirect)
8959     return TRUE;
8960
8961   info = (struct bfd_link_info *) inf;
8962   htab = ppc_hash_table (info);
8963   if (htab == NULL)
8964     return FALSE;
8965
8966   if ((htab->elf.dynamic_sections_created
8967        && h->dynindx != -1
8968        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8969       || h->type == STT_GNU_IFUNC)
8970     {
8971       struct plt_entry *pent;
8972       bfd_boolean doneone = FALSE;
8973       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8974         if (pent->plt.refcount > 0)
8975           {
8976             if (!htab->elf.dynamic_sections_created
8977                 || h->dynindx == -1)
8978               {
8979                 s = htab->iplt;
8980                 pent->plt.offset = s->size;
8981                 s->size += PLT_ENTRY_SIZE;
8982                 s = htab->reliplt;
8983               }
8984             else
8985               {
8986                 /* If this is the first .plt entry, make room for the special
8987                    first entry.  */
8988                 s = htab->plt;
8989                 if (s->size == 0)
8990                   s->size += PLT_INITIAL_ENTRY_SIZE;
8991
8992                 pent->plt.offset = s->size;
8993
8994                 /* Make room for this entry.  */
8995                 s->size += PLT_ENTRY_SIZE;
8996
8997                 /* Make room for the .glink code.  */
8998                 s = htab->glink;
8999                 if (s->size == 0)
9000                   s->size += GLINK_CALL_STUB_SIZE;
9001                 /* We need bigger stubs past index 32767.  */
9002                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9003                   s->size += 4;
9004                 s->size += 2*4;
9005
9006                 /* We also need to make an entry in the .rela.plt section.  */
9007                 s = htab->relplt;
9008               }
9009             s->size += sizeof (Elf64_External_Rela);
9010             doneone = TRUE;
9011           }
9012         else
9013           pent->plt.offset = (bfd_vma) -1;
9014       if (!doneone)
9015         {
9016           h->plt.plist = NULL;
9017           h->needs_plt = 0;
9018         }
9019     }
9020   else
9021     {
9022       h->plt.plist = NULL;
9023       h->needs_plt = 0;
9024     }
9025
9026   eh = (struct ppc_link_hash_entry *) h;
9027   /* Run through the TLS GD got entries first if we're changing them
9028      to TPREL.  */
9029   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9030     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9031       if (gent->got.refcount > 0
9032           && (gent->tls_type & TLS_GD) != 0)
9033         {
9034           /* This was a GD entry that has been converted to TPREL.  If
9035              there happens to be a TPREL entry we can use that one.  */
9036           struct got_entry *ent;
9037           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9038             if (ent->got.refcount > 0
9039                 && (ent->tls_type & TLS_TPREL) != 0
9040                 && ent->addend == gent->addend
9041                 && ent->owner == gent->owner)
9042               {
9043                 gent->got.refcount = 0;
9044                 break;
9045               }
9046
9047           /* If not, then we'll be using our own TPREL entry.  */
9048           if (gent->got.refcount != 0)
9049             gent->tls_type = TLS_TLS | TLS_TPREL;
9050         }
9051
9052   /* Remove any list entry that won't generate a word in the GOT before
9053      we call merge_got_entries.  Otherwise we risk merging to empty
9054      entries.  */
9055   pgent = &h->got.glist;
9056   while ((gent = *pgent) != NULL)
9057     if (gent->got.refcount > 0)
9058       {
9059         if ((gent->tls_type & TLS_LD) != 0
9060             && !h->def_dynamic)
9061           {
9062             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9063             *pgent = gent->next;
9064           }
9065         else
9066           pgent = &gent->next;
9067       }
9068     else
9069       *pgent = gent->next;
9070
9071   if (!htab->do_multi_toc)
9072     merge_got_entries (&h->got.glist);
9073
9074   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9075     if (!gent->is_indirect)
9076       {
9077         /* Make sure this symbol is output as a dynamic symbol.
9078            Undefined weak syms won't yet be marked as dynamic,
9079            nor will all TLS symbols.  */
9080         if (h->dynindx == -1
9081             && !h->forced_local
9082             && h->type != STT_GNU_IFUNC
9083             && htab->elf.dynamic_sections_created)
9084           {
9085             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9086               return FALSE;
9087           }
9088
9089         if (!is_ppc64_elf (gent->owner))
9090           abort ();
9091
9092         allocate_got (h, info, gent);
9093       }
9094
9095   if (eh->dyn_relocs == NULL
9096       || (!htab->elf.dynamic_sections_created
9097           && h->type != STT_GNU_IFUNC))
9098     return TRUE;
9099
9100   /* In the shared -Bsymbolic case, discard space allocated for
9101      dynamic pc-relative relocs against symbols which turn out to be
9102      defined in regular objects.  For the normal shared case, discard
9103      space for relocs that have become local due to symbol visibility
9104      changes.  */
9105
9106   if (info->shared)
9107     {
9108       /* Relocs that use pc_count are those that appear on a call insn,
9109          or certain REL relocs (see must_be_dyn_reloc) that can be
9110          generated via assembly.  We want calls to protected symbols to
9111          resolve directly to the function rather than going via the plt.
9112          If people want function pointer comparisons to work as expected
9113          then they should avoid writing weird assembly.  */
9114       if (SYMBOL_CALLS_LOCAL (info, h))
9115         {
9116           struct elf_dyn_relocs **pp;
9117
9118           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9119             {
9120               p->count -= p->pc_count;
9121               p->pc_count = 0;
9122               if (p->count == 0)
9123                 *pp = p->next;
9124               else
9125                 pp = &p->next;
9126             }
9127         }
9128
9129       /* Also discard relocs on undefined weak syms with non-default
9130          visibility.  */
9131       if (eh->dyn_relocs != NULL
9132           && h->root.type == bfd_link_hash_undefweak)
9133         {
9134           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9135             eh->dyn_relocs = NULL;
9136
9137           /* Make sure this symbol is output as a dynamic symbol.
9138              Undefined weak syms won't yet be marked as dynamic.  */
9139           else if (h->dynindx == -1
9140                    && !h->forced_local)
9141             {
9142               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9143                 return FALSE;
9144             }
9145         }
9146     }
9147   else if (h->type == STT_GNU_IFUNC)
9148     {
9149       if (!h->non_got_ref)
9150         eh->dyn_relocs = NULL;
9151     }
9152   else if (ELIMINATE_COPY_RELOCS)
9153     {
9154       /* For the non-shared case, discard space for relocs against
9155          symbols which turn out to need copy relocs or are not
9156          dynamic.  */
9157
9158       if (!h->non_got_ref
9159           && !h->def_regular)
9160         {
9161           /* Make sure this symbol is output as a dynamic symbol.
9162              Undefined weak syms won't yet be marked as dynamic.  */
9163           if (h->dynindx == -1
9164               && !h->forced_local)
9165             {
9166               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9167                 return FALSE;
9168             }
9169
9170           /* If that succeeded, we know we'll be keeping all the
9171              relocs.  */
9172           if (h->dynindx != -1)
9173             goto keep;
9174         }
9175
9176       eh->dyn_relocs = NULL;
9177
9178     keep: ;
9179     }
9180
9181   /* Finally, allocate space.  */
9182   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9183     {
9184       asection *sreloc = elf_section_data (p->sec)->sreloc;
9185       if (eh->elf.type == STT_GNU_IFUNC)
9186         sreloc = htab->reliplt;
9187       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9188     }
9189
9190   return TRUE;
9191 }
9192
9193 /* Find any dynamic relocs that apply to read-only sections.  */
9194
9195 static bfd_boolean
9196 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9197 {
9198   struct ppc_link_hash_entry *eh;
9199   struct elf_dyn_relocs *p;
9200
9201   eh = (struct ppc_link_hash_entry *) h;
9202   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9203     {
9204       asection *s = p->sec->output_section;
9205
9206       if (s != NULL && (s->flags & SEC_READONLY) != 0)
9207         {
9208           struct bfd_link_info *info = inf;
9209
9210           info->flags |= DF_TEXTREL;
9211
9212           /* Not an error, just cut short the traversal.  */
9213           return FALSE;
9214         }
9215     }
9216   return TRUE;
9217 }
9218
9219 /* Set the sizes of the dynamic sections.  */
9220
9221 static bfd_boolean
9222 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9223                                  struct bfd_link_info *info)
9224 {
9225   struct ppc_link_hash_table *htab;
9226   bfd *dynobj;
9227   asection *s;
9228   bfd_boolean relocs;
9229   bfd *ibfd;
9230   struct got_entry *first_tlsld;
9231
9232   htab = ppc_hash_table (info);
9233   if (htab == NULL)
9234     return FALSE;
9235
9236   dynobj = htab->elf.dynobj;
9237   if (dynobj == NULL)
9238     abort ();
9239
9240   if (htab->elf.dynamic_sections_created)
9241     {
9242       /* Set the contents of the .interp section to the interpreter.  */
9243       if (info->executable)
9244         {
9245           s = bfd_get_linker_section (dynobj, ".interp");
9246           if (s == NULL)
9247             abort ();
9248           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9249           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9250         }
9251     }
9252
9253   /* Set up .got offsets for local syms, and space for local dynamic
9254      relocs.  */
9255   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9256     {
9257       struct got_entry **lgot_ents;
9258       struct got_entry **end_lgot_ents;
9259       struct plt_entry **local_plt;
9260       struct plt_entry **end_local_plt;
9261       unsigned char *lgot_masks;
9262       bfd_size_type locsymcount;
9263       Elf_Internal_Shdr *symtab_hdr;
9264
9265       if (!is_ppc64_elf (ibfd))
9266         continue;
9267
9268       for (s = ibfd->sections; s != NULL; s = s->next)
9269         {
9270           struct ppc_dyn_relocs *p;
9271
9272           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9273             {
9274               if (!bfd_is_abs_section (p->sec)
9275                   && bfd_is_abs_section (p->sec->output_section))
9276                 {
9277                   /* Input section has been discarded, either because
9278                      it is a copy of a linkonce section or due to
9279                      linker script /DISCARD/, so we'll be discarding
9280                      the relocs too.  */
9281                 }
9282               else if (p->count != 0)
9283                 {
9284                   asection *srel = elf_section_data (p->sec)->sreloc;
9285                   if (p->ifunc)
9286                     srel = htab->reliplt;
9287                   srel->size += p->count * sizeof (Elf64_External_Rela);
9288                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9289                     info->flags |= DF_TEXTREL;
9290                 }
9291             }
9292         }
9293
9294       lgot_ents = elf_local_got_ents (ibfd);
9295       if (!lgot_ents)
9296         continue;
9297
9298       symtab_hdr = &elf_symtab_hdr (ibfd);
9299       locsymcount = symtab_hdr->sh_info;
9300       end_lgot_ents = lgot_ents + locsymcount;
9301       local_plt = (struct plt_entry **) end_lgot_ents;
9302       end_local_plt = local_plt + locsymcount;
9303       lgot_masks = (unsigned char *) end_local_plt;
9304       s = ppc64_elf_tdata (ibfd)->got;
9305       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9306         {
9307           struct got_entry **pent, *ent;
9308
9309           pent = lgot_ents;
9310           while ((ent = *pent) != NULL)
9311             if (ent->got.refcount > 0)
9312               {
9313                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9314                   {
9315                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9316                     *pent = ent->next;
9317                   }
9318                 else
9319                   {
9320                     unsigned int ent_size = 8;
9321                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9322
9323                     ent->got.offset = s->size;
9324                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9325                       {
9326                         ent_size *= 2;
9327                         rel_size *= 2;
9328                       }
9329                     s->size += ent_size;
9330                     if ((*lgot_masks & PLT_IFUNC) != 0)
9331                       {
9332                         htab->reliplt->size += rel_size;
9333                         htab->got_reli_size += rel_size;
9334                       }
9335                     else if (info->shared)
9336                       {
9337                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9338                         srel->size += rel_size;
9339                       }
9340                     pent = &ent->next;
9341                   }
9342               }
9343             else
9344               *pent = ent->next;
9345         }
9346
9347       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9348       for (; local_plt < end_local_plt; ++local_plt)
9349         {
9350           struct plt_entry *ent;
9351
9352           for (ent = *local_plt; ent != NULL; ent = ent->next)
9353             if (ent->plt.refcount > 0)
9354               {
9355                 s = htab->iplt;
9356                 ent->plt.offset = s->size;
9357                 s->size += PLT_ENTRY_SIZE;
9358
9359                 htab->reliplt->size += sizeof (Elf64_External_Rela);
9360               }
9361             else
9362               ent->plt.offset = (bfd_vma) -1;
9363         }
9364     }
9365
9366   /* Allocate global sym .plt and .got entries, and space for global
9367      sym dynamic relocs.  */
9368   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9369
9370   first_tlsld = NULL;
9371   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9372     {
9373       struct got_entry *ent;
9374
9375       if (!is_ppc64_elf (ibfd))
9376         continue;
9377
9378       ent = ppc64_tlsld_got (ibfd);
9379       if (ent->got.refcount > 0)
9380         {
9381           if (!htab->do_multi_toc && first_tlsld != NULL)
9382             {
9383               ent->is_indirect = TRUE;
9384               ent->got.ent = first_tlsld;
9385             }
9386           else
9387             {
9388               if (first_tlsld == NULL)
9389                 first_tlsld = ent;
9390               s = ppc64_elf_tdata (ibfd)->got;
9391               ent->got.offset = s->size;
9392               ent->owner = ibfd;
9393               s->size += 16;
9394               if (info->shared)
9395                 {
9396                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9397                   srel->size += sizeof (Elf64_External_Rela);
9398                 }
9399             }
9400         }
9401       else
9402         ent->got.offset = (bfd_vma) -1;
9403     }
9404
9405   /* We now have determined the sizes of the various dynamic sections.
9406      Allocate memory for them.  */
9407   relocs = FALSE;
9408   for (s = dynobj->sections; s != NULL; s = s->next)
9409     {
9410       if ((s->flags & SEC_LINKER_CREATED) == 0)
9411         continue;
9412
9413       if (s == htab->brlt || s == htab->relbrlt)
9414         /* These haven't been allocated yet;  don't strip.  */
9415         continue;
9416       else if (s == htab->got
9417                || s == htab->plt
9418                || s == htab->iplt
9419                || s == htab->glink
9420                || s == htab->dynbss)
9421         {
9422           /* Strip this section if we don't need it; see the
9423              comment below.  */
9424         }
9425       else if (s == htab->glink_eh_frame)
9426         {
9427           if (!bfd_is_abs_section (s->output_section))
9428             /* Not sized yet.  */
9429             continue;
9430         }
9431       else if (CONST_STRNEQ (s->name, ".rela"))
9432         {
9433           if (s->size != 0)
9434             {
9435               if (s != htab->relplt)
9436                 relocs = TRUE;
9437
9438               /* We use the reloc_count field as a counter if we need
9439                  to copy relocs into the output file.  */
9440               s->reloc_count = 0;
9441             }
9442         }
9443       else
9444         {
9445           /* It's not one of our sections, so don't allocate space.  */
9446           continue;
9447         }
9448
9449       if (s->size == 0)
9450         {
9451           /* If we don't need this section, strip it from the
9452              output file.  This is mostly to handle .rela.bss and
9453              .rela.plt.  We must create both sections in
9454              create_dynamic_sections, because they must be created
9455              before the linker maps input sections to output
9456              sections.  The linker does that before
9457              adjust_dynamic_symbol is called, and it is that
9458              function which decides whether anything needs to go
9459              into these sections.  */
9460           s->flags |= SEC_EXCLUDE;
9461           continue;
9462         }
9463
9464       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9465         continue;
9466
9467       /* Allocate memory for the section contents.  We use bfd_zalloc
9468          here in case unused entries are not reclaimed before the
9469          section's contents are written out.  This should not happen,
9470          but this way if it does we get a R_PPC64_NONE reloc in .rela
9471          sections instead of garbage.
9472          We also rely on the section contents being zero when writing
9473          the GOT.  */
9474       s->contents = bfd_zalloc (dynobj, s->size);
9475       if (s->contents == NULL)
9476         return FALSE;
9477     }
9478
9479   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9480     {
9481       if (!is_ppc64_elf (ibfd))
9482         continue;
9483
9484       s = ppc64_elf_tdata (ibfd)->got;
9485       if (s != NULL && s != htab->got)
9486         {
9487           if (s->size == 0)
9488             s->flags |= SEC_EXCLUDE;
9489           else
9490             {
9491               s->contents = bfd_zalloc (ibfd, s->size);
9492               if (s->contents == NULL)
9493                 return FALSE;
9494             }
9495         }
9496       s = ppc64_elf_tdata (ibfd)->relgot;
9497       if (s != NULL)
9498         {
9499           if (s->size == 0)
9500             s->flags |= SEC_EXCLUDE;
9501           else
9502             {
9503               s->contents = bfd_zalloc (ibfd, s->size);
9504               if (s->contents == NULL)
9505                 return FALSE;
9506               relocs = TRUE;
9507               s->reloc_count = 0;
9508             }
9509         }
9510     }
9511
9512   if (htab->elf.dynamic_sections_created)
9513     {
9514       /* Add some entries to the .dynamic section.  We fill in the
9515          values later, in ppc64_elf_finish_dynamic_sections, but we
9516          must add the entries now so that we get the correct size for
9517          the .dynamic section.  The DT_DEBUG entry is filled in by the
9518          dynamic linker and used by the debugger.  */
9519 #define add_dynamic_entry(TAG, VAL) \
9520   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9521
9522       if (info->executable)
9523         {
9524           if (!add_dynamic_entry (DT_DEBUG, 0))
9525             return FALSE;
9526         }
9527
9528       if (htab->plt != NULL && htab->plt->size != 0)
9529         {
9530           if (!add_dynamic_entry (DT_PLTGOT, 0)
9531               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9532               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9533               || !add_dynamic_entry (DT_JMPREL, 0)
9534               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9535             return FALSE;
9536         }
9537
9538       if (NO_OPD_RELOCS)
9539         {
9540           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9541               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9542             return FALSE;
9543         }
9544
9545       if (!htab->no_tls_get_addr_opt
9546           && htab->tls_get_addr_fd != NULL
9547           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9548           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9549         return FALSE;
9550
9551       if (relocs)
9552         {
9553           if (!add_dynamic_entry (DT_RELA, 0)
9554               || !add_dynamic_entry (DT_RELASZ, 0)
9555               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9556             return FALSE;
9557
9558           /* If any dynamic relocs apply to a read-only section,
9559              then we need a DT_TEXTREL entry.  */
9560           if ((info->flags & DF_TEXTREL) == 0)
9561             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9562
9563           if ((info->flags & DF_TEXTREL) != 0)
9564             {
9565               if (!add_dynamic_entry (DT_TEXTREL, 0))
9566                 return FALSE;
9567             }
9568         }
9569     }
9570 #undef add_dynamic_entry
9571
9572   return TRUE;
9573 }
9574
9575 /* Determine the type of stub needed, if any, for a call.  */
9576
9577 static inline enum ppc_stub_type
9578 ppc_type_of_stub (asection *input_sec,
9579                   const Elf_Internal_Rela *rel,
9580                   struct ppc_link_hash_entry **hash,
9581                   struct plt_entry **plt_ent,
9582                   bfd_vma destination)
9583 {
9584   struct ppc_link_hash_entry *h = *hash;
9585   bfd_vma location;
9586   bfd_vma branch_offset;
9587   bfd_vma max_branch_offset;
9588   enum elf_ppc64_reloc_type r_type;
9589
9590   if (h != NULL)
9591     {
9592       struct plt_entry *ent;
9593       struct ppc_link_hash_entry *fdh = h;
9594       if (h->oh != NULL
9595           && h->oh->is_func_descriptor)
9596         {
9597           fdh = ppc_follow_link (h->oh);
9598           *hash = fdh;
9599         }
9600
9601       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9602         if (ent->addend == rel->r_addend
9603             && ent->plt.offset != (bfd_vma) -1)
9604           {
9605             *plt_ent = ent;
9606             return ppc_stub_plt_call;
9607           }
9608
9609       /* Here, we know we don't have a plt entry.  If we don't have a
9610          either a defined function descriptor or a defined entry symbol
9611          in a regular object file, then it is pointless trying to make
9612          any other type of stub.  */
9613       if (!is_static_defined (&fdh->elf)
9614           && !is_static_defined (&h->elf))
9615         return ppc_stub_none;
9616     }
9617   else if (elf_local_got_ents (input_sec->owner) != NULL)
9618     {
9619       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9620       struct plt_entry **local_plt = (struct plt_entry **)
9621         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9622       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9623
9624       if (local_plt[r_symndx] != NULL)
9625         {
9626           struct plt_entry *ent;
9627
9628           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9629             if (ent->addend == rel->r_addend
9630                 && ent->plt.offset != (bfd_vma) -1)
9631               {
9632                 *plt_ent = ent;
9633                 return ppc_stub_plt_call;
9634               }
9635         }
9636     }
9637
9638   /* Determine where the call point is.  */
9639   location = (input_sec->output_offset
9640               + input_sec->output_section->vma
9641               + rel->r_offset);
9642
9643   branch_offset = destination - location;
9644   r_type = ELF64_R_TYPE (rel->r_info);
9645
9646   /* Determine if a long branch stub is needed.  */
9647   max_branch_offset = 1 << 25;
9648   if (r_type != R_PPC64_REL24)
9649     max_branch_offset = 1 << 15;
9650
9651   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9652     /* We need a stub.  Figure out whether a long_branch or plt_branch
9653        is needed later.  */
9654     return ppc_stub_long_branch;
9655
9656   return ppc_stub_none;
9657 }
9658
9659 /* With power7 weakly ordered memory model, it is possible for ld.so
9660    to update a plt entry in one thread and have another thread see a
9661    stale zero toc entry.  To avoid this we need some sort of acquire
9662    barrier in the call stub.  One solution is to make the load of the
9663    toc word seem to appear to depend on the load of the function entry
9664    word.  Another solution is to test for r2 being zero, and branch to
9665    the appropriate glink entry if so.
9666
9667    .    fake dep barrier        compare
9668    .    ld 11,xxx(2)            ld 11,xxx(2)
9669    .    mtctr 11                mtctr 11
9670    .    xor 11,11,11            ld 2,xxx+8(2)
9671    .    add 2,2,11              cmpldi 2,0
9672    .    ld 2,xxx+8(2)           bnectr+
9673    .    bctr                    b <glink_entry>
9674
9675    The solution involving the compare turns out to be faster, so
9676    that's what we use unless the branch won't reach.  */
9677
9678 #define ALWAYS_USE_FAKE_DEP 0
9679 #define ALWAYS_EMIT_R2SAVE 0
9680
9681 #define PPC_LO(v) ((v) & 0xffff)
9682 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9683 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9684
9685 static inline unsigned int
9686 plt_stub_size (struct ppc_link_hash_table *htab,
9687                struct ppc_stub_hash_entry *stub_entry,
9688                bfd_vma off)
9689 {
9690   unsigned size = PLT_CALL_STUB_SIZE;
9691
9692   if (!(ALWAYS_EMIT_R2SAVE
9693         || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9694     size -= 4;
9695   if (!htab->plt_static_chain)
9696     size -= 4;
9697   if (htab->plt_thread_safe)
9698     size += 8;
9699   if (PPC_HA (off) == 0)
9700     size -= 4;
9701   if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9702     size += 4;
9703   if (stub_entry->h != NULL
9704       && (stub_entry->h == htab->tls_get_addr_fd
9705           || stub_entry->h == htab->tls_get_addr)
9706       && !htab->no_tls_get_addr_opt)
9707     size += 13 * 4;
9708   return size;
9709 }
9710
9711 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9712    then return the padding needed to do so.  */
9713 static inline unsigned int
9714 plt_stub_pad (struct ppc_link_hash_table *htab,
9715               struct ppc_stub_hash_entry *stub_entry,
9716               bfd_vma plt_off)
9717 {
9718   int stub_align = 1 << htab->plt_stub_align;
9719   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9720   bfd_vma stub_off = stub_entry->stub_sec->size;
9721
9722   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9723       > (stub_size & -stub_align))
9724     return stub_align - (stub_off & (stub_align - 1));
9725   return 0;
9726 }
9727
9728 /* Build a .plt call stub.  */
9729
9730 static inline bfd_byte *
9731 build_plt_stub (struct ppc_link_hash_table *htab,
9732                 struct ppc_stub_hash_entry *stub_entry,
9733                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9734 {
9735   bfd *obfd = htab->stub_bfd;
9736   bfd_boolean plt_static_chain = htab->plt_static_chain;
9737   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9738   bfd_boolean use_fake_dep = plt_thread_safe;
9739   bfd_vma cmp_branch_off = 0;
9740
9741   if (!ALWAYS_USE_FAKE_DEP
9742       && plt_thread_safe
9743       && !(stub_entry->h != NULL
9744            && (stub_entry->h == htab->tls_get_addr_fd
9745                || stub_entry->h == htab->tls_get_addr)
9746            && !htab->no_tls_get_addr_opt))
9747     {
9748       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9749       bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9750       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9751       bfd_vma to, from;
9752
9753       if (pltindex > 32768)
9754         glinkoff += (pltindex - 32768) * 4;
9755       to = (glinkoff
9756             + htab->glink->output_offset
9757             + htab->glink->output_section->vma);
9758       from = (p - stub_entry->stub_sec->contents
9759               + 4 * (ALWAYS_EMIT_R2SAVE
9760                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9761               + 4 * (PPC_HA (offset) != 0)
9762               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9763                      != PPC_HA (offset))
9764               + 4 * (plt_static_chain != 0)
9765               + 20
9766               + stub_entry->stub_sec->output_offset
9767               + stub_entry->stub_sec->output_section->vma);
9768       cmp_branch_off = to - from;
9769       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9770     }
9771
9772   if (PPC_HA (offset) != 0)
9773     {
9774       if (r != NULL)
9775         {
9776           if (ALWAYS_EMIT_R2SAVE
9777               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9778             r[0].r_offset += 4;
9779           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9780           r[1].r_offset = r[0].r_offset + 4;
9781           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9782           r[1].r_addend = r[0].r_addend;
9783           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9784             {
9785               r[2].r_offset = r[1].r_offset + 4;
9786               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9787               r[2].r_addend = r[0].r_addend;
9788             }
9789           else
9790             {
9791               r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
9792               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9793               r[2].r_addend = r[0].r_addend + 8;
9794               if (plt_static_chain)
9795                 {
9796                   r[3].r_offset = r[2].r_offset + 4;
9797                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9798                   r[3].r_addend = r[0].r_addend + 16;
9799                 }
9800             }
9801         }
9802       if (ALWAYS_EMIT_R2SAVE
9803           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9804         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
9805       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9806       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9807       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9808         {
9809           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9810           offset = 0;
9811         }
9812       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9813       if (use_fake_dep)
9814         {
9815           bfd_put_32 (obfd, XOR_R11_R11_R11, p),                p += 4;
9816           bfd_put_32 (obfd, ADD_R12_R12_R11, p),                p += 4;
9817         }
9818       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9819       if (plt_static_chain)
9820         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9821     }
9822   else
9823     {
9824       if (r != NULL)
9825         {
9826           if (ALWAYS_EMIT_R2SAVE
9827               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9828             r[0].r_offset += 4;
9829           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9830           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9831             {
9832               r[1].r_offset = r[0].r_offset + 4;
9833               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9834               r[1].r_addend = r[0].r_addend;
9835             }
9836           else
9837             {
9838               r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
9839               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9840               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9841               if (plt_static_chain)
9842                 {
9843                   r[2].r_offset = r[1].r_offset + 4;
9844                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9845                   r[2].r_addend = r[0].r_addend + 8;
9846                 }
9847             }
9848         }
9849       if (ALWAYS_EMIT_R2SAVE
9850           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9851         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
9852       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9853       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9854         {
9855           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9856           offset = 0;
9857         }
9858       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9859       if (use_fake_dep)
9860         {
9861           bfd_put_32 (obfd, XOR_R11_R11_R11, p),                p += 4;
9862           bfd_put_32 (obfd, ADD_R2_R2_R11, p),                  p += 4;
9863         }
9864       if (plt_static_chain)
9865         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9866       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9867     }
9868   if (plt_thread_safe && !use_fake_dep)
9869     {
9870       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
9871       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
9872       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
9873     }
9874   else
9875     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
9876   return p;
9877 }
9878
9879 /* Build a special .plt call stub for __tls_get_addr.  */
9880
9881 #define LD_R11_0R3      0xe9630000
9882 #define LD_R12_0R3      0xe9830000
9883 #define MR_R0_R3        0x7c601b78
9884 #define CMPDI_R11_0     0x2c2b0000
9885 #define ADD_R3_R12_R13  0x7c6c6a14
9886 #define BEQLR           0x4d820020
9887 #define MR_R3_R0        0x7c030378
9888 #define MFLR_R11        0x7d6802a6
9889 #define STD_R11_0R1     0xf9610000
9890 #define BCTRL           0x4e800421
9891 #define LD_R11_0R1      0xe9610000
9892 #define LD_R2_0R1       0xe8410000
9893 #define MTLR_R11        0x7d6803a6
9894
9895 static inline bfd_byte *
9896 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
9897                          struct ppc_stub_hash_entry *stub_entry,
9898                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9899 {
9900   bfd *obfd = htab->stub_bfd;
9901
9902   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9903   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9904   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9905   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9906   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9907   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9908   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9909   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9910   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9911
9912   if (r != NULL)
9913     r[0].r_offset += 9 * 4;
9914   p = build_plt_stub (htab, stub_entry, p, offset, r);
9915   bfd_put_32 (obfd, BCTRL, p - 4);
9916
9917   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9918   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9919   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9920   bfd_put_32 (obfd, BLR, p),                    p += 4;
9921
9922   return p;
9923 }
9924
9925 static Elf_Internal_Rela *
9926 get_relocs (asection *sec, int count)
9927 {
9928   Elf_Internal_Rela *relocs;
9929   struct bfd_elf_section_data *elfsec_data;
9930
9931   elfsec_data = elf_section_data (sec);
9932   relocs = elfsec_data->relocs;
9933   if (relocs == NULL)
9934     {
9935       bfd_size_type relsize;
9936       relsize = sec->reloc_count * sizeof (*relocs);
9937       relocs = bfd_alloc (sec->owner, relsize);
9938       if (relocs == NULL)
9939         return NULL;
9940       elfsec_data->relocs = relocs;
9941       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9942                                           sizeof (Elf_Internal_Shdr));
9943       if (elfsec_data->rela.hdr == NULL)
9944         return NULL;
9945       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9946                                         * sizeof (Elf64_External_Rela));
9947       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9948       sec->reloc_count = 0;
9949     }
9950   relocs += sec->reloc_count;
9951   sec->reloc_count += count;
9952   return relocs;
9953 }
9954
9955 static bfd_vma
9956 get_r2off (struct bfd_link_info *info,
9957            struct ppc_stub_hash_entry *stub_entry)
9958 {
9959   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9960   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9961
9962   if (r2off == 0)
9963     {
9964       /* Support linking -R objects.  Get the toc pointer from the
9965          opd entry.  */
9966       char buf[8];
9967       asection *opd = stub_entry->h->elf.root.u.def.section;
9968       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9969
9970       if (strcmp (opd->name, ".opd") != 0
9971           || opd->reloc_count != 0)
9972         {
9973           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
9974                                   stub_entry->h->elf.root.root.string);
9975           bfd_set_error (bfd_error_bad_value);
9976           return 0;
9977         }
9978       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9979         return 0;
9980       r2off = bfd_get_64 (opd->owner, buf);
9981       r2off -= elf_gp (info->output_bfd);
9982     }
9983   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9984   return r2off;
9985 }
9986
9987 static bfd_boolean
9988 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9989 {
9990   struct ppc_stub_hash_entry *stub_entry;
9991   struct ppc_branch_hash_entry *br_entry;
9992   struct bfd_link_info *info;
9993   struct ppc_link_hash_table *htab;
9994   bfd_byte *loc;
9995   bfd_byte *p;
9996   bfd_vma dest, off;
9997   int size;
9998   Elf_Internal_Rela *r;
9999   asection *plt;
10000
10001   /* Massage our args to the form they really have.  */
10002   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10003   info = in_arg;
10004
10005   htab = ppc_hash_table (info);
10006   if (htab == NULL)
10007     return FALSE;
10008
10009   /* Make a note of the offset within the stubs for this entry.  */
10010   stub_entry->stub_offset = stub_entry->stub_sec->size;
10011   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10012
10013   htab->stub_count[stub_entry->stub_type - 1] += 1;
10014   switch (stub_entry->stub_type)
10015     {
10016     case ppc_stub_long_branch:
10017     case ppc_stub_long_branch_r2off:
10018       /* Branches are relative.  This is where we are going to.  */
10019       off = dest = (stub_entry->target_value
10020                     + stub_entry->target_section->output_offset
10021                     + stub_entry->target_section->output_section->vma);
10022
10023       /* And this is where we are coming from.  */
10024       off -= (stub_entry->stub_offset
10025               + stub_entry->stub_sec->output_offset
10026               + stub_entry->stub_sec->output_section->vma);
10027
10028       size = 4;
10029       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10030         {
10031           bfd_vma r2off = get_r2off (info, stub_entry);
10032
10033           if (r2off == 0)
10034             {
10035               htab->stub_error = TRUE;
10036               return FALSE;
10037             }
10038           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10039           loc += 4;
10040           size = 12;
10041           if (PPC_HA (r2off) != 0)
10042             {
10043               size = 16;
10044               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10045               loc += 4;
10046             }
10047           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10048           loc += 4;
10049           off -= size - 4;
10050         }
10051       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10052
10053       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10054         {
10055           info->callbacks->einfo
10056             (_("%P: long branch stub `%s' offset overflow\n"),
10057              stub_entry->root.string);
10058           htab->stub_error = TRUE;
10059           return FALSE;
10060         }
10061
10062       if (info->emitrelocations)
10063         {
10064           r = get_relocs (stub_entry->stub_sec, 1);
10065           if (r == NULL)
10066             return FALSE;
10067           r->r_offset = loc - stub_entry->stub_sec->contents;
10068           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10069           r->r_addend = dest;
10070           if (stub_entry->h != NULL)
10071             {
10072               struct elf_link_hash_entry **hashes;
10073               unsigned long symndx;
10074               struct ppc_link_hash_entry *h;
10075
10076               hashes = elf_sym_hashes (htab->stub_bfd);
10077               if (hashes == NULL)
10078                 {
10079                   bfd_size_type hsize;
10080
10081                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10082                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10083                   if (hashes == NULL)
10084                     return FALSE;
10085                   elf_sym_hashes (htab->stub_bfd) = hashes;
10086                   htab->stub_globals = 1;
10087                 }
10088               symndx = htab->stub_globals++;
10089               h = stub_entry->h;
10090               hashes[symndx] = &h->elf;
10091               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10092               if (h->oh != NULL && h->oh->is_func)
10093                 h = ppc_follow_link (h->oh);
10094               if (h->elf.root.u.def.section != stub_entry->target_section)
10095                 /* H is an opd symbol.  The addend must be zero.  */
10096                 r->r_addend = 0;
10097               else
10098                 {
10099                   off = (h->elf.root.u.def.value
10100                          + h->elf.root.u.def.section->output_offset
10101                          + h->elf.root.u.def.section->output_section->vma);
10102                   r->r_addend -= off;
10103                 }
10104             }
10105         }
10106       break;
10107
10108     case ppc_stub_plt_branch:
10109     case ppc_stub_plt_branch_r2off:
10110       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10111                                          stub_entry->root.string + 9,
10112                                          FALSE, FALSE);
10113       if (br_entry == NULL)
10114         {
10115           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10116                                   stub_entry->root.string);
10117           htab->stub_error = TRUE;
10118           return FALSE;
10119         }
10120
10121       dest = (stub_entry->target_value
10122               + stub_entry->target_section->output_offset
10123               + stub_entry->target_section->output_section->vma);
10124
10125       bfd_put_64 (htab->brlt->owner, dest,
10126                   htab->brlt->contents + br_entry->offset);
10127
10128       if (br_entry->iter == htab->stub_iteration)
10129         {
10130           br_entry->iter = 0;
10131
10132           if (htab->relbrlt != NULL)
10133             {
10134               /* Create a reloc for the branch lookup table entry.  */
10135               Elf_Internal_Rela rela;
10136               bfd_byte *rl;
10137
10138               rela.r_offset = (br_entry->offset
10139                                + htab->brlt->output_offset
10140                                + htab->brlt->output_section->vma);
10141               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10142               rela.r_addend = dest;
10143
10144               rl = htab->relbrlt->contents;
10145               rl += (htab->relbrlt->reloc_count++
10146                      * sizeof (Elf64_External_Rela));
10147               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10148             }
10149           else if (info->emitrelocations)
10150             {
10151               r = get_relocs (htab->brlt, 1);
10152               if (r == NULL)
10153                 return FALSE;
10154               /* brlt, being SEC_LINKER_CREATED does not go through the
10155                  normal reloc processing.  Symbols and offsets are not
10156                  translated from input file to output file form, so
10157                  set up the offset per the output file.  */
10158               r->r_offset = (br_entry->offset
10159                              + htab->brlt->output_offset
10160                              + htab->brlt->output_section->vma);
10161               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10162               r->r_addend = dest;
10163             }
10164         }
10165
10166       dest = (br_entry->offset
10167               + htab->brlt->output_offset
10168               + htab->brlt->output_section->vma);
10169
10170       off = (dest
10171              - elf_gp (htab->brlt->output_section->owner)
10172              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10173
10174       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10175         {
10176           info->callbacks->einfo
10177             (_("%P: linkage table error against `%T'\n"),
10178              stub_entry->root.string);
10179           bfd_set_error (bfd_error_bad_value);
10180           htab->stub_error = TRUE;
10181           return FALSE;
10182         }
10183
10184       if (info->emitrelocations)
10185         {
10186           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10187           if (r == NULL)
10188             return FALSE;
10189           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10190           if (bfd_big_endian (info->output_bfd))
10191             r[0].r_offset += 2;
10192           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10193             r[0].r_offset += 4;
10194           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10195           r[0].r_addend = dest;
10196           if (PPC_HA (off) != 0)
10197             {
10198               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10199               r[1].r_offset = r[0].r_offset + 4;
10200               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10201               r[1].r_addend = r[0].r_addend;
10202             }
10203         }
10204
10205       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10206         {
10207           if (PPC_HA (off) != 0)
10208             {
10209               size = 16;
10210               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10211               loc += 4;
10212               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10213             }
10214           else
10215             {
10216               size = 12;
10217               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10218             }
10219         }
10220       else
10221         {
10222           bfd_vma r2off = get_r2off (info, stub_entry);
10223
10224           if (r2off == 0)
10225             {
10226               htab->stub_error = TRUE;
10227               return FALSE;
10228             }
10229
10230           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10231           loc += 4;
10232           size = 20;
10233           if (PPC_HA (off) != 0)
10234             {
10235               size += 4;
10236               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10237               loc += 4;
10238               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10239               loc += 4;
10240             }
10241           else
10242             {
10243               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10244               loc += 4;
10245             }
10246
10247           if (PPC_HA (r2off) != 0)
10248             {
10249               size += 4;
10250               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10251               loc += 4;
10252             }
10253           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10254         }
10255       loc += 4;
10256       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
10257       loc += 4;
10258       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10259       break;
10260
10261     case ppc_stub_plt_call:
10262     case ppc_stub_plt_call_r2save:
10263       if (stub_entry->h != NULL
10264           && stub_entry->h->is_func_descriptor
10265           && stub_entry->h->oh != NULL)
10266         {
10267           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10268
10269           /* If the old-ABI "dot-symbol" is undefined make it weak so
10270              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10271              FIXME: We used to define the symbol on one of the call
10272              stubs instead, which is why we test symbol section id
10273              against htab->top_id in various places.  Likely all
10274              these checks could now disappear.  */
10275           if (fh->elf.root.type == bfd_link_hash_undefined)
10276             fh->elf.root.type = bfd_link_hash_undefweak;
10277           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10278           fh->was_undefined = 0;
10279         }
10280
10281       /* Now build the stub.  */
10282       dest = stub_entry->plt_ent->plt.offset & ~1;
10283       if (dest >= (bfd_vma) -2)
10284         abort ();
10285
10286       plt = htab->plt;
10287       if (!htab->elf.dynamic_sections_created
10288           || stub_entry->h == NULL
10289           || stub_entry->h->elf.dynindx == -1)
10290         plt = htab->iplt;
10291
10292       dest += plt->output_offset + plt->output_section->vma;
10293
10294       if (stub_entry->h == NULL
10295           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10296         {
10297           Elf_Internal_Rela rela;
10298           bfd_byte *rl;
10299
10300           rela.r_offset = dest;
10301           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10302           rela.r_addend = (stub_entry->target_value
10303                            + stub_entry->target_section->output_offset
10304                            + stub_entry->target_section->output_section->vma);
10305
10306           rl = (htab->reliplt->contents
10307                 + (htab->reliplt->reloc_count++
10308                    * sizeof (Elf64_External_Rela)));
10309           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10310           stub_entry->plt_ent->plt.offset |= 1;
10311         }
10312
10313       off = (dest
10314              - elf_gp (plt->output_section->owner)
10315              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10316
10317       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10318         {
10319           info->callbacks->einfo
10320             (_("%P: linkage table error against `%T'\n"),
10321              stub_entry->h != NULL
10322              ? stub_entry->h->elf.root.root.string
10323              : "<local sym>");
10324           bfd_set_error (bfd_error_bad_value);
10325           htab->stub_error = TRUE;
10326           return FALSE;
10327         }
10328
10329       if (htab->plt_stub_align != 0)
10330         {
10331           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10332
10333           stub_entry->stub_sec->size += pad;
10334           stub_entry->stub_offset = stub_entry->stub_sec->size;
10335           loc += pad;
10336         }
10337
10338       r = NULL;
10339       if (info->emitrelocations)
10340         {
10341           r = get_relocs (stub_entry->stub_sec,
10342                           (2
10343                            + (PPC_HA (off) != 0)
10344                            + (htab->plt_static_chain
10345                               && PPC_HA (off + 16) == PPC_HA (off))));
10346           if (r == NULL)
10347             return FALSE;
10348           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10349           if (bfd_big_endian (info->output_bfd))
10350             r[0].r_offset += 2;
10351           r[0].r_addend = dest;
10352         }
10353       if (stub_entry->h != NULL
10354           && (stub_entry->h == htab->tls_get_addr_fd
10355               || stub_entry->h == htab->tls_get_addr)
10356           && !htab->no_tls_get_addr_opt)
10357         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10358       else
10359         p = build_plt_stub (htab, stub_entry, loc, off, r);
10360       size = p - loc;
10361       break;
10362
10363     default:
10364       BFD_FAIL ();
10365       return FALSE;
10366     }
10367
10368   stub_entry->stub_sec->size += size;
10369
10370   if (htab->emit_stub_syms)
10371     {
10372       struct elf_link_hash_entry *h;
10373       size_t len1, len2;
10374       char *name;
10375       const char *const stub_str[] = { "long_branch",
10376                                        "long_branch_r2off",
10377                                        "plt_branch",
10378                                        "plt_branch_r2off",
10379                                        "plt_call",
10380                                        "plt_call" };
10381
10382       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10383       len2 = strlen (stub_entry->root.string);
10384       name = bfd_malloc (len1 + len2 + 2);
10385       if (name == NULL)
10386         return FALSE;
10387       memcpy (name, stub_entry->root.string, 9);
10388       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10389       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10390       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10391       if (h == NULL)
10392         return FALSE;
10393       if (h->root.type == bfd_link_hash_new)
10394         {
10395           h->root.type = bfd_link_hash_defined;
10396           h->root.u.def.section = stub_entry->stub_sec;
10397           h->root.u.def.value = stub_entry->stub_offset;
10398           h->ref_regular = 1;
10399           h->def_regular = 1;
10400           h->ref_regular_nonweak = 1;
10401           h->forced_local = 1;
10402           h->non_elf = 0;
10403         }
10404     }
10405
10406   return TRUE;
10407 }
10408
10409 /* As above, but don't actually build the stub.  Just bump offset so
10410    we know stub section sizes, and select plt_branch stubs where
10411    long_branch stubs won't do.  */
10412
10413 static bfd_boolean
10414 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10415 {
10416   struct ppc_stub_hash_entry *stub_entry;
10417   struct bfd_link_info *info;
10418   struct ppc_link_hash_table *htab;
10419   bfd_vma off;
10420   int size;
10421
10422   /* Massage our args to the form they really have.  */
10423   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10424   info = in_arg;
10425
10426   htab = ppc_hash_table (info);
10427   if (htab == NULL)
10428     return FALSE;
10429
10430   if (stub_entry->stub_type == ppc_stub_plt_call
10431       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10432     {
10433       asection *plt;
10434       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10435       if (off >= (bfd_vma) -2)
10436         abort ();
10437       plt = htab->plt;
10438       if (!htab->elf.dynamic_sections_created
10439           || stub_entry->h == NULL
10440           || stub_entry->h->elf.dynindx == -1)
10441         plt = htab->iplt;
10442       off += (plt->output_offset
10443               + plt->output_section->vma
10444               - elf_gp (plt->output_section->owner)
10445               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10446
10447       size = plt_stub_size (htab, stub_entry, off);
10448       if (htab->plt_stub_align)
10449         size += plt_stub_pad (htab, stub_entry, off);
10450       if (info->emitrelocations)
10451         {
10452           stub_entry->stub_sec->reloc_count
10453             += (2
10454                 + (PPC_HA (off) != 0)
10455                 + (htab->plt_static_chain
10456                    && PPC_HA (off + 16) == PPC_HA (off)));
10457           stub_entry->stub_sec->flags |= SEC_RELOC;
10458         }
10459     }
10460   else
10461     {
10462       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10463          variants.  */
10464       bfd_vma r2off = 0;
10465
10466       off = (stub_entry->target_value
10467              + stub_entry->target_section->output_offset
10468              + stub_entry->target_section->output_section->vma);
10469       off -= (stub_entry->stub_sec->size
10470               + stub_entry->stub_sec->output_offset
10471               + stub_entry->stub_sec->output_section->vma);
10472
10473       /* Reset the stub type from the plt variant in case we now
10474          can reach with a shorter stub.  */
10475       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10476         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10477
10478       size = 4;
10479       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10480         {
10481           r2off = get_r2off (info, stub_entry);
10482           if (r2off == 0)
10483             {
10484               htab->stub_error = TRUE;
10485               return FALSE;
10486             }
10487           size = 12;
10488           if (PPC_HA (r2off) != 0)
10489             size = 16;
10490           off -= size - 4;
10491         }
10492
10493       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
10494       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10495         {
10496           struct ppc_branch_hash_entry *br_entry;
10497
10498           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10499                                              stub_entry->root.string + 9,
10500                                              TRUE, FALSE);
10501           if (br_entry == NULL)
10502             {
10503               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10504                                       stub_entry->root.string);
10505               htab->stub_error = TRUE;
10506               return FALSE;
10507             }
10508
10509           if (br_entry->iter != htab->stub_iteration)
10510             {
10511               br_entry->iter = htab->stub_iteration;
10512               br_entry->offset = htab->brlt->size;
10513               htab->brlt->size += 8;
10514
10515               if (htab->relbrlt != NULL)
10516                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10517               else if (info->emitrelocations)
10518                 {
10519                   htab->brlt->reloc_count += 1;
10520                   htab->brlt->flags |= SEC_RELOC;
10521                 }
10522             }
10523
10524           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10525           off = (br_entry->offset
10526                  + htab->brlt->output_offset
10527                  + htab->brlt->output_section->vma
10528                  - elf_gp (htab->brlt->output_section->owner)
10529                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10530
10531           if (info->emitrelocations)
10532             {
10533               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10534               stub_entry->stub_sec->flags |= SEC_RELOC;
10535             }
10536
10537           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10538             {
10539               size = 12;
10540               if (PPC_HA (off) != 0)
10541                 size = 16;
10542             }
10543           else
10544             {
10545               size = 20;
10546               if (PPC_HA (off) != 0)
10547                 size += 4;
10548
10549               if (PPC_HA (r2off) != 0)
10550                 size += 4;
10551             }
10552         }
10553       else if (info->emitrelocations)
10554         {
10555           stub_entry->stub_sec->reloc_count += 1;
10556           stub_entry->stub_sec->flags |= SEC_RELOC;
10557         }
10558     }
10559
10560   stub_entry->stub_sec->size += size;
10561   return TRUE;
10562 }
10563
10564 /* Set up various things so that we can make a list of input sections
10565    for each output section included in the link.  Returns -1 on error,
10566    0 when no stubs will be needed, and 1 on success.  */
10567
10568 int
10569 ppc64_elf_setup_section_lists
10570   (struct bfd_link_info *info,
10571    asection *(*add_stub_section) (const char *, asection *),
10572    void (*layout_sections_again) (void))
10573 {
10574   bfd *input_bfd;
10575   int top_id, top_index, id;
10576   asection *section;
10577   asection **input_list;
10578   bfd_size_type amt;
10579   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10580
10581   if (htab == NULL)
10582     return -1;
10583   /* Stash our params away.  */
10584   htab->add_stub_section = add_stub_section;
10585   htab->layout_sections_again = layout_sections_again;
10586
10587   /* Find the top input section id.  */
10588   for (input_bfd = info->input_bfds, top_id = 3;
10589        input_bfd != NULL;
10590        input_bfd = input_bfd->link_next)
10591     {
10592       for (section = input_bfd->sections;
10593            section != NULL;
10594            section = section->next)
10595         {
10596           if (top_id < section->id)
10597             top_id = section->id;
10598         }
10599     }
10600
10601   htab->top_id = top_id;
10602   amt = sizeof (struct map_stub) * (top_id + 1);
10603   htab->stub_group = bfd_zmalloc (amt);
10604   if (htab->stub_group == NULL)
10605     return -1;
10606
10607   /* Set toc_off for com, und, abs and ind sections.  */
10608   for (id = 0; id < 3; id++)
10609     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10610
10611   /* We can't use output_bfd->section_count here to find the top output
10612      section index as some sections may have been removed, and
10613      strip_excluded_output_sections doesn't renumber the indices.  */
10614   for (section = info->output_bfd->sections, top_index = 0;
10615        section != NULL;
10616        section = section->next)
10617     {
10618       if (top_index < section->index)
10619         top_index = section->index;
10620     }
10621
10622   htab->top_index = top_index;
10623   amt = sizeof (asection *) * (top_index + 1);
10624   input_list = bfd_zmalloc (amt);
10625   htab->input_list = input_list;
10626   if (input_list == NULL)
10627     return -1;
10628
10629   return 1;
10630 }
10631
10632 /* Set up for first pass at multitoc partitioning.  */
10633
10634 void
10635 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10636 {
10637   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10638
10639   htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
10640   htab->toc_bfd = NULL;
10641   htab->toc_first_sec = NULL;
10642 }
10643
10644 /* The linker repeatedly calls this function for each TOC input section
10645    and linker generated GOT section.  Group input bfds such that the toc
10646    within a group is less than 64k in size.  */
10647
10648 bfd_boolean
10649 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10650 {
10651   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10652   bfd_vma addr, off, limit;
10653
10654   if (htab == NULL)
10655     return FALSE;
10656
10657   if (!htab->second_toc_pass)
10658     {
10659       /* Keep track of the first .toc or .got section for this input bfd.  */
10660       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10661
10662       if (new_bfd)
10663         {
10664           htab->toc_bfd = isec->owner;
10665           htab->toc_first_sec = isec;
10666         }
10667
10668       addr = isec->output_offset + isec->output_section->vma;
10669       off = addr - htab->toc_curr;
10670       limit = 0x80008000;
10671       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10672         limit = 0x10000;
10673       if (off + isec->size > limit)
10674         {
10675           addr = (htab->toc_first_sec->output_offset
10676                   + htab->toc_first_sec->output_section->vma);
10677           htab->toc_curr = addr;
10678         }
10679
10680       /* toc_curr is the base address of this toc group.  Set elf_gp
10681          for the input section to be the offset relative to the
10682          output toc base plus 0x8000.  Making the input elf_gp an
10683          offset allows us to move the toc as a whole without
10684          recalculating input elf_gp.  */
10685       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10686       off += TOC_BASE_OFF;
10687
10688       /* Die if someone uses a linker script that doesn't keep input
10689          file .toc and .got together.  */
10690       if (new_bfd
10691           && elf_gp (isec->owner) != 0
10692           && elf_gp (isec->owner) != off)
10693         return FALSE;
10694
10695       elf_gp (isec->owner) = off;
10696       return TRUE;
10697     }
10698
10699   /* During the second pass toc_first_sec points to the start of
10700      a toc group, and toc_curr is used to track the old elf_gp.
10701      We use toc_bfd to ensure we only look at each bfd once.  */
10702   if (htab->toc_bfd == isec->owner)
10703     return TRUE;
10704   htab->toc_bfd = isec->owner;
10705
10706   if (htab->toc_first_sec == NULL
10707       || htab->toc_curr != elf_gp (isec->owner))
10708     {
10709       htab->toc_curr = elf_gp (isec->owner);
10710       htab->toc_first_sec = isec;
10711     }
10712   addr = (htab->toc_first_sec->output_offset
10713           + htab->toc_first_sec->output_section->vma);
10714   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10715   elf_gp (isec->owner) = off;
10716
10717   return TRUE;
10718 }
10719
10720 /* Called via elf_link_hash_traverse to merge GOT entries for global
10721    symbol H.  */
10722
10723 static bfd_boolean
10724 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10725 {
10726   if (h->root.type == bfd_link_hash_indirect)
10727     return TRUE;
10728
10729   merge_got_entries (&h->got.glist);
10730
10731   return TRUE;
10732 }
10733
10734 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10735    symbol H.  */
10736
10737 static bfd_boolean
10738 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10739 {
10740   struct got_entry *gent;
10741
10742   if (h->root.type == bfd_link_hash_indirect)
10743     return TRUE;
10744
10745   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10746     if (!gent->is_indirect)
10747       allocate_got (h, (struct bfd_link_info *) inf, gent);
10748   return TRUE;
10749 }
10750
10751 /* Called on the first multitoc pass after the last call to
10752    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10753    entries.  */
10754
10755 bfd_boolean
10756 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10757 {
10758   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10759   struct bfd *ibfd, *ibfd2;
10760   bfd_boolean done_something;
10761
10762   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10763
10764   if (!htab->do_multi_toc)
10765     return FALSE;
10766
10767   /* Merge global sym got entries within a toc group.  */
10768   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10769
10770   /* And tlsld_got.  */
10771   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10772     {
10773       struct got_entry *ent, *ent2;
10774
10775       if (!is_ppc64_elf (ibfd))
10776         continue;
10777
10778       ent = ppc64_tlsld_got (ibfd);
10779       if (!ent->is_indirect
10780           && ent->got.offset != (bfd_vma) -1)
10781         {
10782           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10783             {
10784               if (!is_ppc64_elf (ibfd2))
10785                 continue;
10786
10787               ent2 = ppc64_tlsld_got (ibfd2);
10788               if (!ent2->is_indirect
10789                   && ent2->got.offset != (bfd_vma) -1
10790                   && elf_gp (ibfd2) == elf_gp (ibfd))
10791                 {
10792                   ent2->is_indirect = TRUE;
10793                   ent2->got.ent = ent;
10794                 }
10795             }
10796         }
10797     }
10798
10799   /* Zap sizes of got sections.  */
10800   htab->reliplt->rawsize = htab->reliplt->size;
10801   htab->reliplt->size -= htab->got_reli_size;
10802   htab->got_reli_size = 0;
10803
10804   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10805     {
10806       asection *got, *relgot;
10807
10808       if (!is_ppc64_elf (ibfd))
10809         continue;
10810
10811       got = ppc64_elf_tdata (ibfd)->got;
10812       if (got != NULL)
10813         {
10814           got->rawsize = got->size;
10815           got->size = 0;
10816           relgot = ppc64_elf_tdata (ibfd)->relgot;
10817           relgot->rawsize = relgot->size;
10818           relgot->size = 0;
10819         }
10820     }
10821
10822   /* Now reallocate the got, local syms first.  We don't need to
10823      allocate section contents again since we never increase size.  */
10824   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10825     {
10826       struct got_entry **lgot_ents;
10827       struct got_entry **end_lgot_ents;
10828       struct plt_entry **local_plt;
10829       struct plt_entry **end_local_plt;
10830       unsigned char *lgot_masks;
10831       bfd_size_type locsymcount;
10832       Elf_Internal_Shdr *symtab_hdr;
10833       asection *s;
10834
10835       if (!is_ppc64_elf (ibfd))
10836         continue;
10837
10838       lgot_ents = elf_local_got_ents (ibfd);
10839       if (!lgot_ents)
10840         continue;
10841
10842       symtab_hdr = &elf_symtab_hdr (ibfd);
10843       locsymcount = symtab_hdr->sh_info;
10844       end_lgot_ents = lgot_ents + locsymcount;
10845       local_plt = (struct plt_entry **) end_lgot_ents;
10846       end_local_plt = local_plt + locsymcount;
10847       lgot_masks = (unsigned char *) end_local_plt;
10848       s = ppc64_elf_tdata (ibfd)->got;
10849       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10850         {
10851           struct got_entry *ent;
10852
10853           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10854             {
10855               unsigned int ent_size = 8;
10856               unsigned int rel_size = sizeof (Elf64_External_Rela);
10857
10858               ent->got.offset = s->size;
10859               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10860                 {
10861                   ent_size *= 2;
10862                   rel_size *= 2;
10863                 }
10864               s->size += ent_size;
10865               if ((*lgot_masks & PLT_IFUNC) != 0)
10866                 {
10867                   htab->reliplt->size += rel_size;
10868                   htab->got_reli_size += rel_size;
10869                 }
10870               else if (info->shared)
10871                 {
10872                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10873                   srel->size += rel_size;
10874                 }
10875             }
10876         }
10877     }
10878
10879   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10880
10881   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10882     {
10883       struct got_entry *ent;
10884
10885       if (!is_ppc64_elf (ibfd))
10886         continue;
10887
10888       ent = ppc64_tlsld_got (ibfd);
10889       if (!ent->is_indirect
10890           && ent->got.offset != (bfd_vma) -1)
10891         {
10892           asection *s = ppc64_elf_tdata (ibfd)->got;
10893           ent->got.offset = s->size;
10894           s->size += 16;
10895           if (info->shared)
10896             {
10897               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10898               srel->size += sizeof (Elf64_External_Rela);
10899             }
10900         }
10901     }
10902
10903   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10904   if (!done_something)
10905     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10906       {
10907         asection *got;
10908
10909         if (!is_ppc64_elf (ibfd))
10910           continue;
10911
10912         got = ppc64_elf_tdata (ibfd)->got;
10913         if (got != NULL)
10914           {
10915             done_something = got->rawsize != got->size;
10916             if (done_something)
10917               break;
10918           }
10919       }
10920
10921   if (done_something)
10922     (*htab->layout_sections_again) ();
10923
10924   /* Set up for second pass over toc sections to recalculate elf_gp
10925      on input sections.  */
10926   htab->toc_bfd = NULL;
10927   htab->toc_first_sec = NULL;
10928   htab->second_toc_pass = TRUE;
10929   return done_something;
10930 }
10931
10932 /* Called after second pass of multitoc partitioning.  */
10933
10934 void
10935 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10936 {
10937   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10938
10939   /* After the second pass, toc_curr tracks the TOC offset used
10940      for code sections below in ppc64_elf_next_input_section.  */
10941   htab->toc_curr = TOC_BASE_OFF;
10942 }
10943
10944 /* No toc references were found in ISEC.  If the code in ISEC makes no
10945    calls, then there's no need to use toc adjusting stubs when branching
10946    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10947    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10948    needed, and 2 if a cyclical call-graph was found but no other reason
10949    for a stub was detected.  If called from the top level, a return of
10950    2 means the same as a return of 0.  */
10951
10952 static int
10953 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10954 {
10955   int ret;
10956
10957   /* Mark this section as checked.  */
10958   isec->call_check_done = 1;
10959
10960   /* We know none of our code bearing sections will need toc stubs.  */
10961   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10962     return 0;
10963
10964   if (isec->size == 0)
10965     return 0;
10966
10967   if (isec->output_section == NULL)
10968     return 0;
10969
10970   ret = 0;
10971   if (isec->reloc_count != 0)
10972     {
10973       Elf_Internal_Rela *relstart, *rel;
10974       Elf_Internal_Sym *local_syms;
10975       struct ppc_link_hash_table *htab;
10976
10977       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10978                                             info->keep_memory);
10979       if (relstart == NULL)
10980         return -1;
10981
10982       /* Look for branches to outside of this section.  */
10983       local_syms = NULL;
10984       htab = ppc_hash_table (info);
10985       if (htab == NULL)
10986         return -1;
10987
10988       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10989         {
10990           enum elf_ppc64_reloc_type r_type;
10991           unsigned long r_symndx;
10992           struct elf_link_hash_entry *h;
10993           struct ppc_link_hash_entry *eh;
10994           Elf_Internal_Sym *sym;
10995           asection *sym_sec;
10996           struct _opd_sec_data *opd;
10997           bfd_vma sym_value;
10998           bfd_vma dest;
10999
11000           r_type = ELF64_R_TYPE (rel->r_info);
11001           if (r_type != R_PPC64_REL24
11002               && r_type != R_PPC64_REL14
11003               && r_type != R_PPC64_REL14_BRTAKEN
11004               && r_type != R_PPC64_REL14_BRNTAKEN)
11005             continue;
11006
11007           r_symndx = ELF64_R_SYM (rel->r_info);
11008           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11009                           isec->owner))
11010             {
11011               ret = -1;
11012               break;
11013             }
11014
11015           /* Calls to dynamic lib functions go through a plt call stub
11016              that uses r2.  */
11017           eh = (struct ppc_link_hash_entry *) h;
11018           if (eh != NULL
11019               && (eh->elf.plt.plist != NULL
11020                   || (eh->oh != NULL
11021                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11022             {
11023               ret = 1;
11024               break;
11025             }
11026
11027           if (sym_sec == NULL)
11028             /* Ignore other undefined symbols.  */
11029             continue;
11030
11031           /* Assume branches to other sections not included in the
11032              link need stubs too, to cover -R and absolute syms.  */
11033           if (sym_sec->output_section == NULL)
11034             {
11035               ret = 1;
11036               break;
11037             }
11038
11039           if (h == NULL)
11040             sym_value = sym->st_value;
11041           else
11042             {
11043               if (h->root.type != bfd_link_hash_defined
11044                   && h->root.type != bfd_link_hash_defweak)
11045                 abort ();
11046               sym_value = h->root.u.def.value;
11047             }
11048           sym_value += rel->r_addend;
11049
11050           /* If this branch reloc uses an opd sym, find the code section.  */
11051           opd = get_opd_info (sym_sec);
11052           if (opd != NULL)
11053             {
11054               if (h == NULL && opd->adjust != NULL)
11055                 {
11056                   long adjust;
11057
11058                   adjust = opd->adjust[sym->st_value / 8];
11059                   if (adjust == -1)
11060                     /* Assume deleted functions won't ever be called.  */
11061                     continue;
11062                   sym_value += adjust;
11063                 }
11064
11065               dest = opd_entry_value (sym_sec, sym_value,
11066                                       &sym_sec, NULL, FALSE);
11067               if (dest == (bfd_vma) -1)
11068                 continue;
11069             }
11070           else
11071             dest = (sym_value
11072                     + sym_sec->output_offset
11073                     + sym_sec->output_section->vma);
11074
11075           /* Ignore branch to self.  */
11076           if (sym_sec == isec)
11077             continue;
11078
11079           /* If the called function uses the toc, we need a stub.  */
11080           if (sym_sec->has_toc_reloc
11081               || sym_sec->makes_toc_func_call)
11082             {
11083               ret = 1;
11084               break;
11085             }
11086
11087           /* Assume any branch that needs a long branch stub might in fact
11088              need a plt_branch stub.  A plt_branch stub uses r2.  */
11089           else if (dest - (isec->output_offset
11090                            + isec->output_section->vma
11091                            + rel->r_offset) + (1 << 25) >= (2 << 25))
11092             {
11093               ret = 1;
11094               break;
11095             }
11096
11097           /* If calling back to a section in the process of being
11098              tested, we can't say for sure that no toc adjusting stubs
11099              are needed, so don't return zero.  */
11100           else if (sym_sec->call_check_in_progress)
11101             ret = 2;
11102
11103           /* Branches to another section that itself doesn't have any TOC
11104              references are OK.  Recursively call ourselves to check.  */
11105           else if (!sym_sec->call_check_done)
11106             {
11107               int recur;
11108
11109               /* Mark current section as indeterminate, so that other
11110                  sections that call back to current won't be marked as
11111                  known.  */
11112               isec->call_check_in_progress = 1;
11113               recur = toc_adjusting_stub_needed (info, sym_sec);
11114               isec->call_check_in_progress = 0;
11115
11116               if (recur != 0)
11117                 {
11118                   ret = recur;
11119                   if (recur != 2)
11120                     break;
11121                 }
11122             }
11123         }
11124
11125       if (local_syms != NULL
11126           && (elf_symtab_hdr (isec->owner).contents
11127               != (unsigned char *) local_syms))
11128         free (local_syms);
11129       if (elf_section_data (isec)->relocs != relstart)
11130         free (relstart);
11131     }
11132
11133   if ((ret & 1) == 0
11134       && isec->map_head.s != NULL
11135       && (strcmp (isec->output_section->name, ".init") == 0
11136           || strcmp (isec->output_section->name, ".fini") == 0))
11137     {
11138       if (isec->map_head.s->has_toc_reloc
11139           || isec->map_head.s->makes_toc_func_call)
11140         ret = 1;
11141       else if (!isec->map_head.s->call_check_done)
11142         {
11143           int recur;
11144           isec->call_check_in_progress = 1;
11145           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11146           isec->call_check_in_progress = 0;
11147           if (recur != 0)
11148             ret = recur;
11149         }
11150     }
11151
11152   if (ret == 1)
11153     isec->makes_toc_func_call = 1;
11154
11155   return ret;
11156 }
11157
11158 /* The linker repeatedly calls this function for each input section,
11159    in the order that input sections are linked into output sections.
11160    Build lists of input sections to determine groupings between which
11161    we may insert linker stubs.  */
11162
11163 bfd_boolean
11164 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11165 {
11166   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11167
11168   if (htab == NULL)
11169     return FALSE;
11170
11171   if ((isec->output_section->flags & SEC_CODE) != 0
11172       && isec->output_section->index <= htab->top_index)
11173     {
11174       asection **list = htab->input_list + isec->output_section->index;
11175       /* Steal the link_sec pointer for our list.  */
11176 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11177       /* This happens to make the list in reverse order,
11178          which is what we want.  */
11179       PREV_SEC (isec) = *list;
11180       *list = isec;
11181     }
11182
11183   if (htab->multi_toc_needed)
11184     {
11185       /* If a code section has a function that uses the TOC then we need
11186          to use the right TOC (obviously).  Also, make sure that .opd gets
11187          the correct TOC value for R_PPC64_TOC relocs that don't have or
11188          can't find their function symbol (shouldn't ever happen now).
11189          Also specially treat .fixup for the linux kernel.  .fixup
11190          contains branches, but only back to the function that hit an
11191          exception.  */
11192       if (isec->has_toc_reloc
11193           || (isec->flags & SEC_CODE) == 0
11194           || strcmp (isec->name, ".fixup") == 0)
11195         {
11196           if (elf_gp (isec->owner) != 0)
11197             htab->toc_curr = elf_gp (isec->owner);
11198         }
11199       else
11200         {
11201           if (!isec->call_check_done
11202               && toc_adjusting_stub_needed (info, isec) < 0)
11203             return FALSE;
11204           /* If we make a local call from this section, ie. a branch
11205              without a following nop, then we have no place to put a
11206              toc restoring insn.  We must use the same toc group as
11207              the callee.
11208              Testing makes_toc_func_call actually tests for *any*
11209              calls to functions that need a good toc pointer.  A more
11210              precise test would be better, as this one will set
11211              incorrect values for pasted .init/.fini fragments.
11212              (Fixed later in check_pasted_section.)  */
11213           if (isec->makes_toc_func_call
11214               && elf_gp (isec->owner) != 0)
11215             htab->toc_curr = elf_gp (isec->owner);
11216         }
11217     }
11218
11219   /* Functions that don't use the TOC can belong in any TOC group.
11220      Use the last TOC base.  */
11221   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11222   return TRUE;
11223 }
11224
11225 /* Check that all .init and .fini sections use the same toc, if they
11226    have toc relocs.  */
11227
11228 static bfd_boolean
11229 check_pasted_section (struct bfd_link_info *info, const char *name)
11230 {
11231   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11232
11233   if (o != NULL)
11234     {
11235       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11236       bfd_vma toc_off = 0;
11237       asection *i;
11238
11239       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11240         if (i->has_toc_reloc)
11241           {
11242             if (toc_off == 0)
11243               toc_off = htab->stub_group[i->id].toc_off;
11244             else if (toc_off != htab->stub_group[i->id].toc_off)
11245               return FALSE;
11246           }
11247
11248       if (toc_off == 0)
11249         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11250           if (i->makes_toc_func_call)
11251             {
11252               toc_off = htab->stub_group[i->id].toc_off;
11253               break;
11254             }
11255
11256       /* Make sure the whole pasted function uses the same toc offset.  */
11257       if (toc_off != 0)
11258         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11259           htab->stub_group[i->id].toc_off = toc_off;
11260     }
11261   return TRUE;
11262 }
11263
11264 bfd_boolean
11265 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11266 {
11267   return (check_pasted_section (info, ".init")
11268           & check_pasted_section (info, ".fini"));
11269 }
11270
11271 /* See whether we can group stub sections together.  Grouping stub
11272    sections may result in fewer stubs.  More importantly, we need to
11273    put all .init* and .fini* stubs at the beginning of the .init or
11274    .fini output sections respectively, because glibc splits the
11275    _init and _fini functions into multiple parts.  Putting a stub in
11276    the middle of a function is not a good idea.  */
11277
11278 static void
11279 group_sections (struct ppc_link_hash_table *htab,
11280                 bfd_size_type stub_group_size,
11281                 bfd_boolean stubs_always_before_branch)
11282 {
11283   asection **list;
11284   bfd_size_type stub14_group_size;
11285   bfd_boolean suppress_size_errors;
11286
11287   suppress_size_errors = FALSE;
11288   stub14_group_size = stub_group_size;
11289   if (stub_group_size == 1)
11290     {
11291       /* Default values.  */
11292       if (stubs_always_before_branch)
11293         {
11294           stub_group_size = 0x1e00000;
11295           stub14_group_size = 0x7800;
11296         }
11297       else
11298         {
11299           stub_group_size = 0x1c00000;
11300           stub14_group_size = 0x7000;
11301         }
11302       suppress_size_errors = TRUE;
11303     }
11304
11305   list = htab->input_list + htab->top_index;
11306   do
11307     {
11308       asection *tail = *list;
11309       while (tail != NULL)
11310         {
11311           asection *curr;
11312           asection *prev;
11313           bfd_size_type total;
11314           bfd_boolean big_sec;
11315           bfd_vma curr_toc;
11316
11317           curr = tail;
11318           total = tail->size;
11319           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11320                              && ppc64_elf_section_data (tail)->has_14bit_branch
11321                              ? stub14_group_size : stub_group_size);
11322           if (big_sec && !suppress_size_errors)
11323             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11324                                      tail->owner, tail);
11325           curr_toc = htab->stub_group[tail->id].toc_off;
11326
11327           while ((prev = PREV_SEC (curr)) != NULL
11328                  && ((total += curr->output_offset - prev->output_offset)
11329                      < (ppc64_elf_section_data (prev) != NULL
11330                         && ppc64_elf_section_data (prev)->has_14bit_branch
11331                         ? stub14_group_size : stub_group_size))
11332                  && htab->stub_group[prev->id].toc_off == curr_toc)
11333             curr = prev;
11334
11335           /* OK, the size from the start of CURR to the end is less
11336              than stub_group_size and thus can be handled by one stub
11337              section.  (or the tail section is itself larger than
11338              stub_group_size, in which case we may be toast.)  We
11339              should really be keeping track of the total size of stubs
11340              added here, as stubs contribute to the final output
11341              section size.  That's a little tricky, and this way will
11342              only break if stubs added make the total size more than
11343              2^25, ie. for the default stub_group_size, if stubs total
11344              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11345           do
11346             {
11347               prev = PREV_SEC (tail);
11348               /* Set up this stub group.  */
11349               htab->stub_group[tail->id].link_sec = curr;
11350             }
11351           while (tail != curr && (tail = prev) != NULL);
11352
11353           /* But wait, there's more!  Input sections up to stub_group_size
11354              bytes before the stub section can be handled by it too.
11355              Don't do this if we have a really large section after the
11356              stubs, as adding more stubs increases the chance that
11357              branches may not reach into the stub section.  */
11358           if (!stubs_always_before_branch && !big_sec)
11359             {
11360               total = 0;
11361               while (prev != NULL
11362                      && ((total += tail->output_offset - prev->output_offset)
11363                          < (ppc64_elf_section_data (prev) != NULL
11364                             && ppc64_elf_section_data (prev)->has_14bit_branch
11365                             ? stub14_group_size : stub_group_size))
11366                      && htab->stub_group[prev->id].toc_off == curr_toc)
11367                 {
11368                   tail = prev;
11369                   prev = PREV_SEC (tail);
11370                   htab->stub_group[tail->id].link_sec = curr;
11371                 }
11372             }
11373           tail = prev;
11374         }
11375     }
11376   while (list-- != htab->input_list);
11377   free (htab->input_list);
11378 #undef PREV_SEC
11379 }
11380
11381 static const unsigned char glink_eh_frame_cie[] =
11382 {
11383   0, 0, 0, 16,                          /* length.  */
11384   0, 0, 0, 0,                           /* id.  */
11385   1,                                    /* CIE version.  */
11386   'z', 'R', 0,                          /* Augmentation string.  */
11387   4,                                    /* Code alignment.  */
11388   0x78,                                 /* Data alignment.  */
11389   65,                                   /* RA reg.  */
11390   1,                                    /* Augmentation size.  */
11391   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11392   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11393 };
11394
11395 /* Stripping output sections is normally done before dynamic section
11396    symbols have been allocated.  This function is called later, and
11397    handles cases like htab->brlt which is mapped to its own output
11398    section.  */
11399
11400 static void
11401 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11402 {
11403   if (isec->size == 0
11404       && isec->output_section->size == 0
11405       && !(isec->output_section->flags & SEC_KEEP)
11406       && !bfd_section_removed_from_list (info->output_bfd,
11407                                          isec->output_section)
11408       && elf_section_data (isec->output_section)->dynindx == 0)
11409     {
11410       isec->output_section->flags |= SEC_EXCLUDE;
11411       bfd_section_list_remove (info->output_bfd, isec->output_section);
11412       info->output_bfd->section_count--;
11413     }
11414 }
11415
11416 /* Determine and set the size of the stub section for a final link.
11417
11418    The basic idea here is to examine all the relocations looking for
11419    PC-relative calls to a target that is unreachable with a "bl"
11420    instruction.  */
11421
11422 bfd_boolean
11423 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11424                       bfd_boolean plt_static_chain, int plt_thread_safe,
11425                       int plt_stub_align)
11426 {
11427   bfd_size_type stub_group_size;
11428   bfd_boolean stubs_always_before_branch;
11429   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11430
11431   if (htab == NULL)
11432     return FALSE;
11433
11434   htab->plt_static_chain = plt_static_chain;
11435   htab->plt_stub_align = plt_stub_align;
11436   if (plt_thread_safe == -1 && !info->executable)
11437     plt_thread_safe = 1;
11438   if (plt_thread_safe == -1)
11439     {
11440       static const char *const thread_starter[] =
11441         {
11442           "pthread_create",
11443           /* libstdc++ */
11444           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11445           /* librt */
11446           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11447           "mq_notify", "create_timer",
11448           /* libanl */
11449           "getaddrinfo_a",
11450           /* libgomp */
11451           "GOMP_parallel_start",
11452           "GOMP_parallel_loop_static_start",
11453           "GOMP_parallel_loop_dynamic_start",
11454           "GOMP_parallel_loop_guided_start",
11455           "GOMP_parallel_loop_runtime_start",
11456           "GOMP_parallel_sections_start",
11457         };
11458       unsigned i;
11459
11460       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11461         {
11462           struct elf_link_hash_entry *h;
11463           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11464                                     FALSE, FALSE, TRUE);
11465           plt_thread_safe = h != NULL && h->ref_regular;
11466           if (plt_thread_safe)
11467             break;
11468         }
11469     }
11470   htab->plt_thread_safe = plt_thread_safe;
11471   stubs_always_before_branch = group_size < 0;
11472   if (group_size < 0)
11473     stub_group_size = -group_size;
11474   else
11475     stub_group_size = group_size;
11476
11477   group_sections (htab, stub_group_size, stubs_always_before_branch);
11478
11479   while (1)
11480     {
11481       bfd *input_bfd;
11482       unsigned int bfd_indx;
11483       asection *stub_sec;
11484
11485       htab->stub_iteration += 1;
11486
11487       for (input_bfd = info->input_bfds, bfd_indx = 0;
11488            input_bfd != NULL;
11489            input_bfd = input_bfd->link_next, bfd_indx++)
11490         {
11491           Elf_Internal_Shdr *symtab_hdr;
11492           asection *section;
11493           Elf_Internal_Sym *local_syms = NULL;
11494
11495           if (!is_ppc64_elf (input_bfd))
11496             continue;
11497
11498           /* We'll need the symbol table in a second.  */
11499           symtab_hdr = &elf_symtab_hdr (input_bfd);
11500           if (symtab_hdr->sh_info == 0)
11501             continue;
11502
11503           /* Walk over each section attached to the input bfd.  */
11504           for (section = input_bfd->sections;
11505                section != NULL;
11506                section = section->next)
11507             {
11508               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11509
11510               /* If there aren't any relocs, then there's nothing more
11511                  to do.  */
11512               if ((section->flags & SEC_RELOC) == 0
11513                   || (section->flags & SEC_ALLOC) == 0
11514                   || (section->flags & SEC_LOAD) == 0
11515                   || (section->flags & SEC_CODE) == 0
11516                   || section->reloc_count == 0)
11517                 continue;
11518
11519               /* If this section is a link-once section that will be
11520                  discarded, then don't create any stubs.  */
11521               if (section->output_section == NULL
11522                   || section->output_section->owner != info->output_bfd)
11523                 continue;
11524
11525               /* Get the relocs.  */
11526               internal_relocs
11527                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11528                                              info->keep_memory);
11529               if (internal_relocs == NULL)
11530                 goto error_ret_free_local;
11531
11532               /* Now examine each relocation.  */
11533               irela = internal_relocs;
11534               irelaend = irela + section->reloc_count;
11535               for (; irela < irelaend; irela++)
11536                 {
11537                   enum elf_ppc64_reloc_type r_type;
11538                   unsigned int r_indx;
11539                   enum ppc_stub_type stub_type;
11540                   struct ppc_stub_hash_entry *stub_entry;
11541                   asection *sym_sec, *code_sec;
11542                   bfd_vma sym_value, code_value;
11543                   bfd_vma destination;
11544                   bfd_boolean ok_dest;
11545                   struct ppc_link_hash_entry *hash;
11546                   struct ppc_link_hash_entry *fdh;
11547                   struct elf_link_hash_entry *h;
11548                   Elf_Internal_Sym *sym;
11549                   char *stub_name;
11550                   const asection *id_sec;
11551                   struct _opd_sec_data *opd;
11552                   struct plt_entry *plt_ent;
11553
11554                   r_type = ELF64_R_TYPE (irela->r_info);
11555                   r_indx = ELF64_R_SYM (irela->r_info);
11556
11557                   if (r_type >= R_PPC64_max)
11558                     {
11559                       bfd_set_error (bfd_error_bad_value);
11560                       goto error_ret_free_internal;
11561                     }
11562
11563                   /* Only look for stubs on branch instructions.  */
11564                   if (r_type != R_PPC64_REL24
11565                       && r_type != R_PPC64_REL14
11566                       && r_type != R_PPC64_REL14_BRTAKEN
11567                       && r_type != R_PPC64_REL14_BRNTAKEN)
11568                     continue;
11569
11570                   /* Now determine the call target, its name, value,
11571                      section.  */
11572                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11573                                   r_indx, input_bfd))
11574                     goto error_ret_free_internal;
11575                   hash = (struct ppc_link_hash_entry *) h;
11576
11577                   ok_dest = FALSE;
11578                   fdh = NULL;
11579                   sym_value = 0;
11580                   if (hash == NULL)
11581                     {
11582                       sym_value = sym->st_value;
11583                       ok_dest = TRUE;
11584                     }
11585                   else if (hash->elf.root.type == bfd_link_hash_defined
11586                            || hash->elf.root.type == bfd_link_hash_defweak)
11587                     {
11588                       sym_value = hash->elf.root.u.def.value;
11589                       if (sym_sec->output_section != NULL)
11590                         ok_dest = TRUE;
11591                     }
11592                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11593                            || hash->elf.root.type == bfd_link_hash_undefined)
11594                     {
11595                       /* Recognise an old ABI func code entry sym, and
11596                          use the func descriptor sym instead if it is
11597                          defined.  */
11598                       if (hash->elf.root.root.string[0] == '.'
11599                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11600                         {
11601                           if (fdh->elf.root.type == bfd_link_hash_defined
11602                               || fdh->elf.root.type == bfd_link_hash_defweak)
11603                             {
11604                               sym_sec = fdh->elf.root.u.def.section;
11605                               sym_value = fdh->elf.root.u.def.value;
11606                               if (sym_sec->output_section != NULL)
11607                                 ok_dest = TRUE;
11608                             }
11609                           else
11610                             fdh = NULL;
11611                         }
11612                     }
11613                   else
11614                     {
11615                       bfd_set_error (bfd_error_bad_value);
11616                       goto error_ret_free_internal;
11617                     }
11618
11619                   destination = 0;
11620                   if (ok_dest)
11621                     {
11622                       sym_value += irela->r_addend;
11623                       destination = (sym_value
11624                                      + sym_sec->output_offset
11625                                      + sym_sec->output_section->vma);
11626                     }
11627
11628                   code_sec = sym_sec;
11629                   code_value = sym_value;
11630                   opd = get_opd_info (sym_sec);
11631                   if (opd != NULL)
11632                     {
11633                       bfd_vma dest;
11634
11635                       if (hash == NULL && opd->adjust != NULL)
11636                         {
11637                           long adjust = opd->adjust[sym_value / 8];
11638                           if (adjust == -1)
11639                             continue;
11640                           code_value += adjust;
11641                           sym_value += adjust;
11642                         }
11643                       dest = opd_entry_value (sym_sec, sym_value,
11644                                               &code_sec, &code_value, FALSE);
11645                       if (dest != (bfd_vma) -1)
11646                         {
11647                           destination = dest;
11648                           if (fdh != NULL)
11649                             {
11650                               /* Fixup old ABI sym to point at code
11651                                  entry.  */
11652                               hash->elf.root.type = bfd_link_hash_defweak;
11653                               hash->elf.root.u.def.section = code_sec;
11654                               hash->elf.root.u.def.value = code_value;
11655                             }
11656                         }
11657                     }
11658
11659                   /* Determine what (if any) linker stub is needed.  */
11660                   plt_ent = NULL;
11661                   stub_type = ppc_type_of_stub (section, irela, &hash,
11662                                                 &plt_ent, destination);
11663
11664                   if (stub_type != ppc_stub_plt_call)
11665                     {
11666                       /* Check whether we need a TOC adjusting stub.
11667                          Since the linker pastes together pieces from
11668                          different object files when creating the
11669                          _init and _fini functions, it may be that a
11670                          call to what looks like a local sym is in
11671                          fact a call needing a TOC adjustment.  */
11672                       if (code_sec != NULL
11673                           && code_sec->output_section != NULL
11674                           && (htab->stub_group[code_sec->id].toc_off
11675                               != htab->stub_group[section->id].toc_off)
11676                           && (code_sec->has_toc_reloc
11677                               || code_sec->makes_toc_func_call))
11678                         stub_type = ppc_stub_long_branch_r2off;
11679                     }
11680
11681                   if (stub_type == ppc_stub_none)
11682                     continue;
11683
11684                   /* __tls_get_addr calls might be eliminated.  */
11685                   if (stub_type != ppc_stub_plt_call
11686                       && hash != NULL
11687                       && (hash == htab->tls_get_addr
11688                           || hash == htab->tls_get_addr_fd)
11689                       && section->has_tls_reloc
11690                       && irela != internal_relocs)
11691                     {
11692                       /* Get tls info.  */
11693                       unsigned char *tls_mask;
11694
11695                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11696                                          irela - 1, input_bfd))
11697                         goto error_ret_free_internal;
11698                       if (*tls_mask != 0)
11699                         continue;
11700                     }
11701
11702                   if (stub_type == ppc_stub_plt_call
11703                       && irela + 1 < irelaend
11704                       && irela[1].r_offset == irela->r_offset + 4
11705                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11706                     {
11707                       if (!tocsave_find (htab, INSERT,
11708                                          &local_syms, irela + 1, input_bfd))
11709                         goto error_ret_free_internal;
11710                     }
11711                   else if (stub_type == ppc_stub_plt_call)
11712                     stub_type = ppc_stub_plt_call_r2save;
11713
11714                   /* Support for grouping stub sections.  */
11715                   id_sec = htab->stub_group[section->id].link_sec;
11716
11717                   /* Get the name of this stub.  */
11718                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11719                   if (!stub_name)
11720                     goto error_ret_free_internal;
11721
11722                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11723                                                      stub_name, FALSE, FALSE);
11724                   if (stub_entry != NULL)
11725                     {
11726                       /* The proper stub has already been created.  */
11727                       free (stub_name);
11728                       if (stub_type == ppc_stub_plt_call_r2save)
11729                         stub_entry->stub_type = stub_type;
11730                       continue;
11731                     }
11732
11733                   stub_entry = ppc_add_stub (stub_name, section, info);
11734                   if (stub_entry == NULL)
11735                     {
11736                       free (stub_name);
11737                     error_ret_free_internal:
11738                       if (elf_section_data (section)->relocs == NULL)
11739                         free (internal_relocs);
11740                     error_ret_free_local:
11741                       if (local_syms != NULL
11742                           && (symtab_hdr->contents
11743                               != (unsigned char *) local_syms))
11744                         free (local_syms);
11745                       return FALSE;
11746                     }
11747
11748                   stub_entry->stub_type = stub_type;
11749                   if (stub_type != ppc_stub_plt_call
11750                       && stub_type != ppc_stub_plt_call_r2save)
11751                     {
11752                       stub_entry->target_value = code_value;
11753                       stub_entry->target_section = code_sec;
11754                     }
11755                   else
11756                     {
11757                       stub_entry->target_value = sym_value;
11758                       stub_entry->target_section = sym_sec;
11759                     }
11760                   stub_entry->h = hash;
11761                   stub_entry->plt_ent = plt_ent;
11762
11763                   if (stub_entry->h != NULL)
11764                     htab->stub_globals += 1;
11765                 }
11766
11767               /* We're done with the internal relocs, free them.  */
11768               if (elf_section_data (section)->relocs != internal_relocs)
11769                 free (internal_relocs);
11770             }
11771
11772           if (local_syms != NULL
11773               && symtab_hdr->contents != (unsigned char *) local_syms)
11774             {
11775               if (!info->keep_memory)
11776                 free (local_syms);
11777               else
11778                 symtab_hdr->contents = (unsigned char *) local_syms;
11779             }
11780         }
11781
11782       /* We may have added some stubs.  Find out the new size of the
11783          stub sections.  */
11784       for (stub_sec = htab->stub_bfd->sections;
11785            stub_sec != NULL;
11786            stub_sec = stub_sec->next)
11787         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11788           {
11789             stub_sec->rawsize = stub_sec->size;
11790             stub_sec->size = 0;
11791             stub_sec->reloc_count = 0;
11792             stub_sec->flags &= ~SEC_RELOC;
11793           }
11794
11795       htab->brlt->size = 0;
11796       htab->brlt->reloc_count = 0;
11797       htab->brlt->flags &= ~SEC_RELOC;
11798       if (htab->relbrlt != NULL)
11799         htab->relbrlt->size = 0;
11800
11801       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11802
11803       if (info->emitrelocations
11804           && htab->glink != NULL && htab->glink->size != 0)
11805         {
11806           htab->glink->reloc_count = 1;
11807           htab->glink->flags |= SEC_RELOC;
11808         }
11809
11810       if (htab->glink_eh_frame != NULL
11811           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11812           && htab->glink_eh_frame->output_section->size != 0)
11813         {
11814           size_t size = 0, align;
11815
11816           for (stub_sec = htab->stub_bfd->sections;
11817                stub_sec != NULL;
11818                stub_sec = stub_sec->next)
11819             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11820               size += 20;
11821           if (htab->glink != NULL && htab->glink->size != 0)
11822             size += 24;
11823           if (size != 0)
11824             size += sizeof (glink_eh_frame_cie);
11825           align = 1;
11826           align <<= htab->glink_eh_frame->output_section->alignment_power;
11827           align -= 1;
11828           size = (size + align) & ~align;
11829           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11830           htab->glink_eh_frame->size = size;
11831         }
11832
11833       if (htab->plt_stub_align != 0)
11834         for (stub_sec = htab->stub_bfd->sections;
11835              stub_sec != NULL;
11836              stub_sec = stub_sec->next)
11837           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11838             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
11839                               & (-1 << htab->plt_stub_align));
11840
11841       for (stub_sec = htab->stub_bfd->sections;
11842            stub_sec != NULL;
11843            stub_sec = stub_sec->next)
11844         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11845             && stub_sec->rawsize != stub_sec->size)
11846           break;
11847
11848       /* Exit from this loop when no stubs have been added, and no stubs
11849          have changed size.  */
11850       if (stub_sec == NULL
11851           && (htab->glink_eh_frame == NULL
11852               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11853         break;
11854
11855       /* Ask the linker to do its stuff.  */
11856       (*htab->layout_sections_again) ();
11857     }
11858
11859   maybe_strip_output (info, htab->brlt);
11860   if (htab->glink_eh_frame != NULL)
11861     maybe_strip_output (info, htab->glink_eh_frame);
11862
11863   return TRUE;
11864 }
11865
11866 /* Called after we have determined section placement.  If sections
11867    move, we'll be called again.  Provide a value for TOCstart.  */
11868
11869 bfd_vma
11870 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
11871 {
11872   asection *s;
11873   bfd_vma TOCstart;
11874
11875   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11876      order.  The TOC starts where the first of these sections starts.  */
11877   s = bfd_get_section_by_name (obfd, ".got");
11878   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11879     s = bfd_get_section_by_name (obfd, ".toc");
11880   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11881     s = bfd_get_section_by_name (obfd, ".tocbss");
11882   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11883     s = bfd_get_section_by_name (obfd, ".plt");
11884   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11885     {
11886       /* This may happen for
11887          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11888          .toc directive
11889          o  bad linker script
11890          o --gc-sections and empty TOC sections
11891
11892          FIXME: Warn user?  */
11893
11894       /* Look for a likely section.  We probably won't even be
11895          using TOCstart.  */
11896       for (s = obfd->sections; s != NULL; s = s->next)
11897         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11898                          | SEC_EXCLUDE))
11899             == (SEC_ALLOC | SEC_SMALL_DATA))
11900           break;
11901       if (s == NULL)
11902         for (s = obfd->sections; s != NULL; s = s->next)
11903           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11904               == (SEC_ALLOC | SEC_SMALL_DATA))
11905             break;
11906       if (s == NULL)
11907         for (s = obfd->sections; s != NULL; s = s->next)
11908           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11909               == SEC_ALLOC)
11910             break;
11911       if (s == NULL)
11912         for (s = obfd->sections; s != NULL; s = s->next)
11913           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11914             break;
11915     }
11916
11917   TOCstart = 0;
11918   if (s != NULL)
11919     TOCstart = s->output_section->vma + s->output_offset;
11920
11921   _bfd_set_gp_value (obfd, TOCstart);
11922
11923   if (info != NULL && s != NULL && is_ppc64_elf (obfd))
11924     {
11925       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11926
11927       if (htab != NULL
11928           && htab->elf.hgot != NULL)
11929         {
11930           htab->elf.hgot->type = STT_OBJECT;
11931           htab->elf.hgot->root.type = bfd_link_hash_defined;
11932           htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
11933           htab->elf.hgot->root.u.def.section = s;
11934         }
11935     }
11936   return TOCstart;
11937 }
11938
11939 /* Build all the stubs associated with the current output file.
11940    The stubs are kept in a hash table attached to the main linker
11941    hash table.  This function is called via gldelf64ppc_finish.  */
11942
11943 bfd_boolean
11944 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11945                        struct bfd_link_info *info,
11946                        char **stats)
11947 {
11948   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11949   asection *stub_sec;
11950   bfd_byte *p;
11951   int stub_sec_count = 0;
11952
11953   if (htab == NULL)
11954     return FALSE;
11955
11956   htab->emit_stub_syms = emit_stub_syms;
11957
11958   /* Allocate memory to hold the linker stubs.  */
11959   for (stub_sec = htab->stub_bfd->sections;
11960        stub_sec != NULL;
11961        stub_sec = stub_sec->next)
11962     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11963         && stub_sec->size != 0)
11964       {
11965         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11966         if (stub_sec->contents == NULL)
11967           return FALSE;
11968         /* We want to check that built size is the same as calculated
11969            size.  rawsize is a convenient location to use.  */
11970         stub_sec->rawsize = stub_sec->size;
11971         stub_sec->size = 0;
11972       }
11973
11974   if (htab->glink != NULL && htab->glink->size != 0)
11975     {
11976       unsigned int indx;
11977       bfd_vma plt0;
11978
11979       /* Build the .glink plt call stub.  */
11980       if (htab->emit_stub_syms)
11981         {
11982           struct elf_link_hash_entry *h;
11983           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11984                                     TRUE, FALSE, FALSE);
11985           if (h == NULL)
11986             return FALSE;
11987           if (h->root.type == bfd_link_hash_new)
11988             {
11989               h->root.type = bfd_link_hash_defined;
11990               h->root.u.def.section = htab->glink;
11991               h->root.u.def.value = 8;
11992               h->ref_regular = 1;
11993               h->def_regular = 1;
11994               h->ref_regular_nonweak = 1;
11995               h->forced_local = 1;
11996               h->non_elf = 0;
11997             }
11998         }
11999       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
12000       if (info->emitrelocations)
12001         {
12002           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12003           if (r == NULL)
12004             return FALSE;
12005           r->r_offset = (htab->glink->output_offset
12006                          + htab->glink->output_section->vma);
12007           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12008           r->r_addend = plt0;
12009         }
12010       p = htab->glink->contents;
12011       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12012       bfd_put_64 (htab->glink->owner, plt0, p);
12013       p += 8;
12014       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12015       p += 4;
12016       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12017       p += 4;
12018       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12019       p += 4;
12020       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
12021       p += 4;
12022       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12023       p += 4;
12024       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
12025       p += 4;
12026       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
12027       p += 4;
12028       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
12029       p += 4;
12030       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
12031       p += 4;
12032       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
12033       p += 4;
12034       bfd_put_32 (htab->glink->owner, BCTR, p);
12035       p += 4;
12036       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12037         {
12038           bfd_put_32 (htab->glink->owner, NOP, p);
12039           p += 4;
12040         }
12041
12042       /* Build the .glink lazy link call stubs.  */
12043       indx = 0;
12044       while (p < htab->glink->contents + htab->glink->size)
12045         {
12046           if (indx < 0x8000)
12047             {
12048               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12049               p += 4;
12050             }
12051           else
12052             {
12053               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12054               p += 4;
12055               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12056               p += 4;
12057             }
12058           bfd_put_32 (htab->glink->owner,
12059                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12060           indx++;
12061           p += 4;
12062         }
12063       htab->glink->rawsize = p - htab->glink->contents;
12064     }
12065
12066   if (htab->brlt->size != 0)
12067     {
12068       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12069                                          htab->brlt->size);
12070       if (htab->brlt->contents == NULL)
12071         return FALSE;
12072     }
12073   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12074     {
12075       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12076                                             htab->relbrlt->size);
12077       if (htab->relbrlt->contents == NULL)
12078         return FALSE;
12079     }
12080
12081   if (htab->glink_eh_frame != NULL
12082       && htab->glink_eh_frame->size != 0)
12083     {
12084       bfd_vma val;
12085       bfd_byte *last_fde;
12086       size_t last_fde_len, size, align, pad;
12087
12088       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12089       if (p == NULL)
12090         return FALSE;
12091       htab->glink_eh_frame->contents = p;
12092       last_fde = p;
12093
12094       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12095
12096       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12097       /* CIE length (rewrite in case little-endian).  */
12098       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12099       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12100       p += sizeof (glink_eh_frame_cie);
12101
12102       for (stub_sec = htab->stub_bfd->sections;
12103            stub_sec != NULL;
12104            stub_sec = stub_sec->next)
12105         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12106           {
12107             last_fde = p;
12108             last_fde_len = 16;
12109             /* FDE length.  */
12110             bfd_put_32 (htab->elf.dynobj, 16, p);
12111             p += 4;
12112             /* CIE pointer.  */
12113             val = p - htab->glink_eh_frame->contents;
12114             bfd_put_32 (htab->elf.dynobj, val, p);
12115             p += 4;
12116             /* Offset to stub section.  */
12117             val = (stub_sec->output_section->vma
12118                    + stub_sec->output_offset);
12119             val -= (htab->glink_eh_frame->output_section->vma
12120                     + htab->glink_eh_frame->output_offset);
12121             val -= p - htab->glink_eh_frame->contents;
12122             if (val + 0x80000000 > 0xffffffff)
12123               {
12124                 info->callbacks->einfo
12125                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12126                    stub_sec->name);
12127                 return FALSE;
12128               }
12129             bfd_put_32 (htab->elf.dynobj, val, p);
12130             p += 4;
12131             /* stub section size.  */
12132             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12133             p += 4;
12134             /* Augmentation.  */
12135             p += 1;
12136             /* Pad.  */
12137             p += 3;
12138           }
12139       if (htab->glink != NULL && htab->glink->size != 0)
12140         {
12141           last_fde = p;
12142           last_fde_len = 20;
12143           /* FDE length.  */
12144           bfd_put_32 (htab->elf.dynobj, 20, p);
12145           p += 4;
12146           /* CIE pointer.  */
12147           val = p - htab->glink_eh_frame->contents;
12148           bfd_put_32 (htab->elf.dynobj, val, p);
12149           p += 4;
12150           /* Offset to .glink.  */
12151           val = (htab->glink->output_section->vma
12152                  + htab->glink->output_offset
12153                  + 8);
12154           val -= (htab->glink_eh_frame->output_section->vma
12155                   + htab->glink_eh_frame->output_offset);
12156           val -= p - htab->glink_eh_frame->contents;
12157           if (val + 0x80000000 > 0xffffffff)
12158             {
12159               info->callbacks->einfo
12160                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12161                  htab->glink->name);
12162               return FALSE;
12163             }
12164           bfd_put_32 (htab->elf.dynobj, val, p);
12165           p += 4;
12166           /* .glink size.  */
12167           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12168           p += 4;
12169           /* Augmentation.  */
12170           p += 1;
12171
12172           *p++ = DW_CFA_advance_loc + 1;
12173           *p++ = DW_CFA_register;
12174           *p++ = 65;
12175           *p++ = 12;
12176           *p++ = DW_CFA_advance_loc + 4;
12177           *p++ = DW_CFA_restore_extended;
12178           *p++ = 65;
12179         }
12180       /* Subsume any padding into the last FDE if user .eh_frame
12181          sections are aligned more than glink_eh_frame.  Otherwise any
12182          zero padding will be seen as a terminator.  */
12183       size = p - htab->glink_eh_frame->contents;
12184       align = 1;
12185       align <<= htab->glink_eh_frame->output_section->alignment_power;
12186       align -= 1;
12187       pad = ((size + align) & ~align) - size;
12188       htab->glink_eh_frame->size = size + pad;
12189       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12190     }
12191
12192   /* Build the stubs as directed by the stub hash table.  */
12193   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12194
12195   if (htab->relbrlt != NULL)
12196     htab->relbrlt->reloc_count = 0;
12197
12198   if (htab->plt_stub_align != 0)
12199     for (stub_sec = htab->stub_bfd->sections;
12200          stub_sec != NULL;
12201          stub_sec = stub_sec->next)
12202       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12203         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12204                           & (-1 << htab->plt_stub_align));
12205
12206   for (stub_sec = htab->stub_bfd->sections;
12207        stub_sec != NULL;
12208        stub_sec = stub_sec->next)
12209     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12210       {
12211         stub_sec_count += 1;
12212         if (stub_sec->rawsize != stub_sec->size)
12213           break;
12214       }
12215
12216   if (stub_sec != NULL
12217       || htab->glink->rawsize != htab->glink->size
12218       || (htab->glink_eh_frame != NULL
12219           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12220     {
12221       htab->stub_error = TRUE;
12222       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12223     }
12224
12225   if (htab->stub_error)
12226     return FALSE;
12227
12228   if (stats != NULL)
12229     {
12230       *stats = bfd_malloc (500);
12231       if (*stats == NULL)
12232         return FALSE;
12233
12234       sprintf (*stats, _("linker stubs in %u group%s\n"
12235                          "  branch       %lu\n"
12236                          "  toc adjust   %lu\n"
12237                          "  long branch  %lu\n"
12238                          "  long toc adj %lu\n"
12239                          "  plt call     %lu\n"
12240                          "  plt call toc %lu"),
12241                stub_sec_count,
12242                stub_sec_count == 1 ? "" : "s",
12243                htab->stub_count[ppc_stub_long_branch - 1],
12244                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12245                htab->stub_count[ppc_stub_plt_branch - 1],
12246                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12247                htab->stub_count[ppc_stub_plt_call - 1],
12248                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12249     }
12250   return TRUE;
12251 }
12252
12253 /* This function undoes the changes made by add_symbol_adjust.  */
12254
12255 static bfd_boolean
12256 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12257 {
12258   struct ppc_link_hash_entry *eh;
12259
12260   if (h->root.type == bfd_link_hash_indirect)
12261     return TRUE;
12262
12263   eh = (struct ppc_link_hash_entry *) h;
12264   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12265     return TRUE;
12266
12267   eh->elf.root.type = bfd_link_hash_undefined;
12268   return TRUE;
12269 }
12270
12271 void
12272 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12273 {
12274   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12275
12276   if (htab != NULL)
12277     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12278 }
12279
12280 /* What to do when ld finds relocations against symbols defined in
12281    discarded sections.  */
12282
12283 static unsigned int
12284 ppc64_elf_action_discarded (asection *sec)
12285 {
12286   if (strcmp (".opd", sec->name) == 0)
12287     return 0;
12288
12289   if (strcmp (".toc", sec->name) == 0)
12290     return 0;
12291
12292   if (strcmp (".toc1", sec->name) == 0)
12293     return 0;
12294
12295   return _bfd_elf_default_action_discarded (sec);
12296 }
12297
12298 /* The RELOCATE_SECTION function is called by the ELF backend linker
12299    to handle the relocations for a section.
12300
12301    The relocs are always passed as Rela structures; if the section
12302    actually uses Rel structures, the r_addend field will always be
12303    zero.
12304
12305    This function is responsible for adjust the section contents as
12306    necessary, and (if using Rela relocs and generating a
12307    relocatable output file) adjusting the reloc addend as
12308    necessary.
12309
12310    This function does not have to worry about setting the reloc
12311    address or the reloc symbol index.
12312
12313    LOCAL_SYMS is a pointer to the swapped in local symbols.
12314
12315    LOCAL_SECTIONS is an array giving the section in the input file
12316    corresponding to the st_shndx field of each local symbol.
12317
12318    The global hash table entry for the global symbols can be found
12319    via elf_sym_hashes (input_bfd).
12320
12321    When generating relocatable output, this function must handle
12322    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12323    going to be the section symbol corresponding to the output
12324    section, which means that the addend must be adjusted
12325    accordingly.  */
12326
12327 static bfd_boolean
12328 ppc64_elf_relocate_section (bfd *output_bfd,
12329                             struct bfd_link_info *info,
12330                             bfd *input_bfd,
12331                             asection *input_section,
12332                             bfd_byte *contents,
12333                             Elf_Internal_Rela *relocs,
12334                             Elf_Internal_Sym *local_syms,
12335                             asection **local_sections)
12336 {
12337   struct ppc_link_hash_table *htab;
12338   Elf_Internal_Shdr *symtab_hdr;
12339   struct elf_link_hash_entry **sym_hashes;
12340   Elf_Internal_Rela *rel;
12341   Elf_Internal_Rela *relend;
12342   Elf_Internal_Rela outrel;
12343   bfd_byte *loc;
12344   struct got_entry **local_got_ents;
12345   bfd_vma TOCstart;
12346   bfd_boolean ret = TRUE;
12347   bfd_boolean is_opd;
12348   /* Assume 'at' branch hints.  */
12349   bfd_boolean is_isa_v2 = TRUE;
12350   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12351
12352   /* Initialize howto table if needed.  */
12353   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12354     ppc_howto_init ();
12355
12356   htab = ppc_hash_table (info);
12357   if (htab == NULL)
12358     return FALSE;
12359
12360   /* Don't relocate stub sections.  */
12361   if (input_section->owner == htab->stub_bfd)
12362     return TRUE;
12363
12364   BFD_ASSERT (is_ppc64_elf (input_bfd));
12365
12366   local_got_ents = elf_local_got_ents (input_bfd);
12367   TOCstart = elf_gp (output_bfd);
12368   symtab_hdr = &elf_symtab_hdr (input_bfd);
12369   sym_hashes = elf_sym_hashes (input_bfd);
12370   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12371
12372   rel = relocs;
12373   relend = relocs + input_section->reloc_count;
12374   for (; rel < relend; rel++)
12375     {
12376       enum elf_ppc64_reloc_type r_type;
12377       bfd_vma addend;
12378       bfd_reloc_status_type r;
12379       Elf_Internal_Sym *sym;
12380       asection *sec;
12381       struct elf_link_hash_entry *h_elf;
12382       struct ppc_link_hash_entry *h;
12383       struct ppc_link_hash_entry *fdh;
12384       const char *sym_name;
12385       unsigned long r_symndx, toc_symndx;
12386       bfd_vma toc_addend;
12387       unsigned char tls_mask, tls_gd, tls_type;
12388       unsigned char sym_type;
12389       bfd_vma relocation;
12390       bfd_boolean unresolved_reloc;
12391       bfd_boolean warned;
12392       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12393       unsigned int insn;
12394       unsigned int mask;
12395       struct ppc_stub_hash_entry *stub_entry;
12396       bfd_vma max_br_offset;
12397       bfd_vma from;
12398       const Elf_Internal_Rela orig_rel = *rel;
12399
12400       r_type = ELF64_R_TYPE (rel->r_info);
12401       r_symndx = ELF64_R_SYM (rel->r_info);
12402
12403       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12404          symbol of the previous ADDR64 reloc.  The symbol gives us the
12405          proper TOC base to use.  */
12406       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12407           && rel != relocs
12408           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12409           && is_opd)
12410         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12411
12412       sym = NULL;
12413       sec = NULL;
12414       h_elf = NULL;
12415       sym_name = NULL;
12416       unresolved_reloc = FALSE;
12417       warned = FALSE;
12418
12419       if (r_symndx < symtab_hdr->sh_info)
12420         {
12421           /* It's a local symbol.  */
12422           struct _opd_sec_data *opd;
12423
12424           sym = local_syms + r_symndx;
12425           sec = local_sections[r_symndx];
12426           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12427           sym_type = ELF64_ST_TYPE (sym->st_info);
12428           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12429           opd = get_opd_info (sec);
12430           if (opd != NULL && opd->adjust != NULL)
12431             {
12432               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12433               if (adjust == -1)
12434                 relocation = 0;
12435               else
12436                 {
12437                   /* If this is a relocation against the opd section sym
12438                      and we have edited .opd, adjust the reloc addend so
12439                      that ld -r and ld --emit-relocs output is correct.
12440                      If it is a reloc against some other .opd symbol,
12441                      then the symbol value will be adjusted later.  */
12442                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12443                     rel->r_addend += adjust;
12444                   else
12445                     relocation += adjust;
12446                 }
12447             }
12448         }
12449       else
12450         {
12451           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12452                                    r_symndx, symtab_hdr, sym_hashes,
12453                                    h_elf, sec, relocation,
12454                                    unresolved_reloc, warned);
12455           sym_name = h_elf->root.root.string;
12456           sym_type = h_elf->type;
12457           if (sec != NULL
12458               && sec->owner == output_bfd
12459               && strcmp (sec->name, ".opd") == 0)
12460             {
12461               /* This is a symbol defined in a linker script.  All
12462                  such are defined in output sections, even those
12463                  defined by simple assignment from a symbol defined in
12464                  an input section.  Transfer the symbol to an
12465                  appropriate input .opd section, so that a branch to
12466                  this symbol will be mapped to the location specified
12467                  by the opd entry.  */
12468               struct bfd_link_order *lo;
12469               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12470                 if (lo->type == bfd_indirect_link_order)
12471                   {
12472                     asection *isec = lo->u.indirect.section;
12473                     if (h_elf->root.u.def.value >= isec->output_offset
12474                         && h_elf->root.u.def.value < (isec->output_offset
12475                                                       + isec->size))
12476                       {
12477                         h_elf->root.u.def.value -= isec->output_offset;
12478                         h_elf->root.u.def.section = isec;
12479                         sec = isec;
12480                         break;
12481                       }
12482                   }
12483             }
12484         }
12485       h = (struct ppc_link_hash_entry *) h_elf;
12486
12487       if (sec != NULL && discarded_section (sec))
12488         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12489                                          rel, 1, relend,
12490                                          ppc64_elf_howto_table[r_type], 0,
12491                                          contents);
12492
12493       if (info->relocatable)
12494         continue;
12495
12496       if (h != NULL && &h->elf == htab->elf.hgot)
12497         {
12498           relocation = (TOCstart
12499                         + htab->stub_group[input_section->id].toc_off);
12500           sec = bfd_abs_section_ptr;
12501           unresolved_reloc = FALSE;
12502         }
12503
12504       /* TLS optimizations.  Replace instruction sequences and relocs
12505          based on information we collected in tls_optimize.  We edit
12506          RELOCS so that --emit-relocs will output something sensible
12507          for the final instruction stream.  */
12508       tls_mask = 0;
12509       tls_gd = 0;
12510       toc_symndx = 0;
12511       if (h != NULL)
12512         tls_mask = h->tls_mask;
12513       else if (local_got_ents != NULL)
12514         {
12515           struct plt_entry **local_plt = (struct plt_entry **)
12516             (local_got_ents + symtab_hdr->sh_info);
12517           unsigned char *lgot_masks = (unsigned char *)
12518             (local_plt + symtab_hdr->sh_info);
12519           tls_mask = lgot_masks[r_symndx];
12520         }
12521       if (tls_mask == 0
12522           && (r_type == R_PPC64_TLS
12523               || r_type == R_PPC64_TLSGD
12524               || r_type == R_PPC64_TLSLD))
12525         {
12526           /* Check for toc tls entries.  */
12527           unsigned char *toc_tls;
12528
12529           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12530                              &local_syms, rel, input_bfd))
12531             return FALSE;
12532
12533           if (toc_tls)
12534             tls_mask = *toc_tls;
12535         }
12536
12537       /* Check that tls relocs are used with tls syms, and non-tls
12538          relocs are used with non-tls syms.  */
12539       if (r_symndx != STN_UNDEF
12540           && r_type != R_PPC64_NONE
12541           && (h == NULL
12542               || h->elf.root.type == bfd_link_hash_defined
12543               || h->elf.root.type == bfd_link_hash_defweak)
12544           && (IS_PPC64_TLS_RELOC (r_type)
12545               != (sym_type == STT_TLS
12546                   || (sym_type == STT_SECTION
12547                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12548         {
12549           if (tls_mask != 0
12550               && (r_type == R_PPC64_TLS
12551                   || r_type == R_PPC64_TLSGD
12552                   || r_type == R_PPC64_TLSLD))
12553             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
12554             ;
12555           else
12556             info->callbacks->einfo
12557               (!IS_PPC64_TLS_RELOC (r_type)
12558                ? _("%P: %H: %s used with TLS symbol `%T'\n")
12559                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12560                input_bfd, input_section, rel->r_offset,
12561                ppc64_elf_howto_table[r_type]->name,
12562                sym_name);
12563         }
12564
12565       /* Ensure reloc mapping code below stays sane.  */
12566       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12567           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12568           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
12569           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12570           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12571           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12572           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
12573           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12574           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12575           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12576         abort ();
12577
12578       switch (r_type)
12579         {
12580         default:
12581           break;
12582
12583         case R_PPC64_LO_DS_OPT:
12584           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12585           if ((insn & (0x3f << 26)) != 58u << 26)
12586             abort ();
12587           insn += (14u << 26) - (58u << 26);
12588           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12589           r_type = R_PPC64_TOC16_LO;
12590           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12591           break;
12592
12593         case R_PPC64_TOC16:
12594         case R_PPC64_TOC16_LO:
12595         case R_PPC64_TOC16_DS:
12596         case R_PPC64_TOC16_LO_DS:
12597           {
12598             /* Check for toc tls entries.  */
12599             unsigned char *toc_tls;
12600             int retval;
12601
12602             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12603                                    &local_syms, rel, input_bfd);
12604             if (retval == 0)
12605               return FALSE;
12606
12607             if (toc_tls)
12608               {
12609                 tls_mask = *toc_tls;
12610                 if (r_type == R_PPC64_TOC16_DS
12611                     || r_type == R_PPC64_TOC16_LO_DS)
12612                   {
12613                     if (tls_mask != 0
12614                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12615                       goto toctprel;
12616                   }
12617                 else
12618                   {
12619                     /* If we found a GD reloc pair, then we might be
12620                        doing a GD->IE transition.  */
12621                     if (retval == 2)
12622                       {
12623                         tls_gd = TLS_TPRELGD;
12624                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12625                           goto tls_ldgd_opt;
12626                       }
12627                     else if (retval == 3)
12628                       {
12629                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12630                           goto tls_ldgd_opt;
12631                       }
12632                   }
12633               }
12634           }
12635           break;
12636
12637         case R_PPC64_GOT_TPREL16_HI:
12638         case R_PPC64_GOT_TPREL16_HA:
12639           if (tls_mask != 0
12640               && (tls_mask & TLS_TPREL) == 0)
12641             {
12642               rel->r_offset -= d_offset;
12643               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12644               r_type = R_PPC64_NONE;
12645               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12646             }
12647           break;
12648
12649         case R_PPC64_GOT_TPREL16_DS:
12650         case R_PPC64_GOT_TPREL16_LO_DS:
12651           if (tls_mask != 0
12652               && (tls_mask & TLS_TPREL) == 0)
12653             {
12654             toctprel:
12655               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12656               insn &= 31 << 21;
12657               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12658               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12659               r_type = R_PPC64_TPREL16_HA;
12660               if (toc_symndx != 0)
12661                 {
12662                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12663                   rel->r_addend = toc_addend;
12664                   /* We changed the symbol.  Start over in order to
12665                      get h, sym, sec etc. right.  */
12666                   rel--;
12667                   continue;
12668                 }
12669               else
12670                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12671             }
12672           break;
12673
12674         case R_PPC64_TLS:
12675           if (tls_mask != 0
12676               && (tls_mask & TLS_TPREL) == 0)
12677             {
12678               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12679               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12680               if (insn == 0)
12681                 abort ();
12682               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12683               /* Was PPC64_TLS which sits on insn boundary, now
12684                  PPC64_TPREL16_LO which is at low-order half-word.  */
12685               rel->r_offset += d_offset;
12686               r_type = R_PPC64_TPREL16_LO;
12687               if (toc_symndx != 0)
12688                 {
12689                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12690                   rel->r_addend = toc_addend;
12691                   /* We changed the symbol.  Start over in order to
12692                      get h, sym, sec etc. right.  */
12693                   rel--;
12694                   continue;
12695                 }
12696               else
12697                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12698             }
12699           break;
12700
12701         case R_PPC64_GOT_TLSGD16_HI:
12702         case R_PPC64_GOT_TLSGD16_HA:
12703           tls_gd = TLS_TPRELGD;
12704           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12705             goto tls_gdld_hi;
12706           break;
12707
12708         case R_PPC64_GOT_TLSLD16_HI:
12709         case R_PPC64_GOT_TLSLD16_HA:
12710           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12711             {
12712             tls_gdld_hi:
12713               if ((tls_mask & tls_gd) != 0)
12714                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12715                           + R_PPC64_GOT_TPREL16_DS);
12716               else
12717                 {
12718                   rel->r_offset -= d_offset;
12719                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12720                   r_type = R_PPC64_NONE;
12721                 }
12722               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12723             }
12724           break;
12725
12726         case R_PPC64_GOT_TLSGD16:
12727         case R_PPC64_GOT_TLSGD16_LO:
12728           tls_gd = TLS_TPRELGD;
12729           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12730             goto tls_ldgd_opt;
12731           break;
12732
12733         case R_PPC64_GOT_TLSLD16:
12734         case R_PPC64_GOT_TLSLD16_LO:
12735           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12736             {
12737               unsigned int insn1, insn2, insn3;
12738               bfd_vma offset;
12739
12740             tls_ldgd_opt:
12741               offset = (bfd_vma) -1;
12742               /* If not using the newer R_PPC64_TLSGD/LD to mark
12743                  __tls_get_addr calls, we must trust that the call
12744                  stays with its arg setup insns, ie. that the next
12745                  reloc is the __tls_get_addr call associated with
12746                  the current reloc.  Edit both insns.  */
12747               if (input_section->has_tls_get_addr_call
12748                   && rel + 1 < relend
12749                   && branch_reloc_hash_match (input_bfd, rel + 1,
12750                                               htab->tls_get_addr,
12751                                               htab->tls_get_addr_fd))
12752                 offset = rel[1].r_offset;
12753               if ((tls_mask & tls_gd) != 0)
12754                 {
12755                   /* IE */
12756                   insn1 = bfd_get_32 (output_bfd,
12757                                       contents + rel->r_offset - d_offset);
12758                   insn1 &= (1 << 26) - (1 << 2);
12759                   insn1 |= 58 << 26;    /* ld */
12760                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12761                   if (offset != (bfd_vma) -1)
12762                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12763                   if ((tls_mask & TLS_EXPLICIT) == 0)
12764                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12765                               + R_PPC64_GOT_TPREL16_DS);
12766                   else
12767                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12768                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12769                 }
12770               else
12771                 {
12772                   /* LE */
12773                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12774                   insn2 = 0x38630000;   /* addi 3,3,0 */
12775                   if (tls_gd == 0)
12776                     {
12777                       /* Was an LD reloc.  */
12778                       if (toc_symndx)
12779                         sec = local_sections[toc_symndx];
12780                       for (r_symndx = 0;
12781                            r_symndx < symtab_hdr->sh_info;
12782                            r_symndx++)
12783                         if (local_sections[r_symndx] == sec)
12784                           break;
12785                       if (r_symndx >= symtab_hdr->sh_info)
12786                         r_symndx = STN_UNDEF;
12787                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12788                       if (r_symndx != STN_UNDEF)
12789                         rel->r_addend -= (local_syms[r_symndx].st_value
12790                                           + sec->output_offset
12791                                           + sec->output_section->vma);
12792                     }
12793                   else if (toc_symndx != 0)
12794                     {
12795                       r_symndx = toc_symndx;
12796                       rel->r_addend = toc_addend;
12797                     }
12798                   r_type = R_PPC64_TPREL16_HA;
12799                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12800                   if (offset != (bfd_vma) -1)
12801                     {
12802                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12803                                                     R_PPC64_TPREL16_LO);
12804                       rel[1].r_offset = offset + d_offset;
12805                       rel[1].r_addend = rel->r_addend;
12806                     }
12807                 }
12808               bfd_put_32 (output_bfd, insn1,
12809                           contents + rel->r_offset - d_offset);
12810               if (offset != (bfd_vma) -1)
12811                 {
12812                   insn3 = bfd_get_32 (output_bfd,
12813                                       contents + offset + 4);
12814                   if (insn3 == NOP
12815                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12816                     {
12817                       rel[1].r_offset += 4;
12818                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12819                       insn2 = NOP;
12820                     }
12821                   bfd_put_32 (output_bfd, insn2, contents + offset);
12822                 }
12823               if ((tls_mask & tls_gd) == 0
12824                   && (tls_gd == 0 || toc_symndx != 0))
12825                 {
12826                   /* We changed the symbol.  Start over in order
12827                      to get h, sym, sec etc. right.  */
12828                   rel--;
12829                   continue;
12830                 }
12831             }
12832           break;
12833
12834         case R_PPC64_TLSGD:
12835           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12836             {
12837               unsigned int insn2, insn3;
12838               bfd_vma offset = rel->r_offset;
12839
12840               if ((tls_mask & TLS_TPRELGD) != 0)
12841                 {
12842                   /* IE */
12843                   r_type = R_PPC64_NONE;
12844                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12845                 }
12846               else
12847                 {
12848                   /* LE */
12849                   if (toc_symndx != 0)
12850                     {
12851                       r_symndx = toc_symndx;
12852                       rel->r_addend = toc_addend;
12853                     }
12854                   r_type = R_PPC64_TPREL16_LO;
12855                   rel->r_offset = offset + d_offset;
12856                   insn2 = 0x38630000;   /* addi 3,3,0 */
12857                 }
12858               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12859               /* Zap the reloc on the _tls_get_addr call too.  */
12860               BFD_ASSERT (offset == rel[1].r_offset);
12861               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12862               insn3 = bfd_get_32 (output_bfd,
12863                                   contents + offset + 4);
12864               if (insn3 == NOP
12865                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12866                 {
12867                   rel->r_offset += 4;
12868                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12869                   insn2 = NOP;
12870                 }
12871               bfd_put_32 (output_bfd, insn2, contents + offset);
12872               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12873                 {
12874                   rel--;
12875                   continue;
12876                 }
12877             }
12878           break;
12879
12880         case R_PPC64_TLSLD:
12881           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12882             {
12883               unsigned int insn2, insn3;
12884               bfd_vma offset = rel->r_offset;
12885
12886               if (toc_symndx)
12887                 sec = local_sections[toc_symndx];
12888               for (r_symndx = 0;
12889                    r_symndx < symtab_hdr->sh_info;
12890                    r_symndx++)
12891                 if (local_sections[r_symndx] == sec)
12892                   break;
12893               if (r_symndx >= symtab_hdr->sh_info)
12894                 r_symndx = STN_UNDEF;
12895               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12896               if (r_symndx != STN_UNDEF)
12897                 rel->r_addend -= (local_syms[r_symndx].st_value
12898                                   + sec->output_offset
12899                                   + sec->output_section->vma);
12900
12901               r_type = R_PPC64_TPREL16_LO;
12902               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12903               rel->r_offset = offset + d_offset;
12904               /* Zap the reloc on the _tls_get_addr call too.  */
12905               BFD_ASSERT (offset == rel[1].r_offset);
12906               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12907               insn2 = 0x38630000;       /* addi 3,3,0 */
12908               insn3 = bfd_get_32 (output_bfd,
12909                                   contents + offset + 4);
12910               if (insn3 == NOP
12911                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12912                 {
12913                   rel->r_offset += 4;
12914                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12915                   insn2 = NOP;
12916                 }
12917               bfd_put_32 (output_bfd, insn2, contents + offset);
12918               rel--;
12919               continue;
12920             }
12921           break;
12922
12923         case R_PPC64_DTPMOD64:
12924           if (rel + 1 < relend
12925               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12926               && rel[1].r_offset == rel->r_offset + 8)
12927             {
12928               if ((tls_mask & TLS_GD) == 0)
12929                 {
12930                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12931                   if ((tls_mask & TLS_TPRELGD) != 0)
12932                     r_type = R_PPC64_TPREL64;
12933                   else
12934                     {
12935                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12936                       r_type = R_PPC64_NONE;
12937                     }
12938                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12939                 }
12940             }
12941           else
12942             {
12943               if ((tls_mask & TLS_LD) == 0)
12944                 {
12945                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12946                   r_type = R_PPC64_NONE;
12947                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12948                 }
12949             }
12950           break;
12951
12952         case R_PPC64_TPREL64:
12953           if ((tls_mask & TLS_TPREL) == 0)
12954             {
12955               r_type = R_PPC64_NONE;
12956               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12957             }
12958           break;
12959         }
12960
12961       /* Handle other relocations that tweak non-addend part of insn.  */
12962       insn = 0;
12963       max_br_offset = 1 << 25;
12964       addend = rel->r_addend;
12965       reloc_dest = DEST_NORMAL;
12966       switch (r_type)
12967         {
12968         default:
12969           break;
12970
12971         case R_PPC64_TOCSAVE:
12972           if (relocation + addend == (rel->r_offset
12973                                       + input_section->output_offset
12974                                       + input_section->output_section->vma)
12975               && tocsave_find (htab, NO_INSERT,
12976                                &local_syms, rel, input_bfd))
12977             {
12978               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12979               if (insn == NOP
12980                   || insn == CROR_151515 || insn == CROR_313131)
12981                 bfd_put_32 (input_bfd, STD_R2_40R1,
12982                             contents + rel->r_offset);
12983             }
12984           break;
12985
12986           /* Branch taken prediction relocations.  */
12987         case R_PPC64_ADDR14_BRTAKEN:
12988         case R_PPC64_REL14_BRTAKEN:
12989           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12990           /* Fall thru.  */
12991
12992           /* Branch not taken prediction relocations.  */
12993         case R_PPC64_ADDR14_BRNTAKEN:
12994         case R_PPC64_REL14_BRNTAKEN:
12995           insn |= bfd_get_32 (output_bfd,
12996                               contents + rel->r_offset) & ~(0x01 << 21);
12997           /* Fall thru.  */
12998
12999         case R_PPC64_REL14:
13000           max_br_offset = 1 << 15;
13001           /* Fall thru.  */
13002
13003         case R_PPC64_REL24:
13004           /* Calls to functions with a different TOC, such as calls to
13005              shared objects, need to alter the TOC pointer.  This is
13006              done using a linkage stub.  A REL24 branching to these
13007              linkage stubs needs to be followed by a nop, as the nop
13008              will be replaced with an instruction to restore the TOC
13009              base pointer.  */
13010           fdh = h;
13011           if (h != NULL
13012               && h->oh != NULL
13013               && h->oh->is_func_descriptor)
13014             fdh = ppc_follow_link (h->oh);
13015           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13016                                            htab);
13017           if (stub_entry != NULL
13018               && (stub_entry->stub_type == ppc_stub_plt_call
13019                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
13020                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13021                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13022             {
13023               bfd_boolean can_plt_call = FALSE;
13024
13025               /* All of these stubs will modify r2, so there must be a
13026                  branch and link followed by a nop.  The nop is
13027                  replaced by an insn to restore r2.  */
13028               if (rel->r_offset + 8 <= input_section->size)
13029                 {
13030                   unsigned long br;
13031
13032                   br = bfd_get_32 (input_bfd,
13033                                    contents + rel->r_offset);
13034                   if ((br & 1) != 0)
13035                     {
13036                       unsigned long nop;
13037
13038                       nop = bfd_get_32 (input_bfd,
13039                                         contents + rel->r_offset + 4);
13040                       if (nop == NOP
13041                           || nop == CROR_151515 || nop == CROR_313131)
13042                         {
13043                           if (h != NULL
13044                               && (h == htab->tls_get_addr_fd
13045                                   || h == htab->tls_get_addr)
13046                               && !htab->no_tls_get_addr_opt)
13047                             {
13048                               /* Special stub used, leave nop alone.  */
13049                             }
13050                           else
13051                             bfd_put_32 (input_bfd, LD_R2_40R1,
13052                                         contents + rel->r_offset + 4);
13053                           can_plt_call = TRUE;
13054                         }
13055                     }
13056                 }
13057
13058               if (!can_plt_call && h != NULL)
13059                 {
13060                   const char *name = h->elf.root.root.string;
13061
13062                   if (*name == '.')
13063                     ++name;
13064
13065                   if (strncmp (name, "__libc_start_main", 17) == 0
13066                       && (name[17] == 0 || name[17] == '@'))
13067                     {
13068                       /* Allow crt1 branch to go via a toc adjusting
13069                          stub.  Other calls that never return could do
13070                          the same, if we could detect such.  */
13071                       can_plt_call = TRUE;
13072                     }
13073                 }
13074
13075               if (!can_plt_call)
13076                 {
13077                   /* g++ as of 20130507 emits self-calls without a
13078                      following nop.  This is arguably wrong since we
13079                      have conflicting information.  On the one hand a
13080                      global symbol and on the other a local call
13081                      sequence, but don't error for this special case.
13082                      It isn't possible to cheaply verify we have
13083                      exactly such a call.  Allow all calls to the same
13084                      section.  */
13085                   asection *code_sec = sec;
13086
13087                   if (get_opd_info (sec) != NULL)
13088                     {
13089                       bfd_vma off = (relocation + addend
13090                                      - sec->output_section->vma
13091                                      - sec->output_offset);
13092
13093                       opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13094                     }
13095                   if (code_sec == input_section)
13096                     can_plt_call = TRUE;
13097                 }
13098
13099               if (!can_plt_call)
13100                 {
13101                   info->callbacks->einfo
13102                     (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13103                        "recompile with -fPIC"),
13104                      input_bfd, input_section, rel->r_offset, sym_name);
13105
13106                   bfd_set_error (bfd_error_bad_value);
13107                   ret = FALSE;
13108                 }
13109
13110               if (can_plt_call
13111                   && (stub_entry->stub_type == ppc_stub_plt_call
13112                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13113                 unresolved_reloc = FALSE;
13114             }
13115
13116           if ((stub_entry == NULL
13117                || stub_entry->stub_type == ppc_stub_long_branch
13118                || stub_entry->stub_type == ppc_stub_plt_branch)
13119               && get_opd_info (sec) != NULL)
13120             {
13121               /* The branch destination is the value of the opd entry. */
13122               bfd_vma off = (relocation + addend
13123                              - sec->output_section->vma
13124                              - sec->output_offset);
13125               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13126               if (dest != (bfd_vma) -1)
13127                 {
13128                   relocation = dest;
13129                   addend = 0;
13130                   reloc_dest = DEST_OPD;
13131                 }
13132             }
13133
13134           /* If the branch is out of reach we ought to have a long
13135              branch stub.  */
13136           from = (rel->r_offset
13137                   + input_section->output_offset
13138                   + input_section->output_section->vma);
13139
13140           if (stub_entry != NULL
13141               && (stub_entry->stub_type == ppc_stub_long_branch
13142                   || stub_entry->stub_type == ppc_stub_plt_branch)
13143               && (r_type == R_PPC64_ADDR14_BRTAKEN
13144                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13145                   || (relocation + addend - from + max_br_offset
13146                       < 2 * max_br_offset)))
13147             /* Don't use the stub if this branch is in range.  */
13148             stub_entry = NULL;
13149
13150           if (stub_entry != NULL)
13151             {
13152               /* Munge up the value and addend so that we call the stub
13153                  rather than the procedure directly.  */
13154               relocation = (stub_entry->stub_offset
13155                             + stub_entry->stub_sec->output_offset
13156                             + stub_entry->stub_sec->output_section->vma);
13157               addend = 0;
13158               reloc_dest = DEST_STUB;
13159
13160               if ((stub_entry->stub_type == ppc_stub_plt_call
13161                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13162                   && (ALWAYS_EMIT_R2SAVE
13163                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13164                   && rel + 1 < relend
13165                   && rel[1].r_offset == rel->r_offset + 4
13166                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13167                 relocation += 4;
13168             }
13169
13170           if (insn != 0)
13171             {
13172               if (is_isa_v2)
13173                 {
13174                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13175                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13176                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13177                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13178                     insn |= 0x02 << 21;
13179                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13180                     insn |= 0x08 << 21;
13181                   else
13182                     break;
13183                 }
13184               else
13185                 {
13186                   /* Invert 'y' bit if not the default.  */
13187                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13188                     insn ^= 0x01 << 21;
13189                 }
13190
13191               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13192             }
13193
13194           /* NOP out calls to undefined weak functions.
13195              We can thus call a weak function without first
13196              checking whether the function is defined.  */
13197           else if (h != NULL
13198                    && h->elf.root.type == bfd_link_hash_undefweak
13199                    && h->elf.dynindx == -1
13200                    && r_type == R_PPC64_REL24
13201                    && relocation == 0
13202                    && addend == 0)
13203             {
13204               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13205               continue;
13206             }
13207           break;
13208         }
13209
13210       /* Set `addend'.  */
13211       tls_type = 0;
13212       switch (r_type)
13213         {
13214         default:
13215           info->callbacks->einfo
13216             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13217              input_bfd, (int) r_type, sym_name);
13218
13219           bfd_set_error (bfd_error_bad_value);
13220           ret = FALSE;
13221           continue;
13222
13223         case R_PPC64_NONE:
13224         case R_PPC64_TLS:
13225         case R_PPC64_TLSGD:
13226         case R_PPC64_TLSLD:
13227         case R_PPC64_TOCSAVE:
13228         case R_PPC64_GNU_VTINHERIT:
13229         case R_PPC64_GNU_VTENTRY:
13230           continue;
13231
13232           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13233              address in the GOT as relocation value instead of the
13234              symbol's value itself.  Also, create a GOT entry for the
13235              symbol and put the symbol value there.  */
13236         case R_PPC64_GOT_TLSGD16:
13237         case R_PPC64_GOT_TLSGD16_LO:
13238         case R_PPC64_GOT_TLSGD16_HI:
13239         case R_PPC64_GOT_TLSGD16_HA:
13240           tls_type = TLS_TLS | TLS_GD;
13241           goto dogot;
13242
13243         case R_PPC64_GOT_TLSLD16:
13244         case R_PPC64_GOT_TLSLD16_LO:
13245         case R_PPC64_GOT_TLSLD16_HI:
13246         case R_PPC64_GOT_TLSLD16_HA:
13247           tls_type = TLS_TLS | TLS_LD;
13248           goto dogot;
13249
13250         case R_PPC64_GOT_TPREL16_DS:
13251         case R_PPC64_GOT_TPREL16_LO_DS:
13252         case R_PPC64_GOT_TPREL16_HI:
13253         case R_PPC64_GOT_TPREL16_HA:
13254           tls_type = TLS_TLS | TLS_TPREL;
13255           goto dogot;
13256
13257         case R_PPC64_GOT_DTPREL16_DS:
13258         case R_PPC64_GOT_DTPREL16_LO_DS:
13259         case R_PPC64_GOT_DTPREL16_HI:
13260         case R_PPC64_GOT_DTPREL16_HA:
13261           tls_type = TLS_TLS | TLS_DTPREL;
13262           goto dogot;
13263
13264         case R_PPC64_GOT16:
13265         case R_PPC64_GOT16_LO:
13266         case R_PPC64_GOT16_HI:
13267         case R_PPC64_GOT16_HA:
13268         case R_PPC64_GOT16_DS:
13269         case R_PPC64_GOT16_LO_DS:
13270         dogot:
13271           {
13272             /* Relocation is to the entry for this symbol in the global
13273                offset table.  */
13274             asection *got;
13275             bfd_vma *offp;
13276             bfd_vma off;
13277             unsigned long indx = 0;
13278             struct got_entry *ent;
13279
13280             if (tls_type == (TLS_TLS | TLS_LD)
13281                 && (h == NULL
13282                     || !h->elf.def_dynamic))
13283               ent = ppc64_tlsld_got (input_bfd);
13284             else
13285               {
13286
13287                 if (h != NULL)
13288                   {
13289                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13290                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13291                                                           &h->elf)
13292                         || (info->shared
13293                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13294                       /* This is actually a static link, or it is a
13295                          -Bsymbolic link and the symbol is defined
13296                          locally, or the symbol was forced to be local
13297                          because of a version file.  */
13298                       ;
13299                     else
13300                       {
13301                         BFD_ASSERT (h->elf.dynindx != -1);
13302                         indx = h->elf.dynindx;
13303                         unresolved_reloc = FALSE;
13304                       }
13305                     ent = h->elf.got.glist;
13306                   }
13307                 else
13308                   {
13309                     if (local_got_ents == NULL)
13310                       abort ();
13311                     ent = local_got_ents[r_symndx];
13312                   }
13313
13314                 for (; ent != NULL; ent = ent->next)
13315                   if (ent->addend == orig_rel.r_addend
13316                       && ent->owner == input_bfd
13317                       && ent->tls_type == tls_type)
13318                     break;
13319               }
13320
13321             if (ent == NULL)
13322               abort ();
13323             if (ent->is_indirect)
13324               ent = ent->got.ent;
13325             offp = &ent->got.offset;
13326             got = ppc64_elf_tdata (ent->owner)->got;
13327             if (got == NULL)
13328               abort ();
13329
13330             /* The offset must always be a multiple of 8.  We use the
13331                least significant bit to record whether we have already
13332                processed this entry.  */
13333             off = *offp;
13334             if ((off & 1) != 0)
13335               off &= ~1;
13336             else
13337               {
13338                 /* Generate relocs for the dynamic linker, except in
13339                    the case of TLSLD where we'll use one entry per
13340                    module.  */
13341                 asection *relgot;
13342                 bfd_boolean ifunc;
13343
13344                 *offp = off | 1;
13345                 relgot = NULL;
13346                 ifunc = (h != NULL
13347                          ? h->elf.type == STT_GNU_IFUNC
13348                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13349                 if (ifunc)
13350                   relgot = htab->reliplt;
13351                 else if ((info->shared || indx != 0)
13352                          && (h == NULL
13353                              || (tls_type == (TLS_TLS | TLS_LD)
13354                                  && !h->elf.def_dynamic)
13355                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13356                              || h->elf.root.type != bfd_link_hash_undefweak))
13357                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13358                 if (relgot != NULL)
13359                   {
13360                     outrel.r_offset = (got->output_section->vma
13361                                        + got->output_offset
13362                                        + off);
13363                     outrel.r_addend = addend;
13364                     if (tls_type & (TLS_LD | TLS_GD))
13365                       {
13366                         outrel.r_addend = 0;
13367                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13368                         if (tls_type == (TLS_TLS | TLS_GD))
13369                           {
13370                             loc = relgot->contents;
13371                             loc += (relgot->reloc_count++
13372                                     * sizeof (Elf64_External_Rela));
13373                             bfd_elf64_swap_reloca_out (output_bfd,
13374                                                        &outrel, loc);
13375                             outrel.r_offset += 8;
13376                             outrel.r_addend = addend;
13377                             outrel.r_info
13378                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13379                           }
13380                       }
13381                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13382                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13383                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13384                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13385                     else if (indx != 0)
13386                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13387                     else
13388                       {
13389                         if (ifunc)
13390                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13391                         else
13392                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13393
13394                         /* Write the .got section contents for the sake
13395                            of prelink.  */
13396                         loc = got->contents + off;
13397                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13398                                     loc);
13399                       }
13400
13401                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13402                       {
13403                         outrel.r_addend += relocation;
13404                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13405                           outrel.r_addend -= htab->elf.tls_sec->vma;
13406                       }
13407                     loc = relgot->contents;
13408                     loc += (relgot->reloc_count++
13409                             * sizeof (Elf64_External_Rela));
13410                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13411                   }
13412
13413                 /* Init the .got section contents here if we're not
13414                    emitting a reloc.  */
13415                 else
13416                   {
13417                     relocation += addend;
13418                     if (tls_type == (TLS_TLS | TLS_LD))
13419                       relocation = 1;
13420                     else if (tls_type != 0)
13421                       {
13422                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13423                         if (tls_type == (TLS_TLS | TLS_TPREL))
13424                           relocation += DTP_OFFSET - TP_OFFSET;
13425
13426                         if (tls_type == (TLS_TLS | TLS_GD))
13427                           {
13428                             bfd_put_64 (output_bfd, relocation,
13429                                         got->contents + off + 8);
13430                             relocation = 1;
13431                           }
13432                       }
13433
13434                     bfd_put_64 (output_bfd, relocation,
13435                                 got->contents + off);
13436                   }
13437               }
13438
13439             if (off >= (bfd_vma) -2)
13440               abort ();
13441
13442             relocation = got->output_section->vma + got->output_offset + off;
13443             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13444           }
13445           break;
13446
13447         case R_PPC64_PLT16_HA:
13448         case R_PPC64_PLT16_HI:
13449         case R_PPC64_PLT16_LO:
13450         case R_PPC64_PLT32:
13451         case R_PPC64_PLT64:
13452           /* Relocation is to the entry for this symbol in the
13453              procedure linkage table.  */
13454
13455           /* Resolve a PLT reloc against a local symbol directly,
13456              without using the procedure linkage table.  */
13457           if (h == NULL)
13458             break;
13459
13460           /* It's possible that we didn't make a PLT entry for this
13461              symbol.  This happens when statically linking PIC code,
13462              or when using -Bsymbolic.  Go find a match if there is a
13463              PLT entry.  */
13464           if (htab->plt != NULL)
13465             {
13466               struct plt_entry *ent;
13467               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13468                 if (ent->addend == orig_rel.r_addend
13469                     && ent->plt.offset != (bfd_vma) -1)
13470                   {
13471                     relocation = (htab->plt->output_section->vma
13472                                   + htab->plt->output_offset
13473                                   + ent->plt.offset);
13474                     unresolved_reloc = FALSE;
13475                   }
13476             }
13477           break;
13478
13479         case R_PPC64_TOC:
13480           /* Relocation value is TOC base.  */
13481           relocation = TOCstart;
13482           if (r_symndx == STN_UNDEF)
13483             relocation += htab->stub_group[input_section->id].toc_off;
13484           else if (unresolved_reloc)
13485             ;
13486           else if (sec != NULL && sec->id <= htab->top_id)
13487             relocation += htab->stub_group[sec->id].toc_off;
13488           else
13489             unresolved_reloc = TRUE;
13490           goto dodyn;
13491
13492           /* TOC16 relocs.  We want the offset relative to the TOC base,
13493              which is the address of the start of the TOC plus 0x8000.
13494              The TOC consists of sections .got, .toc, .tocbss, and .plt,
13495              in this order.  */
13496         case R_PPC64_TOC16:
13497         case R_PPC64_TOC16_LO:
13498         case R_PPC64_TOC16_HI:
13499         case R_PPC64_TOC16_DS:
13500         case R_PPC64_TOC16_LO_DS:
13501         case R_PPC64_TOC16_HA:
13502           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13503           break;
13504
13505           /* Relocate against the beginning of the section.  */
13506         case R_PPC64_SECTOFF:
13507         case R_PPC64_SECTOFF_LO:
13508         case R_PPC64_SECTOFF_HI:
13509         case R_PPC64_SECTOFF_DS:
13510         case R_PPC64_SECTOFF_LO_DS:
13511         case R_PPC64_SECTOFF_HA:
13512           if (sec != NULL)
13513             addend -= sec->output_section->vma;
13514           break;
13515
13516         case R_PPC64_REL16:
13517         case R_PPC64_REL16_LO:
13518         case R_PPC64_REL16_HI:
13519         case R_PPC64_REL16_HA:
13520           break;
13521
13522         case R_PPC64_REL14:
13523         case R_PPC64_REL14_BRNTAKEN:
13524         case R_PPC64_REL14_BRTAKEN:
13525         case R_PPC64_REL24:
13526           break;
13527
13528         case R_PPC64_TPREL16:
13529         case R_PPC64_TPREL16_LO:
13530         case R_PPC64_TPREL16_HI:
13531         case R_PPC64_TPREL16_HA:
13532         case R_PPC64_TPREL16_DS:
13533         case R_PPC64_TPREL16_LO_DS:
13534         case R_PPC64_TPREL16_HIGHER:
13535         case R_PPC64_TPREL16_HIGHERA:
13536         case R_PPC64_TPREL16_HIGHEST:
13537         case R_PPC64_TPREL16_HIGHESTA:
13538           if (h != NULL
13539               && h->elf.root.type == bfd_link_hash_undefweak
13540               && h->elf.dynindx == -1)
13541             {
13542               /* Make this relocation against an undefined weak symbol
13543                  resolve to zero.  This is really just a tweak, since
13544                  code using weak externs ought to check that they are
13545                  defined before using them.  */
13546               bfd_byte *p = contents + rel->r_offset - d_offset;
13547
13548               insn = bfd_get_32 (output_bfd, p);
13549               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13550               if (insn != 0)
13551                 bfd_put_32 (output_bfd, insn, p);
13552               break;
13553             }
13554           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13555           if (info->shared)
13556             /* The TPREL16 relocs shouldn't really be used in shared
13557                libs as they will result in DT_TEXTREL being set, but
13558                support them anyway.  */
13559             goto dodyn;
13560           break;
13561
13562         case R_PPC64_DTPREL16:
13563         case R_PPC64_DTPREL16_LO:
13564         case R_PPC64_DTPREL16_HI:
13565         case R_PPC64_DTPREL16_HA:
13566         case R_PPC64_DTPREL16_DS:
13567         case R_PPC64_DTPREL16_LO_DS:
13568         case R_PPC64_DTPREL16_HIGHER:
13569         case R_PPC64_DTPREL16_HIGHERA:
13570         case R_PPC64_DTPREL16_HIGHEST:
13571         case R_PPC64_DTPREL16_HIGHESTA:
13572           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13573           break;
13574
13575         case R_PPC64_DTPMOD64:
13576           relocation = 1;
13577           addend = 0;
13578           goto dodyn;
13579
13580         case R_PPC64_TPREL64:
13581           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13582           goto dodyn;
13583
13584         case R_PPC64_DTPREL64:
13585           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13586           /* Fall thru */
13587
13588           /* Relocations that may need to be propagated if this is a
13589              dynamic object.  */
13590         case R_PPC64_REL30:
13591         case R_PPC64_REL32:
13592         case R_PPC64_REL64:
13593         case R_PPC64_ADDR14:
13594         case R_PPC64_ADDR14_BRNTAKEN:
13595         case R_PPC64_ADDR14_BRTAKEN:
13596         case R_PPC64_ADDR16:
13597         case R_PPC64_ADDR16_DS:
13598         case R_PPC64_ADDR16_HA:
13599         case R_PPC64_ADDR16_HI:
13600         case R_PPC64_ADDR16_HIGHER:
13601         case R_PPC64_ADDR16_HIGHERA:
13602         case R_PPC64_ADDR16_HIGHEST:
13603         case R_PPC64_ADDR16_HIGHESTA:
13604         case R_PPC64_ADDR16_LO:
13605         case R_PPC64_ADDR16_LO_DS:
13606         case R_PPC64_ADDR24:
13607         case R_PPC64_ADDR32:
13608         case R_PPC64_ADDR64:
13609         case R_PPC64_UADDR16:
13610         case R_PPC64_UADDR32:
13611         case R_PPC64_UADDR64:
13612         dodyn:
13613           if ((input_section->flags & SEC_ALLOC) == 0)
13614             break;
13615
13616           if (NO_OPD_RELOCS && is_opd)
13617             break;
13618
13619           if ((info->shared
13620                && (h == NULL
13621                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13622                    || h->elf.root.type != bfd_link_hash_undefweak)
13623                && (must_be_dyn_reloc (info, r_type)
13624                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13625               || (ELIMINATE_COPY_RELOCS
13626                   && !info->shared
13627                   && h != NULL
13628                   && h->elf.dynindx != -1
13629                   && !h->elf.non_got_ref
13630                   && !h->elf.def_regular)
13631               || (!info->shared
13632                   && (h != NULL
13633                       ? h->elf.type == STT_GNU_IFUNC
13634                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13635             {
13636               bfd_boolean skip, relocate;
13637               asection *sreloc;
13638               bfd_vma out_off;
13639
13640               /* When generating a dynamic object, these relocations
13641                  are copied into the output file to be resolved at run
13642                  time.  */
13643
13644               skip = FALSE;
13645               relocate = FALSE;
13646
13647               out_off = _bfd_elf_section_offset (output_bfd, info,
13648                                                  input_section, rel->r_offset);
13649               if (out_off == (bfd_vma) -1)
13650                 skip = TRUE;
13651               else if (out_off == (bfd_vma) -2)
13652                 skip = TRUE, relocate = TRUE;
13653               out_off += (input_section->output_section->vma
13654                           + input_section->output_offset);
13655               outrel.r_offset = out_off;
13656               outrel.r_addend = rel->r_addend;
13657
13658               /* Optimize unaligned reloc use.  */
13659               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13660                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13661                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13662               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13663                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13664                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13665               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13666                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13667                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13668
13669               if (skip)
13670                 memset (&outrel, 0, sizeof outrel);
13671               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13672                        && !is_opd
13673                        && r_type != R_PPC64_TOC)
13674                 {
13675                   BFD_ASSERT (h->elf.dynindx != -1);
13676                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13677                 }
13678               else
13679                 {
13680                   /* This symbol is local, or marked to become local,
13681                      or this is an opd section reloc which must point
13682                      at a local function.  */
13683                   outrel.r_addend += relocation;
13684                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13685                     {
13686                       if (is_opd && h != NULL)
13687                         {
13688                           /* Lie about opd entries.  This case occurs
13689                              when building shared libraries and we
13690                              reference a function in another shared
13691                              lib.  The same thing happens for a weak
13692                              definition in an application that's
13693                              overridden by a strong definition in a
13694                              shared lib.  (I believe this is a generic
13695                              bug in binutils handling of weak syms.)
13696                              In these cases we won't use the opd
13697                              entry in this lib.  */
13698                           unresolved_reloc = FALSE;
13699                         }
13700                       if (!is_opd
13701                           && r_type == R_PPC64_ADDR64
13702                           && (h != NULL
13703                               ? h->elf.type == STT_GNU_IFUNC
13704                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13705                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13706                       else
13707                         {
13708                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13709
13710                           /* We need to relocate .opd contents for ld.so.
13711                              Prelink also wants simple and consistent rules
13712                              for relocs.  This make all RELATIVE relocs have
13713                              *r_offset equal to r_addend.  */
13714                           relocate = TRUE;
13715                         }
13716                     }
13717                   else
13718                     {
13719                       long indx = 0;
13720
13721                       if (h != NULL
13722                           ? h->elf.type == STT_GNU_IFUNC
13723                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13724                         {
13725                           info->callbacks->einfo
13726                             (_("%P: %H: %s for indirect "
13727                                "function `%T' unsupported\n"),
13728                              input_bfd, input_section, rel->r_offset,
13729                              ppc64_elf_howto_table[r_type]->name,
13730                              sym_name);
13731                           ret = FALSE;
13732                         }
13733                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13734                         ;
13735                       else if (sec == NULL || sec->owner == NULL)
13736                         {
13737                           bfd_set_error (bfd_error_bad_value);
13738                           return FALSE;
13739                         }
13740                       else
13741                         {
13742                           asection *osec;
13743
13744                           osec = sec->output_section;
13745                           indx = elf_section_data (osec)->dynindx;
13746
13747                           if (indx == 0)
13748                             {
13749                               if ((osec->flags & SEC_READONLY) == 0
13750                                   && htab->elf.data_index_section != NULL)
13751                                 osec = htab->elf.data_index_section;
13752                               else
13753                                 osec = htab->elf.text_index_section;
13754                               indx = elf_section_data (osec)->dynindx;
13755                             }
13756                           BFD_ASSERT (indx != 0);
13757
13758                           /* We are turning this relocation into one
13759                              against a section symbol, so subtract out
13760                              the output section's address but not the
13761                              offset of the input section in the output
13762                              section.  */
13763                           outrel.r_addend -= osec->vma;
13764                         }
13765
13766                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13767                     }
13768                 }
13769
13770               sreloc = elf_section_data (input_section)->sreloc;
13771               if (h != NULL
13772                   ? h->elf.type == STT_GNU_IFUNC
13773                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13774                 sreloc = htab->reliplt;
13775               if (sreloc == NULL)
13776                 abort ();
13777
13778               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13779                   >= sreloc->size)
13780                 abort ();
13781               loc = sreloc->contents;
13782               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13783               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13784
13785               /* If this reloc is against an external symbol, it will
13786                  be computed at runtime, so there's no need to do
13787                  anything now.  However, for the sake of prelink ensure
13788                  that the section contents are a known value.  */
13789               if (! relocate)
13790                 {
13791                   unresolved_reloc = FALSE;
13792                   /* The value chosen here is quite arbitrary as ld.so
13793                      ignores section contents except for the special
13794                      case of .opd where the contents might be accessed
13795                      before relocation.  Choose zero, as that won't
13796                      cause reloc overflow.  */
13797                   relocation = 0;
13798                   addend = 0;
13799                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13800                      to improve backward compatibility with older
13801                      versions of ld.  */
13802                   if (r_type == R_PPC64_ADDR64)
13803                     addend = outrel.r_addend;
13804                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13805                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13806                     addend = (input_section->output_section->vma
13807                               + input_section->output_offset
13808                               + rel->r_offset);
13809                 }
13810             }
13811           break;
13812
13813         case R_PPC64_COPY:
13814         case R_PPC64_GLOB_DAT:
13815         case R_PPC64_JMP_SLOT:
13816         case R_PPC64_JMP_IREL:
13817         case R_PPC64_RELATIVE:
13818           /* We shouldn't ever see these dynamic relocs in relocatable
13819              files.  */
13820           /* Fall through.  */
13821
13822         case R_PPC64_PLTGOT16:
13823         case R_PPC64_PLTGOT16_DS:
13824         case R_PPC64_PLTGOT16_HA:
13825         case R_PPC64_PLTGOT16_HI:
13826         case R_PPC64_PLTGOT16_LO:
13827         case R_PPC64_PLTGOT16_LO_DS:
13828         case R_PPC64_PLTREL32:
13829         case R_PPC64_PLTREL64:
13830           /* These ones haven't been implemented yet.  */
13831
13832           info->callbacks->einfo
13833             (_("%P: %B: %s is not supported for `%T'\n"),
13834              input_bfd,
13835              ppc64_elf_howto_table[r_type]->name, sym_name);
13836
13837           bfd_set_error (bfd_error_invalid_operation);
13838           ret = FALSE;
13839           continue;
13840         }
13841
13842       /* Multi-instruction sequences that access the TOC can be
13843          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13844          to             nop;           addi rb,r2,x;  */
13845       switch (r_type)
13846         {
13847         default:
13848           break;
13849
13850         case R_PPC64_GOT_TLSLD16_HI:
13851         case R_PPC64_GOT_TLSGD16_HI:
13852         case R_PPC64_GOT_TPREL16_HI:
13853         case R_PPC64_GOT_DTPREL16_HI:
13854         case R_PPC64_GOT16_HI:
13855         case R_PPC64_TOC16_HI:
13856           /* These relocs would only be useful if building up an
13857              offset to later add to r2, perhaps in an indexed
13858              addressing mode instruction.  Don't try to optimize.
13859              Unfortunately, the possibility of someone building up an
13860              offset like this or even with the HA relocs, means that
13861              we need to check the high insn when optimizing the low
13862              insn.  */
13863           break;
13864
13865         case R_PPC64_GOT_TLSLD16_HA:
13866         case R_PPC64_GOT_TLSGD16_HA:
13867         case R_PPC64_GOT_TPREL16_HA:
13868         case R_PPC64_GOT_DTPREL16_HA:
13869         case R_PPC64_GOT16_HA:
13870         case R_PPC64_TOC16_HA:
13871           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13872               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13873             {
13874               bfd_byte *p = contents + (rel->r_offset & ~3);
13875               bfd_put_32 (input_bfd, NOP, p);
13876             }
13877           break;
13878
13879         case R_PPC64_GOT_TLSLD16_LO:
13880         case R_PPC64_GOT_TLSGD16_LO:
13881         case R_PPC64_GOT_TPREL16_LO_DS:
13882         case R_PPC64_GOT_DTPREL16_LO_DS:
13883         case R_PPC64_GOT16_LO:
13884         case R_PPC64_GOT16_LO_DS:
13885         case R_PPC64_TOC16_LO:
13886         case R_PPC64_TOC16_LO_DS:
13887           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13888               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13889             {
13890               bfd_byte *p = contents + (rel->r_offset & ~3);
13891               insn = bfd_get_32 (input_bfd, p);
13892               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13893                 {
13894                   /* Transform addic to addi when we change reg.  */
13895                   insn &= ~((0x3f << 26) | (0x1f << 16));
13896                   insn |= (14u << 26) | (2 << 16);
13897                 }
13898               else
13899                 {
13900                   insn &= ~(0x1f << 16);
13901                   insn |= 2 << 16;
13902                 }
13903               bfd_put_32 (input_bfd, insn, p);
13904             }
13905           break;
13906         }
13907
13908       /* Do any further special processing.  */
13909       switch (r_type)
13910         {
13911         default:
13912           break;
13913
13914         case R_PPC64_ADDR16_HA:
13915         case R_PPC64_REL16_HA:
13916         case R_PPC64_ADDR16_HIGHERA:
13917         case R_PPC64_ADDR16_HIGHESTA:
13918         case R_PPC64_TOC16_HA:
13919         case R_PPC64_SECTOFF_HA:
13920         case R_PPC64_TPREL16_HA:
13921         case R_PPC64_DTPREL16_HA:
13922         case R_PPC64_TPREL16_HIGHER:
13923         case R_PPC64_TPREL16_HIGHERA:
13924         case R_PPC64_TPREL16_HIGHEST:
13925         case R_PPC64_TPREL16_HIGHESTA:
13926         case R_PPC64_DTPREL16_HIGHER:
13927         case R_PPC64_DTPREL16_HIGHERA:
13928         case R_PPC64_DTPREL16_HIGHEST:
13929         case R_PPC64_DTPREL16_HIGHESTA:
13930           /* It's just possible that this symbol is a weak symbol
13931              that's not actually defined anywhere. In that case,
13932              'sec' would be NULL, and we should leave the symbol
13933              alone (it will be set to zero elsewhere in the link).  */
13934           if (sec == NULL)
13935             break;
13936           /* Fall thru */
13937
13938         case R_PPC64_GOT16_HA:
13939         case R_PPC64_PLTGOT16_HA:
13940         case R_PPC64_PLT16_HA:
13941         case R_PPC64_GOT_TLSGD16_HA:
13942         case R_PPC64_GOT_TLSLD16_HA:
13943         case R_PPC64_GOT_TPREL16_HA:
13944         case R_PPC64_GOT_DTPREL16_HA:
13945           /* Add 0x10000 if sign bit in 0:15 is set.
13946              Bits 0:15 are not used.  */
13947           addend += 0x8000;
13948           break;
13949
13950         case R_PPC64_ADDR16_DS:
13951         case R_PPC64_ADDR16_LO_DS:
13952         case R_PPC64_GOT16_DS:
13953         case R_PPC64_GOT16_LO_DS:
13954         case R_PPC64_PLT16_LO_DS:
13955         case R_PPC64_SECTOFF_DS:
13956         case R_PPC64_SECTOFF_LO_DS:
13957         case R_PPC64_TOC16_DS:
13958         case R_PPC64_TOC16_LO_DS:
13959         case R_PPC64_PLTGOT16_DS:
13960         case R_PPC64_PLTGOT16_LO_DS:
13961         case R_PPC64_GOT_TPREL16_DS:
13962         case R_PPC64_GOT_TPREL16_LO_DS:
13963         case R_PPC64_GOT_DTPREL16_DS:
13964         case R_PPC64_GOT_DTPREL16_LO_DS:
13965         case R_PPC64_TPREL16_DS:
13966         case R_PPC64_TPREL16_LO_DS:
13967         case R_PPC64_DTPREL16_DS:
13968         case R_PPC64_DTPREL16_LO_DS:
13969           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13970           mask = 3;
13971           /* If this reloc is against an lq insn, then the value must be
13972              a multiple of 16.  This is somewhat of a hack, but the
13973              "correct" way to do this by defining _DQ forms of all the
13974              _DS relocs bloats all reloc switches in this file.  It
13975              doesn't seem to make much sense to use any of these relocs
13976              in data, so testing the insn should be safe.  */
13977           if ((insn & (0x3f << 26)) == (56u << 26))
13978             mask = 15;
13979           if (((relocation + addend) & mask) != 0)
13980             {
13981               info->callbacks->einfo
13982                 (_("%P: %H: error: %s not a multiple of %u\n"),
13983                  input_bfd, input_section, rel->r_offset,
13984                  ppc64_elf_howto_table[r_type]->name,
13985                  mask + 1);
13986               bfd_set_error (bfd_error_bad_value);
13987               ret = FALSE;
13988               continue;
13989             }
13990           break;
13991         }
13992
13993       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13994          because such sections are not SEC_ALLOC and thus ld.so will
13995          not process them.  */
13996       if (unresolved_reloc
13997           && !((input_section->flags & SEC_DEBUGGING) != 0
13998                && h->elf.def_dynamic)
13999           && _bfd_elf_section_offset (output_bfd, info, input_section,
14000                                       rel->r_offset) != (bfd_vma) -1)
14001         {
14002           info->callbacks->einfo
14003             (_("%P: %H: unresolvable %s against `%T'\n"),
14004              input_bfd, input_section, rel->r_offset,
14005              ppc64_elf_howto_table[(int) r_type]->name,
14006              h->elf.root.root.string);
14007           ret = FALSE;
14008         }
14009
14010       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14011                                     input_bfd,
14012                                     input_section,
14013                                     contents,
14014                                     rel->r_offset,
14015                                     relocation,
14016                                     addend);
14017
14018       if (r != bfd_reloc_ok)
14019         {
14020           char *more_info = NULL;
14021           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14022
14023           if (reloc_dest != DEST_NORMAL)
14024             {
14025               more_info = bfd_malloc (strlen (reloc_name) + 8);
14026               if (more_info != NULL)
14027                 {
14028                   strcpy (more_info, reloc_name);
14029                   strcat (more_info, (reloc_dest == DEST_OPD
14030                                       ? " (OPD)" : " (stub)"));
14031                   reloc_name = more_info;
14032                 }
14033             }
14034
14035           if (r == bfd_reloc_overflow)
14036             {
14037               if (warned)
14038                 continue;
14039               if (h != NULL
14040                   && h->elf.root.type == bfd_link_hash_undefweak
14041                   && ppc64_elf_howto_table[r_type]->pc_relative)
14042                 {
14043                   /* Assume this is a call protected by other code that
14044                      detects the symbol is undefined.  If this is the case,
14045                      we can safely ignore the overflow.  If not, the
14046                      program is hosed anyway, and a little warning isn't
14047                      going to help.  */
14048
14049                   continue;
14050                 }
14051
14052               if (!((*info->callbacks->reloc_overflow)
14053                     (info, &h->elf.root, sym_name,
14054                      reloc_name, orig_rel.r_addend,
14055                      input_bfd, input_section, rel->r_offset)))
14056                 return FALSE;
14057             }
14058           else
14059             {
14060               info->callbacks->einfo
14061                 (_("%P: %H: %s against `%T': error %d\n"),
14062                  input_bfd, input_section, rel->r_offset,
14063                  reloc_name, sym_name, (int) r);
14064               ret = FALSE;
14065             }
14066           if (more_info != NULL)
14067             free (more_info);
14068         }
14069     }
14070
14071   /* If we're emitting relocations, then shortly after this function
14072      returns, reloc offsets and addends for this section will be
14073      adjusted.  Worse, reloc symbol indices will be for the output
14074      file rather than the input.  Save a copy of the relocs for
14075      opd_entry_value.  */
14076   if (is_opd && (info->emitrelocations || info->relocatable))
14077     {
14078       bfd_size_type amt;
14079       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14080       rel = bfd_alloc (input_bfd, amt);
14081       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14082       ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14083       if (rel == NULL)
14084         return FALSE;
14085       memcpy (rel, relocs, amt);
14086     }
14087   return ret;
14088 }
14089
14090 /* Adjust the value of any local symbols in opd sections.  */
14091
14092 static int
14093 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14094                               const char *name ATTRIBUTE_UNUSED,
14095                               Elf_Internal_Sym *elfsym,
14096                               asection *input_sec,
14097                               struct elf_link_hash_entry *h)
14098 {
14099   struct _opd_sec_data *opd;
14100   long adjust;
14101   bfd_vma value;
14102
14103   if (h != NULL)
14104     return 1;
14105
14106   opd = get_opd_info (input_sec);
14107   if (opd == NULL || opd->adjust == NULL)
14108     return 1;
14109
14110   value = elfsym->st_value - input_sec->output_offset;
14111   if (!info->relocatable)
14112     value -= input_sec->output_section->vma;
14113
14114   adjust = opd->adjust[value / 8];
14115   if (adjust == -1)
14116     return 2;
14117
14118   elfsym->st_value += adjust;
14119   return 1;
14120 }
14121
14122 /* Finish up dynamic symbol handling.  We set the contents of various
14123    dynamic sections here.  */
14124
14125 static bfd_boolean
14126 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14127                                  struct bfd_link_info *info,
14128                                  struct elf_link_hash_entry *h,
14129                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14130 {
14131   struct ppc_link_hash_table *htab;
14132   struct plt_entry *ent;
14133   Elf_Internal_Rela rela;
14134   bfd_byte *loc;
14135
14136   htab = ppc_hash_table (info);
14137   if (htab == NULL)
14138     return FALSE;
14139
14140   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14141     if (ent->plt.offset != (bfd_vma) -1)
14142       {
14143         /* This symbol has an entry in the procedure linkage
14144            table.  Set it up.  */
14145         if (!htab->elf.dynamic_sections_created
14146             || h->dynindx == -1)
14147           {
14148             BFD_ASSERT (h->type == STT_GNU_IFUNC
14149                         && h->def_regular
14150                         && (h->root.type == bfd_link_hash_defined
14151                             || h->root.type == bfd_link_hash_defweak));
14152             rela.r_offset = (htab->iplt->output_section->vma
14153                              + htab->iplt->output_offset
14154                              + ent->plt.offset);
14155             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14156             rela.r_addend = (h->root.u.def.value
14157                              + h->root.u.def.section->output_offset
14158                              + h->root.u.def.section->output_section->vma
14159                              + ent->addend);
14160             loc = (htab->reliplt->contents
14161                    + (htab->reliplt->reloc_count++
14162                       * sizeof (Elf64_External_Rela)));
14163           }
14164         else
14165           {
14166             rela.r_offset = (htab->plt->output_section->vma
14167                              + htab->plt->output_offset
14168                              + ent->plt.offset);
14169             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14170             rela.r_addend = ent->addend;
14171             loc = (htab->relplt->contents
14172                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14173                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14174           }
14175         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14176       }
14177
14178   if (h->needs_copy)
14179     {
14180       /* This symbol needs a copy reloc.  Set it up.  */
14181
14182       if (h->dynindx == -1
14183           || (h->root.type != bfd_link_hash_defined
14184               && h->root.type != bfd_link_hash_defweak)
14185           || htab->relbss == NULL)
14186         abort ();
14187
14188       rela.r_offset = (h->root.u.def.value
14189                        + h->root.u.def.section->output_section->vma
14190                        + h->root.u.def.section->output_offset);
14191       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14192       rela.r_addend = 0;
14193       loc = htab->relbss->contents;
14194       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14195       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14196     }
14197
14198   return TRUE;
14199 }
14200
14201 /* Used to decide how to sort relocs in an optimal manner for the
14202    dynamic linker, before writing them out.  */
14203
14204 static enum elf_reloc_type_class
14205 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14206                             const asection *rel_sec,
14207                             const Elf_Internal_Rela *rela)
14208 {
14209   enum elf_ppc64_reloc_type r_type;
14210   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14211
14212   if (rel_sec == htab->reliplt)
14213     return reloc_class_ifunc;
14214
14215   r_type = ELF64_R_TYPE (rela->r_info);
14216   switch (r_type)
14217     {
14218     case R_PPC64_RELATIVE:
14219       return reloc_class_relative;
14220     case R_PPC64_JMP_SLOT:
14221       return reloc_class_plt;
14222     case R_PPC64_COPY:
14223       return reloc_class_copy;
14224     default:
14225       return reloc_class_normal;
14226     }
14227 }
14228
14229 /* Finish up the dynamic sections.  */
14230
14231 static bfd_boolean
14232 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14233                                    struct bfd_link_info *info)
14234 {
14235   struct ppc_link_hash_table *htab;
14236   bfd *dynobj;
14237   asection *sdyn;
14238
14239   htab = ppc_hash_table (info);
14240   if (htab == NULL)
14241     return FALSE;
14242
14243   dynobj = htab->elf.dynobj;
14244   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14245
14246   if (htab->elf.dynamic_sections_created)
14247     {
14248       Elf64_External_Dyn *dyncon, *dynconend;
14249
14250       if (sdyn == NULL || htab->got == NULL)
14251         abort ();
14252
14253       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14254       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14255       for (; dyncon < dynconend; dyncon++)
14256         {
14257           Elf_Internal_Dyn dyn;
14258           asection *s;
14259
14260           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14261
14262           switch (dyn.d_tag)
14263             {
14264             default:
14265               continue;
14266
14267             case DT_PPC64_GLINK:
14268               s = htab->glink;
14269               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14270               /* We stupidly defined DT_PPC64_GLINK to be the start
14271                  of glink rather than the first entry point, which is
14272                  what ld.so needs, and now have a bigger stub to
14273                  support automatic multiple TOCs.  */
14274               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14275               break;
14276
14277             case DT_PPC64_OPD:
14278               s = bfd_get_section_by_name (output_bfd, ".opd");
14279               if (s == NULL)
14280                 continue;
14281               dyn.d_un.d_ptr = s->vma;
14282               break;
14283
14284             case DT_PPC64_OPDSZ:
14285               s = bfd_get_section_by_name (output_bfd, ".opd");
14286               if (s == NULL)
14287                 continue;
14288               dyn.d_un.d_val = s->size;
14289               break;
14290
14291             case DT_PLTGOT:
14292               s = htab->plt;
14293               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14294               break;
14295
14296             case DT_JMPREL:
14297               s = htab->relplt;
14298               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14299               break;
14300
14301             case DT_PLTRELSZ:
14302               dyn.d_un.d_val = htab->relplt->size;
14303               break;
14304
14305             case DT_RELASZ:
14306               /* Don't count procedure linkage table relocs in the
14307                  overall reloc count.  */
14308               s = htab->relplt;
14309               if (s == NULL)
14310                 continue;
14311               dyn.d_un.d_val -= s->size;
14312               break;
14313
14314             case DT_RELA:
14315               /* We may not be using the standard ELF linker script.
14316                  If .rela.plt is the first .rela section, we adjust
14317                  DT_RELA to not include it.  */
14318               s = htab->relplt;
14319               if (s == NULL)
14320                 continue;
14321               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14322                 continue;
14323               dyn.d_un.d_ptr += s->size;
14324               break;
14325             }
14326
14327           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14328         }
14329     }
14330
14331   if (htab->got != NULL && htab->got->size != 0)
14332     {
14333       /* Fill in the first entry in the global offset table.
14334          We use it to hold the link-time TOCbase.  */
14335       bfd_put_64 (output_bfd,
14336                   elf_gp (output_bfd) + TOC_BASE_OFF,
14337                   htab->got->contents);
14338
14339       /* Set .got entry size.  */
14340       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14341     }
14342
14343   if (htab->plt != NULL && htab->plt->size != 0)
14344     {
14345       /* Set .plt entry size.  */
14346       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14347         = PLT_ENTRY_SIZE;
14348     }
14349
14350   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14351      brlt ourselves if emitrelocations.  */
14352   if (htab->brlt != NULL
14353       && htab->brlt->reloc_count != 0
14354       && !_bfd_elf_link_output_relocs (output_bfd,
14355                                        htab->brlt,
14356                                        elf_section_data (htab->brlt)->rela.hdr,
14357                                        elf_section_data (htab->brlt)->relocs,
14358                                        NULL))
14359     return FALSE;
14360
14361   if (htab->glink != NULL
14362       && htab->glink->reloc_count != 0
14363       && !_bfd_elf_link_output_relocs (output_bfd,
14364                                        htab->glink,
14365                                        elf_section_data (htab->glink)->rela.hdr,
14366                                        elf_section_data (htab->glink)->relocs,
14367                                        NULL))
14368     return FALSE;
14369
14370
14371   if (htab->glink_eh_frame != NULL
14372       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14373       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14374                                            htab->glink_eh_frame,
14375                                            htab->glink_eh_frame->contents))
14376     return FALSE;
14377
14378   /* We need to handle writing out multiple GOT sections ourselves,
14379      since we didn't add them to DYNOBJ.  We know dynobj is the first
14380      bfd.  */
14381   while ((dynobj = dynobj->link_next) != NULL)
14382     {
14383       asection *s;
14384
14385       if (!is_ppc64_elf (dynobj))
14386         continue;
14387
14388       s = ppc64_elf_tdata (dynobj)->got;
14389       if (s != NULL
14390           && s->size != 0
14391           && s->output_section != bfd_abs_section_ptr
14392           && !bfd_set_section_contents (output_bfd, s->output_section,
14393                                         s->contents, s->output_offset,
14394                                         s->size))
14395         return FALSE;
14396       s = ppc64_elf_tdata (dynobj)->relgot;
14397       if (s != NULL
14398           && s->size != 0
14399           && s->output_section != bfd_abs_section_ptr
14400           && !bfd_set_section_contents (output_bfd, s->output_section,
14401                                         s->contents, s->output_offset,
14402                                         s->size))
14403         return FALSE;
14404     }
14405
14406   return TRUE;
14407 }
14408
14409 #include "elf64-target.h"
14410
14411 /* FreeBSD support */
14412
14413 #undef  TARGET_LITTLE_SYM
14414 #undef  TARGET_LITTLE_NAME
14415
14416 #undef  TARGET_BIG_SYM
14417 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
14418 #undef  TARGET_BIG_NAME
14419 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14420
14421 #undef  ELF_OSABI
14422 #define ELF_OSABI       ELFOSABI_FREEBSD
14423
14424 #undef  elf64_bed
14425 #define elf64_bed       elf64_powerpc_fbsd_bed
14426
14427 #include "elf64-target.h"
14428