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