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_as_needed_cleanup         ppc64_elf_as_needed_cleanup
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_maybe_function_sym        ppc64_elf_maybe_function_sym
 109 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 110 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 111 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 112 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 113 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 114 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 115 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 116 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 117 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 118 #define elf_backend_special_sections          ppc64_elf_special_sections
 119 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 120
 121 /* The name of the dynamic interpreter.  This is put in the .interp
 122    section.  */
 123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 124
 125 /* The size in bytes of an entry in the procedure linkage table.  */
 126 #define PLT_ENTRY_SIZE 24
 127
 128 /* The initial size of the plt reserved for the dynamic linker.  */
 129 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 130
 131 /* TOC base pointers offset from start of TOC.  */
 132 #define TOC_BASE_OFF    0x8000
 133
 134 /* Offset of tp and dtp pointers from start of TLS block.  */
 135 #define TP_OFFSET       0x7000
 136 #define DTP_OFFSET      0x8000
 137
 138 /* .plt call stub instructions.  The normal stub is like this, but
 139    sometimes the .plt entry crosses a 64k boundary and we need to
 140    insert an addi to adjust r12.  */
 141 #define PLT_CALL_STUB_SIZE (7*4)
 142 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 143 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 144 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 145 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 146 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 147                                         /* ld    %r11,xxx+16@l(%r12) */
 148 #define BCTR            0x4e800420      /* bctr                      */
 149
 150
 151 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 152 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 153 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 154 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 155
 156 #define XOR_R11_R11_R11 0x7d6b5a78      /* xor   %r11,%r11,%r11  */
 157 #define ADD_R12_R12_R11 0x7d8c5a14      /* add   %r12,%r12,%r11  */
 158 #define ADD_R2_R2_R11   0x7c425a14      /* add   %r2,%r2,%r11    */
 159 #define CMPLDI_R2_0     0x28220000      /* cmpldi %r2,0          */
 160 #define BNECTR          0x4ca20420      /* bnectr+               */
 161 #define BNECTR_P4       0x4ce20420      /* bnectr+               */
 162
 163 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 164 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 165
 166 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 167
 168 /* glink call stub instructions.  We enter with the index in R0.  */
 169 #define GLINK_CALL_STUB_SIZE (16*4)
 170                                         /* 0:                           */
 171                                         /*  .quad plt0-1f               */
 172                                         /* __glink:                     */
 173 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 174 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 175                                         /* 1:                           */
 176 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 177 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 178 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 179 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 180                                         /*  ld %11,0(%12)               */
 181                                         /*  ld %2,8(%12)                */
 182                                         /*  mtctr %11                   */
 183                                         /*  ld %11,16(%12)              */
 184                                         /*  bctr                        */
 185
 186 /* Pad with this.  */
 187 #define NOP             0x60000000
 188
 189 /* Some other nops.  */
 190 #define CROR_151515     0x4def7b82
 191 #define CROR_313131     0x4ffffb82
 192
 193 /* .glink entries for the first 32k functions are two instructions.  */
 194 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 195 #define B_DOT           0x48000000      /* b     .              */
 196
 197 /* After that, we need two instructions to load the index, followed by
 198    a branch.  */
 199 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 200 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 201
 202 /* Instructions used by the save and restore reg functions.  */
 203 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 204 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 205 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 206 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 207 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 208 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 209 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 210 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 211 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 212 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 213 #define BLR             0x4e800020      /* blr                  */
 214
 215 /* Since .opd is an array of descriptors and each entry will end up
 216    with identical R_PPC64_RELATIVE relocs, there is really no need to
 217    propagate .opd relocs;  The dynamic linker should be taught to
 218    relocate .opd without reloc entries.  */
 219 #ifndef NO_OPD_RELOCS
 220 #define NO_OPD_RELOCS 0
 221 #endif
 222 \f
 223 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 224
 225 /* Relocation HOWTO's.  */
 226 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 227
 228 static reloc_howto_type ppc64_elf_howto_raw[] = {
 229   /* This reloc does nothing.  */
 230   HOWTO (R_PPC64_NONE,          /* type */
 231          0,                     /* rightshift */
 232          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 233          32,                    /* bitsize */
 234          FALSE,                 /* pc_relative */
 235          0,                     /* bitpos */
 236          complain_overflow_dont, /* complain_on_overflow */
 237          bfd_elf_generic_reloc, /* special_function */
 238          "R_PPC64_NONE",        /* name */
 239          FALSE,                 /* partial_inplace */
 240          0,                     /* src_mask */
 241          0,                     /* dst_mask */
 242          FALSE),                /* pcrel_offset */
 243
 244   /* A standard 32 bit relocation.  */
 245   HOWTO (R_PPC64_ADDR32,        /* type */
 246          0,                     /* rightshift */
 247          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 248          32,                    /* bitsize */
 249          FALSE,                 /* pc_relative */
 250          0,                     /* bitpos */
 251          complain_overflow_bitfield, /* complain_on_overflow */
 252          bfd_elf_generic_reloc, /* special_function */
 253          "R_PPC64_ADDR32",      /* name */
 254          FALSE,                 /* partial_inplace */
 255          0,                     /* src_mask */
 256          0xffffffff,            /* dst_mask */
 257          FALSE),                /* pcrel_offset */
 258
 259   /* An absolute 26 bit branch; the lower two bits must be zero.
 260      FIXME: we don't check that, we just clear them.  */
 261   HOWTO (R_PPC64_ADDR24,        /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          26,                    /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_bitfield, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_PPC64_ADDR24",      /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0x03fffffc,            /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* A standard 16 bit relocation.  */
 276   HOWTO (R_PPC64_ADDR16,        /* type */
 277          0,                     /* rightshift */
 278          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          16,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_bitfield, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_PPC64_ADDR16",      /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0xffff,                /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* A 16 bit relocation without overflow.  */
 291   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 292          0,                     /* rightshift */
 293          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 294          16,                    /* bitsize */
 295          FALSE,                 /* pc_relative */
 296          0,                     /* bitpos */
 297          complain_overflow_dont,/* complain_on_overflow */
 298          bfd_elf_generic_reloc, /* special_function */
 299          "R_PPC64_ADDR16_LO",   /* name */
 300          FALSE,                 /* partial_inplace */
 301          0,                     /* src_mask */
 302          0xffff,                /* dst_mask */
 303          FALSE),                /* pcrel_offset */
 304
 305   /* Bits 16-31 of an address.  */
 306   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 307          16,                    /* rightshift */
 308          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 309          16,                    /* bitsize */
 310          FALSE,                 /* pc_relative */
 311          0,                     /* bitpos */
 312          complain_overflow_dont, /* complain_on_overflow */
 313          bfd_elf_generic_reloc, /* special_function */
 314          "R_PPC64_ADDR16_HI",   /* name */
 315          FALSE,                 /* partial_inplace */
 316          0,                     /* src_mask */
 317          0xffff,                /* dst_mask */
 318          FALSE),                /* pcrel_offset */
 319
 320   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 321      bits, treated as a signed number, is negative.  */
 322   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 323          16,                    /* rightshift */
 324          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          16,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_dont, /* complain_on_overflow */
 329          ppc64_elf_ha_reloc,    /* special_function */
 330          "R_PPC64_ADDR16_HA",   /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffff,                /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* An absolute 16 bit branch; the lower two bits must be zero.
 337      FIXME: we don't check that, we just clear them.  */
 338   HOWTO (R_PPC64_ADDR14,        /* type */
 339          0,                     /* rightshift */
 340          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield, /* complain_on_overflow */
 345          ppc64_elf_branch_reloc, /* special_function */
 346          "R_PPC64_ADDR14",      /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0x0000fffc,            /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   /* An absolute 16 bit branch, for which bit 10 should be set to
 353      indicate that the branch is expected to be taken.  The lower two
 354      bits must be zero.  */
 355   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 356          0,                     /* rightshift */
 357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 358          16,                    /* bitsize */
 359          FALSE,                 /* pc_relative */
 360          0,                     /* bitpos */
 361          complain_overflow_bitfield, /* complain_on_overflow */
 362          ppc64_elf_brtaken_reloc, /* special_function */
 363          "R_PPC64_ADDR14_BRTAKEN",/* name */
 364          FALSE,                 /* partial_inplace */
 365          0,                     /* src_mask */
 366          0x0000fffc,            /* dst_mask */
 367          FALSE),                /* pcrel_offset */
 368
 369   /* An absolute 16 bit branch, for which bit 10 should be set to
 370      indicate that the branch is not expected to be taken.  The lower
 371      two bits must be zero.  */
 372   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          16,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_bitfield, /* complain_on_overflow */
 379          ppc64_elf_brtaken_reloc, /* special_function */
 380          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 381          FALSE,                 /* partial_inplace */
 382          0,                     /* src_mask */
 383          0x0000fffc,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   /* A relative 26 bit branch; the lower two bits must be zero.  */
 387   HOWTO (R_PPC64_REL24,         /* type */
 388          0,                     /* rightshift */
 389          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          26,                    /* bitsize */
 391          TRUE,                  /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_signed, /* complain_on_overflow */
 394          ppc64_elf_branch_reloc, /* special_function */
 395          "R_PPC64_REL24",       /* name */
 396          FALSE,                 /* partial_inplace */
 397          0,                     /* src_mask */
 398          0x03fffffc,            /* dst_mask */
 399          TRUE),                 /* pcrel_offset */
 400
 401   /* A relative 16 bit branch; the lower two bits must be zero.  */
 402   HOWTO (R_PPC64_REL14,         /* type */
 403          0,                     /* rightshift */
 404          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 405          16,                    /* bitsize */
 406          TRUE,                  /* pc_relative */
 407          0,                     /* bitpos */
 408          complain_overflow_signed, /* complain_on_overflow */
 409          ppc64_elf_branch_reloc, /* special_function */
 410          "R_PPC64_REL14",       /* name */
 411          FALSE,                 /* partial_inplace */
 412          0,                     /* src_mask */
 413          0x0000fffc,            /* dst_mask */
 414          TRUE),                 /* pcrel_offset */
 415
 416   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 417      the branch is expected to be taken.  The lower two bits must be
 418      zero.  */
 419   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          16,                    /* bitsize */
 423          TRUE,                  /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_signed, /* complain_on_overflow */
 426          ppc64_elf_brtaken_reloc, /* special_function */
 427          "R_PPC64_REL14_BRTAKEN", /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000fffc,            /* dst_mask */
 431          TRUE),                 /* pcrel_offset */
 432
 433   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 434      the branch is not expected to be taken.  The lower two bits must
 435      be zero.  */
 436   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          16,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_signed, /* complain_on_overflow */
 443          ppc64_elf_brtaken_reloc, /* special_function */
 444          "R_PPC64_REL14_BRNTAKEN",/* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000fffc,            /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 451      symbol.  */
 452   HOWTO (R_PPC64_GOT16,         /* type */
 453          0,                     /* rightshift */
 454          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          16,                    /* bitsize */
 456          FALSE,                 /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_signed, /* complain_on_overflow */
 459          ppc64_elf_unhandled_reloc, /* special_function */
 460          "R_PPC64_GOT16",       /* name */
 461          FALSE,                 /* partial_inplace */
 462          0,                     /* src_mask */
 463          0xffff,                /* dst_mask */
 464          FALSE),                /* pcrel_offset */
 465
 466   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 467      the symbol.  */
 468   HOWTO (R_PPC64_GOT16_LO,      /* type */
 469          0,                     /* rightshift */
 470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_dont, /* complain_on_overflow */
 475          ppc64_elf_unhandled_reloc, /* special_function */
 476          "R_PPC64_GOT16_LO",    /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0xffff,                /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 483      the symbol.  */
 484   HOWTO (R_PPC64_GOT16_HI,      /* type */
 485          16,                    /* rightshift */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          16,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont,/* complain_on_overflow */
 491          ppc64_elf_unhandled_reloc, /* special_function */
 492          "R_PPC64_GOT16_HI",    /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0xffff,                /* dst_mask */
 496          FALSE),                /* pcrel_offset */
 497
 498   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 499      the symbol.  */
 500   HOWTO (R_PPC64_GOT16_HA,      /* type */
 501          16,                    /* rightshift */
 502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 503          16,                    /* bitsize */
 504          FALSE,                 /* pc_relative */
 505          0,                     /* bitpos */
 506          complain_overflow_dont,/* complain_on_overflow */
 507          ppc64_elf_unhandled_reloc, /* special_function */
 508          "R_PPC64_GOT16_HA",    /* name */
 509          FALSE,                 /* partial_inplace */
 510          0,                     /* src_mask */
 511          0xffff,                /* dst_mask */
 512          FALSE),                /* pcrel_offset */
 513
 514   /* This is used only by the dynamic linker.  The symbol should exist
 515      both in the object being run and in some shared library.  The
 516      dynamic linker copies the data addressed by the symbol from the
 517      shared library into the object, because the object being
 518      run has to have the data at some particular address.  */
 519   HOWTO (R_PPC64_COPY,          /* type */
 520          0,                     /* rightshift */
 521          0,                     /* this one is variable size */
 522          0,                     /* bitsize */
 523          FALSE,                 /* pc_relative */
 524          0,                     /* bitpos */
 525          complain_overflow_dont, /* complain_on_overflow */
 526          ppc64_elf_unhandled_reloc, /* special_function */
 527          "R_PPC64_COPY",        /* name */
 528          FALSE,                 /* partial_inplace */
 529          0,                     /* src_mask */
 530          0,                     /* dst_mask */
 531          FALSE),                /* pcrel_offset */
 532
 533   /* Like R_PPC64_ADDR64, but used when setting global offset table
 534      entries.  */
 535   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 536          0,                     /* rightshift */
 537          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 538          64,                    /* bitsize */
 539          FALSE,                 /* pc_relative */
 540          0,                     /* bitpos */
 541          complain_overflow_dont, /* complain_on_overflow */
 542          ppc64_elf_unhandled_reloc,  /* special_function */
 543          "R_PPC64_GLOB_DAT",    /* name */
 544          FALSE,                 /* partial_inplace */
 545          0,                     /* src_mask */
 546          ONES (64),             /* dst_mask */
 547          FALSE),                /* pcrel_offset */
 548
 549   /* Created by the link editor.  Marks a procedure linkage table
 550      entry for a symbol.  */
 551   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 552          0,                     /* rightshift */
 553          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 554          0,                     /* bitsize */
 555          FALSE,                 /* pc_relative */
 556          0,                     /* bitpos */
 557          complain_overflow_dont, /* complain_on_overflow */
 558          ppc64_elf_unhandled_reloc, /* special_function */
 559          "R_PPC64_JMP_SLOT",    /* name */
 560          FALSE,                 /* partial_inplace */
 561          0,                     /* src_mask */
 562          0,                     /* dst_mask */
 563          FALSE),                /* pcrel_offset */
 564
 565   /* Used only by the dynamic linker.  When the object is run, this
 566      doubleword64 is set to the load address of the object, plus the
 567      addend.  */
 568   HOWTO (R_PPC64_RELATIVE,      /* type */
 569          0,                     /* rightshift */
 570          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 571          64,                    /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          0,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          bfd_elf_generic_reloc, /* special_function */
 576          "R_PPC64_RELATIVE",    /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          ONES (64),             /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 583   HOWTO (R_PPC64_UADDR32,       /* type */
 584          0,                     /* rightshift */
 585          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 586          32,                    /* bitsize */
 587          FALSE,                 /* pc_relative */
 588          0,                     /* bitpos */
 589          complain_overflow_bitfield, /* complain_on_overflow */
 590          bfd_elf_generic_reloc, /* special_function */
 591          "R_PPC64_UADDR32",     /* name */
 592          FALSE,                 /* partial_inplace */
 593          0,                     /* src_mask */
 594          0xffffffff,            /* dst_mask */
 595          FALSE),                /* pcrel_offset */
 596
 597   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 598   HOWTO (R_PPC64_UADDR16,       /* type */
 599          0,                     /* rightshift */
 600          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 601          16,                    /* bitsize */
 602          FALSE,                 /* pc_relative */
 603          0,                     /* bitpos */
 604          complain_overflow_bitfield, /* complain_on_overflow */
 605          bfd_elf_generic_reloc, /* special_function */
 606          "R_PPC64_UADDR16",     /* name */
 607          FALSE,                 /* partial_inplace */
 608          0,                     /* src_mask */
 609          0xffff,                /* dst_mask */
 610          FALSE),                /* pcrel_offset */
 611
 612   /* 32-bit PC relative.  */
 613   HOWTO (R_PPC64_REL32,         /* type */
 614          0,                     /* rightshift */
 615          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 616          32,                    /* bitsize */
 617          TRUE,                  /* pc_relative */
 618          0,                     /* bitpos */
 619          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 620          complain_overflow_signed, /* complain_on_overflow */
 621          bfd_elf_generic_reloc, /* special_function */
 622          "R_PPC64_REL32",       /* name */
 623          FALSE,                 /* partial_inplace */
 624          0,                     /* src_mask */
 625          0xffffffff,            /* dst_mask */
 626          TRUE),                 /* pcrel_offset */
 627
 628   /* 32-bit relocation to the symbol's procedure linkage table.  */
 629   HOWTO (R_PPC64_PLT32,         /* type */
 630          0,                     /* rightshift */
 631          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 632          32,                    /* bitsize */
 633          FALSE,                 /* pc_relative */
 634          0,                     /* bitpos */
 635          complain_overflow_bitfield, /* complain_on_overflow */
 636          ppc64_elf_unhandled_reloc, /* special_function */
 637          "R_PPC64_PLT32",       /* name */
 638          FALSE,                 /* partial_inplace */
 639          0,                     /* src_mask */
 640          0xffffffff,            /* dst_mask */
 641          FALSE),                /* pcrel_offset */
 642
 643   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 644      FIXME: R_PPC64_PLTREL32 not supported.  */
 645   HOWTO (R_PPC64_PLTREL32,      /* type */
 646          0,                     /* rightshift */
 647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          32,                    /* bitsize */
 649          TRUE,                  /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_signed, /* complain_on_overflow */
 652          bfd_elf_generic_reloc, /* special_function */
 653          "R_PPC64_PLTREL32",    /* name */
 654          FALSE,                 /* partial_inplace */
 655          0,                     /* src_mask */
 656          0xffffffff,            /* dst_mask */
 657          TRUE),                 /* pcrel_offset */
 658
 659   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 660      the symbol.  */
 661   HOWTO (R_PPC64_PLT16_LO,      /* type */
 662          0,                     /* rightshift */
 663          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          16,                    /* bitsize */
 665          FALSE,                 /* pc_relative */
 666          0,                     /* bitpos */
 667          complain_overflow_dont, /* complain_on_overflow */
 668          ppc64_elf_unhandled_reloc, /* special_function */
 669          "R_PPC64_PLT16_LO",    /* name */
 670          FALSE,                 /* partial_inplace */
 671          0,                     /* src_mask */
 672          0xffff,                /* dst_mask */
 673          FALSE),                /* pcrel_offset */
 674
 675   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 676      the symbol.  */
 677   HOWTO (R_PPC64_PLT16_HI,      /* type */
 678          16,                    /* rightshift */
 679          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          16,                    /* bitsize */
 681          FALSE,                 /* pc_relative */
 682          0,                     /* bitpos */
 683          complain_overflow_dont, /* complain_on_overflow */
 684          ppc64_elf_unhandled_reloc, /* special_function */
 685          "R_PPC64_PLT16_HI",    /* name */
 686          FALSE,                 /* partial_inplace */
 687          0,                     /* src_mask */
 688          0xffff,                /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 692      the symbol.  */
 693   HOWTO (R_PPC64_PLT16_HA,      /* type */
 694          16,                    /* rightshift */
 695          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 696          16,                    /* bitsize */
 697          FALSE,                 /* pc_relative */
 698          0,                     /* bitpos */
 699          complain_overflow_dont, /* complain_on_overflow */
 700          ppc64_elf_unhandled_reloc, /* special_function */
 701          "R_PPC64_PLT16_HA",    /* name */
 702          FALSE,                 /* partial_inplace */
 703          0,                     /* src_mask */
 704          0xffff,                /* dst_mask */
 705          FALSE),                /* pcrel_offset */
 706
 707   /* 16-bit section relative relocation.  */
 708   HOWTO (R_PPC64_SECTOFF,       /* type */
 709          0,                     /* rightshift */
 710          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_bitfield, /* complain_on_overflow */
 715          ppc64_elf_sectoff_reloc, /* special_function */
 716          "R_PPC64_SECTOFF",     /* name */
 717          FALSE,                 /* partial_inplace */
 718          0,                     /* src_mask */
 719          0xffff,                /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 723   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 724          0,                     /* rightshift */
 725          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 726          16,                    /* bitsize */
 727          FALSE,                 /* pc_relative */
 728          0,                     /* bitpos */
 729          complain_overflow_dont, /* complain_on_overflow */
 730          ppc64_elf_sectoff_reloc, /* special_function */
 731          "R_PPC64_SECTOFF_LO",  /* name */
 732          FALSE,                 /* partial_inplace */
 733          0,                     /* src_mask */
 734          0xffff,                /* dst_mask */
 735          FALSE),                /* pcrel_offset */
 736
 737   /* 16-bit upper half section relative relocation.  */
 738   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 739          16,                    /* rightshift */
 740          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 741          16,                    /* bitsize */
 742          FALSE,                 /* pc_relative */
 743          0,                     /* bitpos */
 744          complain_overflow_dont, /* complain_on_overflow */
 745          ppc64_elf_sectoff_reloc, /* special_function */
 746          "R_PPC64_SECTOFF_HI",  /* name */
 747          FALSE,                 /* partial_inplace */
 748          0,                     /* src_mask */
 749          0xffff,                /* dst_mask */
 750          FALSE),                /* pcrel_offset */
 751
 752   /* 16-bit upper half adjusted section relative relocation.  */
 753   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 754          16,                    /* rightshift */
 755          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 756          16,                    /* bitsize */
 757          FALSE,                 /* pc_relative */
 758          0,                     /* bitpos */
 759          complain_overflow_dont, /* complain_on_overflow */
 760          ppc64_elf_sectoff_ha_reloc, /* special_function */
 761          "R_PPC64_SECTOFF_HA",  /* name */
 762          FALSE,                 /* partial_inplace */
 763          0,                     /* src_mask */
 764          0xffff,                /* dst_mask */
 765          FALSE),                /* pcrel_offset */
 766
 767   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 768   HOWTO (R_PPC64_REL30,         /* type */
 769          2,                     /* rightshift */
 770          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          30,                    /* bitsize */
 772          TRUE,                  /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont, /* complain_on_overflow */
 775          bfd_elf_generic_reloc, /* special_function */
 776          "R_PPC64_REL30",       /* name */
 777          FALSE,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0xfffffffc,            /* dst_mask */
 780          TRUE),                 /* pcrel_offset */
 781
 782   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 783
 784   /* A standard 64-bit relocation.  */
 785   HOWTO (R_PPC64_ADDR64,        /* type */
 786          0,                     /* rightshift */
 787          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 788          64,                    /* bitsize */
 789          FALSE,                 /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_dont, /* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_PPC64_ADDR64",      /* name */
 794          FALSE,                 /* partial_inplace */
 795          0,                     /* src_mask */
 796          ONES (64),             /* dst_mask */
 797          FALSE),                /* pcrel_offset */
 798
 799   /* The bits 32-47 of an address.  */
 800   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 801          32,                    /* rightshift */
 802          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 803          16,                    /* bitsize */
 804          FALSE,                 /* pc_relative */
 805          0,                     /* bitpos */
 806          complain_overflow_dont, /* complain_on_overflow */
 807          bfd_elf_generic_reloc, /* special_function */
 808          "R_PPC64_ADDR16_HIGHER", /* name */
 809          FALSE,                 /* partial_inplace */
 810          0,                     /* src_mask */
 811          0xffff,                /* dst_mask */
 812          FALSE),                /* pcrel_offset */
 813
 814   /* The bits 32-47 of an address, plus 1 if the contents of the low
 815      16 bits, treated as a signed number, is negative.  */
 816   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 817          32,                    /* rightshift */
 818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          16,                    /* bitsize */
 820          FALSE,                 /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_dont, /* complain_on_overflow */
 823          ppc64_elf_ha_reloc,    /* special_function */
 824          "R_PPC64_ADDR16_HIGHERA", /* name */
 825          FALSE,                 /* partial_inplace */
 826          0,                     /* src_mask */
 827          0xffff,                /* dst_mask */
 828          FALSE),                /* pcrel_offset */
 829
 830   /* The bits 48-63 of an address.  */
 831   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 832          48,                    /* rightshift */
 833          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 834          16,                    /* bitsize */
 835          FALSE,                 /* pc_relative */
 836          0,                     /* bitpos */
 837          complain_overflow_dont, /* complain_on_overflow */
 838          bfd_elf_generic_reloc, /* special_function */
 839          "R_PPC64_ADDR16_HIGHEST", /* name */
 840          FALSE,                 /* partial_inplace */
 841          0,                     /* src_mask */
 842          0xffff,                /* dst_mask */
 843          FALSE),                /* pcrel_offset */
 844
 845   /* The bits 48-63 of an address, plus 1 if the contents of the low
 846      16 bits, treated as a signed number, is negative.  */
 847   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 848          48,                    /* rightshift */
 849          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          16,                    /* bitsize */
 851          FALSE,                 /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont, /* complain_on_overflow */
 854          ppc64_elf_ha_reloc,    /* special_function */
 855          "R_PPC64_ADDR16_HIGHESTA", /* name */
 856          FALSE,                 /* partial_inplace */
 857          0,                     /* src_mask */
 858          0xffff,                /* dst_mask */
 859          FALSE),                /* pcrel_offset */
 860
 861   /* Like ADDR64, but may be unaligned.  */
 862   HOWTO (R_PPC64_UADDR64,       /* type */
 863          0,                     /* rightshift */
 864          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 865          64,                    /* bitsize */
 866          FALSE,                 /* pc_relative */
 867          0,                     /* bitpos */
 868          complain_overflow_dont, /* complain_on_overflow */
 869          bfd_elf_generic_reloc, /* special_function */
 870          "R_PPC64_UADDR64",     /* name */
 871          FALSE,                 /* partial_inplace */
 872          0,                     /* src_mask */
 873          ONES (64),             /* dst_mask */
 874          FALSE),                /* pcrel_offset */
 875
 876   /* 64-bit relative relocation.  */
 877   HOWTO (R_PPC64_REL64,         /* type */
 878          0,                     /* rightshift */
 879          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 880          64,                    /* bitsize */
 881          TRUE,                  /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont, /* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_PPC64_REL64",       /* name */
 886          FALSE,                 /* partial_inplace */
 887          0,                     /* src_mask */
 888          ONES (64),             /* dst_mask */
 889          TRUE),                 /* pcrel_offset */
 890
 891   /* 64-bit relocation to the symbol's procedure linkage table.  */
 892   HOWTO (R_PPC64_PLT64,         /* type */
 893          0,                     /* rightshift */
 894          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 895          64,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont, /* complain_on_overflow */
 899          ppc64_elf_unhandled_reloc, /* special_function */
 900          "R_PPC64_PLT64",       /* name */
 901          FALSE,                 /* partial_inplace */
 902          0,                     /* src_mask */
 903          ONES (64),             /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   /* 64-bit PC relative relocation to the symbol's procedure linkage
 907      table.  */
 908   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 909   HOWTO (R_PPC64_PLTREL64,      /* type */
 910          0,                     /* rightshift */
 911          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 912          64,                    /* bitsize */
 913          TRUE,                  /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont, /* complain_on_overflow */
 916          ppc64_elf_unhandled_reloc, /* special_function */
 917          "R_PPC64_PLTREL64",    /* name */
 918          FALSE,                 /* partial_inplace */
 919          0,                     /* src_mask */
 920          ONES (64),             /* dst_mask */
 921          TRUE),                 /* pcrel_offset */
 922
 923   /* 16 bit TOC-relative relocation.  */
 924
 925   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 926   HOWTO (R_PPC64_TOC16,         /* type */
 927          0,                     /* rightshift */
 928          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 929          16,                    /* bitsize */
 930          FALSE,                 /* pc_relative */
 931          0,                     /* bitpos */
 932          complain_overflow_signed, /* complain_on_overflow */
 933          ppc64_elf_toc_reloc,   /* special_function */
 934          "R_PPC64_TOC16",       /* name */
 935          FALSE,                 /* partial_inplace */
 936          0,                     /* src_mask */
 937          0xffff,                /* dst_mask */
 938          FALSE),                /* pcrel_offset */
 939
 940   /* 16 bit TOC-relative relocation without overflow.  */
 941
 942   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 943   HOWTO (R_PPC64_TOC16_LO,      /* type */
 944          0,                     /* rightshift */
 945          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 946          16,                    /* bitsize */
 947          FALSE,                 /* pc_relative */
 948          0,                     /* bitpos */
 949          complain_overflow_dont, /* complain_on_overflow */
 950          ppc64_elf_toc_reloc,   /* special_function */
 951          "R_PPC64_TOC16_LO",    /* name */
 952          FALSE,                 /* partial_inplace */
 953          0,                     /* src_mask */
 954          0xffff,                /* dst_mask */
 955          FALSE),                /* pcrel_offset */
 956
 957   /* 16 bit TOC-relative relocation, high 16 bits.  */
 958
 959   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 960   HOWTO (R_PPC64_TOC16_HI,      /* type */
 961          16,                    /* rightshift */
 962          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 963          16,                    /* bitsize */
 964          FALSE,                 /* pc_relative */
 965          0,                     /* bitpos */
 966          complain_overflow_dont, /* complain_on_overflow */
 967          ppc64_elf_toc_reloc,   /* special_function */
 968          "R_PPC64_TOC16_HI",    /* name */
 969          FALSE,                 /* partial_inplace */
 970          0,                     /* src_mask */
 971          0xffff,                /* dst_mask */
 972          FALSE),                /* pcrel_offset */
 973
 974   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 975      contents of the low 16 bits, treated as a signed number, is
 976      negative.  */
 977
 978   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 979   HOWTO (R_PPC64_TOC16_HA,      /* type */
 980          16,                    /* rightshift */
 981          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 982          16,                    /* bitsize */
 983          FALSE,                 /* pc_relative */
 984          0,                     /* bitpos */
 985          complain_overflow_dont, /* complain_on_overflow */
 986          ppc64_elf_toc_ha_reloc, /* special_function */
 987          "R_PPC64_TOC16_HA",    /* name */
 988          FALSE,                 /* partial_inplace */
 989          0,                     /* src_mask */
 990          0xffff,                /* dst_mask */
 991          FALSE),                /* pcrel_offset */
 992
 993   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 994
 995   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 996   HOWTO (R_PPC64_TOC,           /* type */
 997          0,                     /* rightshift */
 998          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 999          64,                    /* bitsize */
1000          FALSE,                 /* pc_relative */
1001          0,                     /* bitpos */
1002          complain_overflow_bitfield, /* complain_on_overflow */
1003          ppc64_elf_toc64_reloc, /* special_function */
1004          "R_PPC64_TOC",         /* name */
1005          FALSE,                 /* partial_inplace */
1006          0,                     /* src_mask */
1007          ONES (64),             /* dst_mask */
1008          FALSE),                /* pcrel_offset */
1009
1010   /* Like R_PPC64_GOT16, but also informs the link editor that the
1011      value to relocate may (!) refer to a PLT entry which the link
1012      editor (a) may replace with the symbol value.  If the link editor
1013      is unable to fully resolve the symbol, it may (b) create a PLT
1014      entry and store the address to the new PLT entry in the GOT.
1015      This permits lazy resolution of function symbols at run time.
1016      The link editor may also skip all of this and just (c) emit a
1017      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1018   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1019     HOWTO (R_PPC64_PLTGOT16,    /* type */
1020          0,                     /* rightshift */
1021          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1022          16,                    /* bitsize */
1023          FALSE,                 /* pc_relative */
1024          0,                     /* bitpos */
1025          complain_overflow_signed, /* complain_on_overflow */
1026          ppc64_elf_unhandled_reloc, /* special_function */
1027          "R_PPC64_PLTGOT16",    /* name */
1028          FALSE,                 /* partial_inplace */
1029          0,                     /* src_mask */
1030          0xffff,                /* dst_mask */
1031          FALSE),                /* pcrel_offset */
1032
1033   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1034   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1035   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1036          0,                     /* rightshift */
1037          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          16,                    /* bitsize */
1039          FALSE,                 /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_dont, /* complain_on_overflow */
1042          ppc64_elf_unhandled_reloc, /* special_function */
1043          "R_PPC64_PLTGOT16_LO", /* name */
1044          FALSE,                 /* partial_inplace */
1045          0,                     /* src_mask */
1046          0xffff,                /* dst_mask */
1047          FALSE),                /* pcrel_offset */
1048
1049   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1050   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1051   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1052          16,                    /* rightshift */
1053          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1054          16,                    /* bitsize */
1055          FALSE,                 /* pc_relative */
1056          0,                     /* bitpos */
1057          complain_overflow_dont, /* complain_on_overflow */
1058          ppc64_elf_unhandled_reloc, /* special_function */
1059          "R_PPC64_PLTGOT16_HI", /* name */
1060          FALSE,                 /* partial_inplace */
1061          0,                     /* src_mask */
1062          0xffff,                /* dst_mask */
1063          FALSE),                /* pcrel_offset */
1064
1065   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1066      1 if the contents of the low 16 bits, treated as a signed number,
1067      is negative.  */
1068   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1069   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1070          16,                    /* rightshift */
1071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1072          16,                    /* bitsize */
1073          FALSE,                 /* pc_relative */
1074          0,                     /* bitpos */
1075          complain_overflow_dont,/* complain_on_overflow */
1076          ppc64_elf_unhandled_reloc, /* special_function */
1077          "R_PPC64_PLTGOT16_HA", /* name */
1078          FALSE,                 /* partial_inplace */
1079          0,                     /* src_mask */
1080          0xffff,                /* dst_mask */
1081          FALSE),                /* pcrel_offset */
1082
1083   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1084   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1085          0,                     /* rightshift */
1086          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          16,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_bitfield, /* complain_on_overflow */
1091          bfd_elf_generic_reloc, /* special_function */
1092          "R_PPC64_ADDR16_DS",   /* name */
1093          FALSE,                 /* partial_inplace */
1094          0,                     /* src_mask */
1095          0xfffc,                /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1099   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1100          0,                     /* rightshift */
1101          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1102          16,                    /* bitsize */
1103          FALSE,                 /* pc_relative */
1104          0,                     /* bitpos */
1105          complain_overflow_dont,/* complain_on_overflow */
1106          bfd_elf_generic_reloc, /* special_function */
1107          "R_PPC64_ADDR16_LO_DS",/* name */
1108          FALSE,                 /* partial_inplace */
1109          0,                     /* src_mask */
1110          0xfffc,                /* dst_mask */
1111          FALSE),                /* pcrel_offset */
1112
1113   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1114   HOWTO (R_PPC64_GOT16_DS,      /* type */
1115          0,                     /* rightshift */
1116          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1117          16,                    /* bitsize */
1118          FALSE,                 /* pc_relative */
1119          0,                     /* bitpos */
1120          complain_overflow_signed, /* complain_on_overflow */
1121          ppc64_elf_unhandled_reloc, /* special_function */
1122          "R_PPC64_GOT16_DS",    /* name */
1123          FALSE,                 /* partial_inplace */
1124          0,                     /* src_mask */
1125          0xfffc,                /* dst_mask */
1126          FALSE),                /* pcrel_offset */
1127
1128   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1129   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1130          0,                     /* rightshift */
1131          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          16,                    /* bitsize */
1133          FALSE,                 /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_dont, /* complain_on_overflow */
1136          ppc64_elf_unhandled_reloc, /* special_function */
1137          "R_PPC64_GOT16_LO_DS", /* name */
1138          FALSE,                 /* partial_inplace */
1139          0,                     /* src_mask */
1140          0xfffc,                /* dst_mask */
1141          FALSE),                /* pcrel_offset */
1142
1143   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1144   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1145          0,                     /* rightshift */
1146          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1147          16,                    /* bitsize */
1148          FALSE,                 /* pc_relative */
1149          0,                     /* bitpos */
1150          complain_overflow_dont, /* complain_on_overflow */
1151          ppc64_elf_unhandled_reloc, /* special_function */
1152          "R_PPC64_PLT16_LO_DS", /* name */
1153          FALSE,                 /* partial_inplace */
1154          0,                     /* src_mask */
1155          0xfffc,                /* dst_mask */
1156          FALSE),                /* pcrel_offset */
1157
1158   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1159   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1160          0,                     /* rightshift */
1161          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          16,                    /* bitsize */
1163          FALSE,                 /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_bitfield, /* complain_on_overflow */
1166          ppc64_elf_sectoff_reloc, /* special_function */
1167          "R_PPC64_SECTOFF_DS",  /* name */
1168          FALSE,                 /* partial_inplace */
1169          0,                     /* src_mask */
1170          0xfffc,                /* dst_mask */
1171          FALSE),                /* pcrel_offset */
1172
1173   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1174   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1175          0,                     /* rightshift */
1176          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1177          16,                    /* bitsize */
1178          FALSE,                 /* pc_relative */
1179          0,                     /* bitpos */
1180          complain_overflow_dont, /* complain_on_overflow */
1181          ppc64_elf_sectoff_reloc, /* special_function */
1182          "R_PPC64_SECTOFF_LO_DS",/* name */
1183          FALSE,                 /* partial_inplace */
1184          0,                     /* src_mask */
1185          0xfffc,                /* dst_mask */
1186          FALSE),                /* pcrel_offset */
1187
1188   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1189   HOWTO (R_PPC64_TOC16_DS,      /* type */
1190          0,                     /* rightshift */
1191          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          16,                    /* bitsize */
1193          FALSE,                 /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_signed, /* complain_on_overflow */
1196          ppc64_elf_toc_reloc,   /* special_function */
1197          "R_PPC64_TOC16_DS",    /* name */
1198          FALSE,                 /* partial_inplace */
1199          0,                     /* src_mask */
1200          0xfffc,                /* dst_mask */
1201          FALSE),                /* pcrel_offset */
1202
1203   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1204   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1205          0,                     /* rightshift */
1206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1207          16,                    /* bitsize */
1208          FALSE,                 /* pc_relative */
1209          0,                     /* bitpos */
1210          complain_overflow_dont, /* complain_on_overflow */
1211          ppc64_elf_toc_reloc,   /* special_function */
1212          "R_PPC64_TOC16_LO_DS", /* name */
1213          FALSE,                 /* partial_inplace */
1214          0,                     /* src_mask */
1215          0xfffc,                /* dst_mask */
1216          FALSE),                /* pcrel_offset */
1217
1218   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1219   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1220   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1221          0,                     /* rightshift */
1222          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1223          16,                    /* bitsize */
1224          FALSE,                 /* pc_relative */
1225          0,                     /* bitpos */
1226          complain_overflow_signed, /* complain_on_overflow */
1227          ppc64_elf_unhandled_reloc, /* special_function */
1228          "R_PPC64_PLTGOT16_DS", /* name */
1229          FALSE,                 /* partial_inplace */
1230          0,                     /* src_mask */
1231          0xfffc,                /* dst_mask */
1232          FALSE),                /* pcrel_offset */
1233
1234   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1235   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1236   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1237          0,                     /* rightshift */
1238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1239          16,                    /* bitsize */
1240          FALSE,                 /* pc_relative */
1241          0,                     /* bitpos */
1242          complain_overflow_dont, /* complain_on_overflow */
1243          ppc64_elf_unhandled_reloc, /* special_function */
1244          "R_PPC64_PLTGOT16_LO_DS",/* name */
1245          FALSE,                 /* partial_inplace */
1246          0,                     /* src_mask */
1247          0xfffc,                /* dst_mask */
1248          FALSE),                /* pcrel_offset */
1249
1250   /* Marker relocs for TLS.  */
1251   HOWTO (R_PPC64_TLS,
1252          0,                     /* rightshift */
1253          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1254          32,                    /* bitsize */
1255          FALSE,                 /* pc_relative */
1256          0,                     /* bitpos */
1257          complain_overflow_dont, /* complain_on_overflow */
1258          bfd_elf_generic_reloc, /* special_function */
1259          "R_PPC64_TLS",         /* name */
1260          FALSE,                 /* partial_inplace */
1261          0,                     /* src_mask */
1262          0,                     /* dst_mask */
1263          FALSE),                /* pcrel_offset */
1264
1265   HOWTO (R_PPC64_TLSGD,
1266          0,                     /* rightshift */
1267          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1268          32,                    /* bitsize */
1269          FALSE,                 /* pc_relative */
1270          0,                     /* bitpos */
1271          complain_overflow_dont, /* complain_on_overflow */
1272          bfd_elf_generic_reloc, /* special_function */
1273          "R_PPC64_TLSGD",       /* name */
1274          FALSE,                 /* partial_inplace */
1275          0,                     /* src_mask */
1276          0,                     /* dst_mask */
1277          FALSE),                /* pcrel_offset */
1278
1279   HOWTO (R_PPC64_TLSLD,
1280          0,                     /* rightshift */
1281          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1282          32,                    /* bitsize */
1283          FALSE,                 /* pc_relative */
1284          0,                     /* bitpos */
1285          complain_overflow_dont, /* complain_on_overflow */
1286          bfd_elf_generic_reloc, /* special_function */
1287          "R_PPC64_TLSLD",       /* name */
1288          FALSE,                 /* partial_inplace */
1289          0,                     /* src_mask */
1290          0,                     /* dst_mask */
1291          FALSE),                /* pcrel_offset */
1292
1293   HOWTO (R_PPC64_TOCSAVE,
1294          0,                     /* rightshift */
1295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1296          32,                    /* bitsize */
1297          FALSE,                 /* pc_relative */
1298          0,                     /* bitpos */
1299          complain_overflow_dont, /* complain_on_overflow */
1300          bfd_elf_generic_reloc, /* special_function */
1301          "R_PPC64_TOCSAVE",     /* name */
1302          FALSE,                 /* partial_inplace */
1303          0,                     /* src_mask */
1304          0,                     /* dst_mask */
1305          FALSE),                /* pcrel_offset */
1306
1307   /* Computes the load module index of the load module that contains the
1308      definition of its TLS sym.  */
1309   HOWTO (R_PPC64_DTPMOD64,
1310          0,                     /* rightshift */
1311          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1312          64,                    /* bitsize */
1313          FALSE,                 /* pc_relative */
1314          0,                     /* bitpos */
1315          complain_overflow_dont, /* complain_on_overflow */
1316          ppc64_elf_unhandled_reloc, /* special_function */
1317          "R_PPC64_DTPMOD64",    /* name */
1318          FALSE,                 /* partial_inplace */
1319          0,                     /* src_mask */
1320          ONES (64),             /* dst_mask */
1321          FALSE),                /* pcrel_offset */
1322
1323   /* Computes a dtv-relative displacement, the difference between the value
1324      of sym+add and the base address of the thread-local storage block that
1325      contains the definition of sym, minus 0x8000.  */
1326   HOWTO (R_PPC64_DTPREL64,
1327          0,                     /* rightshift */
1328          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1329          64,                    /* bitsize */
1330          FALSE,                 /* pc_relative */
1331          0,                     /* bitpos */
1332          complain_overflow_dont, /* complain_on_overflow */
1333          ppc64_elf_unhandled_reloc, /* special_function */
1334          "R_PPC64_DTPREL64",    /* name */
1335          FALSE,                 /* partial_inplace */
1336          0,                     /* src_mask */
1337          ONES (64),             /* dst_mask */
1338          FALSE),                /* pcrel_offset */
1339
1340   /* A 16 bit dtprel reloc.  */
1341   HOWTO (R_PPC64_DTPREL16,
1342          0,                     /* rightshift */
1343          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          16,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_signed, /* complain_on_overflow */
1348          ppc64_elf_unhandled_reloc, /* special_function */
1349          "R_PPC64_DTPREL16",    /* name */
1350          FALSE,                 /* partial_inplace */
1351          0,                     /* src_mask */
1352          0xffff,                /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   /* Like DTPREL16, but no overflow.  */
1356   HOWTO (R_PPC64_DTPREL16_LO,
1357          0,                     /* rightshift */
1358          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1359          16,                    /* bitsize */
1360          FALSE,                 /* pc_relative */
1361          0,                     /* bitpos */
1362          complain_overflow_dont, /* complain_on_overflow */
1363          ppc64_elf_unhandled_reloc, /* special_function */
1364          "R_PPC64_DTPREL16_LO", /* name */
1365          FALSE,                 /* partial_inplace */
1366          0,                     /* src_mask */
1367          0xffff,                /* dst_mask */
1368          FALSE),                /* pcrel_offset */
1369
1370   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1371   HOWTO (R_PPC64_DTPREL16_HI,
1372          16,                    /* rightshift */
1373          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1374          16,                    /* bitsize */
1375          FALSE,                 /* pc_relative */
1376          0,                     /* bitpos */
1377          complain_overflow_dont, /* complain_on_overflow */
1378          ppc64_elf_unhandled_reloc, /* special_function */
1379          "R_PPC64_DTPREL16_HI", /* name */
1380          FALSE,                 /* partial_inplace */
1381          0,                     /* src_mask */
1382          0xffff,                /* dst_mask */
1383          FALSE),                /* pcrel_offset */
1384
1385   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1386   HOWTO (R_PPC64_DTPREL16_HA,
1387          16,                    /* rightshift */
1388          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1389          16,                    /* bitsize */
1390          FALSE,                 /* pc_relative */
1391          0,                     /* bitpos */
1392          complain_overflow_dont, /* complain_on_overflow */
1393          ppc64_elf_unhandled_reloc, /* special_function */
1394          "R_PPC64_DTPREL16_HA", /* name */
1395          FALSE,                 /* partial_inplace */
1396          0,                     /* src_mask */
1397          0xffff,                /* dst_mask */
1398          FALSE),                /* pcrel_offset */
1399
1400   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1401   HOWTO (R_PPC64_DTPREL16_HIGHER,
1402          32,                    /* rightshift */
1403          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          16,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_dont, /* complain_on_overflow */
1408          ppc64_elf_unhandled_reloc, /* special_function */
1409          "R_PPC64_DTPREL16_HIGHER", /* name */
1410          FALSE,                 /* partial_inplace */
1411          0,                     /* src_mask */
1412          0xffff,                /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1416   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1417          32,                    /* rightshift */
1418          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          16,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_dont, /* complain_on_overflow */
1423          ppc64_elf_unhandled_reloc, /* special_function */
1424          "R_PPC64_DTPREL16_HIGHERA", /* name */
1425          FALSE,                 /* partial_inplace */
1426          0,                     /* src_mask */
1427          0xffff,                /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1431   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1432          48,                    /* rightshift */
1433          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1434          16,                    /* bitsize */
1435          FALSE,                 /* pc_relative */
1436          0,                     /* bitpos */
1437          complain_overflow_dont, /* complain_on_overflow */
1438          ppc64_elf_unhandled_reloc, /* special_function */
1439          "R_PPC64_DTPREL16_HIGHEST", /* name */
1440          FALSE,                 /* partial_inplace */
1441          0,                     /* src_mask */
1442          0xffff,                /* dst_mask */
1443          FALSE),                /* pcrel_offset */
1444
1445   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1446   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1447          48,                    /* rightshift */
1448          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1449          16,                    /* bitsize */
1450          FALSE,                 /* pc_relative */
1451          0,                     /* bitpos */
1452          complain_overflow_dont, /* complain_on_overflow */
1453          ppc64_elf_unhandled_reloc, /* special_function */
1454          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1455          FALSE,                 /* partial_inplace */
1456          0,                     /* src_mask */
1457          0xffff,                /* dst_mask */
1458          FALSE),                /* pcrel_offset */
1459
1460   /* Like DTPREL16, but for insns with a DS field.  */
1461   HOWTO (R_PPC64_DTPREL16_DS,
1462          0,                     /* rightshift */
1463          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1464          16,                    /* bitsize */
1465          FALSE,                 /* pc_relative */
1466          0,                     /* bitpos */
1467          complain_overflow_signed, /* complain_on_overflow */
1468          ppc64_elf_unhandled_reloc, /* special_function */
1469          "R_PPC64_DTPREL16_DS", /* name */
1470          FALSE,                 /* partial_inplace */
1471          0,                     /* src_mask */
1472          0xfffc,                /* dst_mask */
1473          FALSE),                /* pcrel_offset */
1474
1475   /* Like DTPREL16_DS, but no overflow.  */
1476   HOWTO (R_PPC64_DTPREL16_LO_DS,
1477          0,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          16,                    /* bitsize */
1480          FALSE,                 /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_dont, /* complain_on_overflow */
1483          ppc64_elf_unhandled_reloc, /* special_function */
1484          "R_PPC64_DTPREL16_LO_DS", /* name */
1485          FALSE,                 /* partial_inplace */
1486          0,                     /* src_mask */
1487          0xfffc,                /* dst_mask */
1488          FALSE),                /* pcrel_offset */
1489
1490   /* Computes a tp-relative displacement, the difference between the value of
1491      sym+add and the value of the thread pointer (r13).  */
1492   HOWTO (R_PPC64_TPREL64,
1493          0,                     /* rightshift */
1494          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1495          64,                    /* bitsize */
1496          FALSE,                 /* pc_relative */
1497          0,                     /* bitpos */
1498          complain_overflow_dont, /* complain_on_overflow */
1499          ppc64_elf_unhandled_reloc, /* special_function */
1500          "R_PPC64_TPREL64",     /* name */
1501          FALSE,                 /* partial_inplace */
1502          0,                     /* src_mask */
1503          ONES (64),             /* dst_mask */
1504          FALSE),                /* pcrel_offset */
1505
1506   /* A 16 bit tprel reloc.  */
1507   HOWTO (R_PPC64_TPREL16,
1508          0,                     /* rightshift */
1509          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          16,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_signed, /* complain_on_overflow */
1514          ppc64_elf_unhandled_reloc, /* special_function */
1515          "R_PPC64_TPREL16",     /* name */
1516          FALSE,                 /* partial_inplace */
1517          0,                     /* src_mask */
1518          0xffff,                /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   /* Like TPREL16, but no overflow.  */
1522   HOWTO (R_PPC64_TPREL16_LO,
1523          0,                     /* rightshift */
1524          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1525          16,                    /* bitsize */
1526          FALSE,                 /* pc_relative */
1527          0,                     /* bitpos */
1528          complain_overflow_dont, /* complain_on_overflow */
1529          ppc64_elf_unhandled_reloc, /* special_function */
1530          "R_PPC64_TPREL16_LO",  /* name */
1531          FALSE,                 /* partial_inplace */
1532          0,                     /* src_mask */
1533          0xffff,                /* dst_mask */
1534          FALSE),                /* pcrel_offset */
1535
1536   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1537   HOWTO (R_PPC64_TPREL16_HI,
1538          16,                    /* rightshift */
1539          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1540          16,                    /* bitsize */
1541          FALSE,                 /* pc_relative */
1542          0,                     /* bitpos */
1543          complain_overflow_dont, /* complain_on_overflow */
1544          ppc64_elf_unhandled_reloc, /* special_function */
1545          "R_PPC64_TPREL16_HI",  /* name */
1546          FALSE,                 /* partial_inplace */
1547          0,                     /* src_mask */
1548          0xffff,                /* dst_mask */
1549          FALSE),                /* pcrel_offset */
1550
1551   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1552   HOWTO (R_PPC64_TPREL16_HA,
1553          16,                    /* rightshift */
1554          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1555          16,                    /* bitsize */
1556          FALSE,                 /* pc_relative */
1557          0,                     /* bitpos */
1558          complain_overflow_dont, /* complain_on_overflow */
1559          ppc64_elf_unhandled_reloc, /* special_function */
1560          "R_PPC64_TPREL16_HA",  /* name */
1561          FALSE,                 /* partial_inplace */
1562          0,                     /* src_mask */
1563          0xffff,                /* dst_mask */
1564          FALSE),                /* pcrel_offset */
1565
1566   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1567   HOWTO (R_PPC64_TPREL16_HIGHER,
1568          32,                    /* rightshift */
1569          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1570          16,                    /* bitsize */
1571          FALSE,                 /* pc_relative */
1572          0,                     /* bitpos */
1573          complain_overflow_dont, /* complain_on_overflow */
1574          ppc64_elf_unhandled_reloc, /* special_function */
1575          "R_PPC64_TPREL16_HIGHER",      /* name */
1576          FALSE,                 /* partial_inplace */
1577          0,                     /* src_mask */
1578          0xffff,                /* dst_mask */
1579          FALSE),                /* pcrel_offset */
1580
1581   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1582   HOWTO (R_PPC64_TPREL16_HIGHERA,
1583          32,                    /* rightshift */
1584          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1585          16,                    /* bitsize */
1586          FALSE,                 /* pc_relative */
1587          0,                     /* bitpos */
1588          complain_overflow_dont, /* complain_on_overflow */
1589          ppc64_elf_unhandled_reloc, /* special_function */
1590          "R_PPC64_TPREL16_HIGHERA", /* name */
1591          FALSE,                 /* partial_inplace */
1592          0,                     /* src_mask */
1593          0xffff,                /* dst_mask */
1594          FALSE),                /* pcrel_offset */
1595
1596   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1597   HOWTO (R_PPC64_TPREL16_HIGHEST,
1598          48,                    /* rightshift */
1599          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1600          16,                    /* bitsize */
1601          FALSE,                 /* pc_relative */
1602          0,                     /* bitpos */
1603          complain_overflow_dont, /* complain_on_overflow */
1604          ppc64_elf_unhandled_reloc, /* special_function */
1605          "R_PPC64_TPREL16_HIGHEST", /* name */
1606          FALSE,                 /* partial_inplace */
1607          0,                     /* src_mask */
1608          0xffff,                /* dst_mask */
1609          FALSE),                /* pcrel_offset */
1610
1611   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1612   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1613          48,                    /* rightshift */
1614          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          16,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont, /* complain_on_overflow */
1619          ppc64_elf_unhandled_reloc, /* special_function */
1620          "R_PPC64_TPREL16_HIGHESTA", /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0xffff,                /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   /* Like TPREL16, but for insns with a DS field.  */
1627   HOWTO (R_PPC64_TPREL16_DS,
1628          0,                     /* rightshift */
1629          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1630          16,                    /* bitsize */
1631          FALSE,                 /* pc_relative */
1632          0,                     /* bitpos */
1633          complain_overflow_signed, /* complain_on_overflow */
1634          ppc64_elf_unhandled_reloc, /* special_function */
1635          "R_PPC64_TPREL16_DS",  /* name */
1636          FALSE,                 /* partial_inplace */
1637          0,                     /* src_mask */
1638          0xfffc,                /* dst_mask */
1639          FALSE),                /* pcrel_offset */
1640
1641   /* Like TPREL16_DS, but no overflow.  */
1642   HOWTO (R_PPC64_TPREL16_LO_DS,
1643          0,                     /* rightshift */
1644          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          16,                    /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_dont, /* complain_on_overflow */
1649          ppc64_elf_unhandled_reloc, /* special_function */
1650          "R_PPC64_TPREL16_LO_DS", /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0xfffc,                /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1657      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1658      to the first entry relative to the TOC base (r2).  */
1659   HOWTO (R_PPC64_GOT_TLSGD16,
1660          0,                     /* rightshift */
1661          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1662          16,                    /* bitsize */
1663          FALSE,                 /* pc_relative */
1664          0,                     /* bitpos */
1665          complain_overflow_signed, /* complain_on_overflow */
1666          ppc64_elf_unhandled_reloc, /* special_function */
1667          "R_PPC64_GOT_TLSGD16", /* name */
1668          FALSE,                 /* partial_inplace */
1669          0,                     /* src_mask */
1670          0xffff,                /* dst_mask */
1671          FALSE),                /* pcrel_offset */
1672
1673   /* Like GOT_TLSGD16, but no overflow.  */
1674   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1675          0,                     /* rightshift */
1676          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1677          16,                    /* bitsize */
1678          FALSE,                 /* pc_relative */
1679          0,                     /* bitpos */
1680          complain_overflow_dont, /* complain_on_overflow */
1681          ppc64_elf_unhandled_reloc, /* special_function */
1682          "R_PPC64_GOT_TLSGD16_LO", /* name */
1683          FALSE,                 /* partial_inplace */
1684          0,                     /* src_mask */
1685          0xffff,                /* dst_mask */
1686          FALSE),                /* pcrel_offset */
1687
1688   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1689   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1690          16,                    /* rightshift */
1691          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1692          16,                    /* bitsize */
1693          FALSE,                 /* pc_relative */
1694          0,                     /* bitpos */
1695          complain_overflow_dont, /* complain_on_overflow */
1696          ppc64_elf_unhandled_reloc, /* special_function */
1697          "R_PPC64_GOT_TLSGD16_HI", /* name */
1698          FALSE,                 /* partial_inplace */
1699          0,                     /* src_mask */
1700          0xffff,                /* dst_mask */
1701          FALSE),                /* pcrel_offset */
1702
1703   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1704   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1705          16,                    /* rightshift */
1706          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1707          16,                    /* bitsize */
1708          FALSE,                 /* pc_relative */
1709          0,                     /* bitpos */
1710          complain_overflow_dont, /* complain_on_overflow */
1711          ppc64_elf_unhandled_reloc, /* special_function */
1712          "R_PPC64_GOT_TLSGD16_HA", /* name */
1713          FALSE,                 /* partial_inplace */
1714          0,                     /* src_mask */
1715          0xffff,                /* dst_mask */
1716          FALSE),                /* pcrel_offset */
1717
1718   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1719      with values (sym+add)@dtpmod and zero, and computes the offset to the
1720      first entry relative to the TOC base (r2).  */
1721   HOWTO (R_PPC64_GOT_TLSLD16,
1722          0,                     /* rightshift */
1723          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1724          16,                    /* bitsize */
1725          FALSE,                 /* pc_relative */
1726          0,                     /* bitpos */
1727          complain_overflow_signed, /* complain_on_overflow */
1728          ppc64_elf_unhandled_reloc, /* special_function */
1729          "R_PPC64_GOT_TLSLD16", /* name */
1730          FALSE,                 /* partial_inplace */
1731          0,                     /* src_mask */
1732          0xffff,                /* dst_mask */
1733          FALSE),                /* pcrel_offset */
1734
1735   /* Like GOT_TLSLD16, but no overflow.  */
1736   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1737          0,                     /* rightshift */
1738          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1739          16,                    /* bitsize */
1740          FALSE,                 /* pc_relative */
1741          0,                     /* bitpos */
1742          complain_overflow_dont, /* complain_on_overflow */
1743          ppc64_elf_unhandled_reloc, /* special_function */
1744          "R_PPC64_GOT_TLSLD16_LO", /* name */
1745          FALSE,                 /* partial_inplace */
1746          0,                     /* src_mask */
1747          0xffff,                /* dst_mask */
1748          FALSE),                /* pcrel_offset */
1749
1750   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1751   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1752          16,                    /* rightshift */
1753          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          16,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_dont, /* complain_on_overflow */
1758          ppc64_elf_unhandled_reloc, /* special_function */
1759          "R_PPC64_GOT_TLSLD16_HI", /* name */
1760          FALSE,                 /* partial_inplace */
1761          0,                     /* src_mask */
1762          0xffff,                /* dst_mask */
1763          FALSE),                /* pcrel_offset */
1764
1765   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1766   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1767          16,                    /* rightshift */
1768          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1769          16,                    /* bitsize */
1770          FALSE,                 /* pc_relative */
1771          0,                     /* bitpos */
1772          complain_overflow_dont, /* complain_on_overflow */
1773          ppc64_elf_unhandled_reloc, /* special_function */
1774          "R_PPC64_GOT_TLSLD16_HA", /* name */
1775          FALSE,                 /* partial_inplace */
1776          0,                     /* src_mask */
1777          0xffff,                /* dst_mask */
1778          FALSE),                /* pcrel_offset */
1779
1780   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1781      the offset to the entry relative to the TOC base (r2).  */
1782   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1783          0,                     /* rightshift */
1784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1785          16,                    /* bitsize */
1786          FALSE,                 /* pc_relative */
1787          0,                     /* bitpos */
1788          complain_overflow_signed, /* complain_on_overflow */
1789          ppc64_elf_unhandled_reloc, /* special_function */
1790          "R_PPC64_GOT_DTPREL16_DS", /* name */
1791          FALSE,                 /* partial_inplace */
1792          0,                     /* src_mask */
1793          0xfffc,                /* dst_mask */
1794          FALSE),                /* pcrel_offset */
1795
1796   /* Like GOT_DTPREL16_DS, but no overflow.  */
1797   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1798          0,                     /* rightshift */
1799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          16,                    /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_dont, /* complain_on_overflow */
1804          ppc64_elf_unhandled_reloc, /* special_function */
1805          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0xfffc,                /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1812   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1813          16,                    /* rightshift */
1814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1815          16,                    /* bitsize */
1816          FALSE,                 /* pc_relative */
1817          0,                     /* bitpos */
1818          complain_overflow_dont, /* complain_on_overflow */
1819          ppc64_elf_unhandled_reloc, /* special_function */
1820          "R_PPC64_GOT_DTPREL16_HI", /* name */
1821          FALSE,                 /* partial_inplace */
1822          0,                     /* src_mask */
1823          0xffff,                /* dst_mask */
1824          FALSE),                /* pcrel_offset */
1825
1826   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1827   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1828          16,                    /* rightshift */
1829          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1830          16,                    /* bitsize */
1831          FALSE,                 /* pc_relative */
1832          0,                     /* bitpos */
1833          complain_overflow_dont, /* complain_on_overflow */
1834          ppc64_elf_unhandled_reloc, /* special_function */
1835          "R_PPC64_GOT_DTPREL16_HA", /* name */
1836          FALSE,                 /* partial_inplace */
1837          0,                     /* src_mask */
1838          0xffff,                /* dst_mask */
1839          FALSE),                /* pcrel_offset */
1840
1841   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1842      offset to the entry relative to the TOC base (r2).  */
1843   HOWTO (R_PPC64_GOT_TPREL16_DS,
1844          0,                     /* rightshift */
1845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1846          16,                    /* bitsize */
1847          FALSE,                 /* pc_relative */
1848          0,                     /* bitpos */
1849          complain_overflow_signed, /* complain_on_overflow */
1850          ppc64_elf_unhandled_reloc, /* special_function */
1851          "R_PPC64_GOT_TPREL16_DS", /* name */
1852          FALSE,                 /* partial_inplace */
1853          0,                     /* src_mask */
1854          0xfffc,                /* dst_mask */
1855          FALSE),                /* pcrel_offset */
1856
1857   /* Like GOT_TPREL16_DS, but no overflow.  */
1858   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1859          0,                     /* rightshift */
1860          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1861          16,                    /* bitsize */
1862          FALSE,                 /* pc_relative */
1863          0,                     /* bitpos */
1864          complain_overflow_dont, /* complain_on_overflow */
1865          ppc64_elf_unhandled_reloc, /* special_function */
1866          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1867          FALSE,                 /* partial_inplace */
1868          0,                     /* src_mask */
1869          0xfffc,                /* dst_mask */
1870          FALSE),                /* pcrel_offset */
1871
1872   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1873   HOWTO (R_PPC64_GOT_TPREL16_HI,
1874          16,                    /* rightshift */
1875          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1876          16,                    /* bitsize */
1877          FALSE,                 /* pc_relative */
1878          0,                     /* bitpos */
1879          complain_overflow_dont, /* complain_on_overflow */
1880          ppc64_elf_unhandled_reloc, /* special_function */
1881          "R_PPC64_GOT_TPREL16_HI", /* name */
1882          FALSE,                 /* partial_inplace */
1883          0,                     /* src_mask */
1884          0xffff,                /* dst_mask */
1885          FALSE),                /* pcrel_offset */
1886
1887   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1888   HOWTO (R_PPC64_GOT_TPREL16_HA,
1889          16,                    /* rightshift */
1890          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1891          16,                    /* bitsize */
1892          FALSE,                 /* pc_relative */
1893          0,                     /* bitpos */
1894          complain_overflow_dont, /* complain_on_overflow */
1895          ppc64_elf_unhandled_reloc, /* special_function */
1896          "R_PPC64_GOT_TPREL16_HA", /* name */
1897          FALSE,                 /* partial_inplace */
1898          0,                     /* src_mask */
1899          0xffff,                /* dst_mask */
1900          FALSE),                /* pcrel_offset */
1901
1902   HOWTO (R_PPC64_JMP_IREL,      /* type */
1903          0,                     /* rightshift */
1904          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1905          0,                     /* bitsize */
1906          FALSE,                 /* pc_relative */
1907          0,                     /* bitpos */
1908          complain_overflow_dont, /* complain_on_overflow */
1909          ppc64_elf_unhandled_reloc, /* special_function */
1910          "R_PPC64_JMP_IREL",    /* name */
1911          FALSE,                 /* partial_inplace */
1912          0,                     /* src_mask */
1913          0,                     /* dst_mask */
1914          FALSE),                /* pcrel_offset */
1915
1916   HOWTO (R_PPC64_IRELATIVE,     /* type */
1917          0,                     /* rightshift */
1918          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1919          64,                    /* bitsize */
1920          FALSE,                 /* pc_relative */
1921          0,                     /* bitpos */
1922          complain_overflow_dont, /* complain_on_overflow */
1923          bfd_elf_generic_reloc, /* special_function */
1924          "R_PPC64_IRELATIVE",   /* name */
1925          FALSE,                 /* partial_inplace */
1926          0,                     /* src_mask */
1927          ONES (64),             /* dst_mask */
1928          FALSE),                /* pcrel_offset */
1929
1930   /* A 16 bit relative relocation.  */
1931   HOWTO (R_PPC64_REL16,         /* type */
1932          0,                     /* rightshift */
1933          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1934          16,                    /* bitsize */
1935          TRUE,                  /* pc_relative */
1936          0,                     /* bitpos */
1937          complain_overflow_bitfield, /* complain_on_overflow */
1938          bfd_elf_generic_reloc, /* special_function */
1939          "R_PPC64_REL16",       /* name */
1940          FALSE,                 /* partial_inplace */
1941          0,                     /* src_mask */
1942          0xffff,                /* dst_mask */
1943          TRUE),                 /* pcrel_offset */
1944
1945   /* A 16 bit relative relocation without overflow.  */
1946   HOWTO (R_PPC64_REL16_LO,      /* type */
1947          0,                     /* rightshift */
1948          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1949          16,                    /* bitsize */
1950          TRUE,                  /* pc_relative */
1951          0,                     /* bitpos */
1952          complain_overflow_dont,/* complain_on_overflow */
1953          bfd_elf_generic_reloc, /* special_function */
1954          "R_PPC64_REL16_LO",    /* name */
1955          FALSE,                 /* partial_inplace */
1956          0,                     /* src_mask */
1957          0xffff,                /* dst_mask */
1958          TRUE),                 /* pcrel_offset */
1959
1960   /* The high order 16 bits of a relative address.  */
1961   HOWTO (R_PPC64_REL16_HI,      /* type */
1962          16,                    /* rightshift */
1963          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1964          16,                    /* bitsize */
1965          TRUE,                  /* pc_relative */
1966          0,                     /* bitpos */
1967          complain_overflow_dont, /* complain_on_overflow */
1968          bfd_elf_generic_reloc, /* special_function */
1969          "R_PPC64_REL16_HI",    /* name */
1970          FALSE,                 /* partial_inplace */
1971          0,                     /* src_mask */
1972          0xffff,                /* dst_mask */
1973          TRUE),                 /* pcrel_offset */
1974
1975   /* The high order 16 bits of a relative address, plus 1 if the contents of
1976      the low 16 bits, treated as a signed number, is negative.  */
1977   HOWTO (R_PPC64_REL16_HA,      /* type */
1978          16,                    /* rightshift */
1979          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1980          16,                    /* bitsize */
1981          TRUE,                  /* pc_relative */
1982          0,                     /* bitpos */
1983          complain_overflow_dont, /* complain_on_overflow */
1984          ppc64_elf_ha_reloc,    /* special_function */
1985          "R_PPC64_REL16_HA",    /* name */
1986          FALSE,                 /* partial_inplace */
1987          0,                     /* src_mask */
1988          0xffff,                /* dst_mask */
1989          TRUE),                 /* pcrel_offset */
1990
1991   /* GNU extension to record C++ vtable hierarchy.  */
1992   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1993          0,                     /* rightshift */
1994          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1995          0,                     /* bitsize */
1996          FALSE,                 /* pc_relative */
1997          0,                     /* bitpos */
1998          complain_overflow_dont, /* complain_on_overflow */
1999          NULL,                  /* special_function */
2000          "R_PPC64_GNU_VTINHERIT", /* name */
2001          FALSE,                 /* partial_inplace */
2002          0,                     /* src_mask */
2003          0,                     /* dst_mask */
2004          FALSE),                /* pcrel_offset */
2005
2006   /* GNU extension to record C++ vtable member usage.  */
2007   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2008          0,                     /* rightshift */
2009          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2010          0,                     /* bitsize */
2011          FALSE,                 /* pc_relative */
2012          0,                     /* bitpos */
2013          complain_overflow_dont, /* complain_on_overflow */
2014          NULL,                  /* special_function */
2015          "R_PPC64_GNU_VTENTRY", /* name */
2016          FALSE,                 /* partial_inplace */
2017          0,                     /* src_mask */
2018          0,                     /* dst_mask */
2019          FALSE),                /* pcrel_offset */
2020 };
2021
2022 \f
2023 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2024    be done.  */
2025
2026 static void
2027 ppc_howto_init (void)
2028 {
2029   unsigned int i, type;
2030
2031   for (i = 0;
2032        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2033        i++)
2034     {
2035       type = ppc64_elf_howto_raw[i].type;
2036       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2037                           / sizeof (ppc64_elf_howto_table[0])));
2038       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2039     }
2040 }
2041
2042 static reloc_howto_type *
2043 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2044                              bfd_reloc_code_real_type code)
2045 {
2046   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2047
2048   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2049     /* Initialize howto table if needed.  */
2050     ppc_howto_init ();
2051
2052   switch (code)
2053     {
2054     default:
2055       return NULL;
2056
2057     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2058       break;
2059     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2060       break;
2061     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2062       break;
2063     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2064       break;
2065     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2066       break;
2067     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2068       break;
2069     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2070       break;
2071     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2072       break;
2073     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2074       break;
2075     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2076       break;
2077     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2078       break;
2079     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2080       break;
2081     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2082       break;
2083     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2084       break;
2085     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2086       break;
2087     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2088       break;
2089     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2090       break;
2091     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2092       break;
2093     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2094       break;
2095     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2096       break;
2097     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2098       break;
2099     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2100       break;
2101     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2102       break;
2103     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2104       break;
2105     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2106       break;
2107     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2108       break;
2109     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2110       break;
2111     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2112       break;
2113     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2114       break;
2115     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2116       break;
2117     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2118       break;
2119     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2120       break;
2121     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2122       break;
2123     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2124       break;
2125     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2126       break;
2127     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2128       break;
2129     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2130       break;
2131     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2132       break;
2133     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2134       break;
2135     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2136       break;
2137     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2138       break;
2139     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2140       break;
2141     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2142       break;
2143     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2144       break;
2145     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2146       break;
2147     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2148       break;
2149     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2150       break;
2151     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2152       break;
2153     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2154       break;
2155     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2156       break;
2157     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2158       break;
2159     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2160       break;
2161     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2162       break;
2163     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2164       break;
2165     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2166       break;
2167     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2168       break;
2169     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2170       break;
2171     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2172       break;
2173     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2174       break;
2175     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2176       break;
2177     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2178       break;
2179     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2180       break;
2181     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2182       break;
2183     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2184       break;
2185     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2186       break;
2187     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2188       break;
2189     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2190       break;
2191     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2192       break;
2193     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2194       break;
2195     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2196       break;
2197     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2198       break;
2199     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2200       break;
2201     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2204       break;
2205     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2206       break;
2207     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2208       break;
2209     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2210       break;
2211     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2212       break;
2213     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2214       break;
2215     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2216       break;
2217     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2218       break;
2219     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2220       break;
2221     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2222       break;
2223     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2224       break;
2225     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2226       break;
2227     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2228       break;
2229     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2230       break;
2231     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2232       break;
2233     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2234       break;
2235     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2236       break;
2237     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2238       break;
2239     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2240       break;
2241     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2242       break;
2243     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2244       break;
2245     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2246       break;
2247     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2248       break;
2249     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2250       break;
2251     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2252       break;
2253     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2254       break;
2255     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2256       break;
2257     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2258       break;
2259     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2260       break;
2261     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2262       break;
2263     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2264       break;
2265     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2266       break;
2267     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2268       break;
2269     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2270       break;
2271     }
2272
2273   return ppc64_elf_howto_table[r];
2274 };
2275
2276 static reloc_howto_type *
2277 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2278                              const char *r_name)
2279 {
2280   unsigned int i;
2281
2282   for (i = 0;
2283        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2284        i++)
2285     if (ppc64_elf_howto_raw[i].name != NULL
2286         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2287       return &ppc64_elf_howto_raw[i];
2288
2289   return NULL;
2290 }
2291
2292 /* Set the howto pointer for a PowerPC ELF reloc.  */
2293
2294 static void
2295 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2296                          Elf_Internal_Rela *dst)
2297 {
2298   unsigned int type;
2299
2300   /* Initialize howto table if needed.  */
2301   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2302     ppc_howto_init ();
2303
2304   type = ELF64_R_TYPE (dst->r_info);
2305   if (type >= (sizeof (ppc64_elf_howto_table)
2306                / sizeof (ppc64_elf_howto_table[0])))
2307     {
2308       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2309                              abfd, (int) type);
2310       type = R_PPC64_NONE;
2311     }
2312   cache_ptr->howto = ppc64_elf_howto_table[type];
2313 }
2314
2315 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2316
2317 static bfd_reloc_status_type
2318 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2319                     void *data, asection *input_section,
2320                     bfd *output_bfd, char **error_message)
2321 {
2322   /* If this is a relocatable link (output_bfd test tells us), just
2323      call the generic function.  Any adjustment will be done at final
2324      link time.  */
2325   if (output_bfd != NULL)
2326     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2327                                   input_section, output_bfd, error_message);
2328
2329   /* Adjust the addend for sign extension of the low 16 bits.
2330      We won't actually be using the low 16 bits, so trashing them
2331      doesn't matter.  */
2332   reloc_entry->addend += 0x8000;
2333   return bfd_reloc_continue;
2334 }
2335
2336 static bfd_reloc_status_type
2337 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2338                         void *data, asection *input_section,
2339                         bfd *output_bfd, char **error_message)
2340 {
2341   if (output_bfd != NULL)
2342     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2343                                   input_section, output_bfd, error_message);
2344
2345   if (strcmp (symbol->section->name, ".opd") == 0
2346       && (symbol->section->owner->flags & DYNAMIC) == 0)
2347     {
2348       bfd_vma dest = opd_entry_value (symbol->section,
2349                                       symbol->value + reloc_entry->addend,
2350                                       NULL, NULL, FALSE);
2351       if (dest != (bfd_vma) -1)
2352         reloc_entry->addend = dest - (symbol->value
2353                                       + symbol->section->output_section->vma
2354                                       + symbol->section->output_offset);
2355     }
2356   return bfd_reloc_continue;
2357 }
2358
2359 static bfd_reloc_status_type
2360 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2361                          void *data, asection *input_section,
2362                          bfd *output_bfd, char **error_message)
2363 {
2364   long insn;
2365   enum elf_ppc64_reloc_type r_type;
2366   bfd_size_type octets;
2367   /* Assume 'at' branch hints.  */
2368   bfd_boolean is_isa_v2 = TRUE;
2369
2370   /* If this is a relocatable link (output_bfd test tells us), just
2371      call the generic function.  Any adjustment will be done at final
2372      link time.  */
2373   if (output_bfd != NULL)
2374     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2375                                   input_section, output_bfd, error_message);
2376
2377   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2378   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2379   insn &= ~(0x01 << 21);
2380   r_type = reloc_entry->howto->type;
2381   if (r_type == R_PPC64_ADDR14_BRTAKEN
2382       || r_type == R_PPC64_REL14_BRTAKEN)
2383     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2384
2385   if (is_isa_v2)
2386     {
2387       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2388          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2389          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2390       if ((insn & (0x14 << 21)) == (0x04 << 21))
2391         insn |= 0x02 << 21;
2392       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2393         insn |= 0x08 << 21;
2394       else
2395         goto out;
2396     }
2397   else
2398     {
2399       bfd_vma target = 0;
2400       bfd_vma from;
2401
2402       if (!bfd_is_com_section (symbol->section))
2403         target = symbol->value;
2404       target += symbol->section->output_section->vma;
2405       target += symbol->section->output_offset;
2406       target += reloc_entry->addend;
2407
2408       from = (reloc_entry->address
2409               + input_section->output_offset
2410               + input_section->output_section->vma);
2411
2412       /* Invert 'y' bit if not the default.  */
2413       if ((bfd_signed_vma) (target - from) < 0)
2414         insn ^= 0x01 << 21;
2415     }
2416   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2417  out:
2418   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2419                                  input_section, output_bfd, error_message);
2420 }
2421
2422 static bfd_reloc_status_type
2423 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2424                          void *data, asection *input_section,
2425                          bfd *output_bfd, char **error_message)
2426 {
2427   /* If this is a relocatable link (output_bfd test tells us), just
2428      call the generic function.  Any adjustment will be done at final
2429      link time.  */
2430   if (output_bfd != NULL)
2431     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2432                                   input_section, output_bfd, error_message);
2433
2434   /* Subtract the symbol section base address.  */
2435   reloc_entry->addend -= symbol->section->output_section->vma;
2436   return bfd_reloc_continue;
2437 }
2438
2439 static bfd_reloc_status_type
2440 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2441                             void *data, asection *input_section,
2442                             bfd *output_bfd, char **error_message)
2443 {
2444   /* If this is a relocatable link (output_bfd test tells us), just
2445      call the generic function.  Any adjustment will be done at final
2446      link time.  */
2447   if (output_bfd != NULL)
2448     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2449                                   input_section, output_bfd, error_message);
2450
2451   /* Subtract the symbol section base address.  */
2452   reloc_entry->addend -= symbol->section->output_section->vma;
2453
2454   /* Adjust the addend for sign extension of the low 16 bits.  */
2455   reloc_entry->addend += 0x8000;
2456   return bfd_reloc_continue;
2457 }
2458
2459 static bfd_reloc_status_type
2460 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2461                      void *data, asection *input_section,
2462                      bfd *output_bfd, char **error_message)
2463 {
2464   bfd_vma TOCstart;
2465
2466   /* If this is a relocatable link (output_bfd test tells us), just
2467      call the generic function.  Any adjustment will be done at final
2468      link time.  */
2469   if (output_bfd != NULL)
2470     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2471                                   input_section, output_bfd, error_message);
2472
2473   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2474   if (TOCstart == 0)
2475     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2476
2477   /* Subtract the TOC base address.  */
2478   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2479   return bfd_reloc_continue;
2480 }
2481
2482 static bfd_reloc_status_type
2483 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2484                         void *data, asection *input_section,
2485                         bfd *output_bfd, char **error_message)
2486 {
2487   bfd_vma TOCstart;
2488
2489   /* If this is a relocatable link (output_bfd test tells us), just
2490      call the generic function.  Any adjustment will be done at final
2491      link time.  */
2492   if (output_bfd != NULL)
2493     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494                                   input_section, output_bfd, error_message);
2495
2496   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2497   if (TOCstart == 0)
2498     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2499
2500   /* Subtract the TOC base address.  */
2501   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2502
2503   /* Adjust the addend for sign extension of the low 16 bits.  */
2504   reloc_entry->addend += 0x8000;
2505   return bfd_reloc_continue;
2506 }
2507
2508 static bfd_reloc_status_type
2509 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2510                        void *data, asection *input_section,
2511                        bfd *output_bfd, char **error_message)
2512 {
2513   bfd_vma TOCstart;
2514   bfd_size_type octets;
2515
2516   /* If this is a relocatable link (output_bfd test tells us), just
2517      call the generic function.  Any adjustment will be done at final
2518      link time.  */
2519   if (output_bfd != NULL)
2520     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2521                                   input_section, output_bfd, error_message);
2522
2523   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2524   if (TOCstart == 0)
2525     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2526
2527   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2528   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2529   return bfd_reloc_ok;
2530 }
2531
2532 static bfd_reloc_status_type
2533 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2534                            void *data, asection *input_section,
2535                            bfd *output_bfd, char **error_message)
2536 {
2537   /* If this is a relocatable link (output_bfd test tells us), just
2538      call the generic function.  Any adjustment will be done at final
2539      link time.  */
2540   if (output_bfd != NULL)
2541     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2542                                   input_section, output_bfd, error_message);
2543
2544   if (error_message != NULL)
2545     {
2546       static char buf[60];
2547       sprintf (buf, "generic linker can't handle %s",
2548                reloc_entry->howto->name);
2549       *error_message = buf;
2550     }
2551   return bfd_reloc_dangerous;
2552 }
2553
2554 /* Track GOT entries needed for a given symbol.  We might need more
2555    than one got entry per symbol.  */
2556 struct got_entry
2557 {
2558   struct got_entry *next;
2559
2560   /* The symbol addend that we'll be placing in the GOT.  */
2561   bfd_vma addend;
2562
2563   /* Unlike other ELF targets, we use separate GOT entries for the same
2564      symbol referenced from different input files.  This is to support
2565      automatic multiple TOC/GOT sections, where the TOC base can vary
2566      from one input file to another.  After partitioning into TOC groups
2567      we merge entries within the group.
2568
2569      Point to the BFD owning this GOT entry.  */
2570   bfd *owner;
2571
2572   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2573      TLS_TPREL or TLS_DTPREL for tls entries.  */
2574   unsigned char tls_type;
2575
2576   /* Non-zero if got.ent points to real entry.  */
2577   unsigned char is_indirect;
2578
2579   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2580   union
2581     {
2582       bfd_signed_vma refcount;
2583       bfd_vma offset;
2584       struct got_entry *ent;
2585     } got;
2586 };
2587
2588 /* The same for PLT.  */
2589 struct plt_entry
2590 {
2591   struct plt_entry *next;
2592
2593   bfd_vma addend;
2594
2595   union
2596     {
2597       bfd_signed_vma refcount;
2598       bfd_vma offset;
2599     } plt;
2600 };
2601
2602 struct ppc64_elf_obj_tdata
2603 {
2604   struct elf_obj_tdata elf;
2605
2606   /* Shortcuts to dynamic linker sections.  */
2607   asection *got;
2608   asection *relgot;
2609
2610   /* Used during garbage collection.  We attach global symbols defined
2611      on removed .opd entries to this section so that the sym is removed.  */
2612   asection *deleted_section;
2613
2614   /* TLS local dynamic got entry handling.  Support for multiple GOT
2615      sections means we potentially need one of these for each input bfd.  */
2616   struct got_entry tlsld_got;
2617
2618   /* A copy of relocs before they are modified for --emit-relocs.  */
2619   Elf_Internal_Rela *opd_relocs;
2620
2621   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2622      the reloc to be in the range -32768 to 32767.  */
2623   unsigned int has_small_toc_reloc : 1;
2624
2625   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2626      instruction not one we handle.  */
2627   unsigned int unexpected_toc_insn : 1;
2628 };
2629
2630 #define ppc64_elf_tdata(bfd) \
2631   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2632
2633 #define ppc64_tlsld_got(bfd) \
2634   (&ppc64_elf_tdata (bfd)->tlsld_got)
2635
2636 #define is_ppc64_elf(bfd) \
2637   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2638    && elf_object_id (bfd) == PPC64_ELF_DATA)
2639
2640 /* Override the generic function because we store some extras.  */
2641
2642 static bfd_boolean
2643 ppc64_elf_mkobject (bfd *abfd)
2644 {
2645   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2646                                   PPC64_ELF_DATA);
2647 }
2648
2649 /* Fix bad default arch selected for a 64 bit input bfd when the
2650    default is 32 bit.  */
2651
2652 static bfd_boolean
2653 ppc64_elf_object_p (bfd *abfd)
2654 {
2655   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2656     {
2657       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2658
2659       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2660         {
2661           /* Relies on arch after 32 bit default being 64 bit default.  */
2662           abfd->arch_info = abfd->arch_info->next;
2663           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2664         }
2665     }
2666   return TRUE;
2667 }
2668
2669 /* Support for core dump NOTE sections.  */
2670
2671 static bfd_boolean
2672 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2673 {
2674   size_t offset, size;
2675
2676   if (note->descsz != 504)
2677     return FALSE;
2678
2679   /* pr_cursig */
2680   elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2681
2682   /* pr_pid */
2683   elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2684
2685   /* pr_reg */
2686   offset = 112;
2687   size = 384;
2688
2689   /* Make a ".reg/999" section.  */
2690   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2691                                           size, note->descpos + offset);
2692 }
2693
2694 static bfd_boolean
2695 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2696 {
2697   if (note->descsz != 136)
2698     return FALSE;
2699
2700   elf_tdata (abfd)->core->pid
2701     = bfd_get_32 (abfd, note->descdata + 24);
2702   elf_tdata (abfd)->core->program
2703     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2704   elf_tdata (abfd)->core->command
2705     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2706
2707   return TRUE;
2708 }
2709
2710 static char *
2711 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2712                            ...)
2713 {
2714   switch (note_type)
2715     {
2716     default:
2717       return NULL;
2718
2719     case NT_PRPSINFO:
2720       {
2721         char data[136];
2722         va_list ap;
2723
2724         va_start (ap, note_type);
2725         memset (data, 0, sizeof (data));
2726         strncpy (data + 40, va_arg (ap, const char *), 16);
2727         strncpy (data + 56, va_arg (ap, const char *), 80);
2728         va_end (ap);
2729         return elfcore_write_note (abfd, buf, bufsiz,
2730                                    "CORE", note_type, data, sizeof (data));
2731       }
2732
2733     case NT_PRSTATUS:
2734       {
2735         char data[504];
2736         va_list ap;
2737         long pid;
2738         int cursig;
2739         const void *greg;
2740
2741         va_start (ap, note_type);
2742         memset (data, 0, 112);
2743         pid = va_arg (ap, long);
2744         bfd_put_32 (abfd, pid, data + 32);
2745         cursig = va_arg (ap, int);
2746         bfd_put_16 (abfd, cursig, data + 12);
2747         greg = va_arg (ap, const void *);
2748         memcpy (data + 112, greg, 384);
2749         memset (data + 496, 0, 8);
2750         va_end (ap);
2751         return elfcore_write_note (abfd, buf, bufsiz,
2752                                    "CORE", note_type, data, sizeof (data));
2753       }
2754     }
2755 }
2756
2757 /* Add extra PPC sections.  */
2758
2759 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2760 {
2761   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2762   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2763   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2764   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2765   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2766   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2767   { NULL,                     0,  0, 0,            0 }
2768 };
2769
2770 enum _ppc64_sec_type {
2771   sec_normal = 0,
2772   sec_opd = 1,
2773   sec_toc = 2
2774 };
2775
2776 struct _ppc64_elf_section_data
2777 {
2778   struct bfd_elf_section_data elf;
2779
2780   union
2781   {
2782     /* An array with one entry for each opd function descriptor.  */
2783     struct _opd_sec_data
2784     {
2785       /* Points to the function code section for local opd entries.  */
2786       asection **func_sec;
2787
2788       /* After editing .opd, adjust references to opd local syms.  */
2789       long *adjust;
2790     } opd;
2791
2792     /* An array for toc sections, indexed by offset/8.  */
2793     struct _toc_sec_data
2794     {
2795       /* Specifies the relocation symbol index used at a given toc offset.  */
2796       unsigned *symndx;
2797
2798       /* And the relocation addend.  */
2799       bfd_vma *add;
2800     } toc;
2801   } u;
2802
2803   enum _ppc64_sec_type sec_type:2;
2804
2805   /* Flag set when small branches are detected.  Used to
2806      select suitable defaults for the stub group size.  */
2807   unsigned int has_14bit_branch:1;
2808 };
2809
2810 #define ppc64_elf_section_data(sec) \
2811   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2812
2813 static bfd_boolean
2814 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2815 {
2816   if (!sec->used_by_bfd)
2817     {
2818       struct _ppc64_elf_section_data *sdata;
2819       bfd_size_type amt = sizeof (*sdata);
2820
2821       sdata = bfd_zalloc (abfd, amt);
2822       if (sdata == NULL)
2823         return FALSE;
2824       sec->used_by_bfd = sdata;
2825     }
2826
2827   return _bfd_elf_new_section_hook (abfd, sec);
2828 }
2829
2830 static struct _opd_sec_data *
2831 get_opd_info (asection * sec)
2832 {
2833   if (sec != NULL
2834       && ppc64_elf_section_data (sec) != NULL
2835       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2836     return &ppc64_elf_section_data (sec)->u.opd;
2837   return NULL;
2838 }
2839 \f
2840 /* Parameters for the qsort hook.  */
2841 static bfd_boolean synthetic_relocatable;
2842
2843 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2844
2845 static int
2846 compare_symbols (const void *ap, const void *bp)
2847 {
2848   const asymbol *a = * (const asymbol **) ap;
2849   const asymbol *b = * (const asymbol **) bp;
2850
2851   /* Section symbols first.  */
2852   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2853     return -1;
2854   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2855     return 1;
2856
2857   /* then .opd symbols.  */
2858   if (strcmp (a->section->name, ".opd") == 0
2859       && strcmp (b->section->name, ".opd") != 0)
2860     return -1;
2861   if (strcmp (a->section->name, ".opd") != 0
2862       && strcmp (b->section->name, ".opd") == 0)
2863     return 1;
2864
2865   /* then other code symbols.  */
2866   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867       == (SEC_CODE | SEC_ALLOC)
2868       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2869          != (SEC_CODE | SEC_ALLOC))
2870     return -1;
2871
2872   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2873       != (SEC_CODE | SEC_ALLOC)
2874       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2875          == (SEC_CODE | SEC_ALLOC))
2876     return 1;
2877
2878   if (synthetic_relocatable)
2879     {
2880       if (a->section->id < b->section->id)
2881         return -1;
2882
2883       if (a->section->id > b->section->id)
2884         return 1;
2885     }
2886
2887   if (a->value + a->section->vma < b->value + b->section->vma)
2888     return -1;
2889
2890   if (a->value + a->section->vma > b->value + b->section->vma)
2891     return 1;
2892
2893   /* For syms with the same value, prefer strong dynamic global function
2894      syms over other syms.  */
2895   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2896     return -1;
2897
2898   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2899     return 1;
2900
2901   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2902     return -1;
2903
2904   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2905     return 1;
2906
2907   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2908     return -1;
2909
2910   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2911     return 1;
2912
2913   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2914     return -1;
2915
2916   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2917     return 1;
2918
2919   return 0;
2920 }
2921
2922 /* Search SYMS for a symbol of the given VALUE.  */
2923
2924 static asymbol *
2925 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2926 {
2927   long mid;
2928
2929   if (id == -1)
2930     {
2931       while (lo < hi)
2932         {
2933           mid = (lo + hi) >> 1;
2934           if (syms[mid]->value + syms[mid]->section->vma < value)
2935             lo = mid + 1;
2936           else if (syms[mid]->value + syms[mid]->section->vma > value)
2937             hi = mid;
2938           else
2939             return syms[mid];
2940         }
2941     }
2942   else
2943     {
2944       while (lo < hi)
2945         {
2946           mid = (lo + hi) >> 1;
2947           if (syms[mid]->section->id < id)
2948             lo = mid + 1;
2949           else if (syms[mid]->section->id > id)
2950             hi = mid;
2951           else if (syms[mid]->value < value)
2952             lo = mid + 1;
2953           else if (syms[mid]->value > value)
2954             hi = mid;
2955           else
2956             return syms[mid];
2957         }
2958     }
2959   return NULL;
2960 }
2961
2962 static bfd_boolean
2963 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2964 {
2965   bfd_vma vma = *(bfd_vma *) ptr;
2966   return ((section->flags & SEC_ALLOC) != 0
2967           && section->vma <= vma
2968           && vma < section->vma + section->size);
2969 }
2970
2971 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2972    entry syms.  Also generate @plt symbols for the glink branch table.  */
2973
2974 static long
2975 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2976                                 long static_count, asymbol **static_syms,
2977                                 long dyn_count, asymbol **dyn_syms,
2978                                 asymbol **ret)
2979 {
2980   asymbol *s;
2981   long i;
2982   long count;
2983   char *names;
2984   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2985   asection *opd;
2986   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2987   asymbol **syms;
2988
2989   *ret = NULL;
2990
2991   opd = bfd_get_section_by_name (abfd, ".opd");
2992   if (opd == NULL)
2993     return 0;
2994
2995   symcount = static_count;
2996   if (!relocatable)
2997     symcount += dyn_count;
2998   if (symcount == 0)
2999     return 0;
3000
3001   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3002   if (syms == NULL)
3003     return -1;
3004
3005   if (!relocatable && static_count != 0 && dyn_count != 0)
3006     {
3007       /* Use both symbol tables.  */
3008       memcpy (syms, static_syms, static_count * sizeof (*syms));
3009       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3010     }
3011   else if (!relocatable && static_count == 0)
3012     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3013   else
3014     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3015
3016   synthetic_relocatable = relocatable;
3017   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3018
3019   if (!relocatable && symcount > 1)
3020     {
3021       long j;
3022       /* Trim duplicate syms, since we may have merged the normal and
3023          dynamic symbols.  Actually, we only care about syms that have
3024          different values, so trim any with the same value.  */
3025       for (i = 1, j = 1; i < symcount; ++i)
3026         if (syms[i - 1]->value + syms[i - 1]->section->vma
3027             != syms[i]->value + syms[i]->section->vma)
3028           syms[j++] = syms[i];
3029       symcount = j;
3030     }
3031
3032   i = 0;
3033   if (strcmp (syms[i]->section->name, ".opd") == 0)
3034     ++i;
3035   codesecsym = i;
3036
3037   for (; i < symcount; ++i)
3038     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3039          != (SEC_CODE | SEC_ALLOC))
3040         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3041       break;
3042   codesecsymend = i;
3043
3044   for (; i < symcount; ++i)
3045     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3046       break;
3047   secsymend = i;
3048
3049   for (; i < symcount; ++i)
3050     if (strcmp (syms[i]->section->name, ".opd") != 0)
3051       break;
3052   opdsymend = i;
3053
3054   for (; i < symcount; ++i)
3055     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3056         != (SEC_CODE | SEC_ALLOC))
3057       break;
3058   symcount = i;
3059
3060   count = 0;
3061
3062   if (relocatable)
3063     {
3064       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3065       arelent *r;
3066       size_t size;
3067       long relcount;
3068
3069       if (opdsymend == secsymend)
3070         goto done;
3071
3072       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3073       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3074       if (relcount == 0)
3075         goto done;
3076
3077       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3078         {
3079           count = -1;
3080           goto done;
3081         }
3082
3083       size = 0;
3084       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3085         {
3086           asymbol *sym;
3087
3088           while (r < opd->relocation + relcount
3089                  && r->address < syms[i]->value + opd->vma)
3090             ++r;
3091
3092           if (r == opd->relocation + relcount)
3093             break;
3094
3095           if (r->address != syms[i]->value + opd->vma)
3096             continue;
3097
3098           if (r->howto->type != R_PPC64_ADDR64)
3099             continue;
3100
3101           sym = *r->sym_ptr_ptr;
3102           if (!sym_exists_at (syms, opdsymend, symcount,
3103                               sym->section->id, sym->value + r->addend))
3104             {
3105               ++count;
3106               size += sizeof (asymbol);
3107               size += strlen (syms[i]->name) + 2;
3108             }
3109         }
3110
3111       s = *ret = bfd_malloc (size);
3112       if (s == NULL)
3113         {
3114           count = -1;
3115           goto done;
3116         }
3117
3118       names = (char *) (s + count);
3119
3120       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3121         {
3122           asymbol *sym;
3123
3124           while (r < opd->relocation + relcount
3125                  && r->address < syms[i]->value + opd->vma)
3126             ++r;
3127
3128           if (r == opd->relocation + relcount)
3129             break;
3130
3131           if (r->address != syms[i]->value + opd->vma)
3132             continue;
3133
3134           if (r->howto->type != R_PPC64_ADDR64)
3135             continue;
3136
3137           sym = *r->sym_ptr_ptr;
3138           if (!sym_exists_at (syms, opdsymend, symcount,
3139                               sym->section->id, sym->value + r->addend))
3140             {
3141               size_t len;
3142
3143               *s = *syms[i];
3144               s->flags |= BSF_SYNTHETIC;
3145               s->section = sym->section;
3146               s->value = sym->value + r->addend;
3147               s->name = names;
3148               *names++ = '.';
3149               len = strlen (syms[i]->name);
3150               memcpy (names, syms[i]->name, len + 1);
3151               names += len + 1;
3152               /* Have udata.p point back to the original symbol this
3153                  synthetic symbol was derived from.  */
3154               s->udata.p = syms[i];
3155               s++;
3156             }
3157         }
3158     }
3159   else
3160     {
3161       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3162       bfd_byte *contents;
3163       size_t size;
3164       long plt_count = 0;
3165       bfd_vma glink_vma = 0, resolv_vma = 0;
3166       asection *dynamic, *glink = NULL, *relplt = NULL;
3167       arelent *p;
3168
3169       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3170         {
3171           if (contents)
3172             {
3173             free_contents_and_exit:
3174               free (contents);
3175             }
3176           count = -1;
3177           goto done;
3178         }
3179
3180       size = 0;
3181       for (i = secsymend; i < opdsymend; ++i)
3182         {
3183           bfd_vma ent;
3184
3185           /* Ignore bogus symbols.  */
3186           if (syms[i]->value > opd->size - 8)
3187             continue;
3188
3189           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3190           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3191             {
3192               ++count;
3193               size += sizeof (asymbol);
3194               size += strlen (syms[i]->name) + 2;
3195             }
3196         }
3197
3198       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3199       if (dyn_count != 0
3200           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3201         {
3202           bfd_byte *dynbuf, *extdyn, *extdynend;
3203           size_t extdynsize;
3204           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3205
3206           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3207             goto free_contents_and_exit;
3208
3209           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3210           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3211
3212           extdyn = dynbuf;
3213           extdynend = extdyn + dynamic->size;
3214           for (; extdyn < extdynend; extdyn += extdynsize)
3215             {
3216               Elf_Internal_Dyn dyn;
3217               (*swap_dyn_in) (abfd, extdyn, &dyn);
3218
3219               if (dyn.d_tag == DT_NULL)
3220                 break;
3221
3222               if (dyn.d_tag == DT_PPC64_GLINK)
3223                 {
3224                   /* The first glink stub starts at offset 32; see comment in
3225                      ppc64_elf_finish_dynamic_sections. */
3226                   glink_vma = dyn.d_un.d_val + 32;
3227                   /* The .glink section usually does not survive the final
3228                      link; search for the section (usually .text) where the
3229                      glink stubs now reside.  */
3230                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3231                                                 &glink_vma);
3232                   break;
3233                 }
3234             }
3235
3236           free (dynbuf);
3237         }
3238
3239       if (glink != NULL)
3240         {
3241           /* Determine __glink trampoline by reading the relative branch
3242              from the first glink stub.  */
3243           bfd_byte buf[4];
3244           if (bfd_get_section_contents (abfd, glink, buf,
3245                                         glink_vma + 4 - glink->vma, 4))
3246             {
3247               unsigned int insn = bfd_get_32 (abfd, buf);
3248               insn ^= B_DOT;
3249               if ((insn & ~0x3fffffc) == 0)
3250                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3251             }
3252
3253           if (resolv_vma)
3254             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3255
3256           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3257           if (relplt != NULL)
3258             {
3259               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3260               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3261                 goto free_contents_and_exit;
3262
3263               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3264               size += plt_count * sizeof (asymbol);
3265
3266               p = relplt->relocation;
3267               for (i = 0; i < plt_count; i++, p++)
3268                 {
3269                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3270                   if (p->addend != 0)
3271                     size += sizeof ("+0x") - 1 + 16;
3272                 }
3273             }
3274         }
3275
3276       s = *ret = bfd_malloc (size);
3277       if (s == NULL)
3278         goto free_contents_and_exit;
3279
3280       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3281
3282       for (i = secsymend; i < opdsymend; ++i)
3283         {
3284           bfd_vma ent;
3285
3286           if (syms[i]->value > opd->size - 8)
3287             continue;
3288
3289           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3290           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3291             {
3292               long lo, hi;
3293               size_t len;
3294               asection *sec = abfd->sections;
3295
3296               *s = *syms[i];
3297               lo = codesecsym;
3298               hi = codesecsymend;
3299               while (lo < hi)
3300                 {
3301                   long mid = (lo + hi) >> 1;
3302                   if (syms[mid]->section->vma < ent)
3303                     lo = mid + 1;
3304                   else if (syms[mid]->section->vma > ent)
3305                     hi = mid;
3306                   else
3307                     {
3308                       sec = syms[mid]->section;
3309                       break;
3310                     }
3311                 }
3312
3313               if (lo >= hi && lo > codesecsym)
3314                 sec = syms[lo - 1]->section;
3315
3316               for (; sec != NULL; sec = sec->next)
3317                 {
3318                   if (sec->vma > ent)
3319                     break;
3320                   /* SEC_LOAD may not be set if SEC is from a separate debug
3321                      info file.  */
3322                   if ((sec->flags & SEC_ALLOC) == 0)
3323                     break;
3324                   if ((sec->flags & SEC_CODE) != 0)
3325                     s->section = sec;
3326                 }
3327               s->flags |= BSF_SYNTHETIC;
3328               s->value = ent - s->section->vma;
3329               s->name = names;
3330               *names++ = '.';
3331               len = strlen (syms[i]->name);
3332               memcpy (names, syms[i]->name, len + 1);
3333               names += len + 1;
3334               /* Have udata.p point back to the original symbol this
3335                  synthetic symbol was derived from.  */
3336               s->udata.p = syms[i];
3337               s++;
3338             }
3339         }
3340       free (contents);
3341
3342       if (glink != NULL && relplt != NULL)
3343         {
3344           if (resolv_vma)
3345             {
3346               /* Add a symbol for the main glink trampoline.  */
3347               memset (s, 0, sizeof *s);
3348               s->the_bfd = abfd;
3349               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3350               s->section = glink;
3351               s->value = resolv_vma - glink->vma;
3352               s->name = names;
3353               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3354               names += sizeof ("__glink_PLTresolve");
3355               s++;
3356               count++;
3357             }
3358
3359           /* FIXME: It would be very much nicer to put sym@plt on the
3360              stub rather than on the glink branch table entry.  The
3361              objdump disassembler would then use a sensible symbol
3362              name on plt calls.  The difficulty in doing so is
3363              a) finding the stubs, and,
3364              b) matching stubs against plt entries, and,
3365              c) there can be multiple stubs for a given plt entry.
3366
3367              Solving (a) could be done by code scanning, but older
3368              ppc64 binaries used different stubs to current code.
3369              (b) is the tricky one since you need to known the toc
3370              pointer for at least one function that uses a pic stub to
3371              be able to calculate the plt address referenced.
3372              (c) means gdb would need to set multiple breakpoints (or
3373              find the glink branch itself) when setting breakpoints
3374              for pending shared library loads.  */
3375           p = relplt->relocation;
3376           for (i = 0; i < plt_count; i++, p++)
3377             {
3378               size_t len;
3379
3380               *s = **p->sym_ptr_ptr;
3381               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3382                  we are defining a symbol, ensure one of them is set.  */
3383               if ((s->flags & BSF_LOCAL) == 0)
3384                 s->flags |= BSF_GLOBAL;
3385               s->flags |= BSF_SYNTHETIC;
3386               s->section = glink;
3387               s->value = glink_vma - glink->vma;
3388               s->name = names;
3389               s->udata.p = NULL;
3390               len = strlen ((*p->sym_ptr_ptr)->name);
3391               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3392               names += len;
3393               if (p->addend != 0)
3394                 {
3395                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3396                   names += sizeof ("+0x") - 1;
3397                   bfd_sprintf_vma (abfd, names, p->addend);
3398                   names += strlen (names);
3399                 }
3400               memcpy (names, "@plt", sizeof ("@plt"));
3401               names += sizeof ("@plt");
3402               s++;
3403               glink_vma += 8;
3404               if (i >= 0x8000)
3405                 glink_vma += 4;
3406             }
3407           count += plt_count;
3408         }
3409     }
3410
3411  done:
3412   free (syms);
3413   return count;
3414 }
3415 \f
3416 /* The following functions are specific to the ELF linker, while
3417    functions above are used generally.  Those named ppc64_elf_* are
3418    called by the main ELF linker code.  They appear in this file more
3419    or less in the order in which they are called.  eg.
3420    ppc64_elf_check_relocs is called early in the link process,
3421    ppc64_elf_finish_dynamic_sections is one of the last functions
3422    called.
3423
3424    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3425    functions have both a function code symbol and a function descriptor
3426    symbol.  A call to foo in a relocatable object file looks like:
3427
3428    .            .text
3429    .    x:
3430    .            bl      .foo
3431    .            nop
3432
3433    The function definition in another object file might be:
3434
3435    .            .section .opd
3436    .    foo:    .quad   .foo
3437    .            .quad   .TOC.@tocbase
3438    .            .quad   0
3439    .
3440    .            .text
3441    .    .foo:   blr
3442
3443    When the linker resolves the call during a static link, the branch
3444    unsurprisingly just goes to .foo and the .opd information is unused.
3445    If the function definition is in a shared library, things are a little
3446    different:  The call goes via a plt call stub, the opd information gets
3447    copied to the plt, and the linker patches the nop.
3448
3449    .    x:
3450    .            bl      .foo_stub
3451    .            ld      2,40(1)
3452    .
3453    .
3454    .    .foo_stub:
3455    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3456    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3457    .            std     2,40(1)                 # this is the general idea
3458    .            ld      11,0(12)
3459    .            ld      2,8(12)
3460    .            mtctr   11
3461    .            ld      11,16(12)
3462    .            bctr
3463    .
3464    .            .section .plt
3465    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3466
3467    The "reloc ()" notation is supposed to indicate that the linker emits
3468    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3469    copying.
3470
3471    What are the difficulties here?  Well, firstly, the relocations
3472    examined by the linker in check_relocs are against the function code
3473    sym .foo, while the dynamic relocation in the plt is emitted against
3474    the function descriptor symbol, foo.  Somewhere along the line, we need
3475    to carefully copy dynamic link information from one symbol to the other.
3476    Secondly, the generic part of the elf linker will make .foo a dynamic
3477    symbol as is normal for most other backends.  We need foo dynamic
3478    instead, at least for an application final link.  However, when
3479    creating a shared library containing foo, we need to have both symbols
3480    dynamic so that references to .foo are satisfied during the early
3481    stages of linking.  Otherwise the linker might decide to pull in a
3482    definition from some other object, eg. a static library.
3483
3484    Update: As of August 2004, we support a new convention.  Function
3485    calls may use the function descriptor symbol, ie. "bl foo".  This
3486    behaves exactly as "bl .foo".  */
3487
3488 /* Of those relocs that might be copied as dynamic relocs, this function
3489    selects those that must be copied when linking a shared library,
3490    even when the symbol is local.  */
3491
3492 static int
3493 must_be_dyn_reloc (struct bfd_link_info *info,
3494                    enum elf_ppc64_reloc_type r_type)
3495 {
3496   switch (r_type)
3497     {
3498     default:
3499       return 1;
3500
3501     case R_PPC64_REL32:
3502     case R_PPC64_REL64:
3503     case R_PPC64_REL30:
3504       return 0;
3505
3506     case R_PPC64_TPREL16:
3507     case R_PPC64_TPREL16_LO:
3508     case R_PPC64_TPREL16_HI:
3509     case R_PPC64_TPREL16_HA:
3510     case R_PPC64_TPREL16_DS:
3511     case R_PPC64_TPREL16_LO_DS:
3512     case R_PPC64_TPREL16_HIGHER:
3513     case R_PPC64_TPREL16_HIGHERA:
3514     case R_PPC64_TPREL16_HIGHEST:
3515     case R_PPC64_TPREL16_HIGHESTA:
3516     case R_PPC64_TPREL64:
3517       return !info->executable;
3518     }
3519 }
3520
3521 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3522    copying dynamic variables from a shared lib into an app's dynbss
3523    section, and instead use a dynamic relocation to point into the
3524    shared lib.  With code that gcc generates, it's vital that this be
3525    enabled;  In the PowerPC64 ABI, the address of a function is actually
3526    the address of a function descriptor, which resides in the .opd
3527    section.  gcc uses the descriptor directly rather than going via the
3528    GOT as some other ABI's do, which means that initialized function
3529    pointers must reference the descriptor.  Thus, a function pointer
3530    initialized to the address of a function in a shared library will
3531    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3532    redefines the function descriptor symbol to point to the copy.  This
3533    presents a problem as a plt entry for that function is also
3534    initialized from the function descriptor symbol and the copy reloc
3535    may not be initialized first.  */
3536 #define ELIMINATE_COPY_RELOCS 1
3537
3538 /* Section name for stubs is the associated section name plus this
3539    string.  */
3540 #define STUB_SUFFIX ".stub"
3541
3542 /* Linker stubs.
3543    ppc_stub_long_branch:
3544    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3545    destination, but a 24 bit branch in a stub section will reach.
3546    .    b       dest
3547
3548    ppc_stub_plt_branch:
3549    Similar to the above, but a 24 bit branch in the stub section won't
3550    reach its destination.
3551    .    addis   %r12,%r2,xxx@toc@ha
3552    .    ld      %r11,xxx@toc@l(%r12)
3553    .    mtctr   %r11
3554    .    bctr
3555
3556    ppc_stub_plt_call:
3557    Used to call a function in a shared library.  If it so happens that
3558    the plt entry referenced crosses a 64k boundary, then an extra
3559    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3560    .    addis   %r12,%r2,xxx@toc@ha
3561    .    std     %r2,40(%r1)
3562    .    ld      %r11,xxx+0@toc@l(%r12)
3563    .    mtctr   %r11
3564    .    ld      %r2,xxx+8@toc@l(%r12)
3565    .    ld      %r11,xxx+16@toc@l(%r12)
3566    .    bctr
3567
3568    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3569    code to adjust the value and save r2 to support multiple toc sections.
3570    A ppc_stub_long_branch with an r2 offset looks like:
3571    .    std     %r2,40(%r1)
3572    .    addis   %r2,%r2,off@ha
3573    .    addi    %r2,%r2,off@l
3574    .    b       dest
3575
3576    A ppc_stub_plt_branch with an r2 offset looks like:
3577    .    std     %r2,40(%r1)
3578    .    addis   %r12,%r2,xxx@toc@ha
3579    .    ld      %r11,xxx@toc@l(%r12)
3580    .    addis   %r2,%r2,off@ha
3581    .    addi    %r2,%r2,off@l
3582    .    mtctr   %r11
3583    .    bctr
3584
3585    In cases where the "addis" instruction would add zero, the "addis" is
3586    omitted and following instructions modified slightly in some cases.
3587 */
3588
3589 enum ppc_stub_type {
3590   ppc_stub_none,
3591   ppc_stub_long_branch,
3592   ppc_stub_long_branch_r2off,
3593   ppc_stub_plt_branch,
3594   ppc_stub_plt_branch_r2off,
3595   ppc_stub_plt_call,
3596   ppc_stub_plt_call_r2save
3597 };
3598
3599 struct ppc_stub_hash_entry {
3600
3601   /* Base hash table entry structure.  */
3602   struct bfd_hash_entry root;
3603
3604   enum ppc_stub_type stub_type;
3605
3606   /* The stub section.  */
3607   asection *stub_sec;
3608
3609   /* Offset within stub_sec of the beginning of this stub.  */
3610   bfd_vma stub_offset;
3611
3612   /* Given the symbol's value and its section we can determine its final
3613      value when building the stubs (so the stub knows where to jump.  */
3614   bfd_vma target_value;
3615   asection *target_section;
3616
3617   /* The symbol table entry, if any, that this was derived from.  */
3618   struct ppc_link_hash_entry *h;
3619   struct plt_entry *plt_ent;
3620
3621   /* And the reloc addend that this was derived from.  */
3622   bfd_vma addend;
3623
3624   /* Where this stub is being called from, or, in the case of combined
3625      stub sections, the first input section in the group.  */
3626   asection *id_sec;
3627 };
3628
3629 struct ppc_branch_hash_entry {
3630
3631   /* Base hash table entry structure.  */
3632   struct bfd_hash_entry root;
3633
3634   /* Offset within branch lookup table.  */
3635   unsigned int offset;
3636
3637   /* Generation marker.  */
3638   unsigned int iter;
3639 };
3640
3641 /* Used to track dynamic relocations for local symbols.  */
3642 struct ppc_dyn_relocs
3643 {
3644   struct ppc_dyn_relocs *next;
3645
3646   /* The input section of the reloc.  */
3647   asection *sec;
3648
3649   /* Total number of relocs copied for the input section.  */
3650   unsigned int count : 31;
3651
3652   /* Whether this entry is for STT_GNU_IFUNC symbols.  */
3653   unsigned int ifunc : 1;
3654 };
3655
3656 struct ppc_link_hash_entry
3657 {
3658   struct elf_link_hash_entry elf;
3659
3660   union {
3661     /* A pointer to the most recently used stub hash entry against this
3662        symbol.  */
3663     struct ppc_stub_hash_entry *stub_cache;
3664
3665     /* A pointer to the next symbol starting with a '.'  */
3666     struct ppc_link_hash_entry *next_dot_sym;
3667   } u;
3668
3669   /* Track dynamic relocs copied for this symbol.  */
3670   struct elf_dyn_relocs *dyn_relocs;
3671
3672   /* Link between function code and descriptor symbols.  */
3673   struct ppc_link_hash_entry *oh;
3674
3675   /* Flag function code and descriptor symbols.  */
3676   unsigned int is_func:1;
3677   unsigned int is_func_descriptor:1;
3678   unsigned int fake:1;
3679
3680   /* Whether global opd/toc sym has been adjusted or not.
3681      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3682      should be set for all globals defined in any opd/toc section.  */
3683   unsigned int adjust_done:1;
3684
3685   /* Set if we twiddled this symbol to weak at some stage.  */
3686   unsigned int was_undefined:1;
3687
3688   /* Contexts in which symbol is used in the GOT (or TOC).
3689      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3690      corresponding relocs are encountered during check_relocs.
3691      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3692      indicate the corresponding GOT entry type is not needed.
3693      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3694      a TPREL one.  We use a separate flag rather than setting TPREL
3695      just for convenience in distinguishing the two cases.  */
3696 #define TLS_GD           1      /* GD reloc. */
3697 #define TLS_LD           2      /* LD reloc. */
3698 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3699 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3700 #define TLS_TLS         16      /* Any TLS reloc.  */
3701 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3702 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3703 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3704   unsigned char tls_mask;
3705 };
3706
3707 /* ppc64 ELF linker hash table.  */
3708
3709 struct ppc_link_hash_table
3710 {
3711   struct elf_link_hash_table elf;
3712
3713   /* The stub hash table.  */
3714   struct bfd_hash_table stub_hash_table;
3715
3716   /* Another hash table for plt_branch stubs.  */
3717   struct bfd_hash_table branch_hash_table;
3718
3719   /* Hash table for function prologue tocsave.  */
3720   htab_t tocsave_htab;
3721
3722   /* Linker stub bfd.  */
3723   bfd *stub_bfd;
3724
3725   /* Linker call-backs.  */
3726   asection * (*add_stub_section) (const char *, asection *);
3727   void (*layout_sections_again) (void);
3728
3729   /* Array to keep track of which stub sections have been created, and
3730      information on stub grouping.  */
3731   struct map_stub {
3732     /* This is the section to which stubs in the group will be attached.  */
3733     asection *link_sec;
3734     /* The stub section.  */
3735     asection *stub_sec;
3736     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3737     bfd_vma toc_off;
3738   } *stub_group;
3739
3740   /* Temp used when calculating TOC pointers.  */
3741   bfd_vma toc_curr;
3742   bfd *toc_bfd;
3743   asection *toc_first_sec;
3744
3745   /* Highest input section id.  */
3746   int top_id;
3747
3748   /* Highest output section index.  */
3749   int top_index;
3750
3751   /* Used when adding symbols.  */
3752   struct ppc_link_hash_entry *dot_syms;
3753
3754   /* List of input sections for each output section.  */
3755   asection **input_list;
3756
3757   /* Short-cuts to get to dynamic linker sections.  */
3758   asection *got;
3759   asection *plt;
3760   asection *relplt;
3761   asection *iplt;
3762   asection *reliplt;
3763   asection *dynbss;
3764   asection *relbss;
3765   asection *glink;
3766   asection *sfpr;
3767   asection *brlt;
3768   asection *relbrlt;
3769   asection *glink_eh_frame;
3770
3771   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3772   struct ppc_link_hash_entry *tls_get_addr;
3773   struct ppc_link_hash_entry *tls_get_addr_fd;
3774
3775   /* The special .TOC. symbol.  */
3776   struct ppc_link_hash_entry *dot_toc_dot;
3777
3778   /* The size of reliplt used by got entry relocs.  */
3779   bfd_size_type got_reli_size;
3780
3781   /* Statistics.  */
3782   unsigned long stub_count[ppc_stub_plt_call_r2save];
3783
3784   /* Number of stubs against global syms.  */
3785   unsigned long stub_globals;
3786
3787   /* Alignment of PLT call stubs.  */
3788   unsigned int plt_stub_align:4;
3789
3790   /* Set if PLT call stubs should load r11.  */
3791   unsigned int plt_static_chain:1;
3792
3793   /* Set if PLT call stubs need a read-read barrier.  */
3794   unsigned int plt_thread_safe:1;
3795
3796   /* Set if we should emit symbols for stubs.  */
3797   unsigned int emit_stub_syms:1;
3798
3799   /* Set if __tls_get_addr optimization should not be done.  */
3800   unsigned int no_tls_get_addr_opt:1;
3801
3802   /* Support for multiple toc sections.  */
3803   unsigned int do_multi_toc:1;
3804   unsigned int multi_toc_needed:1;
3805   unsigned int second_toc_pass:1;
3806   unsigned int do_toc_opt:1;
3807
3808   /* Set on error.  */
3809   unsigned int stub_error:1;
3810
3811   /* Temp used by ppc64_elf_process_dot_syms.  */
3812   unsigned int twiddled_syms:1;
3813
3814   /* Incremented every time we size stubs.  */
3815   unsigned int stub_iteration;
3816
3817   /* Small local sym cache.  */
3818   struct sym_cache sym_cache;
3819 };
3820
3821 /* Rename some of the generic section flags to better document how they
3822    are used here.  */
3823
3824 /* Nonzero if this section has TLS related relocations.  */
3825 #define has_tls_reloc sec_flg0
3826
3827 /* Nonzero if this section has a call to __tls_get_addr.  */
3828 #define has_tls_get_addr_call sec_flg1
3829
3830 /* Nonzero if this section has any toc or got relocs.  */
3831 #define has_toc_reloc sec_flg2
3832
3833 /* Nonzero if this section has a call to another section that uses
3834    the toc or got.  */
3835 #define makes_toc_func_call sec_flg3
3836
3837 /* Recursion protection when determining above flag.  */
3838 #define call_check_in_progress sec_flg4
3839 #define call_check_done sec_flg5
3840
3841 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3842
3843 #define ppc_hash_table(p) \
3844   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3845   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3846
3847 #define ppc_stub_hash_lookup(table, string, create, copy) \
3848   ((struct ppc_stub_hash_entry *) \
3849    bfd_hash_lookup ((table), (string), (create), (copy)))
3850
3851 #define ppc_branch_hash_lookup(table, string, create, copy) \
3852   ((struct ppc_branch_hash_entry *) \
3853    bfd_hash_lookup ((table), (string), (create), (copy)))
3854
3855 /* Create an entry in the stub hash table.  */
3856
3857 static struct bfd_hash_entry *
3858 stub_hash_newfunc (struct bfd_hash_entry *entry,
3859                    struct bfd_hash_table *table,
3860                    const char *string)
3861 {
3862   /* Allocate the structure if it has not already been allocated by a
3863      subclass.  */
3864   if (entry == NULL)
3865     {
3866       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3867       if (entry == NULL)
3868         return entry;
3869     }
3870
3871   /* Call the allocation method of the superclass.  */
3872   entry = bfd_hash_newfunc (entry, table, string);
3873   if (entry != NULL)
3874     {
3875       struct ppc_stub_hash_entry *eh;
3876
3877       /* Initialize the local fields.  */
3878       eh = (struct ppc_stub_hash_entry *) entry;
3879       eh->stub_type = ppc_stub_none;
3880       eh->stub_sec = NULL;
3881       eh->stub_offset = 0;
3882       eh->target_value = 0;
3883       eh->target_section = NULL;
3884       eh->h = NULL;
3885       eh->id_sec = NULL;
3886     }
3887
3888   return entry;
3889 }
3890
3891 /* Create an entry in the branch hash table.  */
3892
3893 static struct bfd_hash_entry *
3894 branch_hash_newfunc (struct bfd_hash_entry *entry,
3895                      struct bfd_hash_table *table,
3896                      const char *string)
3897 {
3898   /* Allocate the structure if it has not already been allocated by a
3899      subclass.  */
3900   if (entry == NULL)
3901     {
3902       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3903       if (entry == NULL)
3904         return entry;
3905     }
3906
3907   /* Call the allocation method of the superclass.  */
3908   entry = bfd_hash_newfunc (entry, table, string);
3909   if (entry != NULL)
3910     {
3911       struct ppc_branch_hash_entry *eh;
3912
3913       /* Initialize the local fields.  */
3914       eh = (struct ppc_branch_hash_entry *) entry;
3915       eh->offset = 0;
3916       eh->iter = 0;
3917     }
3918
3919   return entry;
3920 }
3921
3922 /* Create an entry in a ppc64 ELF linker hash table.  */
3923
3924 static struct bfd_hash_entry *
3925 link_hash_newfunc (struct bfd_hash_entry *entry,
3926                    struct bfd_hash_table *table,
3927                    const char *string)
3928 {
3929   /* Allocate the structure if it has not already been allocated by a
3930      subclass.  */
3931   if (entry == NULL)
3932     {
3933       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3934       if (entry == NULL)
3935         return entry;
3936     }
3937
3938   /* Call the allocation method of the superclass.  */
3939   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3940   if (entry != NULL)
3941     {
3942       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3943
3944       memset (&eh->u.stub_cache, 0,
3945               (sizeof (struct ppc_link_hash_entry)
3946                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3947
3948       /* When making function calls, old ABI code references function entry
3949          points (dot symbols), while new ABI code references the function
3950          descriptor symbol.  We need to make any combination of reference and
3951          definition work together, without breaking archive linking.
3952
3953          For a defined function "foo" and an undefined call to "bar":
3954          An old object defines "foo" and ".foo", references ".bar" (possibly
3955          "bar" too).
3956          A new object defines "foo" and references "bar".
3957
3958          A new object thus has no problem with its undefined symbols being
3959          satisfied by definitions in an old object.  On the other hand, the
3960          old object won't have ".bar" satisfied by a new object.
3961
3962          Keep a list of newly added dot-symbols.  */
3963
3964       if (string[0] == '.')
3965         {
3966           struct ppc_link_hash_table *htab;
3967
3968           htab = (struct ppc_link_hash_table *) table;
3969           eh->u.next_dot_sym = htab->dot_syms;
3970           htab->dot_syms = eh;
3971         }
3972     }
3973
3974   return entry;
3975 }
3976
3977 struct tocsave_entry {
3978   asection *sec;
3979   bfd_vma offset;
3980 };
3981
3982 static hashval_t
3983 tocsave_htab_hash (const void *p)
3984 {
3985   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3986   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
3987 }
3988
3989 static int
3990 tocsave_htab_eq (const void *p1, const void *p2)
3991 {
3992   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3993   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3994   return e1->sec == e2->sec && e1->offset == e2->offset;
3995 }
3996
3997 /* Create a ppc64 ELF linker hash table.  */
3998
3999 static struct bfd_link_hash_table *
4000 ppc64_elf_link_hash_table_create (bfd *abfd)
4001 {
4002   struct ppc_link_hash_table *htab;
4003   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4004
4005   htab = bfd_zmalloc (amt);
4006   if (htab == NULL)
4007     return NULL;
4008
4009   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4010                                       sizeof (struct ppc_link_hash_entry),
4011                                       PPC64_ELF_DATA))
4012     {
4013       free (htab);
4014       return NULL;
4015     }
4016
4017   /* Init the stub hash table too.  */
4018   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4019                             sizeof (struct ppc_stub_hash_entry)))
4020     return NULL;
4021
4022   /* And the branch hash table.  */
4023   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4024                             sizeof (struct ppc_branch_hash_entry)))
4025     return NULL;
4026
4027   htab->tocsave_htab = htab_try_create (1024,
4028                                         tocsave_htab_hash,
4029                                         tocsave_htab_eq,
4030                                         NULL);
4031   if (htab->tocsave_htab == NULL)
4032     return NULL;
4033
4034   /* Initializing two fields of the union is just cosmetic.  We really
4035      only care about glist, but when compiled on a 32-bit host the
4036      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4037      debugger inspection of these fields look nicer.  */
4038   htab->elf.init_got_refcount.refcount = 0;
4039   htab->elf.init_got_refcount.glist = NULL;
4040   htab->elf.init_plt_refcount.refcount = 0;
4041   htab->elf.init_plt_refcount.glist = NULL;
4042   htab->elf.init_got_offset.offset = 0;
4043   htab->elf.init_got_offset.glist = NULL;
4044   htab->elf.init_plt_offset.offset = 0;
4045   htab->elf.init_plt_offset.glist = NULL;
4046
4047   return &htab->elf.root;
4048 }
4049
4050 /* Free the derived linker hash table.  */
4051
4052 static void
4053 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4054 {
4055   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4056
4057   bfd_hash_table_free (&htab->stub_hash_table);
4058   bfd_hash_table_free (&htab->branch_hash_table);
4059   if (htab->tocsave_htab)
4060     htab_delete (htab->tocsave_htab);
4061   _bfd_elf_link_hash_table_free (hash);
4062 }
4063
4064 /* Create sections for linker generated code.  */
4065
4066 static bfd_boolean
4067 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4068 {
4069   struct ppc_link_hash_table *htab;
4070   flagword flags;
4071
4072   htab = ppc_hash_table (info);
4073
4074   /* Create .sfpr for code to save and restore fp regs.  */
4075   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4076            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4077   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4078                                                    flags);
4079   if (htab->sfpr == NULL
4080       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4081     return FALSE;
4082
4083   /* Create .glink for lazy dynamic linking support.  */
4084   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4085                                                     flags);
4086   if (htab->glink == NULL
4087       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4088     return FALSE;
4089
4090   if (!info->no_ld_generated_unwind_info)
4091     {
4092       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4093                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4094       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4095                                                                  ".eh_frame",
4096                                                                  flags);
4097       if (htab->glink_eh_frame == NULL
4098           || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4099         return FALSE;
4100     }
4101
4102   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4103   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4104   if (htab->iplt == NULL
4105       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4106     return FALSE;
4107
4108   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4109            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4110   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4111                                                       ".rela.iplt",
4112                                                       flags);
4113   if (htab->reliplt == NULL
4114       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4115     return FALSE;
4116
4117   /* Create branch lookup table for plt_branch stubs.  */
4118   flags = (SEC_ALLOC | SEC_LOAD
4119            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4120   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4121                                                    flags);
4122   if (htab->brlt == NULL
4123       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4124     return FALSE;
4125
4126   if (!info->shared)
4127     return TRUE;
4128
4129   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4130            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4131   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4132                                                       ".rela.branch_lt",
4133                                                       flags);
4134   if (htab->relbrlt == NULL
4135       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4136     return FALSE;
4137
4138   return TRUE;
4139 }
4140
4141 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4142
4143 bfd_boolean
4144 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4145 {
4146   struct ppc_link_hash_table *htab;
4147
4148   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4149
4150 /* Always hook our dynamic sections into the first bfd, which is the
4151    linker created stub bfd.  This ensures that the GOT header is at
4152    the start of the output TOC section.  */
4153   htab = ppc_hash_table (info);
4154   if (htab == NULL)
4155     return FALSE;
4156   htab->stub_bfd = abfd;
4157   htab->elf.dynobj = abfd;
4158
4159   if (info->relocatable)
4160     return TRUE;
4161
4162   return create_linkage_sections (htab->elf.dynobj, info);
4163 }
4164
4165 /* Build a name for an entry in the stub hash table.  */
4166
4167 static char *
4168 ppc_stub_name (const asection *input_section,
4169                const asection *sym_sec,
4170                const struct ppc_link_hash_entry *h,
4171                const Elf_Internal_Rela *rel)
4172 {
4173   char *stub_name;
4174   ssize_t len;
4175
4176   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4177      offsets from a sym as a branch target?  In fact, we could
4178      probably assume the addend is always zero.  */
4179   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4180
4181   if (h)
4182     {
4183       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4184       stub_name = bfd_malloc (len);
4185       if (stub_name == NULL)
4186         return stub_name;
4187
4188       len = sprintf (stub_name, "%08x.%s+%x",
4189                      input_section->id & 0xffffffff,
4190                      h->elf.root.root.string,
4191                      (int) rel->r_addend & 0xffffffff);
4192     }
4193   else
4194     {
4195       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4196       stub_name = bfd_malloc (len);
4197       if (stub_name == NULL)
4198         return stub_name;
4199
4200       len = sprintf (stub_name, "%08x.%x:%x+%x",
4201                      input_section->id & 0xffffffff,
4202                      sym_sec->id & 0xffffffff,
4203                      (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4204                      (int) rel->r_addend & 0xffffffff);
4205     }
4206   if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4207     stub_name[len - 2] = 0;
4208   return stub_name;
4209 }
4210
4211 /* Look up an entry in the stub hash.  Stub entries are cached because
4212    creating the stub name takes a bit of time.  */
4213
4214 static struct ppc_stub_hash_entry *
4215 ppc_get_stub_entry (const asection *input_section,
4216                     const asection *sym_sec,
4217                     struct ppc_link_hash_entry *h,
4218                     const Elf_Internal_Rela *rel,
4219                     struct ppc_link_hash_table *htab)
4220 {
4221   struct ppc_stub_hash_entry *stub_entry;
4222   const asection *id_sec;
4223
4224   /* If this input section is part of a group of sections sharing one
4225      stub section, then use the id of the first section in the group.
4226      Stub names need to include a section id, as there may well be
4227      more than one stub used to reach say, printf, and we need to
4228      distinguish between them.  */
4229   id_sec = htab->stub_group[input_section->id].link_sec;
4230
4231   if (h != NULL && h->u.stub_cache != NULL
4232       && h->u.stub_cache->h == h
4233       && h->u.stub_cache->id_sec == id_sec)
4234     {
4235       stub_entry = h->u.stub_cache;
4236     }
4237   else
4238     {
4239       char *stub_name;
4240
4241       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4242       if (stub_name == NULL)
4243         return NULL;
4244
4245       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4246                                          stub_name, FALSE, FALSE);
4247       if (h != NULL)
4248         h->u.stub_cache = stub_entry;
4249
4250       free (stub_name);
4251     }
4252
4253   return stub_entry;
4254 }
4255
4256 /* Add a new stub entry to the stub hash.  Not all fields of the new
4257    stub entry are initialised.  */
4258
4259 static struct ppc_stub_hash_entry *
4260 ppc_add_stub (const char *stub_name,
4261               asection *section,
4262               struct bfd_link_info *info)
4263 {
4264   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4265   asection *link_sec;
4266   asection *stub_sec;
4267   struct ppc_stub_hash_entry *stub_entry;
4268
4269   link_sec = htab->stub_group[section->id].link_sec;
4270   stub_sec = htab->stub_group[section->id].stub_sec;
4271   if (stub_sec == NULL)
4272     {
4273       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4274       if (stub_sec == NULL)
4275         {
4276           size_t namelen;
4277           bfd_size_type len;
4278           char *s_name;
4279
4280           namelen = strlen (link_sec->name);
4281           len = namelen + sizeof (STUB_SUFFIX);
4282           s_name = bfd_alloc (htab->stub_bfd, len);
4283           if (s_name == NULL)
4284             return NULL;
4285
4286           memcpy (s_name, link_sec->name, namelen);
4287           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4288           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4289           if (stub_sec == NULL)
4290             return NULL;
4291           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4292         }
4293       htab->stub_group[section->id].stub_sec = stub_sec;
4294     }
4295
4296   /* Enter this entry into the linker stub hash table.  */
4297   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4298                                      TRUE, FALSE);
4299   if (stub_entry == NULL)
4300     {
4301       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4302                               section->owner, stub_name);
4303       return NULL;
4304     }
4305
4306   stub_entry->stub_sec = stub_sec;
4307   stub_entry->stub_offset = 0;
4308   stub_entry->id_sec = link_sec;
4309   return stub_entry;
4310 }
4311
4312 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4313    not already done.  */
4314
4315 static bfd_boolean
4316 create_got_section (bfd *abfd, struct bfd_link_info *info)
4317 {
4318   asection *got, *relgot;
4319   flagword flags;
4320   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4321
4322   if (!is_ppc64_elf (abfd))
4323     return FALSE;
4324   if (htab == NULL)
4325     return FALSE;
4326
4327   if (!htab->got)
4328     {
4329       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4330         return FALSE;
4331
4332       htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4333       if (!htab->got)
4334         abort ();
4335     }
4336
4337   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4338            | SEC_LINKER_CREATED);
4339
4340   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4341   if (!got
4342       || !bfd_set_section_alignment (abfd, got, 3))
4343     return FALSE;
4344
4345   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4346                                                flags | SEC_READONLY);
4347   if (!relgot
4348       || ! bfd_set_section_alignment (abfd, relgot, 3))
4349     return FALSE;
4350
4351   ppc64_elf_tdata (abfd)->got = got;
4352   ppc64_elf_tdata (abfd)->relgot = relgot;
4353   return TRUE;
4354 }
4355
4356 /* Create the dynamic sections, and set up shortcuts.  */
4357
4358 static bfd_boolean
4359 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4360 {
4361   struct ppc_link_hash_table *htab;
4362
4363   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4364     return FALSE;
4365
4366   htab = ppc_hash_table (info);
4367   if (htab == NULL)
4368     return FALSE;
4369
4370   if (!htab->got)
4371     htab->got = bfd_get_linker_section (dynobj, ".got");
4372   htab->plt = bfd_get_linker_section (dynobj, ".plt");
4373   htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4374   htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4375   if (!info->shared)
4376     htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4377
4378   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4379       || (!info->shared && !htab->relbss))
4380     abort ();
4381
4382   return TRUE;
4383 }
4384
4385 /* Follow indirect and warning symbol links.  */
4386
4387 static inline struct bfd_link_hash_entry *
4388 follow_link (struct bfd_link_hash_entry *h)
4389 {
4390   while (h->type == bfd_link_hash_indirect
4391          || h->type == bfd_link_hash_warning)
4392     h = h->u.i.link;
4393   return h;
4394 }
4395
4396 static inline struct elf_link_hash_entry *
4397 elf_follow_link (struct elf_link_hash_entry *h)
4398 {
4399   return (struct elf_link_hash_entry *) follow_link (&h->root);
4400 }
4401
4402 static inline struct ppc_link_hash_entry *
4403 ppc_follow_link (struct ppc_link_hash_entry *h)
4404 {
4405   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4406 }
4407
4408 /* Merge PLT info on FROM with that on TO.  */
4409
4410 static void
4411 move_plt_plist (struct ppc_link_hash_entry *from,
4412                 struct ppc_link_hash_entry *to)
4413 {
4414   if (from->elf.plt.plist != NULL)
4415     {
4416       if (to->elf.plt.plist != NULL)
4417         {
4418           struct plt_entry **entp;
4419           struct plt_entry *ent;
4420
4421           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4422             {
4423               struct plt_entry *dent;
4424
4425               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4426                 if (dent->addend == ent->addend)
4427                   {
4428                     dent->plt.refcount += ent->plt.refcount;
4429                     *entp = ent->next;
4430                     break;
4431                   }
4432               if (dent == NULL)
4433                 entp = &ent->next;
4434             }
4435           *entp = to->elf.plt.plist;
4436         }
4437
4438       to->elf.plt.plist = from->elf.plt.plist;
4439       from->elf.plt.plist = NULL;
4440     }
4441 }
4442
4443 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4444
4445 static void
4446 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4447                                 struct elf_link_hash_entry *dir,
4448                                 struct elf_link_hash_entry *ind)
4449 {
4450   struct ppc_link_hash_entry *edir, *eind;
4451
4452   edir = (struct ppc_link_hash_entry *) dir;
4453   eind = (struct ppc_link_hash_entry *) ind;
4454
4455   edir->is_func |= eind->is_func;
4456   edir->is_func_descriptor |= eind->is_func_descriptor;
4457   edir->tls_mask |= eind->tls_mask;
4458   if (eind->oh != NULL)
4459     edir->oh = ppc_follow_link (eind->oh);
4460
4461   /* If called to transfer flags for a weakdef during processing
4462      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4463      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4464   if (!(ELIMINATE_COPY_RELOCS
4465         && eind->elf.root.type != bfd_link_hash_indirect
4466         && edir->elf.dynamic_adjusted))
4467     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4468
4469   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4470   edir->elf.ref_regular |= eind->elf.ref_regular;
4471   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4472   edir->elf.needs_plt |= eind->elf.needs_plt;
4473
4474   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4475   if (eind->dyn_relocs != NULL)
4476     {
4477       if (edir->dyn_relocs != NULL)
4478         {
4479           struct elf_dyn_relocs **pp;
4480           struct elf_dyn_relocs *p;
4481
4482           /* Add reloc counts against the indirect sym to the direct sym
4483              list.  Merge any entries against the same section.  */
4484           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4485             {
4486               struct elf_dyn_relocs *q;
4487
4488               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4489                 if (q->sec == p->sec)
4490                   {
4491                     q->pc_count += p->pc_count;
4492                     q->count += p->count;
4493                     *pp = p->next;
4494                     break;
4495                   }
4496               if (q == NULL)
4497                 pp = &p->next;
4498             }
4499           *pp = edir->dyn_relocs;
4500         }
4501
4502       edir->dyn_relocs = eind->dyn_relocs;
4503       eind->dyn_relocs = NULL;
4504     }
4505
4506   /* If we were called to copy over info for a weak sym, that's all.
4507      You might think dyn_relocs need not be copied over;  After all,
4508      both syms will be dynamic or both non-dynamic so we're just
4509      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4510      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4511      dyn_relocs in read-only sections, and it does so on what is the
4512      DIR sym here.  */
4513   if (eind->elf.root.type != bfd_link_hash_indirect)
4514     return;
4515
4516   /* Copy over got entries that we may have already seen to the
4517      symbol which just became indirect.  */
4518   if (eind->elf.got.glist != NULL)
4519     {
4520       if (edir->elf.got.glist != NULL)
4521         {
4522           struct got_entry **entp;
4523           struct got_entry *ent;
4524
4525           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4526             {
4527               struct got_entry *dent;
4528
4529               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4530                 if (dent->addend == ent->addend
4531                     && dent->owner == ent->owner
4532                     && dent->tls_type == ent->tls_type)
4533                   {
4534                     dent->got.refcount += ent->got.refcount;
4535                     *entp = ent->next;
4536                     break;
4537                   }
4538               if (dent == NULL)
4539                 entp = &ent->next;
4540             }
4541           *entp = edir->elf.got.glist;
4542         }
4543
4544       edir->elf.got.glist = eind->elf.got.glist;
4545       eind->elf.got.glist = NULL;
4546     }
4547
4548   /* And plt entries.  */
4549   move_plt_plist (eind, edir);
4550
4551   if (eind->elf.dynindx != -1)
4552     {
4553       if (edir->elf.dynindx != -1)
4554         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4555                                 edir->elf.dynstr_index);
4556       edir->elf.dynindx = eind->elf.dynindx;
4557       edir->elf.dynstr_index = eind->elf.dynstr_index;
4558       eind->elf.dynindx = -1;
4559       eind->elf.dynstr_index = 0;
4560     }
4561 }
4562
4563 /* Find the function descriptor hash entry from the given function code
4564    hash entry FH.  Link the entries via their OH fields.  */
4565
4566 static struct ppc_link_hash_entry *
4567 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4568 {
4569   struct ppc_link_hash_entry *fdh = fh->oh;
4570
4571   if (fdh == NULL)
4572     {
4573       const char *fd_name = fh->elf.root.root.string + 1;
4574
4575       fdh = (struct ppc_link_hash_entry *)
4576         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4577       if (fdh == NULL)
4578         return fdh;
4579
4580       fdh->is_func_descriptor = 1;
4581       fdh->oh = fh;
4582       fh->is_func = 1;
4583       fh->oh = fdh;
4584     }
4585
4586   return ppc_follow_link (fdh);
4587 }
4588
4589 /* Make a fake function descriptor sym for the code sym FH.  */
4590
4591 static struct ppc_link_hash_entry *
4592 make_fdh (struct bfd_link_info *info,
4593           struct ppc_link_hash_entry *fh)
4594 {
4595   bfd *abfd;
4596   asymbol *newsym;
4597   struct bfd_link_hash_entry *bh;
4598   struct ppc_link_hash_entry *fdh;
4599
4600   abfd = fh->elf.root.u.undef.abfd;
4601   newsym = bfd_make_empty_symbol (abfd);
4602   newsym->name = fh->elf.root.root.string + 1;
4603   newsym->section = bfd_und_section_ptr;
4604   newsym->value = 0;
4605   newsym->flags = BSF_WEAK;
4606
4607   bh = NULL;
4608   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4609                                          newsym->flags, newsym->section,
4610                                          newsym->value, NULL, FALSE, FALSE,
4611                                          &bh))
4612     return NULL;
4613
4614   fdh = (struct ppc_link_hash_entry *) bh;
4615   fdh->elf.non_elf = 0;
4616   fdh->fake = 1;
4617   fdh->is_func_descriptor = 1;
4618   fdh->oh = fh;
4619   fh->is_func = 1;
4620   fh->oh = fdh;
4621   return fdh;
4622 }
4623
4624 /* Fix function descriptor symbols defined in .opd sections to be
4625    function type.  */
4626
4627 static bfd_boolean
4628 ppc64_elf_add_symbol_hook (bfd *ibfd,
4629                            struct bfd_link_info *info,
4630                            Elf_Internal_Sym *isym,
4631                            const char **name ATTRIBUTE_UNUSED,
4632                            flagword *flags ATTRIBUTE_UNUSED,
4633                            asection **sec,
4634                            bfd_vma *value ATTRIBUTE_UNUSED)
4635 {
4636   if ((ibfd->flags & DYNAMIC) == 0
4637       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4638     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4639
4640   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4641     {
4642       if ((ibfd->flags & DYNAMIC) == 0)
4643         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4644     }
4645   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4646     ;
4647   else if (*sec != NULL
4648            && strcmp ((*sec)->name, ".opd") == 0)
4649     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4650
4651   return TRUE;
4652 }
4653
4654 /* This function makes an old ABI object reference to ".bar" cause the
4655    inclusion of a new ABI object archive that defines "bar".
4656    NAME is a symbol defined in an archive.  Return a symbol in the hash
4657    table that might be satisfied by the archive symbols.  */
4658
4659 static struct elf_link_hash_entry *
4660 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4661                                  struct bfd_link_info *info,
4662                                  const char *name)
4663 {
4664   struct elf_link_hash_entry *h;
4665   char *dot_name;
4666   size_t len;
4667
4668   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4669   if (h != NULL
4670       /* Don't return this sym if it is a fake function descriptor
4671          created by add_symbol_adjust.  */
4672       && !(h->root.type == bfd_link_hash_undefweak
4673            && ((struct ppc_link_hash_entry *) h)->fake))
4674     return h;
4675
4676   if (name[0] == '.')
4677     return h;
4678
4679   len = strlen (name);
4680   dot_name = bfd_alloc (abfd, len + 2);
4681   if (dot_name == NULL)
4682     return (struct elf_link_hash_entry *) 0 - 1;
4683   dot_name[0] = '.';
4684   memcpy (dot_name + 1, name, len + 1);
4685   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4686   bfd_release (abfd, dot_name);
4687   return h;
4688 }
4689
4690 /* This function satisfies all old ABI object references to ".bar" if a
4691    new ABI object defines "bar".  Well, at least, undefined dot symbols
4692    are made weak.  This stops later archive searches from including an
4693    object if we already have a function descriptor definition.  It also
4694    prevents the linker complaining about undefined symbols.
4695    We also check and correct mismatched symbol visibility here.  The
4696    most restrictive visibility of the function descriptor and the
4697    function entry symbol is used.  */
4698
4699 static bfd_boolean
4700 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4701 {
4702   struct ppc_link_hash_table *htab;
4703   struct ppc_link_hash_entry *fdh;
4704
4705   if (eh->elf.root.type == bfd_link_hash_indirect)
4706     return TRUE;
4707
4708   if (eh->elf.root.type == bfd_link_hash_warning)
4709     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4710
4711   if (eh->elf.root.root.string[0] != '.')
4712     abort ();
4713
4714   htab = ppc_hash_table (info);
4715   if (htab == NULL)
4716     return FALSE;
4717
4718   fdh = lookup_fdh (eh, htab);
4719   if (fdh == NULL)
4720     {
4721       if (!info->relocatable
4722           && (eh->elf.root.type == bfd_link_hash_undefined
4723               || eh->elf.root.type == bfd_link_hash_undefweak)
4724           && eh->elf.ref_regular)
4725         {
4726           /* Make an undefweak function descriptor sym, which is enough to
4727              pull in an --as-needed shared lib, but won't cause link
4728              errors.  Archives are handled elsewhere.  */
4729           fdh = make_fdh (info, eh);
4730           if (fdh == NULL)
4731             return FALSE;
4732           fdh->elf.ref_regular = 1;
4733         }
4734     }
4735   else
4736     {
4737       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4738       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4739       if (entry_vis < descr_vis)
4740         fdh->elf.other += entry_vis - descr_vis;
4741       else if (entry_vis > descr_vis)
4742         eh->elf.other += descr_vis - entry_vis;
4743
4744       if ((fdh->elf.root.type == bfd_link_hash_defined
4745            || fdh->elf.root.type == bfd_link_hash_defweak)
4746           && eh->elf.root.type == bfd_link_hash_undefined)
4747         {
4748           eh->elf.root.type = bfd_link_hash_undefweak;
4749           eh->was_undefined = 1;
4750           htab->twiddled_syms = 1;
4751         }
4752     }
4753
4754   return TRUE;
4755 }
4756
4757 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4758
4759 static bfd_boolean
4760 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4761 {
4762   struct ppc_link_hash_table *htab;
4763   struct ppc_link_hash_entry **p, *eh;
4764
4765   if (!is_ppc64_elf (info->output_bfd))
4766     return TRUE;
4767   htab = ppc_hash_table (info);
4768   if (htab == NULL)
4769     return FALSE;
4770
4771   if (is_ppc64_elf (ibfd))
4772     {
4773       p = &htab->dot_syms;
4774       while ((eh = *p) != NULL)
4775         {
4776           *p = NULL;
4777           if (!add_symbol_adjust (eh, info))
4778             return FALSE;
4779           p = &eh->u.next_dot_sym;
4780         }
4781     }
4782
4783   /* Clear the list for non-ppc64 input files.  */
4784   p = &htab->dot_syms;
4785   while ((eh = *p) != NULL)
4786     {
4787       *p = NULL;
4788       p = &eh->u.next_dot_sym;
4789     }
4790
4791   /* We need to fix the undefs list for any syms we have twiddled to
4792      undef_weak.  */
4793   if (htab->twiddled_syms)
4794     {
4795       bfd_link_repair_undef_list (&htab->elf.root);
4796       htab->twiddled_syms = 0;
4797     }
4798   return TRUE;
4799 }
4800
4801 /* Undo hash table changes when an --as-needed input file is determined
4802    not to be needed.  */
4803
4804 static bfd_boolean
4805 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4806                              struct bfd_link_info *info)
4807 {
4808   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4809
4810   if (htab == NULL)
4811     return FALSE;
4812
4813   htab->dot_syms = NULL;
4814   return TRUE;
4815 }
4816
4817 /* If --just-symbols against a final linked binary, then assume we need
4818    toc adjusting stubs when calling functions defined there.  */
4819
4820 static void
4821 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4822 {
4823   if ((sec->flags & SEC_CODE) != 0
4824       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4825       && is_ppc64_elf (sec->owner))
4826     {
4827       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4828       if (got != NULL
4829           && got->size >= elf_backend_got_header_size
4830           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4831         sec->has_toc_reloc = 1;
4832     }
4833   _bfd_elf_link_just_syms (sec, info);
4834 }
4835
4836 static struct plt_entry **
4837 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4838                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4839 {
4840   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4841   struct plt_entry **local_plt;
4842   unsigned char *local_got_tls_masks;
4843
4844   if (local_got_ents == NULL)
4845     {
4846       bfd_size_type size = symtab_hdr->sh_info;
4847
4848       size *= (sizeof (*local_got_ents)
4849                + sizeof (*local_plt)
4850                + sizeof (*local_got_tls_masks));
4851       local_got_ents = bfd_zalloc (abfd, size);
4852       if (local_got_ents == NULL)
4853         return NULL;
4854       elf_local_got_ents (abfd) = local_got_ents;
4855     }
4856
4857   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4858     {
4859       struct got_entry *ent;
4860
4861       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4862         if (ent->addend == r_addend
4863             && ent->owner == abfd
4864             && ent->tls_type == tls_type)
4865           break;
4866       if (ent == NULL)
4867         {
4868           bfd_size_type amt = sizeof (*ent);
4869           ent = bfd_alloc (abfd, amt);
4870           if (ent == NULL)
4871             return FALSE;
4872           ent->next = local_got_ents[r_symndx];
4873           ent->addend = r_addend;
4874           ent->owner = abfd;
4875           ent->tls_type = tls_type;
4876           ent->is_indirect = FALSE;
4877           ent->got.refcount = 0;
4878           local_got_ents[r_symndx] = ent;
4879         }
4880       ent->got.refcount += 1;
4881     }
4882
4883   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4884   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4885   local_got_tls_masks[r_symndx] |= tls_type;
4886
4887   return local_plt + r_symndx;
4888 }
4889
4890 static bfd_boolean
4891 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4892 {
4893   struct plt_entry *ent;
4894
4895   for (ent = *plist; ent != NULL; ent = ent->next)
4896     if (ent->addend == addend)
4897       break;
4898   if (ent == NULL)
4899     {
4900       bfd_size_type amt = sizeof (*ent);
4901       ent = bfd_alloc (abfd, amt);
4902       if (ent == NULL)
4903         return FALSE;
4904       ent->next = *plist;
4905       ent->addend = addend;
4906       ent->plt.refcount = 0;
4907       *plist = ent;
4908     }
4909   ent->plt.refcount += 1;
4910   return TRUE;
4911 }
4912
4913 static bfd_boolean
4914 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4915 {
4916   return (r_type == R_PPC64_REL24
4917           || r_type == R_PPC64_REL14
4918           || r_type == R_PPC64_REL14_BRTAKEN
4919           || r_type == R_PPC64_REL14_BRNTAKEN
4920           || r_type == R_PPC64_ADDR24
4921           || r_type == R_PPC64_ADDR14
4922           || r_type == R_PPC64_ADDR14_BRTAKEN
4923           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4924 }
4925
4926 /* Look through the relocs for a section during the first phase, and
4927    calculate needed space in the global offset table, procedure
4928    linkage table, and dynamic reloc sections.  */
4929
4930 static bfd_boolean
4931 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4932                         asection *sec, const Elf_Internal_Rela *relocs)
4933 {
4934   struct ppc_link_hash_table *htab;
4935   Elf_Internal_Shdr *symtab_hdr;
4936   struct elf_link_hash_entry **sym_hashes;
4937   const Elf_Internal_Rela *rel;
4938   const Elf_Internal_Rela *rel_end;
4939   asection *sreloc;
4940   asection **opd_sym_map;
4941   struct elf_link_hash_entry *tga, *dottga;
4942
4943   if (info->relocatable)
4944     return TRUE;
4945
4946   /* Don't do anything special with non-loaded, non-alloced sections.
4947      In particular, any relocs in such sections should not affect GOT
4948      and PLT reference counting (ie. we don't allow them to create GOT
4949      or PLT entries), there's no possibility or desire to optimize TLS
4950      relocs, and there's not much point in propagating relocs to shared
4951      libs that the dynamic linker won't relocate.  */
4952   if ((sec->flags & SEC_ALLOC) == 0)
4953     return TRUE;
4954
4955   BFD_ASSERT (is_ppc64_elf (abfd));
4956
4957   htab = ppc_hash_table (info);
4958   if (htab == NULL)
4959     return FALSE;
4960
4961   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4962                               FALSE, FALSE, TRUE);
4963   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4964                                  FALSE, FALSE, TRUE);
4965   symtab_hdr = &elf_symtab_hdr (abfd);
4966   sym_hashes = elf_sym_hashes (abfd);
4967   sreloc = NULL;
4968   opd_sym_map = NULL;
4969   if (strcmp (sec->name, ".opd") == 0)
4970     {
4971       /* Garbage collection needs some extra help with .opd sections.
4972          We don't want to necessarily keep everything referenced by
4973          relocs in .opd, as that would keep all functions.  Instead,
4974          if we reference an .opd symbol (a function descriptor), we
4975          want to keep the function code symbol's section.  This is
4976          easy for global symbols, but for local syms we need to keep
4977          information about the associated function section.  */
4978       bfd_size_type amt;
4979
4980       amt = sec->size * sizeof (*opd_sym_map) / 8;
4981       opd_sym_map = bfd_zalloc (abfd, amt);
4982       if (opd_sym_map == NULL)
4983         return FALSE;
4984       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4985       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4986       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4987     }
4988
4989   rel_end = relocs + sec->reloc_count;
4990   for (rel = relocs; rel < rel_end; rel++)
4991     {
4992       unsigned long r_symndx;
4993       struct elf_link_hash_entry *h;
4994       enum elf_ppc64_reloc_type r_type;
4995       int tls_type;
4996       struct _ppc64_elf_section_data *ppc64_sec;
4997       struct plt_entry **ifunc;
4998
4999       r_symndx = ELF64_R_SYM (rel->r_info);
5000       if (r_symndx < symtab_hdr->sh_info)
5001         h = NULL;
5002       else
5003         {
5004           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5005           h = elf_follow_link (h);
5006
5007           /* PR15323, ref flags aren't set for references in the same
5008              object.  */
5009           h->root.non_ir_ref = 1;
5010         }
5011
5012       tls_type = 0;
5013       ifunc = NULL;
5014       if (h != NULL)
5015         {
5016           if (h->type == STT_GNU_IFUNC)
5017             {
5018               h->needs_plt = 1;
5019               ifunc = &h->plt.plist;
5020             }
5021         }
5022       else
5023         {
5024           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5025                                                           abfd, r_symndx);
5026           if (isym == NULL)
5027             return FALSE;
5028
5029           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5030             {
5031               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5032                                              rel->r_addend, PLT_IFUNC);
5033               if (ifunc == NULL)
5034                 return FALSE;
5035             }
5036         }
5037       r_type = ELF64_R_TYPE (rel->r_info);
5038       if (is_branch_reloc (r_type))
5039         {
5040           if (h != NULL && (h == tga || h == dottga))
5041             {
5042               if (rel != relocs
5043                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5044                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5045                 /* We have a new-style __tls_get_addr call with a marker
5046                    reloc.  */
5047                 ;
5048               else
5049                 /* Mark this section as having an old-style call.  */
5050                 sec->has_tls_get_addr_call = 1;
5051             }
5052
5053           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5054           if (ifunc != NULL
5055               && !update_plt_info (abfd, ifunc, rel->r_addend))
5056             return FALSE;
5057         }
5058
5059       switch (r_type)
5060         {
5061         case R_PPC64_TLSGD:
5062         case R_PPC64_TLSLD:
5063           /* These special tls relocs tie a call to __tls_get_addr with
5064              its parameter symbol.  */
5065           break;
5066
5067         case R_PPC64_GOT_TLSLD16:
5068         case R_PPC64_GOT_TLSLD16_LO:
5069         case R_PPC64_GOT_TLSLD16_HI:
5070         case R_PPC64_GOT_TLSLD16_HA:
5071           tls_type = TLS_TLS | TLS_LD;
5072           goto dogottls;
5073
5074         case R_PPC64_GOT_TLSGD16:
5075         case R_PPC64_GOT_TLSGD16_LO:
5076         case R_PPC64_GOT_TLSGD16_HI:
5077         case R_PPC64_GOT_TLSGD16_HA:
5078           tls_type = TLS_TLS | TLS_GD;
5079           goto dogottls;
5080
5081         case R_PPC64_GOT_TPREL16_DS:
5082         case R_PPC64_GOT_TPREL16_LO_DS:
5083         case R_PPC64_GOT_TPREL16_HI:
5084         case R_PPC64_GOT_TPREL16_HA:
5085           if (!info->executable)
5086             info->flags |= DF_STATIC_TLS;
5087           tls_type = TLS_TLS | TLS_TPREL;
5088           goto dogottls;
5089
5090         case R_PPC64_GOT_DTPREL16_DS:
5091         case R_PPC64_GOT_DTPREL16_LO_DS:
5092         case R_PPC64_GOT_DTPREL16_HI:
5093         case R_PPC64_GOT_DTPREL16_HA:
5094           tls_type = TLS_TLS | TLS_DTPREL;
5095         dogottls:
5096           sec->has_tls_reloc = 1;
5097           /* Fall thru */
5098
5099         case R_PPC64_GOT16:
5100         case R_PPC64_GOT16_DS:
5101         case R_PPC64_GOT16_HA:
5102         case R_PPC64_GOT16_HI:
5103         case R_PPC64_GOT16_LO:
5104         case R_PPC64_GOT16_LO_DS:
5105           /* This symbol requires a global offset table entry.  */
5106           sec->has_toc_reloc = 1;
5107           if (r_type == R_PPC64_GOT_TLSLD16
5108               || r_type == R_PPC64_GOT_TLSGD16
5109               || r_type == R_PPC64_GOT_TPREL16_DS
5110               || r_type == R_PPC64_GOT_DTPREL16_DS
5111               || r_type == R_PPC64_GOT16
5112               || r_type == R_PPC64_GOT16_DS)
5113             {
5114               htab->do_multi_toc = 1;
5115               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5116             }
5117
5118           if (ppc64_elf_tdata (abfd)->got == NULL
5119               && !create_got_section (abfd, info))
5120             return FALSE;
5121
5122           if (h != NULL)
5123             {
5124               struct ppc_link_hash_entry *eh;
5125               struct got_entry *ent;
5126
5127               eh = (struct ppc_link_hash_entry *) h;
5128               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5129                 if (ent->addend == rel->r_addend
5130                     && ent->owner == abfd
5131                     && ent->tls_type == tls_type)
5132                   break;
5133               if (ent == NULL)
5134                 {
5135                   bfd_size_type amt = sizeof (*ent);
5136                   ent = bfd_alloc (abfd, amt);
5137                   if (ent == NULL)
5138                     return FALSE;
5139                   ent->next = eh->elf.got.glist;
5140                   ent->addend = rel->r_addend;
5141                   ent->owner = abfd;
5142                   ent->tls_type = tls_type;
5143                   ent->is_indirect = FALSE;
5144                   ent->got.refcount = 0;
5145                   eh->elf.got.glist = ent;
5146                 }
5147               ent->got.refcount += 1;
5148               eh->tls_mask |= tls_type;
5149             }
5150           else
5151             /* This is a global offset table entry for a local symbol.  */
5152             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5153                                         rel->r_addend, tls_type))
5154               return FALSE;
5155           break;
5156
5157         case R_PPC64_PLT16_HA:
5158         case R_PPC64_PLT16_HI:
5159         case R_PPC64_PLT16_LO:
5160         case R_PPC64_PLT32:
5161         case R_PPC64_PLT64:
5162           /* This symbol requires a procedure linkage table entry.  We
5163              actually build the entry in adjust_dynamic_symbol,
5164              because this might be a case of linking PIC code without
5165              linking in any dynamic objects, in which case we don't
5166              need to generate a procedure linkage table after all.  */
5167           if (h == NULL)
5168             {
5169               /* It does not make sense to have a procedure linkage
5170                  table entry for a local symbol.  */
5171               bfd_set_error (bfd_error_bad_value);
5172               return FALSE;
5173             }
5174           else
5175             {
5176               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5177                 return FALSE;
5178               h->needs_plt = 1;
5179               if (h->root.root.string[0] == '.'
5180                   && h->root.root.string[1] != '\0')
5181                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5182             }
5183           break;
5184
5185           /* The following relocations don't need to propagate the
5186              relocation if linking a shared object since they are
5187              section relative.  */
5188         case R_PPC64_SECTOFF:
5189         case R_PPC64_SECTOFF_LO:
5190         case R_PPC64_SECTOFF_HI:
5191         case R_PPC64_SECTOFF_HA:
5192         case R_PPC64_SECTOFF_DS:
5193         case R_PPC64_SECTOFF_LO_DS:
5194         case R_PPC64_DTPREL16:
5195         case R_PPC64_DTPREL16_LO:
5196         case R_PPC64_DTPREL16_HI:
5197         case R_PPC64_DTPREL16_HA:
5198         case R_PPC64_DTPREL16_DS:
5199         case R_PPC64_DTPREL16_LO_DS:
5200         case R_PPC64_DTPREL16_HIGHER:
5201         case R_PPC64_DTPREL16_HIGHERA:
5202         case R_PPC64_DTPREL16_HIGHEST:
5203         case R_PPC64_DTPREL16_HIGHESTA:
5204           break;
5205
5206           /* Nor do these.  */
5207         case R_PPC64_REL16:
5208         case R_PPC64_REL16_LO:
5209         case R_PPC64_REL16_HI:
5210         case R_PPC64_REL16_HA:
5211           break;
5212
5213         case R_PPC64_TOC16:
5214         case R_PPC64_TOC16_DS:
5215           htab->do_multi_toc = 1;
5216           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5217         case R_PPC64_TOC16_LO:
5218         case R_PPC64_TOC16_HI:
5219         case R_PPC64_TOC16_HA:
5220         case R_PPC64_TOC16_LO_DS:
5221           sec->has_toc_reloc = 1;
5222           break;
5223
5224           /* This relocation describes the C++ object vtable hierarchy.
5225              Reconstruct it for later use during GC.  */
5226         case R_PPC64_GNU_VTINHERIT:
5227           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5228             return FALSE;
5229           break;
5230
5231           /* This relocation describes which C++ vtable entries are actually
5232              used.  Record for later use during GC.  */
5233         case R_PPC64_GNU_VTENTRY:
5234           BFD_ASSERT (h != NULL);
5235           if (h != NULL
5236               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5237             return FALSE;
5238           break;
5239
5240         case R_PPC64_REL14:
5241         case R_PPC64_REL14_BRTAKEN:
5242         case R_PPC64_REL14_BRNTAKEN:
5243           {
5244             asection *dest = NULL;
5245
5246             /* Heuristic: If jumping outside our section, chances are
5247                we are going to need a stub.  */
5248             if (h != NULL)
5249               {
5250                 /* If the sym is weak it may be overridden later, so
5251                    don't assume we know where a weak sym lives.  */
5252                 if (h->root.type == bfd_link_hash_defined)
5253                   dest = h->root.u.def.section;
5254               }
5255             else
5256               {
5257                 Elf_Internal_Sym *isym;
5258
5259                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5260                                               abfd, r_symndx);
5261                 if (isym == NULL)
5262                   return FALSE;
5263
5264                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5265               }
5266
5267             if (dest != sec)
5268               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5269           }
5270           /* Fall through.  */
5271
5272         case R_PPC64_REL24:
5273           if (h != NULL && ifunc == NULL)
5274             {
5275               /* We may need a .plt entry if the function this reloc
5276                  refers to is in a shared lib.  */
5277               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5278                 return FALSE;
5279               h->needs_plt = 1;
5280               if (h->root.root.string[0] == '.'
5281                   && h->root.root.string[1] != '\0')
5282                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5283               if (h == tga || h == dottga)
5284                 sec->has_tls_reloc = 1;
5285             }
5286           break;
5287
5288         case R_PPC64_TPREL64:
5289           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5290           if (!info->executable)
5291             info->flags |= DF_STATIC_TLS;
5292           goto dotlstoc;
5293
5294         case R_PPC64_DTPMOD64:
5295           if (rel + 1 < rel_end
5296               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5297               && rel[1].r_offset == rel->r_offset + 8)
5298             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5299           else
5300             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5301           goto dotlstoc;
5302
5303         case R_PPC64_DTPREL64:
5304           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5305           if (rel != relocs
5306               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5307               && rel[-1].r_offset == rel->r_offset - 8)
5308             /* This is the second reloc of a dtpmod, dtprel pair.
5309                Don't mark with TLS_DTPREL.  */
5310             goto dodyn;
5311
5312         dotlstoc:
5313           sec->has_tls_reloc = 1;
5314           if (h != NULL)
5315             {
5316               struct ppc_link_hash_entry *eh;
5317               eh = (struct ppc_link_hash_entry *) h;
5318               eh->tls_mask |= tls_type;
5319             }
5320           else
5321             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5322                                         rel->r_addend, tls_type))
5323               return FALSE;
5324
5325           ppc64_sec = ppc64_elf_section_data (sec);
5326           if (ppc64_sec->sec_type != sec_toc)
5327             {
5328               bfd_size_type amt;
5329
5330               /* One extra to simplify get_tls_mask.  */
5331               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5332               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5333               if (ppc64_sec->u.toc.symndx == NULL)
5334                 return FALSE;
5335               amt = sec->size * sizeof (bfd_vma) / 8;
5336               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5337               if (ppc64_sec->u.toc.add == NULL)
5338                 return FALSE;
5339               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5340               ppc64_sec->sec_type = sec_toc;
5341             }
5342           BFD_ASSERT (rel->r_offset % 8 == 0);
5343           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5344           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5345
5346           /* Mark the second slot of a GD or LD entry.
5347              -1 to indicate GD and -2 to indicate LD.  */
5348           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5349             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5350           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5351             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5352           goto dodyn;
5353
5354         case R_PPC64_TPREL16:
5355         case R_PPC64_TPREL16_LO:
5356         case R_PPC64_TPREL16_HI:
5357         case R_PPC64_TPREL16_HA:
5358         case R_PPC64_TPREL16_DS:
5359         case R_PPC64_TPREL16_LO_DS:
5360         case R_PPC64_TPREL16_HIGHER:
5361         case R_PPC64_TPREL16_HIGHERA:
5362         case R_PPC64_TPREL16_HIGHEST:
5363         case R_PPC64_TPREL16_HIGHESTA:
5364           if (info->shared)
5365             {
5366               if (!info->executable)
5367                 info->flags |= DF_STATIC_TLS;
5368               goto dodyn;
5369             }
5370           break;
5371
5372         case R_PPC64_ADDR64:
5373           if (opd_sym_map != NULL
5374               && rel + 1 < rel_end
5375               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5376             {
5377               if (h != NULL)
5378                 {
5379                   if (h->root.root.string[0] == '.'
5380                       && h->root.root.string[1] != 0
5381                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5382                     ;
5383                   else
5384                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5385                 }
5386               else
5387                 {
5388                   asection *s;
5389                   Elf_Internal_Sym *isym;
5390
5391                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5392                                                 abfd, r_symndx);
5393                   if (isym == NULL)
5394                     return FALSE;
5395
5396                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5397                   if (s != NULL && s != sec)
5398                     opd_sym_map[rel->r_offset / 8] = s;
5399                 }
5400             }
5401           /* Fall through.  */
5402
5403         case R_PPC64_REL30:
5404         case R_PPC64_REL32:
5405         case R_PPC64_REL64:
5406         case R_PPC64_ADDR14:
5407         case R_PPC64_ADDR14_BRNTAKEN:
5408         case R_PPC64_ADDR14_BRTAKEN:
5409         case R_PPC64_ADDR16:
5410         case R_PPC64_ADDR16_DS:
5411         case R_PPC64_ADDR16_HA:
5412         case R_PPC64_ADDR16_HI:
5413         case R_PPC64_ADDR16_HIGHER:
5414         case R_PPC64_ADDR16_HIGHERA:
5415         case R_PPC64_ADDR16_HIGHEST:
5416         case R_PPC64_ADDR16_HIGHESTA:
5417         case R_PPC64_ADDR16_LO:
5418         case R_PPC64_ADDR16_LO_DS:
5419         case R_PPC64_ADDR24:
5420         case R_PPC64_ADDR32:
5421         case R_PPC64_UADDR16:
5422         case R_PPC64_UADDR32:
5423         case R_PPC64_UADDR64:
5424         case R_PPC64_TOC:
5425           if (h != NULL && !info->shared)
5426             /* We may need a copy reloc.  */
5427             h->non_got_ref = 1;
5428
5429           /* Don't propagate .opd relocs.  */
5430           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5431             break;
5432
5433           /* If we are creating a shared library, and this is a reloc
5434              against a global symbol, or a non PC relative reloc
5435              against a local symbol, then we need to copy the reloc
5436              into the shared library.  However, if we are linking with
5437              -Bsymbolic, we do not need to copy a reloc against a
5438              global symbol which is defined in an object we are
5439              including in the link (i.e., DEF_REGULAR is set).  At
5440              this point we have not seen all the input files, so it is
5441              possible that DEF_REGULAR is not set now but will be set
5442              later (it is never cleared).  In case of a weak definition,
5443              DEF_REGULAR may be cleared later by a strong definition in
5444              a shared library.  We account for that possibility below by
5445              storing information in the dyn_relocs field of the hash
5446              table entry.  A similar situation occurs when creating
5447              shared libraries and symbol visibility changes render the
5448              symbol local.
5449
5450              If on the other hand, we are creating an executable, we
5451              may need to keep relocations for symbols satisfied by a
5452              dynamic library if we manage to avoid copy relocs for the
5453              symbol.  */
5454         dodyn:
5455           if ((info->shared
5456                && (must_be_dyn_reloc (info, r_type)
5457                    || (h != NULL
5458                        && (!SYMBOLIC_BIND (info, h)
5459                            || h->root.type == bfd_link_hash_defweak
5460                            || !h->def_regular))))
5461               || (ELIMINATE_COPY_RELOCS
5462                   && !info->shared
5463                   && h != NULL
5464                   && (h->root.type == bfd_link_hash_defweak
5465                       || !h->def_regular))
5466               || (!info->shared
5467                   && ifunc != NULL))
5468             {
5469               /* We must copy these reloc types into the output file.
5470                  Create a reloc section in dynobj and make room for
5471                  this reloc.  */
5472               if (sreloc == NULL)
5473                 {
5474                   sreloc = _bfd_elf_make_dynamic_reloc_section
5475                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5476
5477                   if (sreloc == NULL)
5478                     return FALSE;
5479                 }
5480
5481               /* If this is a global symbol, we count the number of
5482                  relocations we need for this symbol.  */
5483               if (h != NULL)
5484                 {
5485                   struct elf_dyn_relocs *p;
5486                   struct elf_dyn_relocs **head;
5487
5488                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5489                   p = *head;
5490                   if (p == NULL || p->sec != sec)
5491                     {
5492                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5493                       if (p == NULL)
5494                         return FALSE;
5495                       p->next = *head;
5496                       *head = p;
5497                       p->sec = sec;
5498                       p->count = 0;
5499                       p->pc_count = 0;
5500                     }
5501                   p->count += 1;
5502                   if (!must_be_dyn_reloc (info, r_type))
5503                     p->pc_count += 1;
5504                 }
5505               else
5506                 {
5507                   /* Track dynamic relocs needed for local syms too.
5508                      We really need local syms available to do this
5509                      easily.  Oh well.  */
5510                   struct ppc_dyn_relocs *p;
5511                   struct ppc_dyn_relocs **head;
5512                   bfd_boolean is_ifunc;
5513                   asection *s;
5514                   void *vpp;
5515                   Elf_Internal_Sym *isym;
5516
5517                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5518                                                 abfd, r_symndx);
5519                   if (isym == NULL)
5520                     return FALSE;
5521
5522                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5523                   if (s == NULL)
5524                     s = sec;
5525
5526                   vpp = &elf_section_data (s)->local_dynrel;
5527                   head = (struct ppc_dyn_relocs **) vpp;
5528                   is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5529                   p = *head;
5530                   if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5531                     p = p->next;
5532                   if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5533                     {
5534                       p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5535                       if (p == NULL)
5536                         return FALSE;
5537                       p->next = *head;
5538                       *head = p;
5539                       p->sec = sec;
5540                       p->ifunc = is_ifunc;
5541                       p->count = 0;
5542                     }
5543                   p->count += 1;
5544                 }
5545             }
5546           break;
5547
5548         default:
5549           break;
5550         }
5551     }
5552
5553   return TRUE;
5554 }
5555
5556 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5557    of the code entry point, and its section.  */
5558
5559 static bfd_vma
5560 opd_entry_value (asection *opd_sec,
5561                  bfd_vma offset,
5562                  asection **code_sec,
5563                  bfd_vma *code_off,
5564                  bfd_boolean in_code_sec)
5565 {
5566   bfd *opd_bfd = opd_sec->owner;
5567   Elf_Internal_Rela *relocs;
5568   Elf_Internal_Rela *lo, *hi, *look;
5569   bfd_vma val;
5570
5571   /* No relocs implies we are linking a --just-symbols object, or looking
5572      at a final linked executable with addr2line or somesuch.  */
5573   if (opd_sec->reloc_count == 0)
5574     {
5575       char buf[8];
5576
5577       if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5578         return (bfd_vma) -1;
5579
5580       val = bfd_get_64 (opd_bfd, buf);
5581       if (code_sec != NULL)
5582         {
5583           asection *sec, *likely = NULL;
5584
5585           if (in_code_sec)
5586             {
5587               sec = *code_sec;
5588               if (sec->vma <= val
5589                   && val < sec->vma + sec->size)
5590                 likely = sec;
5591               else
5592                 val = -1;
5593             }
5594           else
5595             for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5596               if (sec->vma <= val
5597                   && (sec->flags & SEC_LOAD) != 0
5598                   && (sec->flags & SEC_ALLOC) != 0)
5599                 likely = sec;
5600           if (likely != NULL)
5601             {
5602               *code_sec = likely;
5603               if (code_off != NULL)
5604                 *code_off = val - likely->vma;
5605             }
5606         }
5607       return val;
5608     }
5609
5610   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5611
5612   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5613   if (relocs == NULL)
5614     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5615
5616   /* Go find the opd reloc at the sym address.  */
5617   lo = relocs;
5618   BFD_ASSERT (lo != NULL);
5619   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5620   val = (bfd_vma) -1;
5621   while (lo < hi)
5622     {
5623       look = lo + (hi - lo) / 2;
5624       if (look->r_offset < offset)
5625         lo = look + 1;
5626       else if (look->r_offset > offset)
5627         hi = look;
5628       else
5629         {
5630           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5631
5632           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5633               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5634             {
5635               unsigned long symndx = ELF64_R_SYM (look->r_info);
5636               asection *sec;
5637
5638               if (symndx < symtab_hdr->sh_info
5639                   || elf_sym_hashes (opd_bfd) == NULL)
5640                 {
5641                   Elf_Internal_Sym *sym;
5642
5643                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5644                   if (sym == NULL)
5645                     {
5646                       size_t symcnt = symtab_hdr->sh_info;
5647                       if (elf_sym_hashes (opd_bfd) == NULL)
5648                         symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5649                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5650                                                   0, NULL, NULL, NULL);
5651                       if (sym == NULL)
5652                         break;
5653                       symtab_hdr->contents = (bfd_byte *) sym;
5654                     }
5655
5656                   sym += symndx;
5657                   val = sym->st_value;
5658                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5659                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5660                 }
5661               else
5662                 {
5663                   struct elf_link_hash_entry **sym_hashes;
5664                   struct elf_link_hash_entry *rh;
5665
5666                   sym_hashes = elf_sym_hashes (opd_bfd);
5667                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5668                   if (rh != NULL)
5669                     {
5670                       rh = elf_follow_link (rh);
5671                       BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5672                                   || rh->root.type == bfd_link_hash_defweak);
5673                       val = rh->root.u.def.value;
5674                       sec = rh->root.u.def.section;
5675                     }
5676                   else
5677                     {
5678                       /* Handle the odd case where we can be called
5679                          during bfd_elf_link_add_symbols before the
5680                          symbol hashes have been fully populated.  */
5681                       Elf_Internal_Sym *sym;
5682
5683                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5684                                                   symndx, NULL, NULL, NULL);
5685                       if (sym == NULL)
5686                         break;
5687
5688                       val = sym->st_value;
5689                       sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5690                       free (sym);
5691                     }
5692                 }
5693               val += look->r_addend;
5694               if (code_off != NULL)
5695                 *code_off = val;
5696               if (code_sec != NULL)
5697                 {
5698                   if (in_code_sec && *code_sec != sec)
5699                     return -1;
5700                   else
5701                     *code_sec = sec;
5702                 }
5703               if (sec != NULL && sec->output_section != NULL)
5704                 val += sec->output_section->vma + sec->output_offset;
5705             }
5706           break;
5707         }
5708     }
5709
5710   return val;
5711 }
5712
5713 /* If the ELF symbol SYM might be a function in SEC, return the
5714    function size and set *CODE_OFF to the function's entry point,
5715    otherwise return zero.  */
5716
5717 static bfd_size_type
5718 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5719                               bfd_vma *code_off)
5720 {
5721   bfd_size_type size;
5722
5723   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5724                      | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5725     return 0;
5726
5727   size = 0;
5728   if (!(sym->flags & BSF_SYNTHETIC))
5729     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5730
5731   if (strcmp (sym->section->name, ".opd") == 0)
5732     {
5733       if (opd_entry_value (sym->section, sym->value,
5734                            &sec, code_off, TRUE) == (bfd_vma) -1)
5735         return 0;
5736       /* An old ABI binary with dot-syms has a size of 24 on the .opd
5737          symbol.  This size has nothing to do with the code size of the
5738          function, which is what we're supposed to return, but the
5739          code size isn't available without looking up the dot-sym.
5740          However, doing that would be a waste of time particularly
5741          since elf_find_function will look at the dot-sym anyway.
5742          Now, elf_find_function will keep the largest size of any
5743          function sym found at the code address of interest, so return
5744          1 here to avoid it incorrectly caching a larger function size
5745          for a small function.  This does mean we return the wrong
5746          size for a new-ABI function of size 24, but all that does is
5747          disable caching for such functions.  */
5748       if (size == 24)
5749         size = 1;
5750     }
5751   else
5752     {
5753       if (sym->section != sec)
5754         return 0;
5755       *code_off = sym->value;
5756     }
5757   if (size == 0)
5758     size = 1;
5759   return size;
5760 }
5761
5762 /* Return true if symbol is defined in a regular object file.  */
5763
5764 static bfd_boolean
5765 is_static_defined (struct elf_link_hash_entry *h)
5766 {
5767   return ((h->root.type == bfd_link_hash_defined
5768            || h->root.type == bfd_link_hash_defweak)
5769           && h->root.u.def.section != NULL
5770           && h->root.u.def.section->output_section != NULL);
5771 }
5772
5773 /* If FDH is a function descriptor symbol, return the associated code
5774    entry symbol if it is defined.  Return NULL otherwise.  */
5775
5776 static struct ppc_link_hash_entry *
5777 defined_code_entry (struct ppc_link_hash_entry *fdh)
5778 {
5779   if (fdh->is_func_descriptor)
5780     {
5781       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5782       if (fh->elf.root.type == bfd_link_hash_defined
5783           || fh->elf.root.type == bfd_link_hash_defweak)
5784         return fh;
5785     }
5786   return NULL;
5787 }
5788
5789 /* If FH is a function code entry symbol, return the associated
5790    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5791
5792 static struct ppc_link_hash_entry *
5793 defined_func_desc (struct ppc_link_hash_entry *fh)
5794 {
5795   if (fh->oh != NULL
5796       && fh->oh->is_func_descriptor)
5797     {
5798       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5799       if (fdh->elf.root.type == bfd_link_hash_defined
5800           || fdh->elf.root.type == bfd_link_hash_defweak)
5801         return fdh;
5802     }
5803   return NULL;
5804 }
5805
5806 /* Mark all our entry sym sections, both opd and code section.  */
5807
5808 static void
5809 ppc64_elf_gc_keep (struct bfd_link_info *info)
5810 {
5811   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5812   struct bfd_sym_chain *sym;
5813
5814   if (htab == NULL)
5815     return;
5816
5817   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5818     {
5819       struct ppc_link_hash_entry *eh, *fh;
5820       asection *sec;
5821
5822       eh = (struct ppc_link_hash_entry *)
5823         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5824       if (eh == NULL)
5825         continue;
5826       if (eh->elf.root.type != bfd_link_hash_defined
5827           && eh->elf.root.type != bfd_link_hash_defweak)
5828         continue;
5829
5830       fh = defined_code_entry (eh);
5831       if (fh != NULL)
5832         {
5833           sec = fh->elf.root.u.def.section;
5834           sec->flags |= SEC_KEEP;
5835         }
5836       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5837                && opd_entry_value (eh->elf.root.u.def.section,
5838                                    eh->elf.root.u.def.value,
5839                                    &sec, NULL, FALSE) != (bfd_vma) -1)
5840         sec->flags |= SEC_KEEP;
5841
5842       sec = eh->elf.root.u.def.section;
5843       sec->flags |= SEC_KEEP;
5844     }
5845 }
5846
5847 /* Mark sections containing dynamically referenced symbols.  When
5848    building shared libraries, we must assume that any visible symbol is
5849    referenced.  */
5850
5851 static bfd_boolean
5852 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5853 {
5854   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5855   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5856   struct ppc_link_hash_entry *fdh;
5857
5858   /* Dynamic linking info is on the func descriptor sym.  */
5859   fdh = defined_func_desc (eh);
5860   if (fdh != NULL)
5861     eh = fdh;
5862
5863   if ((eh->elf.root.type == bfd_link_hash_defined
5864        || eh->elf.root.type == bfd_link_hash_defweak)
5865       && (eh->elf.ref_dynamic
5866           || (!info->executable
5867               && eh->elf.def_regular
5868               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5869               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5870               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5871                   || !bfd_hide_sym_by_version (info->version_info,
5872                                                eh->elf.root.root.string)))))
5873     {
5874       asection *code_sec;
5875       struct ppc_link_hash_entry *fh;
5876
5877       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5878
5879       /* Function descriptor syms cause the associated
5880          function code sym section to be marked.  */
5881       fh = defined_code_entry (eh);
5882       if (fh != NULL)
5883         {
5884           code_sec = fh->elf.root.u.def.section;
5885           code_sec->flags |= SEC_KEEP;
5886         }
5887       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5888                && opd_entry_value (eh->elf.root.u.def.section,
5889                                    eh->elf.root.u.def.value,
5890                                    &code_sec, NULL, FALSE) != (bfd_vma) -1)
5891         code_sec->flags |= SEC_KEEP;
5892     }
5893
5894   return TRUE;
5895 }
5896
5897 /* Return the section that should be marked against GC for a given
5898    relocation.  */
5899
5900 static asection *
5901 ppc64_elf_gc_mark_hook (asection *sec,
5902                         struct bfd_link_info *info,
5903                         Elf_Internal_Rela *rel,
5904                         struct elf_link_hash_entry *h,
5905                         Elf_Internal_Sym *sym)
5906 {
5907   asection *rsec;
5908
5909   /* Syms return NULL if we're marking .opd, so we avoid marking all
5910      function sections, as all functions are referenced in .opd.  */
5911   rsec = NULL;
5912   if (get_opd_info (sec) != NULL)
5913     return rsec;
5914
5915   if (h != NULL)
5916     {
5917       enum elf_ppc64_reloc_type r_type;
5918       struct ppc_link_hash_entry *eh, *fh, *fdh;
5919
5920       r_type = ELF64_R_TYPE (rel->r_info);
5921       switch (r_type)
5922         {
5923         case R_PPC64_GNU_VTINHERIT:
5924         case R_PPC64_GNU_VTENTRY:
5925           break;
5926
5927         default:
5928           switch (h->root.type)
5929             {
5930             case bfd_link_hash_defined:
5931             case bfd_link_hash_defweak:
5932               eh = (struct ppc_link_hash_entry *) h;
5933               fdh = defined_func_desc (eh);
5934               if (fdh != NULL)
5935                 eh = fdh;
5936
5937               /* Function descriptor syms cause the associated
5938                  function code sym section to be marked.  */
5939               fh = defined_code_entry (eh);
5940               if (fh != NULL)
5941                 {
5942                   /* They also mark their opd section.  */
5943                   eh->elf.root.u.def.section->gc_mark = 1;
5944
5945                   rsec = fh->elf.root.u.def.section;
5946                 }
5947               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5948                        && opd_entry_value (eh->elf.root.u.def.section,
5949                                            eh->elf.root.u.def.value,
5950                                            &rsec, NULL, FALSE) != (bfd_vma) -1)
5951                 eh->elf.root.u.def.section->gc_mark = 1;
5952               else
5953                 rsec = h->root.u.def.section;
5954               break;
5955
5956             case bfd_link_hash_common:
5957               rsec = h->root.u.c.p->section;
5958               break;
5959
5960             default:
5961               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5962             }
5963         }
5964     }
5965   else
5966     {
5967       struct _opd_sec_data *opd;
5968
5969       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5970       opd = get_opd_info (rsec);
5971       if (opd != NULL && opd->func_sec != NULL)
5972         {
5973           rsec->gc_mark = 1;
5974
5975           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5976         }
5977     }
5978
5979   return rsec;
5980 }
5981
5982 /* Update the .got, .plt. and dynamic reloc reference counts for the
5983    section being removed.  */
5984
5985 static bfd_boolean
5986 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5987                          asection *sec, const Elf_Internal_Rela *relocs)
5988 {
5989   struct ppc_link_hash_table *htab;
5990   Elf_Internal_Shdr *symtab_hdr;
5991   struct elf_link_hash_entry **sym_hashes;
5992   struct got_entry **local_got_ents;
5993   const Elf_Internal_Rela *rel, *relend;
5994
5995   if (info->relocatable)
5996     return TRUE;
5997
5998   if ((sec->flags & SEC_ALLOC) == 0)
5999     return TRUE;
6000
6001   elf_section_data (sec)->local_dynrel = NULL;
6002
6003   htab = ppc_hash_table (info);
6004   if (htab == NULL)
6005     return FALSE;
6006
6007   symtab_hdr = &elf_symtab_hdr (abfd);
6008   sym_hashes = elf_sym_hashes (abfd);
6009   local_got_ents = elf_local_got_ents (abfd);
6010
6011   relend = relocs + sec->reloc_count;
6012   for (rel = relocs; rel < relend; rel++)
6013     {
6014       unsigned long r_symndx;
6015       enum elf_ppc64_reloc_type r_type;
6016       struct elf_link_hash_entry *h = NULL;
6017       unsigned char tls_type = 0;
6018
6019       r_symndx = ELF64_R_SYM (rel->r_info);
6020       r_type = ELF64_R_TYPE (rel->r_info);
6021       if (r_symndx >= symtab_hdr->sh_info)
6022         {
6023           struct ppc_link_hash_entry *eh;
6024           struct elf_dyn_relocs **pp;
6025           struct elf_dyn_relocs *p;
6026
6027           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6028           h = elf_follow_link (h);
6029           eh = (struct ppc_link_hash_entry *) h;
6030
6031           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6032             if (p->sec == sec)
6033               {
6034                 /* Everything must go for SEC.  */
6035                 *pp = p->next;
6036                 break;
6037               }
6038         }
6039
6040       if (is_branch_reloc (r_type))
6041         {
6042           struct plt_entry **ifunc = NULL;
6043           if (h != NULL)
6044             {
6045               if (h->type == STT_GNU_IFUNC)
6046                 ifunc = &h->plt.plist;
6047             }
6048           else if (local_got_ents != NULL)
6049             {
6050               struct plt_entry **local_plt = (struct plt_entry **)
6051                 (local_got_ents + symtab_hdr->sh_info);
6052               unsigned char *local_got_tls_masks = (unsigned char *)
6053                 (local_plt + symtab_hdr->sh_info);
6054               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6055                 ifunc = local_plt + r_symndx;
6056             }
6057           if (ifunc != NULL)
6058             {
6059               struct plt_entry *ent;
6060
6061               for (ent = *ifunc; ent != NULL; ent = ent->next)
6062                 if (ent->addend == rel->r_addend)
6063                   break;
6064               if (ent == NULL)
6065                 abort ();
6066               if (ent->plt.refcount > 0)
6067                 ent->plt.refcount -= 1;
6068               continue;
6069             }
6070         }
6071
6072       switch (r_type)
6073         {
6074         case R_PPC64_GOT_TLSLD16:
6075         case R_PPC64_GOT_TLSLD16_LO:
6076         case R_PPC64_GOT_TLSLD16_HI:
6077         case R_PPC64_GOT_TLSLD16_HA:
6078           tls_type = TLS_TLS | TLS_LD;
6079           goto dogot;
6080
6081         case R_PPC64_GOT_TLSGD16:
6082         case R_PPC64_GOT_TLSGD16_LO:
6083         case R_PPC64_GOT_TLSGD16_HI:
6084         case R_PPC64_GOT_TLSGD16_HA:
6085           tls_type = TLS_TLS | TLS_GD;
6086           goto dogot;
6087
6088         case R_PPC64_GOT_TPREL16_DS:
6089         case R_PPC64_GOT_TPREL16_LO_DS:
6090         case R_PPC64_GOT_TPREL16_HI:
6091         case R_PPC64_GOT_TPREL16_HA:
6092           tls_type = TLS_TLS | TLS_TPREL;
6093           goto dogot;
6094
6095         case R_PPC64_GOT_DTPREL16_DS:
6096         case R_PPC64_GOT_DTPREL16_LO_DS:
6097         case R_PPC64_GOT_DTPREL16_HI:
6098         case R_PPC64_GOT_DTPREL16_HA:
6099           tls_type = TLS_TLS | TLS_DTPREL;
6100           goto dogot;
6101
6102         case R_PPC64_GOT16:
6103         case R_PPC64_GOT16_DS:
6104         case R_PPC64_GOT16_HA:
6105         case R_PPC64_GOT16_HI:
6106         case R_PPC64_GOT16_LO:
6107         case R_PPC64_GOT16_LO_DS:
6108         dogot:
6109           {
6110             struct got_entry *ent;
6111
6112             if (h != NULL)
6113               ent = h->got.glist;
6114             else
6115               ent = local_got_ents[r_symndx];
6116
6117             for (; ent != NULL; ent = ent->next)
6118               if (ent->addend == rel->r_addend
6119                   && ent->owner == abfd
6120                   && ent->tls_type == tls_type)
6121                 break;
6122             if (ent == NULL)
6123               abort ();
6124             if (ent->got.refcount > 0)
6125               ent->got.refcount -= 1;
6126           }
6127           break;
6128
6129         case R_PPC64_PLT16_HA:
6130         case R_PPC64_PLT16_HI:
6131         case R_PPC64_PLT16_LO:
6132         case R_PPC64_PLT32:
6133         case R_PPC64_PLT64:
6134         case R_PPC64_REL14:
6135         case R_PPC64_REL14_BRNTAKEN:
6136         case R_PPC64_REL14_BRTAKEN:
6137         case R_PPC64_REL24:
6138           if (h != NULL)
6139             {
6140               struct plt_entry *ent;
6141
6142               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6143                 if (ent->addend == rel->r_addend)
6144                   break;
6145               if (ent != NULL && ent->plt.refcount > 0)
6146                 ent->plt.refcount -= 1;
6147             }
6148           break;
6149
6150         default:
6151           break;
6152         }
6153     }
6154   return TRUE;
6155 }
6156
6157 /* The maximum size of .sfpr.  */
6158 #define SFPR_MAX (218*4)
6159
6160 struct sfpr_def_parms
6161 {
6162   const char name[12];
6163   unsigned char lo, hi;
6164   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6165   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6166 };
6167
6168 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6169
6170 static bfd_boolean
6171 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6172 {
6173   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6174   unsigned int i;
6175   size_t len = strlen (parm->name);
6176   bfd_boolean writing = FALSE;
6177   char sym[16];
6178
6179   if (htab == NULL)
6180     return FALSE;
6181
6182   memcpy (sym, parm->name, len);
6183   sym[len + 2] = 0;
6184
6185   for (i = parm->lo; i <= parm->hi; i++)
6186     {
6187       struct elf_link_hash_entry *h;
6188
6189       sym[len + 0] = i / 10 + '0';
6190       sym[len + 1] = i % 10 + '0';
6191       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6192       if (h != NULL
6193           && !h->def_regular)
6194         {
6195           h->root.type = bfd_link_hash_defined;
6196           h->root.u.def.section = htab->sfpr;
6197           h->root.u.def.value = htab->sfpr->size;
6198           h->type = STT_FUNC;
6199           h->def_regular = 1;
6200           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6201           writing = TRUE;
6202           if (htab->sfpr->contents == NULL)
6203             {
6204               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6205               if (htab->sfpr->contents == NULL)
6206                 return FALSE;
6207             }
6208         }
6209       if (writing)
6210         {
6211           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6212           if (i != parm->hi)
6213             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6214           else
6215             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6216           htab->sfpr->size = p - htab->sfpr->contents;
6217         }
6218     }
6219
6220   return TRUE;
6221 }
6222
6223 static bfd_byte *
6224 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6225 {
6226   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6227   return p + 4;
6228 }
6229
6230 static bfd_byte *
6231 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6232 {
6233   p = savegpr0 (abfd, p, r);
6234   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6235   p = p + 4;
6236   bfd_put_32 (abfd, BLR, p);
6237   return p + 4;
6238 }
6239
6240 static bfd_byte *
6241 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6242 {
6243   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6244   return p + 4;
6245 }
6246
6247 static bfd_byte *
6248 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6249 {
6250   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6251   p = p + 4;
6252   p = restgpr0 (abfd, p, r);
6253   bfd_put_32 (abfd, MTLR_R0, p);
6254   p = p + 4;
6255   if (r == 29)
6256     {
6257       p = restgpr0 (abfd, p, 30);
6258       p = restgpr0 (abfd, p, 31);
6259     }
6260   bfd_put_32 (abfd, BLR, p);
6261   return p + 4;
6262 }
6263
6264 static bfd_byte *
6265 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6266 {
6267   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6268   return p + 4;
6269 }
6270
6271 static bfd_byte *
6272 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6273 {
6274   p = savegpr1 (abfd, p, r);
6275   bfd_put_32 (abfd, BLR, p);
6276   return p + 4;
6277 }
6278
6279 static bfd_byte *
6280 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6281 {
6282   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6283   return p + 4;
6284 }
6285
6286 static bfd_byte *
6287 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6288 {
6289   p = restgpr1 (abfd, p, r);
6290   bfd_put_32 (abfd, BLR, p);
6291   return p + 4;
6292 }
6293
6294 static bfd_byte *
6295 savefpr (bfd *abfd, bfd_byte *p, int r)
6296 {
6297   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6298   return p + 4;
6299 }
6300
6301 static bfd_byte *
6302 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6303 {
6304   p = savefpr (abfd, p, r);
6305   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6306   p = p + 4;
6307   bfd_put_32 (abfd, BLR, p);
6308   return p + 4;
6309 }
6310
6311 static bfd_byte *
6312 restfpr (bfd *abfd, bfd_byte *p, int r)
6313 {
6314   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6315   return p + 4;
6316 }
6317
6318 static bfd_byte *
6319 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6320 {
6321   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6322   p = p + 4;
6323   p = restfpr (abfd, p, r);
6324   bfd_put_32 (abfd, MTLR_R0, p);
6325   p = p + 4;
6326   if (r == 29)
6327     {
6328       p = restfpr (abfd, p, 30);
6329       p = restfpr (abfd, p, 31);
6330     }
6331   bfd_put_32 (abfd, BLR, p);
6332   return p + 4;
6333 }
6334
6335 static bfd_byte *
6336 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6337 {
6338   p = savefpr (abfd, p, r);
6339   bfd_put_32 (abfd, BLR, p);
6340   return p + 4;
6341 }
6342
6343 static bfd_byte *
6344 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6345 {
6346   p = restfpr (abfd, p, r);
6347   bfd_put_32 (abfd, BLR, p);
6348   return p + 4;
6349 }
6350
6351 static bfd_byte *
6352 savevr (bfd *abfd, bfd_byte *p, int r)
6353 {
6354   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6355   p = p + 4;
6356   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6357   return p + 4;
6358 }
6359
6360 static bfd_byte *
6361 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6362 {
6363   p = savevr (abfd, p, r);
6364   bfd_put_32 (abfd, BLR, p);
6365   return p + 4;
6366 }
6367
6368 static bfd_byte *
6369 restvr (bfd *abfd, bfd_byte *p, int r)
6370 {
6371   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6372   p = p + 4;
6373   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6374   return p + 4;
6375 }
6376
6377 static bfd_byte *
6378 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6379 {
6380   p = restvr (abfd, p, r);
6381   bfd_put_32 (abfd, BLR, p);
6382   return p + 4;
6383 }
6384
6385 /* Called via elf_link_hash_traverse to transfer dynamic linking
6386    information on function code symbol entries to their corresponding
6387    function descriptor symbol entries.  */
6388
6389 static bfd_boolean
6390 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6391 {
6392   struct bfd_link_info *info;
6393   struct ppc_link_hash_table *htab;
6394   struct plt_entry *ent;
6395   struct ppc_link_hash_entry *fh;
6396   struct ppc_link_hash_entry *fdh;
6397   bfd_boolean force_local;
6398
6399   fh = (struct ppc_link_hash_entry *) h;
6400   if (fh->elf.root.type == bfd_link_hash_indirect)
6401     return TRUE;
6402
6403   info = inf;
6404   htab = ppc_hash_table (info);
6405   if (htab == NULL)
6406     return FALSE;
6407
6408   /* Resolve undefined references to dot-symbols as the value
6409      in the function descriptor, if we have one in a regular object.
6410      This is to satisfy cases like ".quad .foo".  Calls to functions
6411      in dynamic objects are handled elsewhere.  */
6412   if (fh->elf.root.type == bfd_link_hash_undefweak
6413       && fh->was_undefined
6414       && (fdh = defined_func_desc (fh)) != NULL
6415       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6416       && opd_entry_value (fdh->elf.root.u.def.section,
6417                           fdh->elf.root.u.def.value,
6418                           &fh->elf.root.u.def.section,
6419                           &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6420     {
6421       fh->elf.root.type = fdh->elf.root.type;
6422       fh->elf.forced_local = 1;
6423       fh->elf.def_regular = fdh->elf.def_regular;
6424       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6425     }
6426
6427   /* If this is a function code symbol, transfer dynamic linking
6428      information to the function descriptor symbol.  */
6429   if (!fh->is_func)
6430     return TRUE;
6431
6432   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6433     if (ent->plt.refcount > 0)
6434       break;
6435   if (ent == NULL
6436       || fh->elf.root.root.string[0] != '.'
6437       || fh->elf.root.root.string[1] == '\0')
6438     return TRUE;
6439
6440   /* Find the corresponding function descriptor symbol.  Create it
6441      as undefined if necessary.  */
6442
6443   fdh = lookup_fdh (fh, htab);
6444   if (fdh == NULL
6445       && !info->executable
6446       && (fh->elf.root.type == bfd_link_hash_undefined
6447           || fh->elf.root.type == bfd_link_hash_undefweak))
6448     {
6449       fdh = make_fdh (info, fh);
6450       if (fdh == NULL)
6451         return FALSE;
6452     }
6453
6454   /* Fake function descriptors are made undefweak.  If the function
6455      code symbol is strong undefined, make the fake sym the same.
6456      If the function code symbol is defined, then force the fake
6457      descriptor local;  We can't support overriding of symbols in a
6458      shared library on a fake descriptor.  */
6459
6460   if (fdh != NULL
6461       && fdh->fake
6462       && fdh->elf.root.type == bfd_link_hash_undefweak)
6463     {
6464       if (fh->elf.root.type == bfd_link_hash_undefined)
6465         {
6466           fdh->elf.root.type = bfd_link_hash_undefined;
6467           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6468         }
6469       else if (fh->elf.root.type == bfd_link_hash_defined
6470                || fh->elf.root.type == bfd_link_hash_defweak)
6471         {
6472           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6473         }
6474     }
6475
6476   if (fdh != NULL
6477       && !fdh->elf.forced_local
6478       && (!info->executable
6479           || fdh->elf.def_dynamic
6480           || fdh->elf.ref_dynamic
6481           || (fdh->elf.root.type == bfd_link_hash_undefweak
6482               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6483     {
6484       if (fdh->elf.dynindx == -1)
6485         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6486           return FALSE;
6487       fdh->elf.ref_regular |= fh->elf.ref_regular;
6488       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6489       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6490       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6491       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6492         {
6493           move_plt_plist (fh, fdh);
6494           fdh->elf.needs_plt = 1;
6495         }
6496       fdh->is_func_descriptor = 1;
6497       fdh->oh = fh;
6498       fh->oh = fdh;
6499     }
6500
6501   /* Now that the info is on the function descriptor, clear the
6502      function code sym info.  Any function code syms for which we
6503      don't have a definition in a regular file, we force local.
6504      This prevents a shared library from exporting syms that have
6505      been imported from another library.  Function code syms that
6506      are really in the library we must leave global to prevent the
6507      linker dragging in a definition from a static library.  */
6508   force_local = (!fh->elf.def_regular
6509                  || fdh == NULL
6510                  || !fdh->elf.def_regular
6511                  || fdh->elf.forced_local);
6512   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6513
6514   return TRUE;
6515 }
6516
6517 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6518    this hook to a) provide some gcc support functions, and b) transfer
6519    dynamic linking information gathered so far on function code symbol
6520    entries, to their corresponding function descriptor symbol entries.  */
6521
6522 static bfd_boolean
6523 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6524                             struct bfd_link_info *info)
6525 {
6526   struct ppc_link_hash_table *htab;
6527   unsigned int i;
6528   static const struct sfpr_def_parms funcs[] =
6529     {
6530       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6531       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6532       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6533       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6534       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6535       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6536       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6537       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6538       { "._savef", 14, 31, savefpr, savefpr1_tail },
6539       { "._restf", 14, 31, restfpr, restfpr1_tail },
6540       { "_savevr_", 20, 31, savevr, savevr_tail },
6541       { "_restvr_", 20, 31, restvr, restvr_tail }
6542     };
6543
6544   htab = ppc_hash_table (info);
6545   if (htab == NULL)
6546     return FALSE;
6547
6548   if (htab->sfpr == NULL)
6549     /* We don't have any relocs.  */
6550     return TRUE;
6551
6552   /* Provide any missing _save* and _rest* functions.  */
6553   htab->sfpr->size = 0;
6554   if (!info->relocatable)
6555     for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6556       if (!sfpr_define (info, &funcs[i]))
6557         return FALSE;
6558
6559   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6560
6561   if (htab->sfpr->size == 0)
6562     htab->sfpr->flags |= SEC_EXCLUDE;
6563
6564   return TRUE;
6565 }
6566
6567 /* Adjust a symbol defined by a dynamic object and referenced by a
6568    regular object.  The current definition is in some section of the
6569    dynamic object, but we're not including those sections.  We have to
6570    change the definition to something the rest of the link can
6571    understand.  */
6572
6573 static bfd_boolean
6574 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6575                                  struct elf_link_hash_entry *h)
6576 {
6577   struct ppc_link_hash_table *htab;
6578   asection *s;
6579
6580   htab = ppc_hash_table (info);
6581   if (htab == NULL)
6582     return FALSE;
6583
6584   /* Deal with function syms.  */
6585   if (h->type == STT_FUNC
6586       || h->type == STT_GNU_IFUNC
6587       || h->needs_plt)
6588     {
6589       /* Clear procedure linkage table information for any symbol that
6590          won't need a .plt entry.  */
6591       struct plt_entry *ent;
6592       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6593         if (ent->plt.refcount > 0)
6594           break;
6595       if (ent == NULL
6596           || (h->type != STT_GNU_IFUNC
6597               && (SYMBOL_CALLS_LOCAL (info, h)
6598                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6599                       && h->root.type == bfd_link_hash_undefweak))))
6600         {
6601           h->plt.plist = NULL;
6602           h->needs_plt = 0;
6603         }
6604     }
6605   else
6606     h->plt.plist = NULL;
6607
6608   /* If this is a weak symbol, and there is a real definition, the
6609      processor independent code will have arranged for us to see the
6610      real definition first, and we can just use the same value.  */
6611   if (h->u.weakdef != NULL)
6612     {
6613       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6614                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6615       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6616       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6617       if (ELIMINATE_COPY_RELOCS)
6618         h->non_got_ref = h->u.weakdef->non_got_ref;
6619       return TRUE;
6620     }
6621
6622   /* If we are creating a shared library, we must presume that the
6623      only references to the symbol are via the global offset table.
6624      For such cases we need not do anything here; the relocations will
6625      be handled correctly by relocate_section.  */
6626   if (info->shared)
6627     return TRUE;
6628
6629   /* If there are no references to this symbol that do not use the
6630      GOT, we don't need to generate a copy reloc.  */
6631   if (!h->non_got_ref)
6632     return TRUE;
6633
6634   /* Don't generate a copy reloc for symbols defined in the executable.  */
6635   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6636     return TRUE;
6637
6638   if (ELIMINATE_COPY_RELOCS)
6639     {
6640       struct ppc_link_hash_entry * eh;
6641       struct elf_dyn_relocs *p;
6642
6643       eh = (struct ppc_link_hash_entry *) h;
6644       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6645         {
6646           s = p->sec->output_section;
6647           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6648             break;
6649         }
6650
6651       /* If we didn't find any dynamic relocs in read-only sections, then
6652          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6653       if (p == NULL)
6654         {
6655           h->non_got_ref = 0;
6656           return TRUE;
6657         }
6658     }
6659
6660   if (h->plt.plist != NULL)
6661     {
6662       /* We should never get here, but unfortunately there are versions
6663          of gcc out there that improperly (for this ABI) put initialized
6664          function pointers, vtable refs and suchlike in read-only
6665          sections.  Allow them to proceed, but warn that this might
6666          break at runtime.  */
6667       info->callbacks->einfo
6668         (_("%P: copy reloc against `%T' requires lazy plt linking; "
6669            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6670          h->root.root.string);
6671     }
6672
6673   /* This is a reference to a symbol defined by a dynamic object which
6674      is not a function.  */
6675
6676   /* We must allocate the symbol in our .dynbss section, which will
6677      become part of the .bss section of the executable.  There will be
6678      an entry for this symbol in the .dynsym section.  The dynamic
6679      object will contain position independent code, so all references
6680      from the dynamic object to this symbol will go through the global
6681      offset table.  The dynamic linker will use the .dynsym entry to
6682      determine the address it must put in the global offset table, so
6683      both the dynamic object and the regular object will refer to the
6684      same memory location for the variable.  */
6685
6686   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6687      to copy the initial value out of the dynamic object and into the
6688      runtime process image.  We need to remember the offset into the
6689      .rela.bss section we are going to use.  */
6690   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6691     {
6692       htab->relbss->size += sizeof (Elf64_External_Rela);
6693       h->needs_copy = 1;
6694     }
6695
6696   s = htab->dynbss;
6697
6698   return _bfd_elf_adjust_dynamic_copy (h, s);
6699 }
6700
6701 /* If given a function descriptor symbol, hide both the function code
6702    sym and the descriptor.  */
6703 static void
6704 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6705                        struct elf_link_hash_entry *h,
6706                        bfd_boolean force_local)
6707 {
6708   struct ppc_link_hash_entry *eh;
6709   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6710
6711   eh = (struct ppc_link_hash_entry *) h;
6712   if (eh->is_func_descriptor)
6713     {
6714       struct ppc_link_hash_entry *fh = eh->oh;
6715
6716       if (fh == NULL)
6717         {
6718           const char *p, *q;
6719           struct ppc_link_hash_table *htab;
6720           char save;
6721
6722           /* We aren't supposed to use alloca in BFD because on
6723              systems which do not have alloca the version in libiberty
6724              calls xmalloc, which might cause the program to crash
6725              when it runs out of memory.  This function doesn't have a
6726              return status, so there's no way to gracefully return an
6727              error.  So cheat.  We know that string[-1] can be safely
6728              accessed;  It's either a string in an ELF string table,
6729              or allocated in an objalloc structure.  */
6730
6731           p = eh->elf.root.root.string - 1;
6732           save = *p;
6733           *(char *) p = '.';
6734           htab = ppc_hash_table (info);
6735           if (htab == NULL)
6736             return;
6737
6738           fh = (struct ppc_link_hash_entry *)
6739             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6740           *(char *) p = save;
6741
6742           /* Unfortunately, if it so happens that the string we were
6743              looking for was allocated immediately before this string,
6744              then we overwrote the string terminator.  That's the only
6745              reason the lookup should fail.  */
6746           if (fh == NULL)
6747             {
6748               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6749               while (q >= eh->elf.root.root.string && *q == *p)
6750                 --q, --p;
6751               if (q < eh->elf.root.root.string && *p == '.')
6752                 fh = (struct ppc_link_hash_entry *)
6753                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6754             }
6755           if (fh != NULL)
6756             {
6757               eh->oh = fh;
6758               fh->oh = eh;
6759             }
6760         }
6761       if (fh != NULL)
6762         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6763     }
6764 }
6765
6766 static bfd_boolean
6767 get_sym_h (struct elf_link_hash_entry **hp,
6768            Elf_Internal_Sym **symp,
6769            asection **symsecp,
6770            unsigned char **tls_maskp,
6771            Elf_Internal_Sym **locsymsp,
6772            unsigned long r_symndx,
6773            bfd *ibfd)
6774 {
6775   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6776
6777   if (r_symndx >= symtab_hdr->sh_info)
6778     {
6779       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6780       struct elf_link_hash_entry *h;
6781
6782       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6783       h = elf_follow_link (h);
6784
6785       if (hp != NULL)
6786         *hp = h;
6787
6788       if (symp != NULL)
6789         *symp = NULL;
6790
6791       if (symsecp != NULL)
6792         {
6793           asection *symsec = NULL;
6794           if (h->root.type == bfd_link_hash_defined
6795               || h->root.type == bfd_link_hash_defweak)
6796             symsec = h->root.u.def.section;
6797           *symsecp = symsec;
6798         }
6799
6800       if (tls_maskp != NULL)
6801         {
6802           struct ppc_link_hash_entry *eh;
6803
6804           eh = (struct ppc_link_hash_entry *) h;
6805           *tls_maskp = &eh->tls_mask;
6806         }
6807     }
6808   else
6809     {
6810       Elf_Internal_Sym *sym;
6811       Elf_Internal_Sym *locsyms = *locsymsp;
6812
6813       if (locsyms == NULL)
6814         {
6815           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6816           if (locsyms == NULL)
6817             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6818                                             symtab_hdr->sh_info,
6819                                             0, NULL, NULL, NULL);
6820           if (locsyms == NULL)
6821             return FALSE;
6822           *locsymsp = locsyms;
6823         }
6824       sym = locsyms + r_symndx;
6825
6826       if (hp != NULL)
6827         *hp = NULL;
6828
6829       if (symp != NULL)
6830         *symp = sym;
6831
6832       if (symsecp != NULL)
6833         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6834
6835       if (tls_maskp != NULL)
6836         {
6837           struct got_entry **lgot_ents;
6838           unsigned char *tls_mask;
6839
6840           tls_mask = NULL;
6841           lgot_ents = elf_local_got_ents (ibfd);
6842           if (lgot_ents != NULL)
6843             {
6844               struct plt_entry **local_plt = (struct plt_entry **)
6845                 (lgot_ents + symtab_hdr->sh_info);
6846               unsigned char *lgot_masks = (unsigned char *)
6847                 (local_plt + symtab_hdr->sh_info);
6848               tls_mask = &lgot_masks[r_symndx];
6849             }
6850           *tls_maskp = tls_mask;
6851         }
6852     }
6853   return TRUE;
6854 }
6855
6856 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6857    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6858    type suitable for optimization, and 1 otherwise.  */
6859
6860 static int
6861 get_tls_mask (unsigned char **tls_maskp,
6862               unsigned long *toc_symndx,
6863               bfd_vma *toc_addend,
6864               Elf_Internal_Sym **locsymsp,
6865               const Elf_Internal_Rela *rel,
6866               bfd *ibfd)
6867 {
6868   unsigned long r_symndx;
6869   int next_r;
6870   struct elf_link_hash_entry *h;
6871   Elf_Internal_Sym *sym;
6872   asection *sec;
6873   bfd_vma off;
6874
6875   r_symndx = ELF64_R_SYM (rel->r_info);
6876   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6877     return 0;
6878
6879   if ((*tls_maskp != NULL && **tls_maskp != 0)
6880       || sec == NULL
6881       || ppc64_elf_section_data (sec) == NULL
6882       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6883     return 1;
6884
6885   /* Look inside a TOC section too.  */
6886   if (h != NULL)
6887     {
6888       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6889       off = h->root.u.def.value;
6890     }
6891   else
6892     off = sym->st_value;
6893   off += rel->r_addend;
6894   BFD_ASSERT (off % 8 == 0);
6895   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6896   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6897   if (toc_symndx != NULL)
6898     *toc_symndx = r_symndx;
6899   if (toc_addend != NULL)
6900     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6901   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6902     return 0;
6903   if ((h == NULL || is_static_defined (h))
6904       && (next_r == -1 || next_r == -2))
6905     return 1 - next_r;
6906   return 1;
6907 }
6908
6909 /* Find (or create) an entry in the tocsave hash table.  */
6910
6911 static struct tocsave_entry *
6912 tocsave_find (struct ppc_link_hash_table *htab,
6913               enum insert_option insert,
6914               Elf_Internal_Sym **local_syms,
6915               const Elf_Internal_Rela *irela,
6916               bfd *ibfd)
6917 {
6918   unsigned long r_indx;
6919   struct elf_link_hash_entry *h;
6920   Elf_Internal_Sym *sym;
6921   struct tocsave_entry ent, *p;
6922   hashval_t hash;
6923   struct tocsave_entry **slot;
6924
6925   r_indx = ELF64_R_SYM (irela->r_info);
6926   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6927     return NULL;
6928   if (ent.sec == NULL || ent.sec->output_section == NULL)
6929     {
6930       (*_bfd_error_handler)
6931         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6932       return NULL;
6933     }
6934
6935   if (h != NULL)
6936     ent.offset = h->root.u.def.value;
6937   else
6938     ent.offset = sym->st_value;
6939   ent.offset += irela->r_addend;
6940
6941   hash = tocsave_htab_hash (&ent);
6942   slot = ((struct tocsave_entry **)
6943           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6944   if (slot == NULL)
6945     return NULL;
6946
6947   if (*slot == NULL)
6948     {
6949       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6950       if (p == NULL)
6951         return NULL;
6952       *p = ent;
6953       *slot = p;
6954     }
6955   return *slot;
6956 }
6957
6958 /* Adjust all global syms defined in opd sections.  In gcc generated
6959    code for the old ABI, these will already have been done.  */
6960
6961 static bfd_boolean
6962 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6963 {
6964   struct ppc_link_hash_entry *eh;
6965   asection *sym_sec;
6966   struct _opd_sec_data *opd;
6967
6968   if (h->root.type == bfd_link_hash_indirect)
6969     return TRUE;
6970
6971   if (h->root.type != bfd_link_hash_defined
6972       && h->root.type != bfd_link_hash_defweak)
6973     return TRUE;
6974
6975   eh = (struct ppc_link_hash_entry *) h;
6976   if (eh->adjust_done)
6977     return TRUE;
6978
6979   sym_sec = eh->elf.root.u.def.section;
6980   opd = get_opd_info (sym_sec);
6981   if (opd != NULL && opd->adjust != NULL)
6982     {
6983       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6984       if (adjust == -1)
6985         {
6986           /* This entry has been deleted.  */
6987           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6988           if (dsec == NULL)
6989             {
6990               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6991                 if (discarded_section (dsec))
6992                   {
6993                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6994                     break;
6995                   }
6996             }
6997           eh->elf.root.u.def.value = 0;
6998           eh->elf.root.u.def.section = dsec;
6999         }
7000       else
7001         eh->elf.root.u.def.value += adjust;
7002       eh->adjust_done = 1;
7003     }
7004   return TRUE;
7005 }
7006
7007 /* Handles decrementing dynamic reloc counts for the reloc specified by
7008    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM
7009    have already been determined.  */
7010
7011 static bfd_boolean
7012 dec_dynrel_count (bfd_vma r_info,
7013                   asection *sec,
7014                   struct bfd_link_info *info,
7015                   Elf_Internal_Sym **local_syms,
7016                   struct elf_link_hash_entry *h,
7017                   Elf_Internal_Sym *sym)
7018 {
7019   enum elf_ppc64_reloc_type r_type;
7020   asection *sym_sec = NULL;
7021
7022   /* Can this reloc be dynamic?  This switch, and later tests here
7023      should be kept in sync with the code in check_relocs.  */
7024   r_type = ELF64_R_TYPE (r_info);
7025   switch (r_type)
7026     {
7027     default:
7028       return TRUE;
7029
7030     case R_PPC64_TPREL16:
7031     case R_PPC64_TPREL16_LO:
7032     case R_PPC64_TPREL16_HI:
7033     case R_PPC64_TPREL16_HA:
7034     case R_PPC64_TPREL16_DS:
7035     case R_PPC64_TPREL16_LO_DS:
7036     case R_PPC64_TPREL16_HIGHER:
7037     case R_PPC64_TPREL16_HIGHERA:
7038     case R_PPC64_TPREL16_HIGHEST:
7039     case R_PPC64_TPREL16_HIGHESTA:
7040       if (!info->shared)
7041         return TRUE;
7042
7043     case R_PPC64_TPREL64:
7044     case R_PPC64_DTPMOD64:
7045     case R_PPC64_DTPREL64:
7046     case R_PPC64_ADDR64:
7047     case R_PPC64_REL30:
7048     case R_PPC64_REL32:
7049     case R_PPC64_REL64:
7050     case R_PPC64_ADDR14:
7051     case R_PPC64_ADDR14_BRNTAKEN:
7052     case R_PPC64_ADDR14_BRTAKEN:
7053     case R_PPC64_ADDR16:
7054     case R_PPC64_ADDR16_DS:
7055     case R_PPC64_ADDR16_HA:
7056     case R_PPC64_ADDR16_HI:
7057     case R_PPC64_ADDR16_HIGHER:
7058     case R_PPC64_ADDR16_HIGHERA:
7059     case R_PPC64_ADDR16_HIGHEST:
7060     case R_PPC64_ADDR16_HIGHESTA:
7061     case R_PPC64_ADDR16_LO:
7062     case R_PPC64_ADDR16_LO_DS:
7063     case R_PPC64_ADDR24:
7064     case R_PPC64_ADDR32:
7065     case R_PPC64_UADDR16:
7066     case R_PPC64_UADDR32:
7067     case R_PPC64_UADDR64:
7068     case R_PPC64_TOC:
7069       break;
7070     }
7071
7072   if (local_syms != NULL)
7073     {
7074       unsigned long r_symndx;
7075       bfd *ibfd = sec->owner;
7076
7077       r_symndx = ELF64_R_SYM (r_info);
7078       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7079         return FALSE;
7080     }
7081
7082   if ((info->shared
7083        && (must_be_dyn_reloc (info, r_type)
7084            || (h != NULL
7085                && (!SYMBOLIC_BIND (info, h)
7086                    || h->root.type == bfd_link_hash_defweak
7087                    || !h->def_regular))))
7088       || (ELIMINATE_COPY_RELOCS
7089           && !info->shared
7090           && h != NULL
7091           && (h->root.type == bfd_link_hash_defweak
7092               || !h->def_regular)))
7093     ;
7094   else
7095     return TRUE;
7096
7097   if (h != NULL)
7098     {
7099       struct elf_dyn_relocs *p;
7100       struct elf_dyn_relocs **pp;
7101       pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7102
7103       /* elf_gc_sweep may have already removed all dyn relocs associated
7104          with local syms for a given section.  Also, symbol flags are
7105          changed by elf_gc_sweep_symbol, confusing the test above.  Don't
7106          report a dynreloc miscount.  */
7107       if (*pp == NULL && info->gc_sections)
7108         return TRUE;
7109
7110       while ((p = *pp) != NULL)
7111         {
7112           if (p->sec == sec)
7113             {
7114               if (!must_be_dyn_reloc (info, r_type))
7115                 p->pc_count -= 1;
7116               p->count -= 1;
7117               if (p->count == 0)
7118                 *pp = p->next;
7119               return TRUE;
7120             }
7121           pp = &p->next;
7122         }
7123     }
7124   else
7125     {
7126       struct ppc_dyn_relocs *p;
7127       struct ppc_dyn_relocs **pp;
7128       void *vpp;
7129       bfd_boolean is_ifunc;
7130
7131       if (local_syms == NULL)
7132         sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7133       if (sym_sec == NULL)
7134         sym_sec = sec;
7135
7136       vpp = &elf_section_data (sym_sec)->local_dynrel;
7137       pp = (struct ppc_dyn_relocs **) vpp;
7138
7139       if (*pp == NULL && info->gc_sections)
7140         return TRUE;
7141
7142       is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7143       while ((p = *pp) != NULL)
7144         {
7145           if (p->sec == sec && p->ifunc == is_ifunc)
7146             {
7147               p->count -= 1;
7148               if (p->count == 0)
7149                 *pp = p->next;
7150               return TRUE;
7151             }
7152           pp = &p->next;
7153         }
7154     }
7155
7156   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7157                           sec->owner, sec);
7158   bfd_set_error (bfd_error_bad_value);
7159   return FALSE;
7160 }
7161
7162 /* Remove unused Official Procedure Descriptor entries.  Currently we
7163    only remove those associated with functions in discarded link-once
7164    sections, or weakly defined functions that have been overridden.  It
7165    would be possible to remove many more entries for statically linked
7166    applications.  */
7167
7168 bfd_boolean
7169 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7170 {
7171   bfd *ibfd;
7172   bfd_boolean some_edited = FALSE;
7173   asection *need_pad = NULL;
7174
7175   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7176     {
7177       asection *sec;
7178       Elf_Internal_Rela *relstart, *rel, *relend;
7179       Elf_Internal_Shdr *symtab_hdr;
7180       Elf_Internal_Sym *local_syms;
7181       bfd_vma offset;
7182       struct _opd_sec_data *opd;
7183       bfd_boolean need_edit, add_aux_fields;
7184       bfd_size_type cnt_16b = 0;
7185
7186       if (!is_ppc64_elf (ibfd))
7187         continue;
7188
7189       sec = bfd_get_section_by_name (ibfd, ".opd");
7190       if (sec == NULL || sec->size == 0)
7191         continue;
7192
7193       if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7194         continue;
7195
7196       if (sec->output_section == bfd_abs_section_ptr)
7197         continue;
7198
7199       /* Look through the section relocs.  */
7200       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7201         continue;
7202
7203       local_syms = NULL;
7204       symtab_hdr = &elf_symtab_hdr (ibfd);
7205
7206       /* Read the relocations.  */
7207       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7208                                             info->keep_memory);
7209       if (relstart == NULL)
7210         return FALSE;
7211
7212       /* First run through the relocs to check they are sane, and to
7213          determine whether we need to edit this opd section.  */
7214       need_edit = FALSE;
7215       need_pad = sec;
7216       offset = 0;
7217       relend = relstart + sec->reloc_count;
7218       for (rel = relstart; rel < relend; )
7219         {
7220           enum elf_ppc64_reloc_type r_type;
7221           unsigned long r_symndx;
7222           asection *sym_sec;
7223           struct elf_link_hash_entry *h;
7224           Elf_Internal_Sym *sym;
7225
7226           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7227              only interested in the reloc pointing to a function entry
7228              point.  */
7229           if (rel->r_offset != offset
7230               || rel + 1 >= relend
7231               || (rel + 1)->r_offset != offset + 8)
7232             {
7233               /* If someone messes with .opd alignment then after a
7234                  "ld -r" we might have padding in the middle of .opd.
7235                  Also, there's nothing to prevent someone putting
7236                  something silly in .opd with the assembler.  No .opd
7237                  optimization for them!  */
7238             broken_opd:
7239               (*_bfd_error_handler)
7240                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7241               need_edit = FALSE;
7242               break;
7243             }
7244
7245           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7246               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7247             {
7248               (*_bfd_error_handler)
7249                 (_("%B: unexpected reloc type %u in .opd section"),
7250                  ibfd, r_type);
7251               need_edit = FALSE;
7252               break;
7253             }
7254
7255           r_symndx = ELF64_R_SYM (rel->r_info);
7256           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7257                           r_symndx, ibfd))
7258             goto error_ret;
7259
7260           if (sym_sec == NULL || sym_sec->owner == NULL)
7261             {
7262               const char *sym_name;
7263               if (h != NULL)
7264                 sym_name = h->root.root.string;
7265               else
7266                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7267                                              sym_sec);
7268
7269               (*_bfd_error_handler)
7270                 (_("%B: undefined sym `%s' in .opd section"),
7271                  ibfd, sym_name);
7272               need_edit = FALSE;
7273               break;
7274             }
7275
7276           /* opd entries are always for functions defined in the
7277              current input bfd.  If the symbol isn't defined in the
7278              input bfd, then we won't be using the function in this
7279              bfd;  It must be defined in a linkonce section in another
7280              bfd, or is weak.  It's also possible that we are
7281              discarding the function due to a linker script /DISCARD/,
7282              which we test for via the output_section.  */
7283           if (sym_sec->owner != ibfd
7284               || sym_sec->output_section == bfd_abs_section_ptr)
7285             need_edit = TRUE;
7286
7287           rel += 2;
7288           if (rel == relend
7289               || (rel + 1 == relend && rel->r_offset == offset + 16))
7290             {
7291               if (sec->size == offset + 24)
7292                 {
7293                   need_pad = NULL;
7294                   break;
7295                 }
7296               if (rel == relend && sec->size == offset + 16)
7297                 {
7298                   cnt_16b++;
7299                   break;
7300                 }
7301               goto broken_opd;
7302             }
7303
7304           if (rel->r_offset == offset + 24)
7305             offset += 24;
7306           else if (rel->r_offset != offset + 16)
7307             goto broken_opd;
7308           else if (rel + 1 < relend
7309                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7310                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7311             {
7312               offset += 16;
7313               cnt_16b++;
7314             }
7315           else if (rel + 2 < relend
7316                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7317                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7318             {
7319               offset += 24;
7320               rel += 1;
7321             }
7322           else
7323             goto broken_opd;
7324         }
7325
7326       add_aux_fields = non_overlapping && cnt_16b > 0;
7327
7328       if (need_edit || add_aux_fields)
7329         {
7330           Elf_Internal_Rela *write_rel;
7331           Elf_Internal_Shdr *rel_hdr;
7332           bfd_byte *rptr, *wptr;
7333           bfd_byte *new_contents;
7334           bfd_boolean skip;
7335           long opd_ent_size;
7336           bfd_size_type amt;
7337
7338           new_contents = NULL;
7339           amt = sec->size * sizeof (long) / 8;
7340           opd = &ppc64_elf_section_data (sec)->u.opd;
7341           opd->adjust = bfd_zalloc (sec->owner, amt);
7342           if (opd->adjust == NULL)
7343             return FALSE;
7344           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7345
7346           /* This seems a waste of time as input .opd sections are all
7347              zeros as generated by gcc, but I suppose there's no reason
7348              this will always be so.  We might start putting something in
7349              the third word of .opd entries.  */
7350           if ((sec->flags & SEC_IN_MEMORY) == 0)
7351             {
7352               bfd_byte *loc;
7353               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7354                 {
7355                   if (loc != NULL)
7356                     free (loc);
7357                 error_ret:
7358                   if (local_syms != NULL
7359                       && symtab_hdr->contents != (unsigned char *) local_syms)
7360                     free (local_syms);
7361                   if (elf_section_data (sec)->relocs != relstart)
7362                     free (relstart);
7363                   return FALSE;
7364                 }
7365               sec->contents = loc;
7366               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7367             }
7368
7369           elf_section_data (sec)->relocs = relstart;
7370
7371           new_contents = sec->contents;
7372           if (add_aux_fields)
7373             {
7374               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7375               if (new_contents == NULL)
7376                 return FALSE;
7377               need_pad = FALSE;
7378             }
7379           wptr = new_contents;
7380           rptr = sec->contents;
7381
7382           write_rel = relstart;
7383           skip = FALSE;
7384           offset = 0;
7385           opd_ent_size = 0;
7386           for (rel = relstart; rel < relend; rel++)
7387             {
7388               unsigned long r_symndx;
7389               asection *sym_sec;
7390               struct elf_link_hash_entry *h;
7391               Elf_Internal_Sym *sym;
7392
7393               r_symndx = ELF64_R_SYM (rel->r_info);
7394               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7395                               r_symndx, ibfd))
7396                 goto error_ret;
7397
7398               if (rel->r_offset == offset)
7399                 {
7400                   struct ppc_link_hash_entry *fdh = NULL;
7401
7402                   /* See if the .opd entry is full 24 byte or
7403                      16 byte (with fd_aux entry overlapped with next
7404                      fd_func).  */
7405                   opd_ent_size = 24;
7406                   if ((rel + 2 == relend && sec->size == offset + 16)
7407                       || (rel + 3 < relend
7408                           && rel[2].r_offset == offset + 16
7409                           && rel[3].r_offset == offset + 24
7410                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7411                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7412                     opd_ent_size = 16;
7413
7414                   if (h != NULL
7415                       && h->root.root.string[0] == '.')
7416                     {
7417                       struct ppc_link_hash_table *htab;
7418
7419                       htab = ppc_hash_table (info);
7420                       if (htab != NULL)
7421                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7422                                           htab);
7423                       if (fdh != NULL
7424                           && fdh->elf.root.type != bfd_link_hash_defined
7425                           && fdh->elf.root.type != bfd_link_hash_defweak)
7426                         fdh = NULL;
7427                     }
7428
7429                   skip = (sym_sec->owner != ibfd
7430                           || sym_sec->output_section == bfd_abs_section_ptr);
7431                   if (skip)
7432                     {
7433                       if (fdh != NULL && sym_sec->owner == ibfd)
7434                         {
7435                           /* Arrange for the function descriptor sym
7436                              to be dropped.  */
7437                           fdh->elf.root.u.def.value = 0;
7438                           fdh->elf.root.u.def.section = sym_sec;
7439                         }
7440                       opd->adjust[rel->r_offset / 8] = -1;
7441                     }
7442                   else
7443                     {
7444                       /* We'll be keeping this opd entry.  */
7445
7446                       if (fdh != NULL)
7447                         {
7448                           /* Redefine the function descriptor symbol to
7449                              this location in the opd section.  It is
7450                              necessary to update the value here rather
7451                              than using an array of adjustments as we do
7452                              for local symbols, because various places
7453                              in the generic ELF code use the value
7454                              stored in u.def.value.  */
7455                           fdh->elf.root.u.def.value = wptr - new_contents;
7456                           fdh->adjust_done = 1;
7457                         }
7458
7459                       /* Local syms are a bit tricky.  We could
7460                          tweak them as they can be cached, but
7461                          we'd need to look through the local syms
7462                          for the function descriptor sym which we
7463                          don't have at the moment.  So keep an
7464                          array of adjustments.  */
7465                       opd->adjust[rel->r_offset / 8]
7466                         = (wptr - new_contents) - (rptr - sec->contents);
7467
7468                       if (wptr != rptr)
7469                         memcpy (wptr, rptr, opd_ent_size);
7470                       wptr += opd_ent_size;
7471                       if (add_aux_fields && opd_ent_size == 16)
7472                         {
7473                           memset (wptr, '\0', 8);
7474                           wptr += 8;
7475                         }
7476                     }
7477                   rptr += opd_ent_size;
7478                   offset += opd_ent_size;
7479                 }
7480
7481               if (skip)
7482                 {
7483                   if (!NO_OPD_RELOCS
7484                       && !info->relocatable
7485                       && !dec_dynrel_count (rel->r_info, sec, info,
7486                                             NULL, h, sym))
7487                     goto error_ret;
7488                 }
7489               else
7490                 {
7491                   /* We need to adjust any reloc offsets to point to the
7492                      new opd entries.  While we're at it, we may as well
7493                      remove redundant relocs.  */
7494                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7495                   if (write_rel != rel)
7496                     memcpy (write_rel, rel, sizeof (*rel));
7497                   ++write_rel;
7498                 }
7499             }
7500
7501           sec->size = wptr - new_contents;
7502           sec->reloc_count = write_rel - relstart;
7503           if (add_aux_fields)
7504             {
7505               free (sec->contents);
7506               sec->contents = new_contents;
7507             }
7508
7509           /* Fudge the header size too, as this is used later in
7510              elf_bfd_final_link if we are emitting relocs.  */
7511           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7512           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7513           some_edited = TRUE;
7514         }
7515       else if (elf_section_data (sec)->relocs != relstart)
7516         free (relstart);
7517
7518       if (local_syms != NULL
7519           && symtab_hdr->contents != (unsigned char *) local_syms)
7520         {
7521           if (!info->keep_memory)
7522             free (local_syms);
7523           else
7524             symtab_hdr->contents = (unsigned char *) local_syms;
7525         }
7526     }
7527
7528   if (some_edited)
7529     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7530
7531   /* If we are doing a final link and the last .opd entry is just 16 byte
7532      long, add a 8 byte padding after it.  */
7533   if (need_pad != NULL && !info->relocatable)
7534     {
7535       bfd_byte *p;
7536
7537       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7538         {
7539           BFD_ASSERT (need_pad->size > 0);
7540
7541           p = bfd_malloc (need_pad->size + 8);
7542           if (p == NULL)
7543             return FALSE;
7544
7545           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7546                                           p, 0, need_pad->size))
7547             return FALSE;
7548
7549           need_pad->contents = p;
7550           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7551         }
7552       else
7553         {
7554           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7555           if (p == NULL)
7556             return FALSE;
7557
7558           need_pad->contents = p;
7559         }
7560
7561       memset (need_pad->contents + need_pad->size, 0, 8);
7562       need_pad->size += 8;
7563     }
7564
7565   return TRUE;
7566 }
7567
7568 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7569
7570 asection *
7571 ppc64_elf_tls_setup (struct bfd_link_info *info,
7572                      int no_tls_get_addr_opt,
7573                      int *no_multi_toc)
7574 {
7575   struct ppc_link_hash_table *htab;
7576
7577   htab = ppc_hash_table (info);
7578   if (htab == NULL)
7579     return NULL;
7580
7581   if (*no_multi_toc)
7582     htab->do_multi_toc = 0;
7583   else if (!htab->do_multi_toc)
7584     *no_multi_toc = 1;
7585
7586   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7587                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7588                                               FALSE, FALSE, TRUE));
7589   /* Move dynamic linking info to the function descriptor sym.  */
7590   if (htab->tls_get_addr != NULL)
7591     func_desc_adjust (&htab->tls_get_addr->elf, info);
7592   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7593                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7594                                                  FALSE, FALSE, TRUE));
7595   if (!no_tls_get_addr_opt)
7596     {
7597       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7598
7599       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7600                                   FALSE, FALSE, TRUE);
7601       if (opt != NULL)
7602         func_desc_adjust (opt, info);
7603       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7604                                      FALSE, FALSE, TRUE);
7605       if (opt_fd != NULL
7606           && (opt_fd->root.type == bfd_link_hash_defined
7607               || opt_fd->root.type == bfd_link_hash_defweak))
7608         {
7609           /* If glibc supports an optimized __tls_get_addr call stub,
7610              signalled by the presence of __tls_get_addr_opt, and we'll
7611              be calling __tls_get_addr via a plt call stub, then
7612              make __tls_get_addr point to __tls_get_addr_opt.  */
7613           tga_fd = &htab->tls_get_addr_fd->elf;
7614           if (htab->elf.dynamic_sections_created
7615               && tga_fd != NULL
7616               && (tga_fd->type == STT_FUNC
7617                   || tga_fd->needs_plt)
7618               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7619                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7620                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7621             {
7622               struct plt_entry *ent;
7623
7624               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7625                 if (ent->plt.refcount > 0)
7626                   break;
7627               if (ent != NULL)
7628                 {
7629                   tga_fd->root.type = bfd_link_hash_indirect;
7630                   tga_fd->root.u.i.link = &opt_fd->root;
7631                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7632                   if (opt_fd->dynindx != -1)
7633                     {
7634                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7635                       opt_fd->dynindx = -1;
7636                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7637                                               opt_fd->dynstr_index);
7638                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7639                         return NULL;
7640                     }
7641                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7642                   tga = &htab->tls_get_addr->elf;
7643                   if (opt != NULL && tga != NULL)
7644                     {
7645                       tga->root.type = bfd_link_hash_indirect;
7646                       tga->root.u.i.link = &opt->root;
7647                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7648                       _bfd_elf_link_hash_hide_symbol (info, opt,
7649                                                       tga->forced_local);
7650                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7651                     }
7652                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7653                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7654                   if (htab->tls_get_addr != NULL)
7655                     {
7656                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7657                       htab->tls_get_addr->is_func = 1;
7658                     }
7659                 }
7660             }
7661         }
7662       else
7663         no_tls_get_addr_opt = TRUE;
7664     }
7665   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7666   return _bfd_elf_tls_setup (info->output_bfd, info);
7667 }
7668
7669 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7670    HASH1 or HASH2.  */
7671
7672 static bfd_boolean
7673 branch_reloc_hash_match (const bfd *ibfd,
7674                          const Elf_Internal_Rela *rel,
7675                          const struct ppc_link_hash_entry *hash1,
7676                          const struct ppc_link_hash_entry *hash2)
7677 {
7678   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7679   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7680   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7681
7682   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7683     {
7684       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7685       struct elf_link_hash_entry *h;
7686
7687       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7688       h = elf_follow_link (h);
7689       if (h == &hash1->elf || h == &hash2->elf)
7690         return TRUE;
7691     }
7692   return FALSE;
7693 }
7694
7695 /* Run through all the TLS relocs looking for optimization
7696    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7697    a preliminary section layout so that we know the TLS segment
7698    offsets.  We can't optimize earlier because some optimizations need
7699    to know the tp offset, and we need to optimize before allocating
7700    dynamic relocations.  */
7701
7702 bfd_boolean
7703 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7704 {
7705   bfd *ibfd;
7706   asection *sec;
7707   struct ppc_link_hash_table *htab;
7708   unsigned char *toc_ref;
7709   int pass;
7710
7711   if (info->relocatable || !info->executable)
7712     return TRUE;
7713
7714   htab = ppc_hash_table (info);
7715   if (htab == NULL)
7716     return FALSE;
7717
7718   /* Make two passes over the relocs.  On the first pass, mark toc
7719      entries involved with tls relocs, and check that tls relocs
7720      involved in setting up a tls_get_addr call are indeed followed by
7721      such a call.  If they are not, we can't do any tls optimization.
7722      On the second pass twiddle tls_mask flags to notify
7723      relocate_section that optimization can be done, and adjust got
7724      and plt refcounts.  */
7725   toc_ref = NULL;
7726   for (pass = 0; pass < 2; ++pass)
7727     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7728       {
7729         Elf_Internal_Sym *locsyms = NULL;
7730         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7731
7732         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7733           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7734             {
7735               Elf_Internal_Rela *relstart, *rel, *relend;
7736               bfd_boolean found_tls_get_addr_arg = 0;
7737
7738               /* Read the relocations.  */
7739               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7740                                                     info->keep_memory);
7741               if (relstart == NULL)
7742                 return FALSE;
7743
7744               relend = relstart + sec->reloc_count;
7745               for (rel = relstart; rel < relend; rel++)
7746                 {
7747                   enum elf_ppc64_reloc_type r_type;
7748                   unsigned long r_symndx;
7749                   struct elf_link_hash_entry *h;
7750                   Elf_Internal_Sym *sym;
7751                   asection *sym_sec;
7752                   unsigned char *tls_mask;
7753                   unsigned char tls_set, tls_clear, tls_type = 0;
7754                   bfd_vma value;
7755                   bfd_boolean ok_tprel, is_local;
7756                   long toc_ref_index = 0;
7757                   int expecting_tls_get_addr = 0;
7758                   bfd_boolean ret = FALSE;
7759
7760                   r_symndx = ELF64_R_SYM (rel->r_info);
7761                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7762                                   r_symndx, ibfd))
7763                     {
7764                     err_free_rel:
7765                       if (elf_section_data (sec)->relocs != relstart)
7766                         free (relstart);
7767                       if (toc_ref != NULL)
7768                         free (toc_ref);
7769                       if (locsyms != NULL
7770                           && (elf_symtab_hdr (ibfd).contents
7771                               != (unsigned char *) locsyms))
7772                         free (locsyms);
7773                       return ret;
7774                     }
7775
7776                   if (h != NULL)
7777                     {
7778                       if (h->root.type == bfd_link_hash_defined
7779                           || h->root.type == bfd_link_hash_defweak)
7780                         value = h->root.u.def.value;
7781                       else if (h->root.type == bfd_link_hash_undefweak)
7782                         value = 0;
7783                       else
7784                         {
7785                           found_tls_get_addr_arg = 0;
7786                           continue;
7787                         }
7788                     }
7789                   else
7790                     /* Symbols referenced by TLS relocs must be of type
7791                        STT_TLS.  So no need for .opd local sym adjust.  */
7792                     value = sym->st_value;
7793
7794                   ok_tprel = FALSE;
7795                   is_local = FALSE;
7796                   if (h == NULL
7797                       || !h->def_dynamic)
7798                     {
7799                       is_local = TRUE;
7800                       if (h != NULL
7801                           && h->root.type == bfd_link_hash_undefweak)
7802                         ok_tprel = TRUE;
7803                       else
7804                         {
7805                           value += sym_sec->output_offset;
7806                           value += sym_sec->output_section->vma;
7807                           value -= htab->elf.tls_sec->vma;
7808                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7809                                       < (bfd_vma) 1 << 32);
7810                         }
7811                     }
7812
7813                   r_type = ELF64_R_TYPE (rel->r_info);
7814                   /* If this section has old-style __tls_get_addr calls
7815                      without marker relocs, then check that each
7816                      __tls_get_addr call reloc is preceded by a reloc
7817                      that conceivably belongs to the __tls_get_addr arg
7818                      setup insn.  If we don't find matching arg setup
7819                      relocs, don't do any tls optimization.  */
7820                   if (pass == 0
7821                       && sec->has_tls_get_addr_call
7822                       && h != NULL
7823                       && (h == &htab->tls_get_addr->elf
7824                           || h == &htab->tls_get_addr_fd->elf)
7825                       && !found_tls_get_addr_arg
7826                       && is_branch_reloc (r_type))
7827                     {
7828                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7829                                                 "TLS optimization disabled\n"),
7830                                               ibfd, sec, rel->r_offset);
7831                       ret = TRUE;
7832                       goto err_free_rel;
7833                     }
7834
7835                   found_tls_get_addr_arg = 0;
7836                   switch (r_type)
7837                     {
7838                     case R_PPC64_GOT_TLSLD16:
7839                     case R_PPC64_GOT_TLSLD16_LO:
7840                       expecting_tls_get_addr = 1;
7841                       found_tls_get_addr_arg = 1;
7842                       /* Fall thru */
7843
7844                     case R_PPC64_GOT_TLSLD16_HI:
7845                     case R_PPC64_GOT_TLSLD16_HA:
7846                       /* These relocs should never be against a symbol
7847                          defined in a shared lib.  Leave them alone if
7848                          that turns out to be the case.  */
7849                       if (!is_local)
7850                         continue;
7851
7852                       /* LD -> LE */
7853                       tls_set = 0;
7854                       tls_clear = TLS_LD;
7855                       tls_type = TLS_TLS | TLS_LD;
7856                       break;
7857
7858                     case R_PPC64_GOT_TLSGD16:
7859                     case R_PPC64_GOT_TLSGD16_LO:
7860                       expecting_tls_get_addr = 1;
7861                       found_tls_get_addr_arg = 1;
7862                       /* Fall thru */
7863
7864                     case R_PPC64_GOT_TLSGD16_HI:
7865                     case R_PPC64_GOT_TLSGD16_HA:
7866                       if (ok_tprel)
7867                         /* GD -> LE */
7868                         tls_set = 0;
7869                       else
7870                         /* GD -> IE */
7871                         tls_set = TLS_TLS | TLS_TPRELGD;
7872                       tls_clear = TLS_GD;
7873                       tls_type = TLS_TLS | TLS_GD;
7874                       break;
7875
7876                     case R_PPC64_GOT_TPREL16_DS:
7877                     case R_PPC64_GOT_TPREL16_LO_DS:
7878                     case R_PPC64_GOT_TPREL16_HI:
7879                     case R_PPC64_GOT_TPREL16_HA:
7880                       if (ok_tprel)
7881                         {
7882                           /* IE -> LE */
7883                           tls_set = 0;
7884                           tls_clear = TLS_TPREL;
7885                           tls_type = TLS_TLS | TLS_TPREL;
7886                           break;
7887                         }
7888                       continue;
7889
7890                     case R_PPC64_TLSGD:
7891                     case R_PPC64_TLSLD:
7892                       found_tls_get_addr_arg = 1;
7893                       /* Fall thru */
7894
7895                     case R_PPC64_TLS:
7896                     case R_PPC64_TOC16:
7897                     case R_PPC64_TOC16_LO:
7898                       if (sym_sec == NULL || sym_sec != toc)
7899                         continue;
7900
7901                       /* Mark this toc entry as referenced by a TLS
7902                          code sequence.  We can do that now in the
7903                          case of R_PPC64_TLS, and after checking for
7904                          tls_get_addr for the TOC16 relocs.  */
7905                       if (toc_ref == NULL)
7906                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7907                       if (toc_ref == NULL)
7908                         goto err_free_rel;
7909
7910                       if (h != NULL)
7911                         value = h->root.u.def.value;
7912                       else
7913                         value = sym->st_value;
7914                       value += rel->r_addend;
7915                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7916                       toc_ref_index = (value + toc->output_offset) / 8;
7917                       if (r_type == R_PPC64_TLS
7918                           || r_type == R_PPC64_TLSGD
7919                           || r_type == R_PPC64_TLSLD)
7920                         {
7921                           toc_ref[toc_ref_index] = 1;
7922                           continue;
7923                         }
7924
7925                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7926                         continue;
7927
7928                       tls_set = 0;
7929                       tls_clear = 0;
7930                       expecting_tls_get_addr = 2;
7931                       break;
7932
7933                     case R_PPC64_TPREL64:
7934                       if (pass == 0
7935                           || sec != toc
7936                           || toc_ref == NULL
7937                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7938                         continue;
7939                       if (ok_tprel)
7940                         {
7941                           /* IE -> LE */
7942                           tls_set = TLS_EXPLICIT;
7943                           tls_clear = TLS_TPREL;
7944                           break;
7945                         }
7946                       continue;
7947
7948                     case R_PPC64_DTPMOD64:
7949                       if (pass == 0
7950                           || sec != toc
7951                           || toc_ref == NULL
7952                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7953                         continue;
7954                       if (rel + 1 < relend
7955                           && (rel[1].r_info
7956                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7957                           && rel[1].r_offset == rel->r_offset + 8)
7958                         {
7959                           if (ok_tprel)
7960                             /* GD -> LE */
7961                             tls_set = TLS_EXPLICIT | TLS_GD;
7962                           else
7963                             /* GD -> IE */
7964                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7965                           tls_clear = TLS_GD;
7966                         }
7967                       else
7968                         {
7969                           if (!is_local)
7970                             continue;
7971
7972                           /* LD -> LE */
7973                           tls_set = TLS_EXPLICIT;
7974                           tls_clear = TLS_LD;
7975                         }
7976                       break;
7977
7978                     default:
7979                       continue;
7980                     }
7981
7982                   if (pass == 0)
7983                     {
7984                       if (!expecting_tls_get_addr
7985                           || !sec->has_tls_get_addr_call)
7986                         continue;
7987
7988                       if (rel + 1 < relend
7989                           && branch_reloc_hash_match (ibfd, rel + 1,
7990                                                       htab->tls_get_addr,
7991                                                       htab->tls_get_addr_fd))
7992                         {
7993                           if (expecting_tls_get_addr == 2)
7994                             {
7995                               /* Check for toc tls entries.  */
7996                               unsigned char *toc_tls;
7997                               int retval;
7998
7999                               retval = get_tls_mask (&toc_tls, NULL, NULL,
8000                                                      &locsyms,
8001                                                      rel, ibfd);
8002                               if (retval == 0)
8003                                 goto err_free_rel;
8004                               if (toc_tls != NULL)
8005                                 {
8006                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8007                                     found_tls_get_addr_arg = 1;
8008                                   if (retval > 1)
8009                                     toc_ref[toc_ref_index] = 1;
8010                                 }
8011                             }
8012                           continue;
8013                         }
8014
8015                       if (expecting_tls_get_addr != 1)
8016                         continue;
8017
8018                       /* Uh oh, we didn't find the expected call.  We
8019                          could just mark this symbol to exclude it
8020                          from tls optimization but it's safer to skip
8021                          the entire optimization.  */
8022                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8023                                                 "TLS optimization disabled\n"),
8024                                               ibfd, sec, rel->r_offset);
8025                       ret = TRUE;
8026                       goto err_free_rel;
8027                     }
8028
8029                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8030                     {
8031                       struct plt_entry *ent;
8032                       for (ent = htab->tls_get_addr->elf.plt.plist;
8033                            ent != NULL;
8034                            ent = ent->next)
8035                         if (ent->addend == 0)
8036                           {
8037                             if (ent->plt.refcount > 0)
8038                               {
8039                                 ent->plt.refcount -= 1;
8040                                 expecting_tls_get_addr = 0;
8041                               }
8042                             break;
8043                           }
8044                     }
8045
8046                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8047                     {
8048                       struct plt_entry *ent;
8049                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8050                            ent != NULL;
8051                            ent = ent->next)
8052                         if (ent->addend == 0)
8053                           {
8054                             if (ent->plt.refcount > 0)
8055                               ent->plt.refcount -= 1;
8056                             break;
8057                           }
8058                     }
8059
8060                   if (tls_clear == 0)
8061                     continue;
8062
8063                   if ((tls_set & TLS_EXPLICIT) == 0)
8064                     {
8065                       struct got_entry *ent;
8066
8067                       /* Adjust got entry for this reloc.  */
8068                       if (h != NULL)
8069                         ent = h->got.glist;
8070                       else
8071                         ent = elf_local_got_ents (ibfd)[r_symndx];
8072
8073                       for (; ent != NULL; ent = ent->next)
8074                         if (ent->addend == rel->r_addend
8075                             && ent->owner == ibfd
8076                             && ent->tls_type == tls_type)
8077                           break;
8078                       if (ent == NULL)
8079                         abort ();
8080
8081                       if (tls_set == 0)
8082                         {
8083                           /* We managed to get rid of a got entry.  */
8084                           if (ent->got.refcount > 0)
8085                             ent->got.refcount -= 1;
8086                         }
8087                     }
8088                   else
8089                     {
8090                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
8091                          we'll lose one or two dyn relocs.  */
8092                       if (!dec_dynrel_count (rel->r_info, sec, info,
8093                                              NULL, h, sym))
8094                         return FALSE;
8095
8096                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
8097                         {
8098                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8099                                                  NULL, h, sym))
8100                             return FALSE;
8101                         }
8102                     }
8103
8104                   *tls_mask |= tls_set;
8105                   *tls_mask &= ~tls_clear;
8106                 }
8107
8108               if (elf_section_data (sec)->relocs != relstart)
8109                 free (relstart);
8110             }
8111
8112         if (locsyms != NULL
8113             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8114           {
8115             if (!info->keep_memory)
8116               free (locsyms);
8117             else
8118               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8119           }
8120       }
8121
8122   if (toc_ref != NULL)
8123     free (toc_ref);
8124   return TRUE;
8125 }
8126
8127 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8128    the values of any global symbols in a toc section that has been
8129    edited.  Globals in toc sections should be a rarity, so this function
8130    sets a flag if any are found in toc sections other than the one just
8131    edited, so that futher hash table traversals can be avoided.  */
8132
8133 struct adjust_toc_info
8134 {
8135   asection *toc;
8136   unsigned long *skip;
8137   bfd_boolean global_toc_syms;
8138 };
8139
8140 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8141
8142 static bfd_boolean
8143 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8144 {
8145   struct ppc_link_hash_entry *eh;
8146   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8147   unsigned long i;
8148
8149   if (h->root.type != bfd_link_hash_defined
8150       && h->root.type != bfd_link_hash_defweak)
8151     return TRUE;
8152
8153   eh = (struct ppc_link_hash_entry *) h;
8154   if (eh->adjust_done)
8155     return TRUE;
8156
8157   if (eh->elf.root.u.def.section == toc_inf->toc)
8158     {
8159       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8160         i = toc_inf->toc->rawsize >> 3;
8161       else
8162         i = eh->elf.root.u.def.value >> 3;
8163
8164       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8165         {
8166           (*_bfd_error_handler)
8167             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8168           do
8169             ++i;
8170           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8171           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8172         }
8173
8174       eh->elf.root.u.def.value -= toc_inf->skip[i];
8175       eh->adjust_done = 1;
8176     }
8177   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8178     toc_inf->global_toc_syms = TRUE;
8179
8180   return TRUE;
8181 }
8182
8183 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8184
8185 static bfd_boolean
8186 ok_lo_toc_insn (unsigned int insn)
8187 {
8188   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8189           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8190           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8191           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8192           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8193           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8194           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8195           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8196           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8197           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8198           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8199           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8200           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8201           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8202           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8203               && (insn & 3) != 1)
8204           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8205               && ((insn & 3) == 0 || (insn & 3) == 3))
8206           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8207 }
8208
8209 /* Examine all relocs referencing .toc sections in order to remove
8210    unused .toc entries.  */
8211
8212 bfd_boolean
8213 ppc64_elf_edit_toc (struct bfd_link_info *info)
8214 {
8215   bfd *ibfd;
8216   struct adjust_toc_info toc_inf;
8217   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8218
8219   htab->do_toc_opt = 1;
8220   toc_inf.global_toc_syms = TRUE;
8221   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8222     {
8223       asection *toc, *sec;
8224       Elf_Internal_Shdr *symtab_hdr;
8225       Elf_Internal_Sym *local_syms;
8226       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8227       unsigned long *skip, *drop;
8228       unsigned char *used;
8229       unsigned char *keep, last, some_unused;
8230
8231       if (!is_ppc64_elf (ibfd))
8232         continue;
8233
8234       toc = bfd_get_section_by_name (ibfd, ".toc");
8235       if (toc == NULL
8236           || toc->size == 0
8237           || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8238           || discarded_section (toc))
8239         continue;
8240
8241       toc_relocs = NULL;
8242       local_syms = NULL;
8243       symtab_hdr = &elf_symtab_hdr (ibfd);
8244
8245       /* Look at sections dropped from the final link.  */
8246       skip = NULL;
8247       relstart = NULL;
8248       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8249         {
8250           if (sec->reloc_count == 0
8251               || !discarded_section (sec)
8252               || get_opd_info (sec)
8253               || (sec->flags & SEC_ALLOC) == 0
8254               || (sec->flags & SEC_DEBUGGING) != 0)
8255             continue;
8256
8257           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8258           if (relstart == NULL)
8259             goto error_ret;
8260
8261           /* Run through the relocs to see which toc entries might be
8262              unused.  */
8263           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8264             {
8265               enum elf_ppc64_reloc_type r_type;
8266               unsigned long r_symndx;
8267               asection *sym_sec;
8268               struct elf_link_hash_entry *h;
8269               Elf_Internal_Sym *sym;
8270               bfd_vma val;
8271
8272               r_type = ELF64_R_TYPE (rel->r_info);
8273               switch (r_type)
8274                 {
8275                 default:
8276                   continue;
8277
8278                 case R_PPC64_TOC16:
8279                 case R_PPC64_TOC16_LO:
8280                 case R_PPC64_TOC16_HI:
8281                 case R_PPC64_TOC16_HA:
8282                 case R_PPC64_TOC16_DS:
8283                 case R_PPC64_TOC16_LO_DS:
8284                   break;
8285                 }
8286
8287               r_symndx = ELF64_R_SYM (rel->r_info);
8288               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8289                               r_symndx, ibfd))
8290                 goto error_ret;
8291
8292               if (sym_sec != toc)
8293                 continue;
8294
8295               if (h != NULL)
8296                 val = h->root.u.def.value;
8297               else
8298                 val = sym->st_value;
8299               val += rel->r_addend;
8300
8301               if (val >= toc->size)
8302                 continue;
8303
8304               /* Anything in the toc ought to be aligned to 8 bytes.
8305                  If not, don't mark as unused.  */
8306               if (val & 7)
8307                 continue;
8308
8309               if (skip == NULL)
8310                 {
8311                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8312                   if (skip == NULL)
8313                     goto error_ret;
8314                 }
8315
8316               skip[val >> 3] = ref_from_discarded;
8317             }
8318
8319           if (elf_section_data (sec)->relocs != relstart)
8320             free (relstart);
8321         }
8322
8323       /* For largetoc loads of address constants, we can convert
8324          .  addis rx,2,addr@got@ha
8325          .  ld ry,addr@got@l(rx)
8326          to
8327          .  addis rx,2,addr@toc@ha
8328          .  addi ry,rx,addr@toc@l
8329          when addr is within 2G of the toc pointer.  This then means
8330          that the word storing "addr" in the toc is no longer needed.  */
8331
8332       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8333           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8334           && toc->reloc_count != 0)
8335         {
8336           /* Read toc relocs.  */
8337           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8338                                                   info->keep_memory);
8339           if (toc_relocs == NULL)
8340             goto error_ret;
8341
8342           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8343             {
8344               enum elf_ppc64_reloc_type r_type;
8345               unsigned long r_symndx;
8346               asection *sym_sec;
8347               struct elf_link_hash_entry *h;
8348               Elf_Internal_Sym *sym;
8349               bfd_vma val, addr;
8350
8351               r_type = ELF64_R_TYPE (rel->r_info);
8352               if (r_type != R_PPC64_ADDR64)
8353                 continue;
8354
8355               r_symndx = ELF64_R_SYM (rel->r_info);
8356               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8357                               r_symndx, ibfd))
8358                 goto error_ret;
8359
8360               if (sym_sec == NULL
8361                   || discarded_section (sym_sec))
8362                 continue;
8363
8364               if (!SYMBOL_CALLS_LOCAL (info, h))
8365                 continue;
8366
8367               if (h != NULL)
8368                 {
8369                   if (h->type == STT_GNU_IFUNC)
8370                     continue;
8371                   val = h->root.u.def.value;
8372                 }
8373               else
8374                 {
8375                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8376                     continue;
8377                   val = sym->st_value;
8378                 }
8379               val += rel->r_addend;
8380               val += sym_sec->output_section->vma + sym_sec->output_offset;
8381
8382               /* We don't yet know the exact toc pointer value, but we
8383                  know it will be somewhere in the toc section.  Don't
8384                  optimize if the difference from any possible toc
8385                  pointer is outside [ff..f80008000, 7fff7fff].  */
8386               addr = toc->output_section->vma + TOC_BASE_OFF;
8387               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8388                 continue;
8389
8390               addr = toc->output_section->vma + toc->output_section->rawsize;
8391               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8392                 continue;
8393
8394               if (skip == NULL)
8395                 {
8396                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8397                   if (skip == NULL)
8398                     goto error_ret;
8399                 }
8400
8401               skip[rel->r_offset >> 3]
8402                 |= can_optimize | ((rel - toc_relocs) << 2);
8403             }
8404         }
8405
8406       if (skip == NULL)
8407         continue;
8408
8409       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8410       if (used == NULL)
8411         {
8412         error_ret:
8413           if (local_syms != NULL
8414               && symtab_hdr->contents != (unsigned char *) local_syms)
8415             free (local_syms);
8416           if (sec != NULL
8417               && relstart != NULL
8418               && elf_section_data (sec)->relocs != relstart)
8419             free (relstart);
8420           if (toc_relocs != NULL
8421               && elf_section_data (toc)->relocs != toc_relocs)
8422             free (toc_relocs);
8423           if (skip != NULL)
8424             free (skip);
8425           return FALSE;
8426         }
8427
8428       /* Now check all kept sections that might reference the toc.
8429          Check the toc itself last.  */
8430       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8431                   : ibfd->sections);
8432            sec != NULL;
8433            sec = (sec == toc ? NULL
8434                   : sec->next == NULL ? toc
8435                   : sec->next == toc && toc->next ? toc->next
8436                   : sec->next))
8437         {
8438           int repeat;
8439
8440           if (sec->reloc_count == 0
8441               || discarded_section (sec)
8442               || get_opd_info (sec)
8443               || (sec->flags & SEC_ALLOC) == 0
8444               || (sec->flags & SEC_DEBUGGING) != 0)
8445             continue;
8446
8447           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8448                                                 info->keep_memory);
8449           if (relstart == NULL)
8450             goto error_ret;
8451
8452           /* Mark toc entries referenced as used.  */
8453           do
8454             {
8455               repeat = 0;
8456               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8457                 {
8458                   enum elf_ppc64_reloc_type r_type;
8459                   unsigned long r_symndx;
8460                   asection *sym_sec;
8461                   struct elf_link_hash_entry *h;
8462                   Elf_Internal_Sym *sym;
8463                   bfd_vma val;
8464                   enum {no_check, check_lo, check_ha} insn_check;
8465
8466                   r_type = ELF64_R_TYPE (rel->r_info);
8467                   switch (r_type)
8468                     {
8469                     default:
8470                       insn_check = no_check;
8471                       break;
8472
8473                     case R_PPC64_GOT_TLSLD16_HA:
8474                     case R_PPC64_GOT_TLSGD16_HA:
8475                     case R_PPC64_GOT_TPREL16_HA:
8476                     case R_PPC64_GOT_DTPREL16_HA:
8477                     case R_PPC64_GOT16_HA:
8478                     case R_PPC64_TOC16_HA:
8479                       insn_check = check_ha;
8480                       break;
8481
8482                     case R_PPC64_GOT_TLSLD16_LO:
8483                     case R_PPC64_GOT_TLSGD16_LO:
8484                     case R_PPC64_GOT_TPREL16_LO_DS:
8485                     case R_PPC64_GOT_DTPREL16_LO_DS:
8486                     case R_PPC64_GOT16_LO:
8487                     case R_PPC64_GOT16_LO_DS:
8488                     case R_PPC64_TOC16_LO:
8489                     case R_PPC64_TOC16_LO_DS:
8490                       insn_check = check_lo;
8491                       break;
8492                     }
8493
8494                   if (insn_check != no_check)
8495                     {
8496                       bfd_vma off = rel->r_offset & ~3;
8497                       unsigned char buf[4];
8498                       unsigned int insn;
8499
8500                       if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8501                         {
8502                           free (used);
8503                           goto error_ret;
8504                         }
8505                       insn = bfd_get_32 (ibfd, buf);
8506                       if (insn_check == check_lo
8507                           ? !ok_lo_toc_insn (insn)
8508                           : ((insn & ((0x3f << 26) | 0x1f << 16))
8509                              != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8510                         {
8511                           char str[12];
8512
8513                           ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8514                           sprintf (str, "%#08x", insn);
8515                           info->callbacks->einfo
8516                             (_("%P: %H: toc optimization is not supported for"
8517                                " %s instruction.\n"),
8518                              ibfd, sec, rel->r_offset & ~3, str);
8519                         }
8520                     }
8521
8522                   switch (r_type)
8523                     {
8524                     case R_PPC64_TOC16:
8525                     case R_PPC64_TOC16_LO:
8526                     case R_PPC64_TOC16_HI:
8527                     case R_PPC64_TOC16_HA:
8528                     case R_PPC64_TOC16_DS:
8529                     case R_PPC64_TOC16_LO_DS:
8530                       /* In case we're taking addresses of toc entries.  */
8531                     case R_PPC64_ADDR64:
8532                       break;
8533
8534                     default:
8535                       continue;
8536                     }
8537
8538                   r_symndx = ELF64_R_SYM (rel->r_info);
8539                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8540                                   r_symndx, ibfd))
8541                     {
8542                       free (used);
8543                       goto error_ret;
8544                     }
8545
8546                   if (sym_sec != toc)
8547                     continue;
8548
8549                   if (h != NULL)
8550                     val = h->root.u.def.value;
8551                   else
8552                     val = sym->st_value;
8553                   val += rel->r_addend;
8554
8555                   if (val >= toc->size)
8556                     continue;
8557
8558                   if ((skip[val >> 3] & can_optimize) != 0)
8559                     {
8560                       bfd_vma off;
8561                       unsigned char opc;
8562
8563                       switch (r_type)
8564                         {
8565                         case R_PPC64_TOC16_HA:
8566                           break;
8567
8568                         case R_PPC64_TOC16_LO_DS:
8569                           off = rel->r_offset;
8570                           off += (bfd_big_endian (ibfd) ? -2 : 3);
8571                           if (!bfd_get_section_contents (ibfd, sec, &opc,
8572                                                          off, 1))
8573                             {
8574                               free (used);
8575                               goto error_ret;
8576                             }
8577                           if ((opc & (0x3f << 2)) == (58u << 2))
8578                             break;
8579                           /* Fall thru */
8580
8581                         default:
8582                           /* Wrong sort of reloc, or not a ld.  We may
8583                              as well clear ref_from_discarded too.  */
8584                           skip[val >> 3] = 0;
8585                         }
8586                     }
8587
8588                   if (sec != toc)
8589                     used[val >> 3] = 1;
8590                   /* For the toc section, we only mark as used if this
8591                      entry itself isn't unused.  */
8592                   else if ((used[rel->r_offset >> 3]
8593                             || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8594                            && !used[val >> 3])
8595                     {
8596                       /* Do all the relocs again, to catch reference
8597                          chains.  */
8598                       repeat = 1;
8599                       used[val >> 3] = 1;
8600                     }
8601                 }
8602             }
8603           while (repeat);
8604
8605           if (elf_section_data (sec)->relocs != relstart)
8606             free (relstart);
8607         }
8608
8609       /* Merge the used and skip arrays.  Assume that TOC
8610          doublewords not appearing as either used or unused belong
8611          to to an entry more than one doubleword in size.  */
8612       for (drop = skip, keep = used, last = 0, some_unused = 0;
8613            drop < skip + (toc->size + 7) / 8;
8614            ++drop, ++keep)
8615         {
8616           if (*keep)
8617             {
8618               *drop &= ~ref_from_discarded;
8619               if ((*drop & can_optimize) != 0)
8620                 some_unused = 1;
8621               last = 0;
8622             }
8623           else if ((*drop & ref_from_discarded) != 0)
8624             {
8625               some_unused = 1;
8626               last = ref_from_discarded;
8627             }
8628           else
8629             *drop = last;
8630         }
8631
8632       free (used);
8633
8634       if (some_unused)
8635         {
8636           bfd_byte *contents, *src;
8637           unsigned long off;
8638           Elf_Internal_Sym *sym;
8639           bfd_boolean local_toc_syms = FALSE;
8640
8641           /* Shuffle the toc contents, and at the same time convert the
8642              skip array from booleans into offsets.  */
8643           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8644             goto error_ret;
8645
8646           elf_section_data (toc)->this_hdr.contents = contents;
8647
8648           for (src = contents, off = 0, drop = skip;
8649                src < contents + toc->size;
8650                src += 8, ++drop)
8651             {
8652               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8653                 off += 8;
8654               else if (off != 0)
8655                 {
8656                   *drop = off;
8657                   memcpy (src - off, src, 8);
8658                 }
8659             }
8660           *drop = off;
8661           toc->rawsize = toc->size;
8662           toc->size = src - contents - off;
8663
8664           /* Adjust addends for relocs against the toc section sym,
8665              and optimize any accesses we can.  */
8666           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8667             {
8668               if (sec->reloc_count == 0
8669                   || discarded_section (sec))
8670                 continue;
8671
8672               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8673                                                     info->keep_memory);
8674               if (relstart == NULL)
8675                 goto error_ret;
8676
8677               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8678                 {
8679                   enum elf_ppc64_reloc_type r_type;
8680                   unsigned long r_symndx;
8681                   asection *sym_sec;
8682                   struct elf_link_hash_entry *h;
8683                   bfd_vma val;
8684
8685                   r_type = ELF64_R_TYPE (rel->r_info);
8686                   switch (r_type)
8687                     {
8688                     default:
8689                       continue;
8690
8691                     case R_PPC64_TOC16:
8692                     case R_PPC64_TOC16_LO:
8693                     case R_PPC64_TOC16_HI:
8694                     case R_PPC64_TOC16_HA:
8695                     case R_PPC64_TOC16_DS:
8696                     case R_PPC64_TOC16_LO_DS:
8697                     case R_PPC64_ADDR64:
8698                       break;
8699                     }
8700
8701                   r_symndx = ELF64_R_SYM (rel->r_info);
8702                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8703                                   r_symndx, ibfd))
8704                     goto error_ret;
8705
8706                   if (sym_sec != toc)
8707                     continue;
8708
8709                   if (h != NULL)
8710                     val = h->root.u.def.value;
8711                   else
8712                     {
8713                       val = sym->st_value;
8714                       if (val != 0)
8715                         local_toc_syms = TRUE;
8716                     }
8717
8718                   val += rel->r_addend;
8719
8720                   if (val > toc->rawsize)
8721                     val = toc->rawsize;
8722                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8723                     continue;
8724                   else if ((skip[val >> 3] & can_optimize) != 0)
8725                     {
8726                       Elf_Internal_Rela *tocrel
8727                         = toc_relocs + (skip[val >> 3] >> 2);
8728                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8729
8730                       switch (r_type)
8731                         {
8732                         case R_PPC64_TOC16_HA:
8733                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8734                           break;
8735
8736                         case R_PPC64_TOC16_LO_DS:
8737                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8738                           break;
8739
8740                         default:
8741                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8742                             ppc_howto_init ();
8743                           info->callbacks->einfo
8744                             (_("%P: %H: %s references "
8745                                "optimized away TOC entry\n"),
8746                              ibfd, sec, rel->r_offset,
8747                              ppc64_elf_howto_table[r_type]->name);
8748                           bfd_set_error (bfd_error_bad_value);
8749                           goto error_ret;
8750                         }
8751                       rel->r_addend = tocrel->r_addend;
8752                       elf_section_data (sec)->relocs = relstart;
8753                       continue;
8754                     }
8755
8756                   if (h != NULL || sym->st_value != 0)
8757                     continue;
8758
8759                   rel->r_addend -= skip[val >> 3];
8760                   elf_section_data (sec)->relocs = relstart;
8761                 }
8762
8763               if (elf_section_data (sec)->relocs != relstart)
8764                 free (relstart);
8765             }
8766
8767           /* We shouldn't have local or global symbols defined in the TOC,
8768              but handle them anyway.  */
8769           if (local_syms != NULL)
8770             for (sym = local_syms;
8771                  sym < local_syms + symtab_hdr->sh_info;
8772                  ++sym)
8773               if (sym->st_value != 0
8774                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8775                 {
8776                   unsigned long i;
8777
8778                   if (sym->st_value > toc->rawsize)
8779                     i = toc->rawsize >> 3;
8780                   else
8781                     i = sym->st_value >> 3;
8782
8783                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8784                     {
8785                       if (local_toc_syms)
8786                         (*_bfd_error_handler)
8787                           (_("%s defined on removed toc entry"),
8788                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8789                       do
8790                         ++i;
8791                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8792                       sym->st_value = (bfd_vma) i << 3;
8793                     }
8794
8795                   sym->st_value -= skip[i];
8796                   symtab_hdr->contents = (unsigned char *) local_syms;
8797                 }
8798
8799           /* Adjust any global syms defined in this toc input section.  */
8800           if (toc_inf.global_toc_syms)
8801             {
8802               toc_inf.toc = toc;
8803               toc_inf.skip = skip;
8804               toc_inf.global_toc_syms = FALSE;
8805               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8806                                       &toc_inf);
8807             }
8808
8809           if (toc->reloc_count != 0)
8810             {
8811               Elf_Internal_Shdr *rel_hdr;
8812               Elf_Internal_Rela *wrel;
8813               bfd_size_type sz;
8814
8815               /* Remove unused toc relocs, and adjust those we keep.  */
8816               if (toc_relocs == NULL)
8817                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8818                                                         info->keep_memory);
8819               if (toc_relocs == NULL)
8820                 goto error_ret;
8821
8822               wrel = toc_relocs;
8823               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8824                 if ((skip[rel->r_offset >> 3]
8825                      & (ref_from_discarded | can_optimize)) == 0)
8826                   {
8827                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8828                     wrel->r_info = rel->r_info;
8829                     wrel->r_addend = rel->r_addend;
8830                     ++wrel;
8831                   }
8832                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8833                                             &local_syms, NULL, NULL))
8834                   goto error_ret;
8835
8836               elf_section_data (toc)->relocs = toc_relocs;
8837               toc->reloc_count = wrel - toc_relocs;
8838               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8839               sz = rel_hdr->sh_entsize;
8840               rel_hdr->sh_size = toc->reloc_count * sz;
8841             }
8842         }
8843       else if (toc_relocs != NULL
8844                && elf_section_data (toc)->relocs != toc_relocs)
8845         free (toc_relocs);
8846
8847       if (local_syms != NULL
8848           && symtab_hdr->contents != (unsigned char *) local_syms)
8849         {
8850           if (!info->keep_memory)
8851             free (local_syms);
8852           else
8853             symtab_hdr->contents = (unsigned char *) local_syms;
8854         }
8855       free (skip);
8856     }
8857
8858   return TRUE;
8859 }
8860
8861 /* Return true iff input section I references the TOC using
8862    instructions limited to +/-32k offsets.  */
8863
8864 bfd_boolean
8865 ppc64_elf_has_small_toc_reloc (asection *i)
8866 {
8867   return (is_ppc64_elf (i->owner)
8868           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8869 }
8870
8871 /* Allocate space for one GOT entry.  */
8872
8873 static void
8874 allocate_got (struct elf_link_hash_entry *h,
8875               struct bfd_link_info *info,
8876               struct got_entry *gent)
8877 {
8878   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8879   bfd_boolean dyn;
8880   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8881   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8882                  ? 16 : 8);
8883   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8884                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8885   asection *got = ppc64_elf_tdata (gent->owner)->got;
8886
8887   gent->got.offset = got->size;
8888   got->size += entsize;
8889
8890   dyn = htab->elf.dynamic_sections_created;
8891   if (h->type == STT_GNU_IFUNC)
8892     {
8893       htab->reliplt->size += rentsize;
8894       htab->got_reli_size += rentsize;
8895     }
8896   else if ((info->shared
8897             || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8898            && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8899                || h->root.type != bfd_link_hash_undefweak))
8900     {
8901       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8902       relgot->size += rentsize;
8903     }
8904 }
8905
8906 /* This function merges got entries in the same toc group.  */
8907
8908 static void
8909 merge_got_entries (struct got_entry **pent)
8910 {
8911   struct got_entry *ent, *ent2;
8912
8913   for (ent = *pent; ent != NULL; ent = ent->next)
8914     if (!ent->is_indirect)
8915       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8916         if (!ent2->is_indirect
8917             && ent2->addend == ent->addend
8918             && ent2->tls_type == ent->tls_type
8919             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8920           {
8921             ent2->is_indirect = TRUE;
8922             ent2->got.ent = ent;
8923           }
8924 }
8925
8926 /* Allocate space in .plt, .got and associated reloc sections for
8927    dynamic relocs.  */
8928
8929 static bfd_boolean
8930 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8931 {
8932   struct bfd_link_info *info;
8933   struct ppc_link_hash_table *htab;
8934   asection *s;
8935   struct ppc_link_hash_entry *eh;
8936   struct elf_dyn_relocs *p;
8937   struct got_entry **pgent, *gent;
8938
8939   if (h->root.type == bfd_link_hash_indirect)
8940     return TRUE;
8941
8942   info = (struct bfd_link_info *) inf;
8943   htab = ppc_hash_table (info);
8944   if (htab == NULL)
8945     return FALSE;
8946
8947   if ((htab->elf.dynamic_sections_created
8948        && h->dynindx != -1
8949        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8950       || h->type == STT_GNU_IFUNC)
8951     {
8952       struct plt_entry *pent;
8953       bfd_boolean doneone = FALSE;
8954       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8955         if (pent->plt.refcount > 0)
8956           {
8957             if (!htab->elf.dynamic_sections_created
8958                 || h->dynindx == -1)
8959               {
8960                 s = htab->iplt;
8961                 pent->plt.offset = s->size;
8962                 s->size += PLT_ENTRY_SIZE;
8963                 s = htab->reliplt;
8964               }
8965             else
8966               {
8967                 /* If this is the first .plt entry, make room for the special
8968                    first entry.  */
8969                 s = htab->plt;
8970                 if (s->size == 0)
8971                   s->size += PLT_INITIAL_ENTRY_SIZE;
8972
8973                 pent->plt.offset = s->size;
8974
8975                 /* Make room for this entry.  */
8976                 s->size += PLT_ENTRY_SIZE;
8977
8978                 /* Make room for the .glink code.  */
8979                 s = htab->glink;
8980                 if (s->size == 0)
8981                   s->size += GLINK_CALL_STUB_SIZE;
8982                 /* We need bigger stubs past index 32767.  */
8983                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8984                   s->size += 4;
8985                 s->size += 2*4;
8986
8987                 /* We also need to make an entry in the .rela.plt section.  */
8988                 s = htab->relplt;
8989               }
8990             s->size += sizeof (Elf64_External_Rela);
8991             doneone = TRUE;
8992           }
8993         else
8994           pent->plt.offset = (bfd_vma) -1;
8995       if (!doneone)
8996         {
8997           h->plt.plist = NULL;
8998           h->needs_plt = 0;
8999         }
9000     }
9001   else
9002     {
9003       h->plt.plist = NULL;
9004       h->needs_plt = 0;
9005     }
9006
9007   eh = (struct ppc_link_hash_entry *) h;
9008   /* Run through the TLS GD got entries first if we're changing them
9009      to TPREL.  */
9010   if ((eh->tls_mask & TLS_TPRELGD) != 0)
9011     for (gent = h->got.glist; gent != NULL; gent = gent->next)
9012       if (gent->got.refcount > 0
9013           && (gent->tls_type & TLS_GD) != 0)
9014         {
9015           /* This was a GD entry that has been converted to TPREL.  If
9016              there happens to be a TPREL entry we can use that one.  */
9017           struct got_entry *ent;
9018           for (ent = h->got.glist; ent != NULL; ent = ent->next)
9019             if (ent->got.refcount > 0
9020                 && (ent->tls_type & TLS_TPREL) != 0
9021                 && ent->addend == gent->addend
9022                 && ent->owner == gent->owner)
9023               {
9024                 gent->got.refcount = 0;
9025                 break;
9026               }
9027
9028           /* If not, then we'll be using our own TPREL entry.  */
9029           if (gent->got.refcount != 0)
9030             gent->tls_type = TLS_TLS | TLS_TPREL;
9031         }
9032
9033   /* Remove any list entry that won't generate a word in the GOT before
9034      we call merge_got_entries.  Otherwise we risk merging to empty
9035      entries.  */
9036   pgent = &h->got.glist;
9037   while ((gent = *pgent) != NULL)
9038     if (gent->got.refcount > 0)
9039       {
9040         if ((gent->tls_type & TLS_LD) != 0
9041             && !h->def_dynamic)
9042           {
9043             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9044             *pgent = gent->next;
9045           }
9046         else
9047           pgent = &gent->next;
9048       }
9049     else
9050       *pgent = gent->next;
9051
9052   if (!htab->do_multi_toc)
9053     merge_got_entries (&h->got.glist);
9054
9055   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9056     if (!gent->is_indirect)
9057       {
9058         /* Make sure this symbol is output as a dynamic symbol.
9059            Undefined weak syms won't yet be marked as dynamic,
9060            nor will all TLS symbols.  */
9061         if (h->dynindx == -1
9062             && !h->forced_local
9063             && h->type != STT_GNU_IFUNC
9064             && htab->elf.dynamic_sections_created)
9065           {
9066             if (! bfd_elf_link_record_dynamic_symbol (info, h))
9067               return FALSE;
9068           }
9069
9070         if (!is_ppc64_elf (gent->owner))
9071           abort ();
9072
9073         allocate_got (h, info, gent);
9074       }
9075
9076   if (eh->dyn_relocs == NULL
9077       || (!htab->elf.dynamic_sections_created
9078           && h->type != STT_GNU_IFUNC))
9079     return TRUE;
9080
9081   /* In the shared -Bsymbolic case, discard space allocated for
9082      dynamic pc-relative relocs against symbols which turn out to be
9083      defined in regular objects.  For the normal shared case, discard
9084      space for relocs that have become local due to symbol visibility
9085      changes.  */
9086
9087   if (info->shared)
9088     {
9089       /* Relocs that use pc_count are those that appear on a call insn,
9090          or certain REL relocs (see must_be_dyn_reloc) that can be
9091          generated via assembly.  We want calls to protected symbols to
9092          resolve directly to the function rather than going via the plt.
9093          If people want function pointer comparisons to work as expected
9094          then they should avoid writing weird assembly.  */
9095       if (SYMBOL_CALLS_LOCAL (info, h))
9096         {
9097           struct elf_dyn_relocs **pp;
9098
9099           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9100             {
9101               p->count -= p->pc_count;
9102               p->pc_count = 0;
9103               if (p->count == 0)
9104                 *pp = p->next;
9105               else
9106                 pp = &p->next;
9107             }
9108         }
9109
9110       /* Also discard relocs on undefined weak syms with non-default
9111          visibility.  */
9112       if (eh->dyn_relocs != NULL
9113           && h->root.type == bfd_link_hash_undefweak)
9114         {
9115           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9116             eh->dyn_relocs = NULL;
9117
9118           /* Make sure this symbol is output as a dynamic symbol.
9119              Undefined weak syms won't yet be marked as dynamic.  */
9120           else if (h->dynindx == -1
9121                    && !h->forced_local)
9122             {
9123               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9124                 return FALSE;
9125             }
9126         }
9127     }
9128   else if (h->type == STT_GNU_IFUNC)
9129     {
9130       if (!h->non_got_ref)
9131         eh->dyn_relocs = NULL;
9132     }
9133   else if (ELIMINATE_COPY_RELOCS)
9134     {
9135       /* For the non-shared case, discard space for relocs against
9136          symbols which turn out to need copy relocs or are not
9137          dynamic.  */
9138
9139       if (!h->non_got_ref
9140           && !h->def_regular)
9141         {
9142           /* Make sure this symbol is output as a dynamic symbol.
9143              Undefined weak syms won't yet be marked as dynamic.  */
9144           if (h->dynindx == -1
9145               && !h->forced_local)
9146             {
9147               if (! bfd_elf_link_record_dynamic_symbol (info, h))
9148                 return FALSE;
9149             }
9150
9151           /* If that succeeded, we know we'll be keeping all the
9152              relocs.  */
9153           if (h->dynindx != -1)
9154             goto keep;
9155         }
9156
9157       eh->dyn_relocs = NULL;
9158
9159     keep: ;
9160     }
9161
9162   /* Finally, allocate space.  */
9163   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9164     {
9165       asection *sreloc = elf_section_data (p->sec)->sreloc;
9166       if (eh->elf.type == STT_GNU_IFUNC)
9167         sreloc = htab->reliplt;
9168       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9169     }
9170
9171   return TRUE;
9172 }
9173
9174 /* Find any dynamic relocs that apply to read-only sections.  */
9175
9176 static bfd_boolean
9177 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9178 {
9179   struct ppc_link_hash_entry *eh;
9180   struct elf_dyn_relocs *p;
9181
9182   eh = (struct ppc_link_hash_entry *) h;
9183   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9184     {
9185       asection *s = p->sec->output_section;
9186
9187       if (s != NULL && (s->flags & SEC_READONLY) != 0)
9188         {
9189           struct bfd_link_info *info = inf;
9190
9191           info->flags |= DF_TEXTREL;
9192
9193           /* Not an error, just cut short the traversal.  */
9194           return FALSE;
9195         }
9196     }
9197   return TRUE;
9198 }
9199
9200 /* Set the sizes of the dynamic sections.  */
9201
9202 static bfd_boolean
9203 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9204                                  struct bfd_link_info *info)
9205 {
9206   struct ppc_link_hash_table *htab;
9207   bfd *dynobj;
9208   asection *s;
9209   bfd_boolean relocs;
9210   bfd *ibfd;
9211   struct got_entry *first_tlsld;
9212
9213   htab = ppc_hash_table (info);
9214   if (htab == NULL)
9215     return FALSE;
9216
9217   dynobj = htab->elf.dynobj;
9218   if (dynobj == NULL)
9219     abort ();
9220
9221   if (htab->elf.dynamic_sections_created)
9222     {
9223       /* Set the contents of the .interp section to the interpreter.  */
9224       if (info->executable)
9225         {
9226           s = bfd_get_linker_section (dynobj, ".interp");
9227           if (s == NULL)
9228             abort ();
9229           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9230           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9231         }
9232     }
9233
9234   /* Set up .got offsets for local syms, and space for local dynamic
9235      relocs.  */
9236   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9237     {
9238       struct got_entry **lgot_ents;
9239       struct got_entry **end_lgot_ents;
9240       struct plt_entry **local_plt;
9241       struct plt_entry **end_local_plt;
9242       unsigned char *lgot_masks;
9243       bfd_size_type locsymcount;
9244       Elf_Internal_Shdr *symtab_hdr;
9245
9246       if (!is_ppc64_elf (ibfd))
9247         continue;
9248
9249       for (s = ibfd->sections; s != NULL; s = s->next)
9250         {
9251           struct ppc_dyn_relocs *p;
9252
9253           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9254             {
9255               if (!bfd_is_abs_section (p->sec)
9256                   && bfd_is_abs_section (p->sec->output_section))
9257                 {
9258                   /* Input section has been discarded, either because
9259                      it is a copy of a linkonce section or due to
9260                      linker script /DISCARD/, so we'll be discarding
9261                      the relocs too.  */
9262                 }
9263               else if (p->count != 0)
9264                 {
9265                   asection *srel = elf_section_data (p->sec)->sreloc;
9266                   if (p->ifunc)
9267                     srel = htab->reliplt;
9268                   srel->size += p->count * sizeof (Elf64_External_Rela);
9269                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9270                     info->flags |= DF_TEXTREL;
9271                 }
9272             }
9273         }
9274
9275       lgot_ents = elf_local_got_ents (ibfd);
9276       if (!lgot_ents)
9277         continue;
9278
9279       symtab_hdr = &elf_symtab_hdr (ibfd);
9280       locsymcount = symtab_hdr->sh_info;
9281       end_lgot_ents = lgot_ents + locsymcount;
9282       local_plt = (struct plt_entry **) end_lgot_ents;
9283       end_local_plt = local_plt + locsymcount;
9284       lgot_masks = (unsigned char *) end_local_plt;
9285       s = ppc64_elf_tdata (ibfd)->got;
9286       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9287         {
9288           struct got_entry **pent, *ent;
9289
9290           pent = lgot_ents;
9291           while ((ent = *pent) != NULL)
9292             if (ent->got.refcount > 0)
9293               {
9294                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9295                   {
9296                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9297                     *pent = ent->next;
9298                   }
9299                 else
9300                   {
9301                     unsigned int ent_size = 8;
9302                     unsigned int rel_size = sizeof (Elf64_External_Rela);
9303
9304                     ent->got.offset = s->size;
9305                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9306                       {
9307                         ent_size *= 2;
9308                         rel_size *= 2;
9309                       }
9310                     s->size += ent_size;
9311                     if ((*lgot_masks & PLT_IFUNC) != 0)
9312                       {
9313                         htab->reliplt->size += rel_size;
9314                         htab->got_reli_size += rel_size;
9315                       }
9316                     else if (info->shared)
9317                       {
9318                         asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9319                         srel->size += rel_size;
9320                       }
9321                     pent = &ent->next;
9322                   }
9323               }
9324             else
9325               *pent = ent->next;
9326         }
9327
9328       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9329       for (; local_plt < end_local_plt; ++local_plt)
9330         {
9331           struct plt_entry *ent;
9332
9333           for (ent = *local_plt; ent != NULL; ent = ent->next)
9334             if (ent->plt.refcount > 0)
9335               {
9336                 s = htab->iplt;
9337                 ent->plt.offset = s->size;
9338                 s->size += PLT_ENTRY_SIZE;
9339
9340                 htab->reliplt->size += sizeof (Elf64_External_Rela);
9341               }
9342             else
9343               ent->plt.offset = (bfd_vma) -1;
9344         }
9345     }
9346
9347   /* Allocate global sym .plt and .got entries, and space for global
9348      sym dynamic relocs.  */
9349   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9350
9351   first_tlsld = NULL;
9352   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9353     {
9354       struct got_entry *ent;
9355
9356       if (!is_ppc64_elf (ibfd))
9357         continue;
9358
9359       ent = ppc64_tlsld_got (ibfd);
9360       if (ent->got.refcount > 0)
9361         {
9362           if (!htab->do_multi_toc && first_tlsld != NULL)
9363             {
9364               ent->is_indirect = TRUE;
9365               ent->got.ent = first_tlsld;
9366             }
9367           else
9368             {
9369               if (first_tlsld == NULL)
9370                 first_tlsld = ent;
9371               s = ppc64_elf_tdata (ibfd)->got;
9372               ent->got.offset = s->size;
9373               ent->owner = ibfd;
9374               s->size += 16;
9375               if (info->shared)
9376                 {
9377                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9378                   srel->size += sizeof (Elf64_External_Rela);
9379                 }
9380             }
9381         }
9382       else
9383         ent->got.offset = (bfd_vma) -1;
9384     }
9385
9386   /* We now have determined the sizes of the various dynamic sections.
9387      Allocate memory for them.  */
9388   relocs = FALSE;
9389   for (s = dynobj->sections; s != NULL; s = s->next)
9390     {
9391       if ((s->flags & SEC_LINKER_CREATED) == 0)
9392         continue;
9393
9394       if (s == htab->brlt || s == htab->relbrlt)
9395         /* These haven't been allocated yet;  don't strip.  */
9396         continue;
9397       else if (s == htab->got
9398                || s == htab->plt
9399                || s == htab->iplt
9400                || s == htab->glink
9401                || s == htab->dynbss)
9402         {
9403           /* Strip this section if we don't need it; see the
9404              comment below.  */
9405         }
9406       else if (s == htab->glink_eh_frame)
9407         {
9408           if (!bfd_is_abs_section (s->output_section))
9409             /* Not sized yet.  */
9410             continue;
9411         }
9412       else if (CONST_STRNEQ (s->name, ".rela"))
9413         {
9414           if (s->size != 0)
9415             {
9416               if (s != htab->relplt)
9417                 relocs = TRUE;
9418
9419               /* We use the reloc_count field as a counter if we need
9420                  to copy relocs into the output file.  */
9421               s->reloc_count = 0;
9422             }
9423         }
9424       else
9425         {
9426           /* It's not one of our sections, so don't allocate space.  */
9427           continue;
9428         }
9429
9430       if (s->size == 0)
9431         {
9432           /* If we don't need this section, strip it from the
9433              output file.  This is mostly to handle .rela.bss and
9434              .rela.plt.  We must create both sections in
9435              create_dynamic_sections, because they must be created
9436              before the linker maps input sections to output
9437              sections.  The linker does that before
9438              adjust_dynamic_symbol is called, and it is that
9439              function which decides whether anything needs to go
9440              into these sections.  */
9441           s->flags |= SEC_EXCLUDE;
9442           continue;
9443         }
9444
9445       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9446         continue;
9447
9448       /* Allocate memory for the section contents.  We use bfd_zalloc
9449          here in case unused entries are not reclaimed before the
9450          section's contents are written out.  This should not happen,
9451          but this way if it does we get a R_PPC64_NONE reloc in .rela
9452          sections instead of garbage.
9453          We also rely on the section contents being zero when writing
9454          the GOT.  */
9455       s->contents = bfd_zalloc (dynobj, s->size);
9456       if (s->contents == NULL)
9457         return FALSE;
9458     }
9459
9460   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9461     {
9462       if (!is_ppc64_elf (ibfd))
9463         continue;
9464
9465       s = ppc64_elf_tdata (ibfd)->got;
9466       if (s != NULL && s != htab->got)
9467         {
9468           if (s->size == 0)
9469             s->flags |= SEC_EXCLUDE;
9470           else
9471             {
9472               s->contents = bfd_zalloc (ibfd, s->size);
9473               if (s->contents == NULL)
9474                 return FALSE;
9475             }
9476         }
9477       s = ppc64_elf_tdata (ibfd)->relgot;
9478       if (s != NULL)
9479         {
9480           if (s->size == 0)
9481             s->flags |= SEC_EXCLUDE;
9482           else
9483             {
9484               s->contents = bfd_zalloc (ibfd, s->size);
9485               if (s->contents == NULL)
9486                 return FALSE;
9487               relocs = TRUE;
9488               s->reloc_count = 0;
9489             }
9490         }
9491     }
9492
9493   if (htab->elf.dynamic_sections_created)
9494     {
9495       /* Add some entries to the .dynamic section.  We fill in the
9496          values later, in ppc64_elf_finish_dynamic_sections, but we
9497          must add the entries now so that we get the correct size for
9498          the .dynamic section.  The DT_DEBUG entry is filled in by the
9499          dynamic linker and used by the debugger.  */
9500 #define add_dynamic_entry(TAG, VAL) \
9501   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9502
9503       if (info->executable)
9504         {
9505           if (!add_dynamic_entry (DT_DEBUG, 0))
9506             return FALSE;
9507         }
9508
9509       if (htab->plt != NULL && htab->plt->size != 0)
9510         {
9511           if (!add_dynamic_entry (DT_PLTGOT, 0)
9512               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9513               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9514               || !add_dynamic_entry (DT_JMPREL, 0)
9515               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9516             return FALSE;
9517         }
9518
9519       if (NO_OPD_RELOCS)
9520         {
9521           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9522               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9523             return FALSE;
9524         }
9525
9526       if (!htab->no_tls_get_addr_opt
9527           && htab->tls_get_addr_fd != NULL
9528           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9529           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9530         return FALSE;
9531
9532       if (relocs)
9533         {
9534           if (!add_dynamic_entry (DT_RELA, 0)
9535               || !add_dynamic_entry (DT_RELASZ, 0)
9536               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9537             return FALSE;
9538
9539           /* If any dynamic relocs apply to a read-only section,
9540              then we need a DT_TEXTREL entry.  */
9541           if ((info->flags & DF_TEXTREL) == 0)
9542             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9543
9544           if ((info->flags & DF_TEXTREL) != 0)
9545             {
9546               if (!add_dynamic_entry (DT_TEXTREL, 0))
9547                 return FALSE;
9548             }
9549         }
9550     }
9551 #undef add_dynamic_entry
9552
9553   return TRUE;
9554 }
9555
9556 /* Determine the type of stub needed, if any, for a call.  */
9557
9558 static inline enum ppc_stub_type
9559 ppc_type_of_stub (asection *input_sec,
9560                   const Elf_Internal_Rela *rel,
9561                   struct ppc_link_hash_entry **hash,
9562                   struct plt_entry **plt_ent,
9563                   bfd_vma destination)
9564 {
9565   struct ppc_link_hash_entry *h = *hash;
9566   bfd_vma location;
9567   bfd_vma branch_offset;
9568   bfd_vma max_branch_offset;
9569   enum elf_ppc64_reloc_type r_type;
9570
9571   if (h != NULL)
9572     {
9573       struct plt_entry *ent;
9574       struct ppc_link_hash_entry *fdh = h;
9575       if (h->oh != NULL
9576           && h->oh->is_func_descriptor)
9577         {
9578           fdh = ppc_follow_link (h->oh);
9579           *hash = fdh;
9580         }
9581
9582       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9583         if (ent->addend == rel->r_addend
9584             && ent->plt.offset != (bfd_vma) -1)
9585           {
9586             *plt_ent = ent;
9587             return ppc_stub_plt_call;
9588           }
9589
9590       /* Here, we know we don't have a plt entry.  If we don't have a
9591          either a defined function descriptor or a defined entry symbol
9592          in a regular object file, then it is pointless trying to make
9593          any other type of stub.  */
9594       if (!is_static_defined (&fdh->elf)
9595           && !is_static_defined (&h->elf))
9596         return ppc_stub_none;
9597     }
9598   else if (elf_local_got_ents (input_sec->owner) != NULL)
9599     {
9600       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9601       struct plt_entry **local_plt = (struct plt_entry **)
9602         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9603       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9604
9605       if (local_plt[r_symndx] != NULL)
9606         {
9607           struct plt_entry *ent;
9608
9609           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9610             if (ent->addend == rel->r_addend
9611                 && ent->plt.offset != (bfd_vma) -1)
9612               {
9613                 *plt_ent = ent;
9614                 return ppc_stub_plt_call;
9615               }
9616         }
9617     }
9618
9619   /* Determine where the call point is.  */
9620   location = (input_sec->output_offset
9621               + input_sec->output_section->vma
9622               + rel->r_offset);
9623
9624   branch_offset = destination - location;
9625   r_type = ELF64_R_TYPE (rel->r_info);
9626
9627   /* Determine if a long branch stub is needed.  */
9628   max_branch_offset = 1 << 25;
9629   if (r_type != R_PPC64_REL24)
9630     max_branch_offset = 1 << 15;
9631
9632   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9633     /* We need a stub.  Figure out whether a long_branch or plt_branch
9634        is needed later.  */
9635     return ppc_stub_long_branch;
9636
9637   return ppc_stub_none;
9638 }
9639
9640 /* With power7 weakly ordered memory model, it is possible for ld.so
9641    to update a plt entry in one thread and have another thread see a
9642    stale zero toc entry.  To avoid this we need some sort of acquire
9643    barrier in the call stub.  One solution is to make the load of the
9644    toc word seem to appear to depend on the load of the function entry
9645    word.  Another solution is to test for r2 being zero, and branch to
9646    the appropriate glink entry if so.
9647
9648    .    fake dep barrier        compare
9649    .    ld 11,xxx(2)            ld 11,xxx(2)
9650    .    mtctr 11                mtctr 11
9651    .    xor 11,11,11            ld 2,xxx+8(2)
9652    .    add 2,2,11              cmpldi 2,0
9653    .    ld 2,xxx+8(2)           bnectr+
9654    .    bctr                    b <glink_entry>
9655
9656    The solution involving the compare turns out to be faster, so
9657    that's what we use unless the branch won't reach.  */
9658
9659 #define ALWAYS_USE_FAKE_DEP 0
9660 #define ALWAYS_EMIT_R2SAVE 0
9661
9662 #define PPC_LO(v) ((v) & 0xffff)
9663 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9664 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9665
9666 static inline unsigned int
9667 plt_stub_size (struct ppc_link_hash_table *htab,
9668                struct ppc_stub_hash_entry *stub_entry,
9669                bfd_vma off)
9670 {
9671   unsigned size = PLT_CALL_STUB_SIZE;
9672
9673   if (!(ALWAYS_EMIT_R2SAVE
9674         || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9675     size -= 4;
9676   if (!htab->plt_static_chain)
9677     size -= 4;
9678   if (htab->plt_thread_safe)
9679     size += 8;
9680   if (PPC_HA (off) == 0)
9681     size -= 4;
9682   if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9683     size += 4;
9684   if (stub_entry->h != NULL
9685       && (stub_entry->h == htab->tls_get_addr_fd
9686           || stub_entry->h == htab->tls_get_addr)
9687       && !htab->no_tls_get_addr_opt)
9688     size += 13 * 4;
9689   return size;
9690 }
9691
9692 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9693    then return the padding needed to do so.  */
9694 static inline unsigned int
9695 plt_stub_pad (struct ppc_link_hash_table *htab,
9696               struct ppc_stub_hash_entry *stub_entry,
9697               bfd_vma plt_off)
9698 {
9699   int stub_align = 1 << htab->plt_stub_align;
9700   unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9701   bfd_vma stub_off = stub_entry->stub_sec->size;
9702
9703   if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9704       > (stub_size & -stub_align))
9705     return stub_align - (stub_off & (stub_align - 1));
9706   return 0;
9707 }
9708
9709 /* Build a .plt call stub.  */
9710
9711 static inline bfd_byte *
9712 build_plt_stub (struct ppc_link_hash_table *htab,
9713                 struct ppc_stub_hash_entry *stub_entry,
9714                 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9715 {
9716   bfd *obfd = htab->stub_bfd;
9717   bfd_boolean plt_static_chain = htab->plt_static_chain;
9718   bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9719   bfd_boolean use_fake_dep = plt_thread_safe;
9720   bfd_vma cmp_branch_off = 0;
9721
9722   if (!ALWAYS_USE_FAKE_DEP
9723       && plt_thread_safe
9724       && !(stub_entry->h != NULL
9725            && (stub_entry->h == htab->tls_get_addr_fd
9726                || stub_entry->h == htab->tls_get_addr)
9727            && !htab->no_tls_get_addr_opt))
9728     {
9729       bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9730       bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9731       bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9732       bfd_vma to, from;
9733
9734       if (pltindex > 32768)
9735         glinkoff += (pltindex - 32768) * 4;
9736       to = (glinkoff
9737             + htab->glink->output_offset
9738             + htab->glink->output_section->vma);
9739       from = (p - stub_entry->stub_sec->contents
9740               + 4 * (ALWAYS_EMIT_R2SAVE
9741                      || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9742               + 4 * (PPC_HA (offset) != 0)
9743               + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9744                      != PPC_HA (offset))
9745               + 4 * (plt_static_chain != 0)
9746               + 20
9747               + stub_entry->stub_sec->output_offset
9748               + stub_entry->stub_sec->output_section->vma);
9749       cmp_branch_off = to - from;
9750       use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9751     }
9752
9753   if (PPC_HA (offset) != 0)
9754     {
9755       if (r != NULL)
9756         {
9757           if (ALWAYS_EMIT_R2SAVE
9758               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9759             r[0].r_offset += 4;
9760           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9761           r[1].r_offset = r[0].r_offset + 4;
9762           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9763           r[1].r_addend = r[0].r_addend;
9764           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9765             {
9766               r[2].r_offset = r[1].r_offset + 4;
9767               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9768               r[2].r_addend = r[0].r_addend;
9769             }
9770           else
9771             {
9772               r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
9773               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9774               r[2].r_addend = r[0].r_addend + 8;
9775               if (plt_static_chain)
9776                 {
9777                   r[3].r_offset = r[2].r_offset + 4;
9778                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9779                   r[3].r_addend = r[0].r_addend + 16;
9780                 }
9781             }
9782         }
9783       if (ALWAYS_EMIT_R2SAVE
9784           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9785         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
9786       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9787       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9788       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9789         {
9790           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9791           offset = 0;
9792         }
9793       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9794       if (use_fake_dep)
9795         {
9796           bfd_put_32 (obfd, XOR_R11_R11_R11, p),                p += 4;
9797           bfd_put_32 (obfd, ADD_R12_R12_R11, p),                p += 4;
9798         }
9799       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9800       if (plt_static_chain)
9801         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9802     }
9803   else
9804     {
9805       if (r != NULL)
9806         {
9807           if (ALWAYS_EMIT_R2SAVE
9808               || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9809             r[0].r_offset += 4;
9810           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9811           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9812             {
9813               r[1].r_offset = r[0].r_offset + 4;
9814               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9815               r[1].r_addend = r[0].r_addend;
9816             }
9817           else
9818             {
9819               r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
9820               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9821               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9822               if (plt_static_chain)
9823                 {
9824                   r[2].r_offset = r[1].r_offset + 4;
9825                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9826                   r[2].r_addend = r[0].r_addend + 8;
9827                 }
9828             }
9829         }
9830       if (ALWAYS_EMIT_R2SAVE
9831           || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9832         bfd_put_32 (obfd, STD_R2_40R1, p),                      p += 4;
9833       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9834       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9835         {
9836           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9837           offset = 0;
9838         }
9839       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9840       if (use_fake_dep)
9841         {
9842           bfd_put_32 (obfd, XOR_R11_R11_R11, p),                p += 4;
9843           bfd_put_32 (obfd, ADD_R2_R2_R11, p),                  p += 4;
9844         }
9845       if (plt_static_chain)
9846         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9847       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9848     }
9849   if (plt_thread_safe && !use_fake_dep)
9850     {
9851       bfd_put_32 (obfd, CMPLDI_R2_0, p),                        p += 4;
9852       bfd_put_32 (obfd, BNECTR_P4, p),                          p += 4;
9853       bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
9854     }
9855   else
9856     bfd_put_32 (obfd, BCTR, p),                                 p += 4;
9857   return p;
9858 }
9859
9860 /* Build a special .plt call stub for __tls_get_addr.  */
9861
9862 #define LD_R11_0R3      0xe9630000
9863 #define LD_R12_0R3      0xe9830000
9864 #define MR_R0_R3        0x7c601b78
9865 #define CMPDI_R11_0     0x2c2b0000
9866 #define ADD_R3_R12_R13  0x7c6c6a14
9867 #define BEQLR           0x4d820020
9868 #define MR_R3_R0        0x7c030378
9869 #define MFLR_R11        0x7d6802a6
9870 #define STD_R11_0R1     0xf9610000
9871 #define BCTRL           0x4e800421
9872 #define LD_R11_0R1      0xe9610000
9873 #define LD_R2_0R1       0xe8410000
9874 #define MTLR_R11        0x7d6803a6
9875
9876 static inline bfd_byte *
9877 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
9878                          struct ppc_stub_hash_entry *stub_entry,
9879                          bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9880 {
9881   bfd *obfd = htab->stub_bfd;
9882
9883   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9884   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9885   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9886   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9887   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9888   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9889   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9890   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9891   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9892
9893   if (r != NULL)
9894     r[0].r_offset += 9 * 4;
9895   p = build_plt_stub (htab, stub_entry, p, offset, r);
9896   bfd_put_32 (obfd, BCTRL, p - 4);
9897
9898   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9899   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9900   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9901   bfd_put_32 (obfd, BLR, p),                    p += 4;
9902
9903   return p;
9904 }
9905
9906 static Elf_Internal_Rela *
9907 get_relocs (asection *sec, int count)
9908 {
9909   Elf_Internal_Rela *relocs;
9910   struct bfd_elf_section_data *elfsec_data;
9911
9912   elfsec_data = elf_section_data (sec);
9913   relocs = elfsec_data->relocs;
9914   if (relocs == NULL)
9915     {
9916       bfd_size_type relsize;
9917       relsize = sec->reloc_count * sizeof (*relocs);
9918       relocs = bfd_alloc (sec->owner, relsize);
9919       if (relocs == NULL)
9920         return NULL;
9921       elfsec_data->relocs = relocs;
9922       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9923                                           sizeof (Elf_Internal_Shdr));
9924       if (elfsec_data->rela.hdr == NULL)
9925         return NULL;
9926       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9927                                         * sizeof (Elf64_External_Rela));
9928       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9929       sec->reloc_count = 0;
9930     }
9931   relocs += sec->reloc_count;
9932   sec->reloc_count += count;
9933   return relocs;
9934 }
9935
9936 static bfd_vma
9937 get_r2off (struct bfd_link_info *info,
9938            struct ppc_stub_hash_entry *stub_entry)
9939 {
9940   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9941   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9942
9943   if (r2off == 0)
9944     {
9945       /* Support linking -R objects.  Get the toc pointer from the
9946          opd entry.  */
9947       char buf[8];
9948       asection *opd = stub_entry->h->elf.root.u.def.section;
9949       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9950
9951       if (strcmp (opd->name, ".opd") != 0
9952           || opd->reloc_count != 0)
9953         {
9954           info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
9955                                   stub_entry->h->elf.root.root.string);
9956           bfd_set_error (bfd_error_bad_value);
9957           return 0;
9958         }
9959       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9960         return 0;
9961       r2off = bfd_get_64 (opd->owner, buf);
9962       r2off -= elf_gp (info->output_bfd);
9963     }
9964   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9965   return r2off;
9966 }
9967
9968 static bfd_boolean
9969 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9970 {
9971   struct ppc_stub_hash_entry *stub_entry;
9972   struct ppc_branch_hash_entry *br_entry;
9973   struct bfd_link_info *info;
9974   struct ppc_link_hash_table *htab;
9975   bfd_byte *loc;
9976   bfd_byte *p;
9977   bfd_vma dest, off;
9978   int size;
9979   Elf_Internal_Rela *r;
9980   asection *plt;
9981
9982   /* Massage our args to the form they really have.  */
9983   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9984   info = in_arg;
9985
9986   htab = ppc_hash_table (info);
9987   if (htab == NULL)
9988     return FALSE;
9989
9990   /* Make a note of the offset within the stubs for this entry.  */
9991   stub_entry->stub_offset = stub_entry->stub_sec->size;
9992   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9993
9994   htab->stub_count[stub_entry->stub_type - 1] += 1;
9995   switch (stub_entry->stub_type)
9996     {
9997     case ppc_stub_long_branch:
9998     case ppc_stub_long_branch_r2off:
9999       /* Branches are relative.  This is where we are going to.  */
10000       off = dest = (stub_entry->target_value
10001                     + stub_entry->target_section->output_offset
10002                     + stub_entry->target_section->output_section->vma);
10003
10004       /* And this is where we are coming from.  */
10005       off -= (stub_entry->stub_offset
10006               + stub_entry->stub_sec->output_offset
10007               + stub_entry->stub_sec->output_section->vma);
10008
10009       size = 4;
10010       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10011         {
10012           bfd_vma r2off = get_r2off (info, stub_entry);
10013
10014           if (r2off == 0)
10015             {
10016               htab->stub_error = TRUE;
10017               return FALSE;
10018             }
10019           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10020           loc += 4;
10021           size = 12;
10022           if (PPC_HA (r2off) != 0)
10023             {
10024               size = 16;
10025               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10026               loc += 4;
10027             }
10028           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10029           loc += 4;
10030           off -= size - 4;
10031         }
10032       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10033
10034       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10035         {
10036           info->callbacks->einfo
10037             (_("%P: long branch stub `%s' offset overflow\n"),
10038              stub_entry->root.string);
10039           htab->stub_error = TRUE;
10040           return FALSE;
10041         }
10042
10043       if (info->emitrelocations)
10044         {
10045           r = get_relocs (stub_entry->stub_sec, 1);
10046           if (r == NULL)
10047             return FALSE;
10048           r->r_offset = loc - stub_entry->stub_sec->contents;
10049           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10050           r->r_addend = dest;
10051           if (stub_entry->h != NULL)
10052             {
10053               struct elf_link_hash_entry **hashes;
10054               unsigned long symndx;
10055               struct ppc_link_hash_entry *h;
10056
10057               hashes = elf_sym_hashes (htab->stub_bfd);
10058               if (hashes == NULL)
10059                 {
10060                   bfd_size_type hsize;
10061
10062                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10063                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
10064                   if (hashes == NULL)
10065                     return FALSE;
10066                   elf_sym_hashes (htab->stub_bfd) = hashes;
10067                   htab->stub_globals = 1;
10068                 }
10069               symndx = htab->stub_globals++;
10070               h = stub_entry->h;
10071               hashes[symndx] = &h->elf;
10072               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10073               if (h->oh != NULL && h->oh->is_func)
10074                 h = ppc_follow_link (h->oh);
10075               if (h->elf.root.u.def.section != stub_entry->target_section)
10076                 /* H is an opd symbol.  The addend must be zero.  */
10077                 r->r_addend = 0;
10078               else
10079                 {
10080                   off = (h->elf.root.u.def.value
10081                          + h->elf.root.u.def.section->output_offset
10082                          + h->elf.root.u.def.section->output_section->vma);
10083                   r->r_addend -= off;
10084                 }
10085             }
10086         }
10087       break;
10088
10089     case ppc_stub_plt_branch:
10090     case ppc_stub_plt_branch_r2off:
10091       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10092                                          stub_entry->root.string + 9,
10093                                          FALSE, FALSE);
10094       if (br_entry == NULL)
10095         {
10096           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10097                                   stub_entry->root.string);
10098           htab->stub_error = TRUE;
10099           return FALSE;
10100         }
10101
10102       dest = (stub_entry->target_value
10103               + stub_entry->target_section->output_offset
10104               + stub_entry->target_section->output_section->vma);
10105
10106       bfd_put_64 (htab->brlt->owner, dest,
10107                   htab->brlt->contents + br_entry->offset);
10108
10109       if (br_entry->iter == htab->stub_iteration)
10110         {
10111           br_entry->iter = 0;
10112
10113           if (htab->relbrlt != NULL)
10114             {
10115               /* Create a reloc for the branch lookup table entry.  */
10116               Elf_Internal_Rela rela;
10117               bfd_byte *rl;
10118
10119               rela.r_offset = (br_entry->offset
10120                                + htab->brlt->output_offset
10121                                + htab->brlt->output_section->vma);
10122               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10123               rela.r_addend = dest;
10124
10125               rl = htab->relbrlt->contents;
10126               rl += (htab->relbrlt->reloc_count++
10127                      * sizeof (Elf64_External_Rela));
10128               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10129             }
10130           else if (info->emitrelocations)
10131             {
10132               r = get_relocs (htab->brlt, 1);
10133               if (r == NULL)
10134                 return FALSE;
10135               /* brlt, being SEC_LINKER_CREATED does not go through the
10136                  normal reloc processing.  Symbols and offsets are not
10137                  translated from input file to output file form, so
10138                  set up the offset per the output file.  */
10139               r->r_offset = (br_entry->offset
10140                              + htab->brlt->output_offset
10141                              + htab->brlt->output_section->vma);
10142               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10143               r->r_addend = dest;
10144             }
10145         }
10146
10147       dest = (br_entry->offset
10148               + htab->brlt->output_offset
10149               + htab->brlt->output_section->vma);
10150
10151       off = (dest
10152              - elf_gp (htab->brlt->output_section->owner)
10153              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10154
10155       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10156         {
10157           info->callbacks->einfo
10158             (_("%P: linkage table error against `%T'\n"),
10159              stub_entry->root.string);
10160           bfd_set_error (bfd_error_bad_value);
10161           htab->stub_error = TRUE;
10162           return FALSE;
10163         }
10164
10165       if (info->emitrelocations)
10166         {
10167           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10168           if (r == NULL)
10169             return FALSE;
10170           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10171           if (bfd_big_endian (info->output_bfd))
10172             r[0].r_offset += 2;
10173           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10174             r[0].r_offset += 4;
10175           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10176           r[0].r_addend = dest;
10177           if (PPC_HA (off) != 0)
10178             {
10179               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10180               r[1].r_offset = r[0].r_offset + 4;
10181               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10182               r[1].r_addend = r[0].r_addend;
10183             }
10184         }
10185
10186       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10187         {
10188           if (PPC_HA (off) != 0)
10189             {
10190               size = 16;
10191               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10192               loc += 4;
10193               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10194             }
10195           else
10196             {
10197               size = 12;
10198               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10199             }
10200         }
10201       else
10202         {
10203           bfd_vma r2off = get_r2off (info, stub_entry);
10204
10205           if (r2off == 0)
10206             {
10207               htab->stub_error = TRUE;
10208               return FALSE;
10209             }
10210
10211           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10212           loc += 4;
10213           size = 20;
10214           if (PPC_HA (off) != 0)
10215             {
10216               size += 4;
10217               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10218               loc += 4;
10219               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10220               loc += 4;
10221             }
10222           else
10223             {
10224               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10225               loc += 4;
10226             }
10227
10228           if (PPC_HA (r2off) != 0)
10229             {
10230               size += 4;
10231               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10232               loc += 4;
10233             }
10234           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10235         }
10236       loc += 4;
10237       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
10238       loc += 4;
10239       bfd_put_32 (htab->stub_bfd, BCTR, loc);
10240       break;
10241
10242     case ppc_stub_plt_call:
10243     case ppc_stub_plt_call_r2save:
10244       if (stub_entry->h != NULL
10245           && stub_entry->h->is_func_descriptor
10246           && stub_entry->h->oh != NULL)
10247         {
10248           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10249
10250           /* If the old-ABI "dot-symbol" is undefined make it weak so
10251              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10252              FIXME: We used to define the symbol on one of the call
10253              stubs instead, which is why we test symbol section id
10254              against htab->top_id in various places.  Likely all
10255              these checks could now disappear.  */
10256           if (fh->elf.root.type == bfd_link_hash_undefined)
10257             fh->elf.root.type = bfd_link_hash_undefweak;
10258           /* Stop undo_symbol_twiddle changing it back to undefined.  */
10259           fh->was_undefined = 0;
10260         }
10261
10262       /* Now build the stub.  */
10263       dest = stub_entry->plt_ent->plt.offset & ~1;
10264       if (dest >= (bfd_vma) -2)
10265         abort ();
10266
10267       plt = htab->plt;
10268       if (!htab->elf.dynamic_sections_created
10269           || stub_entry->h == NULL
10270           || stub_entry->h->elf.dynindx == -1)
10271         plt = htab->iplt;
10272
10273       dest += plt->output_offset + plt->output_section->vma;
10274
10275       if (stub_entry->h == NULL
10276           && (stub_entry->plt_ent->plt.offset & 1) == 0)
10277         {
10278           Elf_Internal_Rela rela;
10279           bfd_byte *rl;
10280
10281           rela.r_offset = dest;
10282           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10283           rela.r_addend = (stub_entry->target_value
10284                            + stub_entry->target_section->output_offset
10285                            + stub_entry->target_section->output_section->vma);
10286
10287           rl = (htab->reliplt->contents
10288                 + (htab->reliplt->reloc_count++
10289                    * sizeof (Elf64_External_Rela)));
10290           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10291           stub_entry->plt_ent->plt.offset |= 1;
10292         }
10293
10294       off = (dest
10295              - elf_gp (plt->output_section->owner)
10296              - htab->stub_group[stub_entry->id_sec->id].toc_off);
10297
10298       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10299         {
10300           info->callbacks->einfo
10301             (_("%P: linkage table error against `%T'\n"),
10302              stub_entry->h != NULL
10303              ? stub_entry->h->elf.root.root.string
10304              : "<local sym>");
10305           bfd_set_error (bfd_error_bad_value);
10306           htab->stub_error = TRUE;
10307           return FALSE;
10308         }
10309
10310       if (htab->plt_stub_align != 0)
10311         {
10312           unsigned pad = plt_stub_pad (htab, stub_entry, off);
10313
10314           stub_entry->stub_sec->size += pad;
10315           stub_entry->stub_offset = stub_entry->stub_sec->size;
10316           loc += pad;
10317         }
10318
10319       r = NULL;
10320       if (info->emitrelocations)
10321         {
10322           r = get_relocs (stub_entry->stub_sec,
10323                           (2
10324                            + (PPC_HA (off) != 0)
10325                            + (htab->plt_static_chain
10326                               && PPC_HA (off + 16) == PPC_HA (off))));
10327           if (r == NULL)
10328             return FALSE;
10329           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10330           if (bfd_big_endian (info->output_bfd))
10331             r[0].r_offset += 2;
10332           r[0].r_addend = dest;
10333         }
10334       if (stub_entry->h != NULL
10335           && (stub_entry->h == htab->tls_get_addr_fd
10336               || stub_entry->h == htab->tls_get_addr)
10337           && !htab->no_tls_get_addr_opt)
10338         p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10339       else
10340         p = build_plt_stub (htab, stub_entry, loc, off, r);
10341       size = p - loc;
10342       break;
10343
10344     default:
10345       BFD_FAIL ();
10346       return FALSE;
10347     }
10348
10349   stub_entry->stub_sec->size += size;
10350
10351   if (htab->emit_stub_syms)
10352     {
10353       struct elf_link_hash_entry *h;
10354       size_t len1, len2;
10355       char *name;
10356       const char *const stub_str[] = { "long_branch",
10357                                        "long_branch_r2off",
10358                                        "plt_branch",
10359                                        "plt_branch_r2off",
10360                                        "plt_call",
10361                                        "plt_call" };
10362
10363       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10364       len2 = strlen (stub_entry->root.string);
10365       name = bfd_malloc (len1 + len2 + 2);
10366       if (name == NULL)
10367         return FALSE;
10368       memcpy (name, stub_entry->root.string, 9);
10369       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10370       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10371       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10372       if (h == NULL)
10373         return FALSE;
10374       if (h->root.type == bfd_link_hash_new)
10375         {
10376           h->root.type = bfd_link_hash_defined;
10377           h->root.u.def.section = stub_entry->stub_sec;
10378           h->root.u.def.value = stub_entry->stub_offset;
10379           h->ref_regular = 1;
10380           h->def_regular = 1;
10381           h->ref_regular_nonweak = 1;
10382           h->forced_local = 1;
10383           h->non_elf = 0;
10384         }
10385     }
10386
10387   return TRUE;
10388 }
10389
10390 /* As above, but don't actually build the stub.  Just bump offset so
10391    we know stub section sizes, and select plt_branch stubs where
10392    long_branch stubs won't do.  */
10393
10394 static bfd_boolean
10395 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10396 {
10397   struct ppc_stub_hash_entry *stub_entry;
10398   struct bfd_link_info *info;
10399   struct ppc_link_hash_table *htab;
10400   bfd_vma off;
10401   int size;
10402
10403   /* Massage our args to the form they really have.  */
10404   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10405   info = in_arg;
10406
10407   htab = ppc_hash_table (info);
10408   if (htab == NULL)
10409     return FALSE;
10410
10411   if (stub_entry->stub_type == ppc_stub_plt_call
10412       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10413     {
10414       asection *plt;
10415       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10416       if (off >= (bfd_vma) -2)
10417         abort ();
10418       plt = htab->plt;
10419       if (!htab->elf.dynamic_sections_created
10420           || stub_entry->h == NULL
10421           || stub_entry->h->elf.dynindx == -1)
10422         plt = htab->iplt;
10423       off += (plt->output_offset
10424               + plt->output_section->vma
10425               - elf_gp (plt->output_section->owner)
10426               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10427
10428       size = plt_stub_size (htab, stub_entry, off);
10429       if (htab->plt_stub_align)
10430         size += plt_stub_pad (htab, stub_entry, off);
10431       if (info->emitrelocations)
10432         {
10433           stub_entry->stub_sec->reloc_count
10434             += (2
10435                 + (PPC_HA (off) != 0)
10436                 + (htab->plt_static_chain
10437                    && PPC_HA (off + 16) == PPC_HA (off)));
10438           stub_entry->stub_sec->flags |= SEC_RELOC;
10439         }
10440     }
10441   else
10442     {
10443       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10444          variants.  */
10445       bfd_vma r2off = 0;
10446
10447       off = (stub_entry->target_value
10448              + stub_entry->target_section->output_offset
10449              + stub_entry->target_section->output_section->vma);
10450       off -= (stub_entry->stub_sec->size
10451               + stub_entry->stub_sec->output_offset
10452               + stub_entry->stub_sec->output_section->vma);
10453
10454       /* Reset the stub type from the plt variant in case we now
10455          can reach with a shorter stub.  */
10456       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10457         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10458
10459       size = 4;
10460       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10461         {
10462           r2off = get_r2off (info, stub_entry);
10463           if (r2off == 0)
10464             {
10465               htab->stub_error = TRUE;
10466               return FALSE;
10467             }
10468           size = 12;
10469           if (PPC_HA (r2off) != 0)
10470             size = 16;
10471           off -= size - 4;
10472         }
10473
10474       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
10475       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10476         {
10477           struct ppc_branch_hash_entry *br_entry;
10478
10479           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10480                                              stub_entry->root.string + 9,
10481                                              TRUE, FALSE);
10482           if (br_entry == NULL)
10483             {
10484               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10485                                       stub_entry->root.string);
10486               htab->stub_error = TRUE;
10487               return FALSE;
10488             }
10489
10490           if (br_entry->iter != htab->stub_iteration)
10491             {
10492               br_entry->iter = htab->stub_iteration;
10493               br_entry->offset = htab->brlt->size;
10494               htab->brlt->size += 8;
10495
10496               if (htab->relbrlt != NULL)
10497                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10498               else if (info->emitrelocations)
10499                 {
10500                   htab->brlt->reloc_count += 1;
10501                   htab->brlt->flags |= SEC_RELOC;
10502                 }
10503             }
10504
10505           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10506           off = (br_entry->offset
10507                  + htab->brlt->output_offset
10508                  + htab->brlt->output_section->vma
10509                  - elf_gp (htab->brlt->output_section->owner)
10510                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10511
10512           if (info->emitrelocations)
10513             {
10514               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10515               stub_entry->stub_sec->flags |= SEC_RELOC;
10516             }
10517
10518           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10519             {
10520               size = 12;
10521               if (PPC_HA (off) != 0)
10522                 size = 16;
10523             }
10524           else
10525             {
10526               size = 20;
10527               if (PPC_HA (off) != 0)
10528                 size += 4;
10529
10530               if (PPC_HA (r2off) != 0)
10531                 size += 4;
10532             }
10533         }
10534       else if (info->emitrelocations)
10535         {
10536           stub_entry->stub_sec->reloc_count += 1;
10537           stub_entry->stub_sec->flags |= SEC_RELOC;
10538         }
10539     }
10540
10541   stub_entry->stub_sec->size += size;
10542   return TRUE;
10543 }
10544
10545 /* Set up various things so that we can make a list of input sections
10546    for each output section included in the link.  Returns -1 on error,
10547    0 when no stubs will be needed, and 1 on success.  */
10548
10549 int
10550 ppc64_elf_setup_section_lists
10551   (struct bfd_link_info *info,
10552    asection *(*add_stub_section) (const char *, asection *),
10553    void (*layout_sections_again) (void))
10554 {
10555   bfd *input_bfd;
10556   int top_id, top_index, id;
10557   asection *section;
10558   asection **input_list;
10559   bfd_size_type amt;
10560   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10561
10562   if (htab == NULL)
10563     return -1;
10564   /* Stash our params away.  */
10565   htab->add_stub_section = add_stub_section;
10566   htab->layout_sections_again = layout_sections_again;
10567
10568   /* Find the top input section id.  */
10569   for (input_bfd = info->input_bfds, top_id = 3;
10570        input_bfd != NULL;
10571        input_bfd = input_bfd->link_next)
10572     {
10573       for (section = input_bfd->sections;
10574            section != NULL;
10575            section = section->next)
10576         {
10577           if (top_id < section->id)
10578             top_id = section->id;
10579         }
10580     }
10581
10582   htab->top_id = top_id;
10583   amt = sizeof (struct map_stub) * (top_id + 1);
10584   htab->stub_group = bfd_zmalloc (amt);
10585   if (htab->stub_group == NULL)
10586     return -1;
10587
10588   /* Set toc_off for com, und, abs and ind sections.  */
10589   for (id = 0; id < 3; id++)
10590     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10591
10592   /* We can't use output_bfd->section_count here to find the top output
10593      section index as some sections may have been removed, and
10594      strip_excluded_output_sections doesn't renumber the indices.  */
10595   for (section = info->output_bfd->sections, top_index = 0;
10596        section != NULL;
10597        section = section->next)
10598     {
10599       if (top_index < section->index)
10600         top_index = section->index;
10601     }
10602
10603   htab->top_index = top_index;
10604   amt = sizeof (asection *) * (top_index + 1);
10605   input_list = bfd_zmalloc (amt);
10606   htab->input_list = input_list;
10607   if (input_list == NULL)
10608     return -1;
10609
10610   return 1;
10611 }
10612
10613 /* Set up for first pass at multitoc partitioning.  */
10614
10615 void
10616 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10617 {
10618   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10619
10620   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10621   htab->toc_curr = elf_gp (info->output_bfd);
10622   htab->toc_bfd = NULL;
10623   htab->toc_first_sec = NULL;
10624 }
10625
10626 /* The linker repeatedly calls this function for each TOC input section
10627    and linker generated GOT section.  Group input bfds such that the toc
10628    within a group is less than 64k in size.  */
10629
10630 bfd_boolean
10631 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10632 {
10633   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10634   bfd_vma addr, off, limit;
10635
10636   if (htab == NULL)
10637     return FALSE;
10638
10639   if (!htab->second_toc_pass)
10640     {
10641       /* Keep track of the first .toc or .got section for this input bfd.  */
10642       bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10643
10644       if (new_bfd)
10645         {
10646           htab->toc_bfd = isec->owner;
10647           htab->toc_first_sec = isec;
10648         }
10649
10650       addr = isec->output_offset + isec->output_section->vma;
10651       off = addr - htab->toc_curr;
10652       limit = 0x80008000;
10653       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10654         limit = 0x10000;
10655       if (off + isec->size > limit)
10656         {
10657           addr = (htab->toc_first_sec->output_offset
10658                   + htab->toc_first_sec->output_section->vma);
10659           htab->toc_curr = addr;
10660         }
10661
10662       /* toc_curr is the base address of this toc group.  Set elf_gp
10663          for the input section to be the offset relative to the
10664          output toc base plus 0x8000.  Making the input elf_gp an
10665          offset allows us to move the toc as a whole without
10666          recalculating input elf_gp.  */
10667       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10668       off += TOC_BASE_OFF;
10669
10670       /* Die if someone uses a linker script that doesn't keep input
10671          file .toc and .got together.  */
10672       if (new_bfd
10673           && elf_gp (isec->owner) != 0
10674           && elf_gp (isec->owner) != off)
10675         return FALSE;
10676
10677       elf_gp (isec->owner) = off;
10678       return TRUE;
10679     }
10680
10681   /* During the second pass toc_first_sec points to the start of
10682      a toc group, and toc_curr is used to track the old elf_gp.
10683      We use toc_bfd to ensure we only look at each bfd once.  */
10684   if (htab->toc_bfd == isec->owner)
10685     return TRUE;
10686   htab->toc_bfd = isec->owner;
10687
10688   if (htab->toc_first_sec == NULL
10689       || htab->toc_curr != elf_gp (isec->owner))
10690     {
10691       htab->toc_curr = elf_gp (isec->owner);
10692       htab->toc_first_sec = isec;
10693     }
10694   addr = (htab->toc_first_sec->output_offset
10695           + htab->toc_first_sec->output_section->vma);
10696   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10697   elf_gp (isec->owner) = off;
10698
10699   return TRUE;
10700 }
10701
10702 /* Called via elf_link_hash_traverse to merge GOT entries for global
10703    symbol H.  */
10704
10705 static bfd_boolean
10706 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10707 {
10708   if (h->root.type == bfd_link_hash_indirect)
10709     return TRUE;
10710
10711   merge_got_entries (&h->got.glist);
10712
10713   return TRUE;
10714 }
10715
10716 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10717    symbol H.  */
10718
10719 static bfd_boolean
10720 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10721 {
10722   struct got_entry *gent;
10723
10724   if (h->root.type == bfd_link_hash_indirect)
10725     return TRUE;
10726
10727   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10728     if (!gent->is_indirect)
10729       allocate_got (h, (struct bfd_link_info *) inf, gent);
10730   return TRUE;
10731 }
10732
10733 /* Called on the first multitoc pass after the last call to
10734    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10735    entries.  */
10736
10737 bfd_boolean
10738 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10739 {
10740   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10741   struct bfd *ibfd, *ibfd2;
10742   bfd_boolean done_something;
10743
10744   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10745
10746   if (!htab->do_multi_toc)
10747     return FALSE;
10748
10749   /* Merge global sym got entries within a toc group.  */
10750   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10751
10752   /* And tlsld_got.  */
10753   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10754     {
10755       struct got_entry *ent, *ent2;
10756
10757       if (!is_ppc64_elf (ibfd))
10758         continue;
10759
10760       ent = ppc64_tlsld_got (ibfd);
10761       if (!ent->is_indirect
10762           && ent->got.offset != (bfd_vma) -1)
10763         {
10764           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10765             {
10766               if (!is_ppc64_elf (ibfd2))
10767                 continue;
10768
10769               ent2 = ppc64_tlsld_got (ibfd2);
10770               if (!ent2->is_indirect
10771                   && ent2->got.offset != (bfd_vma) -1
10772                   && elf_gp (ibfd2) == elf_gp (ibfd))
10773                 {
10774                   ent2->is_indirect = TRUE;
10775                   ent2->got.ent = ent;
10776                 }
10777             }
10778         }
10779     }
10780
10781   /* Zap sizes of got sections.  */
10782   htab->reliplt->rawsize = htab->reliplt->size;
10783   htab->reliplt->size -= htab->got_reli_size;
10784   htab->got_reli_size = 0;
10785
10786   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10787     {
10788       asection *got, *relgot;
10789
10790       if (!is_ppc64_elf (ibfd))
10791         continue;
10792
10793       got = ppc64_elf_tdata (ibfd)->got;
10794       if (got != NULL)
10795         {
10796           got->rawsize = got->size;
10797           got->size = 0;
10798           relgot = ppc64_elf_tdata (ibfd)->relgot;
10799           relgot->rawsize = relgot->size;
10800           relgot->size = 0;
10801         }
10802     }
10803
10804   /* Now reallocate the got, local syms first.  We don't need to
10805      allocate section contents again since we never increase size.  */
10806   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10807     {
10808       struct got_entry **lgot_ents;
10809       struct got_entry **end_lgot_ents;
10810       struct plt_entry **local_plt;
10811       struct plt_entry **end_local_plt;
10812       unsigned char *lgot_masks;
10813       bfd_size_type locsymcount;
10814       Elf_Internal_Shdr *symtab_hdr;
10815       asection *s;
10816
10817       if (!is_ppc64_elf (ibfd))
10818         continue;
10819
10820       lgot_ents = elf_local_got_ents (ibfd);
10821       if (!lgot_ents)
10822         continue;
10823
10824       symtab_hdr = &elf_symtab_hdr (ibfd);
10825       locsymcount = symtab_hdr->sh_info;
10826       end_lgot_ents = lgot_ents + locsymcount;
10827       local_plt = (struct plt_entry **) end_lgot_ents;
10828       end_local_plt = local_plt + locsymcount;
10829       lgot_masks = (unsigned char *) end_local_plt;
10830       s = ppc64_elf_tdata (ibfd)->got;
10831       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10832         {
10833           struct got_entry *ent;
10834
10835           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10836             {
10837               unsigned int ent_size = 8;
10838               unsigned int rel_size = sizeof (Elf64_External_Rela);
10839
10840               ent->got.offset = s->size;
10841               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10842                 {
10843                   ent_size *= 2;
10844                   rel_size *= 2;
10845                 }
10846               s->size += ent_size;
10847               if ((*lgot_masks & PLT_IFUNC) != 0)
10848                 {
10849                   htab->reliplt->size += rel_size;
10850                   htab->got_reli_size += rel_size;
10851                 }
10852               else if (info->shared)
10853                 {
10854                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10855                   srel->size += rel_size;
10856                 }
10857             }
10858         }
10859     }
10860
10861   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10862
10863   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10864     {
10865       struct got_entry *ent;
10866
10867       if (!is_ppc64_elf (ibfd))
10868         continue;
10869
10870       ent = ppc64_tlsld_got (ibfd);
10871       if (!ent->is_indirect
10872           && ent->got.offset != (bfd_vma) -1)
10873         {
10874           asection *s = ppc64_elf_tdata (ibfd)->got;
10875           ent->got.offset = s->size;
10876           s->size += 16;
10877           if (info->shared)
10878             {
10879               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10880               srel->size += sizeof (Elf64_External_Rela);
10881             }
10882         }
10883     }
10884
10885   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10886   if (!done_something)
10887     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10888       {
10889         asection *got;
10890
10891         if (!is_ppc64_elf (ibfd))
10892           continue;
10893
10894         got = ppc64_elf_tdata (ibfd)->got;
10895         if (got != NULL)
10896           {
10897             done_something = got->rawsize != got->size;
10898             if (done_something)
10899               break;
10900           }
10901       }
10902
10903   if (done_something)
10904     (*htab->layout_sections_again) ();
10905
10906   /* Set up for second pass over toc sections to recalculate elf_gp
10907      on input sections.  */
10908   htab->toc_bfd = NULL;
10909   htab->toc_first_sec = NULL;
10910   htab->second_toc_pass = TRUE;
10911   return done_something;
10912 }
10913
10914 /* Called after second pass of multitoc partitioning.  */
10915
10916 void
10917 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10918 {
10919   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10920
10921   /* After the second pass, toc_curr tracks the TOC offset used
10922      for code sections below in ppc64_elf_next_input_section.  */
10923   htab->toc_curr = TOC_BASE_OFF;
10924 }
10925
10926 /* No toc references were found in ISEC.  If the code in ISEC makes no
10927    calls, then there's no need to use toc adjusting stubs when branching
10928    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10929    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10930    needed, and 2 if a cyclical call-graph was found but no other reason
10931    for a stub was detected.  If called from the top level, a return of
10932    2 means the same as a return of 0.  */
10933
10934 static int
10935 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10936 {
10937   int ret;
10938
10939   /* Mark this section as checked.  */
10940   isec->call_check_done = 1;
10941
10942   /* We know none of our code bearing sections will need toc stubs.  */
10943   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10944     return 0;
10945
10946   if (isec->size == 0)
10947     return 0;
10948
10949   if (isec->output_section == NULL)
10950     return 0;
10951
10952   ret = 0;
10953   if (isec->reloc_count != 0)
10954     {
10955       Elf_Internal_Rela *relstart, *rel;
10956       Elf_Internal_Sym *local_syms;
10957       struct ppc_link_hash_table *htab;
10958
10959       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10960                                             info->keep_memory);
10961       if (relstart == NULL)
10962         return -1;
10963
10964       /* Look for branches to outside of this section.  */
10965       local_syms = NULL;
10966       htab = ppc_hash_table (info);
10967       if (htab == NULL)
10968         return -1;
10969
10970       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10971         {
10972           enum elf_ppc64_reloc_type r_type;
10973           unsigned long r_symndx;
10974           struct elf_link_hash_entry *h;
10975           struct ppc_link_hash_entry *eh;
10976           Elf_Internal_Sym *sym;
10977           asection *sym_sec;
10978           struct _opd_sec_data *opd;
10979           bfd_vma sym_value;
10980           bfd_vma dest;
10981
10982           r_type = ELF64_R_TYPE (rel->r_info);
10983           if (r_type != R_PPC64_REL24
10984               && r_type != R_PPC64_REL14
10985               && r_type != R_PPC64_REL14_BRTAKEN
10986               && r_type != R_PPC64_REL14_BRNTAKEN)
10987             continue;
10988
10989           r_symndx = ELF64_R_SYM (rel->r_info);
10990           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10991                           isec->owner))
10992             {
10993               ret = -1;
10994               break;
10995             }
10996
10997           /* Calls to dynamic lib functions go through a plt call stub
10998              that uses r2.  */
10999           eh = (struct ppc_link_hash_entry *) h;
11000           if (eh != NULL
11001               && (eh->elf.plt.plist != NULL
11002                   || (eh->oh != NULL
11003                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11004             {
11005               ret = 1;
11006               break;
11007             }
11008
11009           if (sym_sec == NULL)
11010             /* Ignore other undefined symbols.  */
11011             continue;
11012
11013           /* Assume branches to other sections not included in the
11014              link need stubs too, to cover -R and absolute syms.  */
11015           if (sym_sec->output_section == NULL)
11016             {
11017               ret = 1;
11018               break;
11019             }
11020
11021           if (h == NULL)
11022             sym_value = sym->st_value;
11023           else
11024             {
11025               if (h->root.type != bfd_link_hash_defined
11026                   && h->root.type != bfd_link_hash_defweak)
11027                 abort ();
11028               sym_value = h->root.u.def.value;
11029             }
11030           sym_value += rel->r_addend;
11031
11032           /* If this branch reloc uses an opd sym, find the code section.  */
11033           opd = get_opd_info (sym_sec);
11034           if (opd != NULL)
11035             {
11036               if (h == NULL && opd->adjust != NULL)
11037                 {
11038                   long adjust;
11039
11040                   adjust = opd->adjust[sym->st_value / 8];
11041                   if (adjust == -1)
11042                     /* Assume deleted functions won't ever be called.  */
11043                     continue;
11044                   sym_value += adjust;
11045                 }
11046
11047               dest = opd_entry_value (sym_sec, sym_value,
11048                                       &sym_sec, NULL, FALSE);
11049               if (dest == (bfd_vma) -1)
11050                 continue;
11051             }
11052           else
11053             dest = (sym_value
11054                     + sym_sec->output_offset
11055                     + sym_sec->output_section->vma);
11056
11057           /* Ignore branch to self.  */
11058           if (sym_sec == isec)
11059             continue;
11060
11061           /* If the called function uses the toc, we need a stub.  */
11062           if (sym_sec->has_toc_reloc
11063               || sym_sec->makes_toc_func_call)
11064             {
11065               ret = 1;
11066               break;
11067             }
11068
11069           /* Assume any branch that needs a long branch stub might in fact
11070              need a plt_branch stub.  A plt_branch stub uses r2.  */
11071           else if (dest - (isec->output_offset
11072                            + isec->output_section->vma
11073                            + rel->r_offset) + (1 << 25) >= (2 << 25))
11074             {
11075               ret = 1;
11076               break;
11077             }
11078
11079           /* If calling back to a section in the process of being
11080              tested, we can't say for sure that no toc adjusting stubs
11081              are needed, so don't return zero.  */
11082           else if (sym_sec->call_check_in_progress)
11083             ret = 2;
11084
11085           /* Branches to another section that itself doesn't have any TOC
11086              references are OK.  Recursively call ourselves to check.  */
11087           else if (!sym_sec->call_check_done)
11088             {
11089               int recur;
11090
11091               /* Mark current section as indeterminate, so that other
11092                  sections that call back to current won't be marked as
11093                  known.  */
11094               isec->call_check_in_progress = 1;
11095               recur = toc_adjusting_stub_needed (info, sym_sec);
11096               isec->call_check_in_progress = 0;
11097
11098               if (recur != 0)
11099                 {
11100                   ret = recur;
11101                   if (recur != 2)
11102                     break;
11103                 }
11104             }
11105         }
11106
11107       if (local_syms != NULL
11108           && (elf_symtab_hdr (isec->owner).contents
11109               != (unsigned char *) local_syms))
11110         free (local_syms);
11111       if (elf_section_data (isec)->relocs != relstart)
11112         free (relstart);
11113     }
11114
11115   if ((ret & 1) == 0
11116       && isec->map_head.s != NULL
11117       && (strcmp (isec->output_section->name, ".init") == 0
11118           || strcmp (isec->output_section->name, ".fini") == 0))
11119     {
11120       if (isec->map_head.s->has_toc_reloc
11121           || isec->map_head.s->makes_toc_func_call)
11122         ret = 1;
11123       else if (!isec->map_head.s->call_check_done)
11124         {
11125           int recur;
11126           isec->call_check_in_progress = 1;
11127           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11128           isec->call_check_in_progress = 0;
11129           if (recur != 0)
11130             ret = recur;
11131         }
11132     }
11133
11134   if (ret == 1)
11135     isec->makes_toc_func_call = 1;
11136
11137   return ret;
11138 }
11139
11140 /* The linker repeatedly calls this function for each input section,
11141    in the order that input sections are linked into output sections.
11142    Build lists of input sections to determine groupings between which
11143    we may insert linker stubs.  */
11144
11145 bfd_boolean
11146 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11147 {
11148   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11149
11150   if (htab == NULL)
11151     return FALSE;
11152
11153   if ((isec->output_section->flags & SEC_CODE) != 0
11154       && isec->output_section->index <= htab->top_index)
11155     {
11156       asection **list = htab->input_list + isec->output_section->index;
11157       /* Steal the link_sec pointer for our list.  */
11158 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11159       /* This happens to make the list in reverse order,
11160          which is what we want.  */
11161       PREV_SEC (isec) = *list;
11162       *list = isec;
11163     }
11164
11165   if (htab->multi_toc_needed)
11166     {
11167       /* If a code section has a function that uses the TOC then we need
11168          to use the right TOC (obviously).  Also, make sure that .opd gets
11169          the correct TOC value for R_PPC64_TOC relocs that don't have or
11170          can't find their function symbol (shouldn't ever happen now).
11171          Also specially treat .fixup for the linux kernel.  .fixup
11172          contains branches, but only back to the function that hit an
11173          exception.  */
11174       if (isec->has_toc_reloc
11175           || (isec->flags & SEC_CODE) == 0
11176           || strcmp (isec->name, ".fixup") == 0)
11177         {
11178           if (elf_gp (isec->owner) != 0)
11179             htab->toc_curr = elf_gp (isec->owner);
11180         }
11181       else
11182         {
11183           if (!isec->call_check_done
11184               && toc_adjusting_stub_needed (info, isec) < 0)
11185             return FALSE;
11186           /* If we make a local call from this section, ie. a branch
11187              without a following nop, then we have no place to put a
11188              toc restoring insn.  We must use the same toc group as
11189              the callee.
11190              Testing makes_toc_func_call actually tests for *any*
11191              calls to functions that need a good toc pointer.  A more
11192              precise test would be better, as this one will set
11193              incorrect values for pasted .init/.fini fragments.
11194              (Fixed later in check_pasted_section.)  */
11195           if (isec->makes_toc_func_call
11196               && elf_gp (isec->owner) != 0)
11197             htab->toc_curr = elf_gp (isec->owner);
11198         }
11199     }
11200
11201   /* Functions that don't use the TOC can belong in any TOC group.
11202      Use the last TOC base.  */
11203   htab->stub_group[isec->id].toc_off = htab->toc_curr;
11204   return TRUE;
11205 }
11206
11207 /* Check that all .init and .fini sections use the same toc, if they
11208    have toc relocs.  */
11209
11210 static bfd_boolean
11211 check_pasted_section (struct bfd_link_info *info, const char *name)
11212 {
11213   asection *o = bfd_get_section_by_name (info->output_bfd, name);
11214
11215   if (o != NULL)
11216     {
11217       struct ppc_link_hash_table *htab = ppc_hash_table (info);
11218       bfd_vma toc_off = 0;
11219       asection *i;
11220
11221       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11222         if (i->has_toc_reloc)
11223           {
11224             if (toc_off == 0)
11225               toc_off = htab->stub_group[i->id].toc_off;
11226             else if (toc_off != htab->stub_group[i->id].toc_off)
11227               return FALSE;
11228           }
11229
11230       if (toc_off == 0)
11231         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11232           if (i->makes_toc_func_call)
11233             {
11234               toc_off = htab->stub_group[i->id].toc_off;
11235               break;
11236             }
11237
11238       /* Make sure the whole pasted function uses the same toc offset.  */
11239       if (toc_off != 0)
11240         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11241           htab->stub_group[i->id].toc_off = toc_off;
11242     }
11243   return TRUE;
11244 }
11245
11246 bfd_boolean
11247 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11248 {
11249   return (check_pasted_section (info, ".init")
11250           & check_pasted_section (info, ".fini"));
11251 }
11252
11253 /* See whether we can group stub sections together.  Grouping stub
11254    sections may result in fewer stubs.  More importantly, we need to
11255    put all .init* and .fini* stubs at the beginning of the .init or
11256    .fini output sections respectively, because glibc splits the
11257    _init and _fini functions into multiple parts.  Putting a stub in
11258    the middle of a function is not a good idea.  */
11259
11260 static void
11261 group_sections (struct ppc_link_hash_table *htab,
11262                 bfd_size_type stub_group_size,
11263                 bfd_boolean stubs_always_before_branch)
11264 {
11265   asection **list;
11266   bfd_size_type stub14_group_size;
11267   bfd_boolean suppress_size_errors;
11268
11269   suppress_size_errors = FALSE;
11270   stub14_group_size = stub_group_size;
11271   if (stub_group_size == 1)
11272     {
11273       /* Default values.  */
11274       if (stubs_always_before_branch)
11275         {
11276           stub_group_size = 0x1e00000;
11277           stub14_group_size = 0x7800;
11278         }
11279       else
11280         {
11281           stub_group_size = 0x1c00000;
11282           stub14_group_size = 0x7000;
11283         }
11284       suppress_size_errors = TRUE;
11285     }
11286
11287   list = htab->input_list + htab->top_index;
11288   do
11289     {
11290       asection *tail = *list;
11291       while (tail != NULL)
11292         {
11293           asection *curr;
11294           asection *prev;
11295           bfd_size_type total;
11296           bfd_boolean big_sec;
11297           bfd_vma curr_toc;
11298
11299           curr = tail;
11300           total = tail->size;
11301           big_sec = total > (ppc64_elf_section_data (tail) != NULL
11302                              && ppc64_elf_section_data (tail)->has_14bit_branch
11303                              ? stub14_group_size : stub_group_size);
11304           if (big_sec && !suppress_size_errors)
11305             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11306                                      tail->owner, tail);
11307           curr_toc = htab->stub_group[tail->id].toc_off;
11308
11309           while ((prev = PREV_SEC (curr)) != NULL
11310                  && ((total += curr->output_offset - prev->output_offset)
11311                      < (ppc64_elf_section_data (prev) != NULL
11312                         && ppc64_elf_section_data (prev)->has_14bit_branch
11313                         ? stub14_group_size : stub_group_size))
11314                  && htab->stub_group[prev->id].toc_off == curr_toc)
11315             curr = prev;
11316
11317           /* OK, the size from the start of CURR to the end is less
11318              than stub_group_size and thus can be handled by one stub
11319              section.  (or the tail section is itself larger than
11320              stub_group_size, in which case we may be toast.)  We
11321              should really be keeping track of the total size of stubs
11322              added here, as stubs contribute to the final output
11323              section size.  That's a little tricky, and this way will
11324              only break if stubs added make the total size more than
11325              2^25, ie. for the default stub_group_size, if stubs total
11326              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11327           do
11328             {
11329               prev = PREV_SEC (tail);
11330               /* Set up this stub group.  */
11331               htab->stub_group[tail->id].link_sec = curr;
11332             }
11333           while (tail != curr && (tail = prev) != NULL);
11334
11335           /* But wait, there's more!  Input sections up to stub_group_size
11336              bytes before the stub section can be handled by it too.
11337              Don't do this if we have a really large section after the
11338              stubs, as adding more stubs increases the chance that
11339              branches may not reach into the stub section.  */
11340           if (!stubs_always_before_branch && !big_sec)
11341             {
11342               total = 0;
11343               while (prev != NULL
11344                      && ((total += tail->output_offset - prev->output_offset)
11345                          < (ppc64_elf_section_data (prev) != NULL
11346                             && ppc64_elf_section_data (prev)->has_14bit_branch
11347                             ? stub14_group_size : stub_group_size))
11348                      && htab->stub_group[prev->id].toc_off == curr_toc)
11349                 {
11350                   tail = prev;
11351                   prev = PREV_SEC (tail);
11352                   htab->stub_group[tail->id].link_sec = curr;
11353                 }
11354             }
11355           tail = prev;
11356         }
11357     }
11358   while (list-- != htab->input_list);
11359   free (htab->input_list);
11360 #undef PREV_SEC
11361 }
11362
11363 static const unsigned char glink_eh_frame_cie[] =
11364 {
11365   0, 0, 0, 16,                          /* length.  */
11366   0, 0, 0, 0,                           /* id.  */
11367   1,                                    /* CIE version.  */
11368   'z', 'R', 0,                          /* Augmentation string.  */
11369   4,                                    /* Code alignment.  */
11370   0x78,                                 /* Data alignment.  */
11371   65,                                   /* RA reg.  */
11372   1,                                    /* Augmentation size.  */
11373   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11374   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11375 };
11376
11377 /* Stripping output sections is normally done before dynamic section
11378    symbols have been allocated.  This function is called later, and
11379    handles cases like htab->brlt which is mapped to its own output
11380    section.  */
11381
11382 static void
11383 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11384 {
11385   if (isec->size == 0
11386       && isec->output_section->size == 0
11387       && !(isec->output_section->flags & SEC_KEEP)
11388       && !bfd_section_removed_from_list (info->output_bfd,
11389                                          isec->output_section)
11390       && elf_section_data (isec->output_section)->dynindx == 0)
11391     {
11392       isec->output_section->flags |= SEC_EXCLUDE;
11393       bfd_section_list_remove (info->output_bfd, isec->output_section);
11394       info->output_bfd->section_count--;
11395     }
11396 }
11397
11398 /* Determine and set the size of the stub section for a final link.
11399
11400    The basic idea here is to examine all the relocations looking for
11401    PC-relative calls to a target that is unreachable with a "bl"
11402    instruction.  */
11403
11404 bfd_boolean
11405 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11406                       bfd_boolean plt_static_chain, int plt_thread_safe,
11407                       int plt_stub_align)
11408 {
11409   bfd_size_type stub_group_size;
11410   bfd_boolean stubs_always_before_branch;
11411   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11412
11413   if (htab == NULL)
11414     return FALSE;
11415
11416   htab->plt_static_chain = plt_static_chain;
11417   htab->plt_stub_align = plt_stub_align;
11418   if (plt_thread_safe == -1 && !info->executable)
11419     plt_thread_safe = 1;
11420   if (plt_thread_safe == -1)
11421     {
11422       static const char *const thread_starter[] =
11423         {
11424           "pthread_create",
11425           /* libstdc++ */
11426           "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11427           /* librt */
11428           "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11429           "mq_notify", "create_timer",
11430           /* libanl */
11431           "getaddrinfo_a",
11432           /* libgomp */
11433           "GOMP_parallel_start",
11434           "GOMP_parallel_loop_static_start",
11435           "GOMP_parallel_loop_dynamic_start",
11436           "GOMP_parallel_loop_guided_start",
11437           "GOMP_parallel_loop_runtime_start",
11438           "GOMP_parallel_sections_start",
11439         };
11440       unsigned i;
11441
11442       for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11443         {
11444           struct elf_link_hash_entry *h;
11445           h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11446                                     FALSE, FALSE, TRUE);
11447           plt_thread_safe = h != NULL && h->ref_regular;
11448           if (plt_thread_safe)
11449             break;
11450         }
11451     }
11452   htab->plt_thread_safe = plt_thread_safe;
11453   htab->dot_toc_dot = ((struct ppc_link_hash_entry *)
11454                        elf_link_hash_lookup (&htab->elf, ".TOC.",
11455                                              FALSE, FALSE, TRUE));
11456   stubs_always_before_branch = group_size < 0;
11457   if (group_size < 0)
11458     stub_group_size = -group_size;
11459   else
11460     stub_group_size = group_size;
11461
11462   group_sections (htab, stub_group_size, stubs_always_before_branch);
11463
11464   while (1)
11465     {
11466       bfd *input_bfd;
11467       unsigned int bfd_indx;
11468       asection *stub_sec;
11469
11470       htab->stub_iteration += 1;
11471
11472       for (input_bfd = info->input_bfds, bfd_indx = 0;
11473            input_bfd != NULL;
11474            input_bfd = input_bfd->link_next, bfd_indx++)
11475         {
11476           Elf_Internal_Shdr *symtab_hdr;
11477           asection *section;
11478           Elf_Internal_Sym *local_syms = NULL;
11479
11480           if (!is_ppc64_elf (input_bfd))
11481             continue;
11482
11483           /* We'll need the symbol table in a second.  */
11484           symtab_hdr = &elf_symtab_hdr (input_bfd);
11485           if (symtab_hdr->sh_info == 0)
11486             continue;
11487
11488           /* Walk over each section attached to the input bfd.  */
11489           for (section = input_bfd->sections;
11490                section != NULL;
11491                section = section->next)
11492             {
11493               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11494
11495               /* If there aren't any relocs, then there's nothing more
11496                  to do.  */
11497               if ((section->flags & SEC_RELOC) == 0
11498                   || (section->flags & SEC_ALLOC) == 0
11499                   || (section->flags & SEC_LOAD) == 0
11500                   || (section->flags & SEC_CODE) == 0
11501                   || section->reloc_count == 0)
11502                 continue;
11503
11504               /* If this section is a link-once section that will be
11505                  discarded, then don't create any stubs.  */
11506               if (section->output_section == NULL
11507                   || section->output_section->owner != info->output_bfd)
11508                 continue;
11509
11510               /* Get the relocs.  */
11511               internal_relocs
11512                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11513                                              info->keep_memory);
11514               if (internal_relocs == NULL)
11515                 goto error_ret_free_local;
11516
11517               /* Now examine each relocation.  */
11518               irela = internal_relocs;
11519               irelaend = irela + section->reloc_count;
11520               for (; irela < irelaend; irela++)
11521                 {
11522                   enum elf_ppc64_reloc_type r_type;
11523                   unsigned int r_indx;
11524                   enum ppc_stub_type stub_type;
11525                   struct ppc_stub_hash_entry *stub_entry;
11526                   asection *sym_sec, *code_sec;
11527                   bfd_vma sym_value, code_value;
11528                   bfd_vma destination;
11529                   bfd_boolean ok_dest;
11530                   struct ppc_link_hash_entry *hash;
11531                   struct ppc_link_hash_entry *fdh;
11532                   struct elf_link_hash_entry *h;
11533                   Elf_Internal_Sym *sym;
11534                   char *stub_name;
11535                   const asection *id_sec;
11536                   struct _opd_sec_data *opd;
11537                   struct plt_entry *plt_ent;
11538
11539                   r_type = ELF64_R_TYPE (irela->r_info);
11540                   r_indx = ELF64_R_SYM (irela->r_info);
11541
11542                   if (r_type >= R_PPC64_max)
11543                     {
11544                       bfd_set_error (bfd_error_bad_value);
11545                       goto error_ret_free_internal;
11546                     }
11547
11548                   /* Only look for stubs on branch instructions.  */
11549                   if (r_type != R_PPC64_REL24
11550                       && r_type != R_PPC64_REL14
11551                       && r_type != R_PPC64_REL14_BRTAKEN
11552                       && r_type != R_PPC64_REL14_BRNTAKEN)
11553                     continue;
11554
11555                   /* Now determine the call target, its name, value,
11556                      section.  */
11557                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11558                                   r_indx, input_bfd))
11559                     goto error_ret_free_internal;
11560                   hash = (struct ppc_link_hash_entry *) h;
11561
11562                   ok_dest = FALSE;
11563                   fdh = NULL;
11564                   sym_value = 0;
11565                   if (hash == NULL)
11566                     {
11567                       sym_value = sym->st_value;
11568                       ok_dest = TRUE;
11569                     }
11570                   else if (hash->elf.root.type == bfd_link_hash_defined
11571                            || hash->elf.root.type == bfd_link_hash_defweak)
11572                     {
11573                       sym_value = hash->elf.root.u.def.value;
11574                       if (sym_sec->output_section != NULL)
11575                         ok_dest = TRUE;
11576                     }
11577                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11578                            || hash->elf.root.type == bfd_link_hash_undefined)
11579                     {
11580                       /* Recognise an old ABI func code entry sym, and
11581                          use the func descriptor sym instead if it is
11582                          defined.  */
11583                       if (hash->elf.root.root.string[0] == '.'
11584                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11585                         {
11586                           if (fdh->elf.root.type == bfd_link_hash_defined
11587                               || fdh->elf.root.type == bfd_link_hash_defweak)
11588                             {
11589                               sym_sec = fdh->elf.root.u.def.section;
11590                               sym_value = fdh->elf.root.u.def.value;
11591                               if (sym_sec->output_section != NULL)
11592                                 ok_dest = TRUE;
11593                             }
11594                           else
11595                             fdh = NULL;
11596                         }
11597                     }
11598                   else
11599                     {
11600                       bfd_set_error (bfd_error_bad_value);
11601                       goto error_ret_free_internal;
11602                     }
11603
11604                   destination = 0;
11605                   if (ok_dest)
11606                     {
11607                       sym_value += irela->r_addend;
11608                       destination = (sym_value
11609                                      + sym_sec->output_offset
11610                                      + sym_sec->output_section->vma);
11611                     }
11612
11613                   code_sec = sym_sec;
11614                   code_value = sym_value;
11615                   opd = get_opd_info (sym_sec);
11616                   if (opd != NULL)
11617                     {
11618                       bfd_vma dest;
11619
11620                       if (hash == NULL && opd->adjust != NULL)
11621                         {
11622                           long adjust = opd->adjust[sym_value / 8];
11623                           if (adjust == -1)
11624                             continue;
11625                           code_value += adjust;
11626                           sym_value += adjust;
11627                         }
11628                       dest = opd_entry_value (sym_sec, sym_value,
11629                                               &code_sec, &code_value, FALSE);
11630                       if (dest != (bfd_vma) -1)
11631                         {
11632                           destination = dest;
11633                           if (fdh != NULL)
11634                             {
11635                               /* Fixup old ABI sym to point at code
11636                                  entry.  */
11637                               hash->elf.root.type = bfd_link_hash_defweak;
11638                               hash->elf.root.u.def.section = code_sec;
11639                               hash->elf.root.u.def.value = code_value;
11640                             }
11641                         }
11642                     }
11643
11644                   /* Determine what (if any) linker stub is needed.  */
11645                   plt_ent = NULL;
11646                   stub_type = ppc_type_of_stub (section, irela, &hash,
11647                                                 &plt_ent, destination);
11648
11649                   if (stub_type != ppc_stub_plt_call)
11650                     {
11651                       /* Check whether we need a TOC adjusting stub.
11652                          Since the linker pastes together pieces from
11653                          different object files when creating the
11654                          _init and _fini functions, it may be that a
11655                          call to what looks like a local sym is in
11656                          fact a call needing a TOC adjustment.  */
11657                       if (code_sec != NULL
11658                           && code_sec->output_section != NULL
11659                           && (htab->stub_group[code_sec->id].toc_off
11660                               != htab->stub_group[section->id].toc_off)
11661                           && (code_sec->has_toc_reloc
11662                               || code_sec->makes_toc_func_call))
11663                         stub_type = ppc_stub_long_branch_r2off;
11664                     }
11665
11666                   if (stub_type == ppc_stub_none)
11667                     continue;
11668
11669                   /* __tls_get_addr calls might be eliminated.  */
11670                   if (stub_type != ppc_stub_plt_call
11671                       && hash != NULL
11672                       && (hash == htab->tls_get_addr
11673                           || hash == htab->tls_get_addr_fd)
11674                       && section->has_tls_reloc
11675                       && irela != internal_relocs)
11676                     {
11677                       /* Get tls info.  */
11678                       unsigned char *tls_mask;
11679
11680                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11681                                          irela - 1, input_bfd))
11682                         goto error_ret_free_internal;
11683                       if (*tls_mask != 0)
11684                         continue;
11685                     }
11686
11687                   if (stub_type == ppc_stub_plt_call
11688                       && irela + 1 < irelaend
11689                       && irela[1].r_offset == irela->r_offset + 4
11690                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11691                     {
11692                       if (!tocsave_find (htab, INSERT,
11693                                          &local_syms, irela + 1, input_bfd))
11694                         goto error_ret_free_internal;
11695                     }
11696                   else if (stub_type == ppc_stub_plt_call)
11697                     stub_type = ppc_stub_plt_call_r2save;
11698
11699                   /* Support for grouping stub sections.  */
11700                   id_sec = htab->stub_group[section->id].link_sec;
11701
11702                   /* Get the name of this stub.  */
11703                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11704                   if (!stub_name)
11705                     goto error_ret_free_internal;
11706
11707                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11708                                                      stub_name, FALSE, FALSE);
11709                   if (stub_entry != NULL)
11710                     {
11711                       /* The proper stub has already been created.  */
11712                       free (stub_name);
11713                       if (stub_type == ppc_stub_plt_call_r2save)
11714                         stub_entry->stub_type = stub_type;
11715                       continue;
11716                     }
11717
11718                   stub_entry = ppc_add_stub (stub_name, section, info);
11719                   if (stub_entry == NULL)
11720                     {
11721                       free (stub_name);
11722                     error_ret_free_internal:
11723                       if (elf_section_data (section)->relocs == NULL)
11724                         free (internal_relocs);
11725                     error_ret_free_local:
11726                       if (local_syms != NULL
11727                           && (symtab_hdr->contents
11728                               != (unsigned char *) local_syms))
11729                         free (local_syms);
11730                       return FALSE;
11731                     }
11732
11733                   stub_entry->stub_type = stub_type;
11734                   if (stub_type != ppc_stub_plt_call
11735                       && stub_type != ppc_stub_plt_call_r2save)
11736                     {
11737                       stub_entry->target_value = code_value;
11738                       stub_entry->target_section = code_sec;
11739                     }
11740                   else
11741                     {
11742                       stub_entry->target_value = sym_value;
11743                       stub_entry->target_section = sym_sec;
11744                     }
11745                   stub_entry->h = hash;
11746                   stub_entry->plt_ent = plt_ent;
11747                   stub_entry->addend = irela->r_addend;
11748
11749                   if (stub_entry->h != NULL)
11750                     htab->stub_globals += 1;
11751                 }
11752
11753               /* We're done with the internal relocs, free them.  */
11754               if (elf_section_data (section)->relocs != internal_relocs)
11755                 free (internal_relocs);
11756             }
11757
11758           if (local_syms != NULL
11759               && symtab_hdr->contents != (unsigned char *) local_syms)
11760             {
11761               if (!info->keep_memory)
11762                 free (local_syms);
11763               else
11764                 symtab_hdr->contents = (unsigned char *) local_syms;
11765             }
11766         }
11767
11768       /* We may have added some stubs.  Find out the new size of the
11769          stub sections.  */
11770       for (stub_sec = htab->stub_bfd->sections;
11771            stub_sec != NULL;
11772            stub_sec = stub_sec->next)
11773         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11774           {
11775             stub_sec->rawsize = stub_sec->size;
11776             stub_sec->size = 0;
11777             stub_sec->reloc_count = 0;
11778             stub_sec->flags &= ~SEC_RELOC;
11779           }
11780
11781       htab->brlt->size = 0;
11782       htab->brlt->reloc_count = 0;
11783       htab->brlt->flags &= ~SEC_RELOC;
11784       if (htab->relbrlt != NULL)
11785         htab->relbrlt->size = 0;
11786
11787       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11788
11789       if (info->emitrelocations
11790           && htab->glink != NULL && htab->glink->size != 0)
11791         {
11792           htab->glink->reloc_count = 1;
11793           htab->glink->flags |= SEC_RELOC;
11794         }
11795
11796       if (htab->glink_eh_frame != NULL
11797           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11798           && htab->glink_eh_frame->output_section->size != 0)
11799         {
11800           size_t size = 0, align;
11801
11802           for (stub_sec = htab->stub_bfd->sections;
11803                stub_sec != NULL;
11804                stub_sec = stub_sec->next)
11805             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11806               size += 20;
11807           if (htab->glink != NULL && htab->glink->size != 0)
11808             size += 24;
11809           if (size != 0)
11810             size += sizeof (glink_eh_frame_cie);
11811           align = 1;
11812           align <<= htab->glink_eh_frame->output_section->alignment_power;
11813           align -= 1;
11814           size = (size + align) & ~align;
11815           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11816           htab->glink_eh_frame->size = size;
11817         }
11818
11819       if (htab->plt_stub_align != 0)
11820         for (stub_sec = htab->stub_bfd->sections;
11821              stub_sec != NULL;
11822              stub_sec = stub_sec->next)
11823           if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11824             stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
11825                               & (-1 << htab->plt_stub_align));
11826
11827       for (stub_sec = htab->stub_bfd->sections;
11828            stub_sec != NULL;
11829            stub_sec = stub_sec->next)
11830         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11831             && stub_sec->rawsize != stub_sec->size)
11832           break;
11833
11834       /* Exit from this loop when no stubs have been added, and no stubs
11835          have changed size.  */
11836       if (stub_sec == NULL
11837           && (htab->glink_eh_frame == NULL
11838               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11839         break;
11840
11841       /* Ask the linker to do its stuff.  */
11842       (*htab->layout_sections_again) ();
11843     }
11844
11845   maybe_strip_output (info, htab->brlt);
11846   if (htab->glink_eh_frame != NULL)
11847     maybe_strip_output (info, htab->glink_eh_frame);
11848
11849   return TRUE;
11850 }
11851
11852 /* Called after we have determined section placement.  If sections
11853    move, we'll be called again.  Provide a value for TOCstart.  */
11854
11855 bfd_vma
11856 ppc64_elf_toc (bfd *obfd)
11857 {
11858   asection *s;
11859   bfd_vma TOCstart;
11860
11861   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11862      order.  The TOC starts where the first of these sections starts.  */
11863   s = bfd_get_section_by_name (obfd, ".got");
11864   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11865     s = bfd_get_section_by_name (obfd, ".toc");
11866   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11867     s = bfd_get_section_by_name (obfd, ".tocbss");
11868   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11869     s = bfd_get_section_by_name (obfd, ".plt");
11870   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11871     {
11872       /* This may happen for
11873          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11874          .toc directive
11875          o  bad linker script
11876          o --gc-sections and empty TOC sections
11877
11878          FIXME: Warn user?  */
11879
11880       /* Look for a likely section.  We probably won't even be
11881          using TOCstart.  */
11882       for (s = obfd->sections; s != NULL; s = s->next)
11883         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11884                          | SEC_EXCLUDE))
11885             == (SEC_ALLOC | SEC_SMALL_DATA))
11886           break;
11887       if (s == NULL)
11888         for (s = obfd->sections; s != NULL; s = s->next)
11889           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11890               == (SEC_ALLOC | SEC_SMALL_DATA))
11891             break;
11892       if (s == NULL)
11893         for (s = obfd->sections; s != NULL; s = s->next)
11894           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11895               == SEC_ALLOC)
11896             break;
11897       if (s == NULL)
11898         for (s = obfd->sections; s != NULL; s = s->next)
11899           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11900             break;
11901     }
11902
11903   TOCstart = 0;
11904   if (s != NULL)
11905     TOCstart = s->output_section->vma + s->output_offset;
11906
11907   return TOCstart;
11908 }
11909
11910 /* Build all the stubs associated with the current output file.
11911    The stubs are kept in a hash table attached to the main linker
11912    hash table.  This function is called via gldelf64ppc_finish.  */
11913
11914 bfd_boolean
11915 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11916                        struct bfd_link_info *info,
11917                        char **stats)
11918 {
11919   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11920   asection *stub_sec;
11921   bfd_byte *p;
11922   int stub_sec_count = 0;
11923
11924   if (htab == NULL)
11925     return FALSE;
11926
11927   htab->emit_stub_syms = emit_stub_syms;
11928
11929   /* Allocate memory to hold the linker stubs.  */
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         && stub_sec->size != 0)
11935       {
11936         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11937         if (stub_sec->contents == NULL)
11938           return FALSE;
11939         /* We want to check that built size is the same as calculated
11940            size.  rawsize is a convenient location to use.  */
11941         stub_sec->rawsize = stub_sec->size;
11942         stub_sec->size = 0;
11943       }
11944
11945   if (htab->glink != NULL && htab->glink->size != 0)
11946     {
11947       unsigned int indx;
11948       bfd_vma plt0;
11949
11950       /* Build the .glink plt call stub.  */
11951       if (htab->emit_stub_syms)
11952         {
11953           struct elf_link_hash_entry *h;
11954           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11955                                     TRUE, FALSE, FALSE);
11956           if (h == NULL)
11957             return FALSE;
11958           if (h->root.type == bfd_link_hash_new)
11959             {
11960               h->root.type = bfd_link_hash_defined;
11961               h->root.u.def.section = htab->glink;
11962               h->root.u.def.value = 8;
11963               h->ref_regular = 1;
11964               h->def_regular = 1;
11965               h->ref_regular_nonweak = 1;
11966               h->forced_local = 1;
11967               h->non_elf = 0;
11968             }
11969         }
11970       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11971       if (info->emitrelocations)
11972         {
11973           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11974           if (r == NULL)
11975             return FALSE;
11976           r->r_offset = (htab->glink->output_offset
11977                          + htab->glink->output_section->vma);
11978           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11979           r->r_addend = plt0;
11980         }
11981       p = htab->glink->contents;
11982       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11983       bfd_put_64 (htab->glink->owner, plt0, p);
11984       p += 8;
11985       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11986       p += 4;
11987       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11988       p += 4;
11989       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11990       p += 4;
11991       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11992       p += 4;
11993       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11994       p += 4;
11995       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11996       p += 4;
11997       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11998       p += 4;
11999       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
12000       p += 4;
12001       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
12002       p += 4;
12003       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
12004       p += 4;
12005       bfd_put_32 (htab->glink->owner, BCTR, p);
12006       p += 4;
12007       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12008         {
12009           bfd_put_32 (htab->glink->owner, NOP, p);
12010           p += 4;
12011         }
12012
12013       /* Build the .glink lazy link call stubs.  */
12014       indx = 0;
12015       while (p < htab->glink->contents + htab->glink->size)
12016         {
12017           if (indx < 0x8000)
12018             {
12019               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12020               p += 4;
12021             }
12022           else
12023             {
12024               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12025               p += 4;
12026               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12027               p += 4;
12028             }
12029           bfd_put_32 (htab->glink->owner,
12030                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12031           indx++;
12032           p += 4;
12033         }
12034       htab->glink->rawsize = p - htab->glink->contents;
12035     }
12036
12037   if (htab->brlt->size != 0)
12038     {
12039       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12040                                          htab->brlt->size);
12041       if (htab->brlt->contents == NULL)
12042         return FALSE;
12043     }
12044   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12045     {
12046       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12047                                             htab->relbrlt->size);
12048       if (htab->relbrlt->contents == NULL)
12049         return FALSE;
12050     }
12051
12052   if (htab->glink_eh_frame != NULL
12053       && htab->glink_eh_frame->size != 0)
12054     {
12055       bfd_vma val;
12056       bfd_byte *last_fde;
12057       size_t last_fde_len, size, align, pad;
12058
12059       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12060       if (p == NULL)
12061         return FALSE;
12062       htab->glink_eh_frame->contents = p;
12063       last_fde = p;
12064
12065       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12066
12067       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12068       /* CIE length (rewrite in case little-endian).  */
12069       last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12070       bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12071       p += sizeof (glink_eh_frame_cie);
12072
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           {
12078             last_fde = p;
12079             last_fde_len = 16;
12080             /* FDE length.  */
12081             bfd_put_32 (htab->elf.dynobj, 16, p);
12082             p += 4;
12083             /* CIE pointer.  */
12084             val = p - htab->glink_eh_frame->contents;
12085             bfd_put_32 (htab->elf.dynobj, val, p);
12086             p += 4;
12087             /* Offset to stub section.  */
12088             val = (stub_sec->output_section->vma
12089                    + stub_sec->output_offset);
12090             val -= (htab->glink_eh_frame->output_section->vma
12091                     + htab->glink_eh_frame->output_offset);
12092             val -= p - htab->glink_eh_frame->contents;
12093             if (val + 0x80000000 > 0xffffffff)
12094               {
12095                 info->callbacks->einfo
12096                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12097                    stub_sec->name);
12098                 return FALSE;
12099               }
12100             bfd_put_32 (htab->elf.dynobj, val, p);
12101             p += 4;
12102             /* stub section size.  */
12103             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12104             p += 4;
12105             /* Augmentation.  */
12106             p += 1;
12107             /* Pad.  */
12108             p += 3;
12109           }
12110       if (htab->glink != NULL && htab->glink->size != 0)
12111         {
12112           last_fde = p;
12113           last_fde_len = 20;
12114           /* FDE length.  */
12115           bfd_put_32 (htab->elf.dynobj, 20, p);
12116           p += 4;
12117           /* CIE pointer.  */
12118           val = p - htab->glink_eh_frame->contents;
12119           bfd_put_32 (htab->elf.dynobj, val, p);
12120           p += 4;
12121           /* Offset to .glink.  */
12122           val = (htab->glink->output_section->vma
12123                  + htab->glink->output_offset
12124                  + 8);
12125           val -= (htab->glink_eh_frame->output_section->vma
12126                   + htab->glink_eh_frame->output_offset);
12127           val -= p - htab->glink_eh_frame->contents;
12128           if (val + 0x80000000 > 0xffffffff)
12129             {
12130               info->callbacks->einfo
12131                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12132                  htab->glink->name);
12133               return FALSE;
12134             }
12135           bfd_put_32 (htab->elf.dynobj, val, p);
12136           p += 4;
12137           /* .glink size.  */
12138           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12139           p += 4;
12140           /* Augmentation.  */
12141           p += 1;
12142
12143           *p++ = DW_CFA_advance_loc + 1;
12144           *p++ = DW_CFA_register;
12145           *p++ = 65;
12146           *p++ = 12;
12147           *p++ = DW_CFA_advance_loc + 4;
12148           *p++ = DW_CFA_restore_extended;
12149           *p++ = 65;
12150         }
12151       /* Subsume any padding into the last FDE if user .eh_frame
12152          sections are aligned more than glink_eh_frame.  Otherwise any
12153          zero padding will be seen as a terminator.  */
12154       size = p - htab->glink_eh_frame->contents;
12155       align = 1;
12156       align <<= htab->glink_eh_frame->output_section->alignment_power;
12157       align -= 1;
12158       pad = ((size + align) & ~align) - size;
12159       htab->glink_eh_frame->size = size + pad;
12160       bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12161     }
12162
12163   /* Build the stubs as directed by the stub hash table.  */
12164   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12165
12166   if (htab->relbrlt != NULL)
12167     htab->relbrlt->reloc_count = 0;
12168
12169   if (htab->plt_stub_align != 0)
12170     for (stub_sec = htab->stub_bfd->sections;
12171          stub_sec != NULL;
12172          stub_sec = stub_sec->next)
12173       if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12174         stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12175                           & (-1 << htab->plt_stub_align));
12176
12177   for (stub_sec = htab->stub_bfd->sections;
12178        stub_sec != NULL;
12179        stub_sec = stub_sec->next)
12180     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12181       {
12182         stub_sec_count += 1;
12183         if (stub_sec->rawsize != stub_sec->size)
12184           break;
12185       }
12186
12187   if (stub_sec != NULL
12188       || htab->glink->rawsize != htab->glink->size
12189       || (htab->glink_eh_frame != NULL
12190           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12191     {
12192       htab->stub_error = TRUE;
12193       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12194     }
12195
12196   if (htab->stub_error)
12197     return FALSE;
12198
12199   if (stats != NULL)
12200     {
12201       *stats = bfd_malloc (500);
12202       if (*stats == NULL)
12203         return FALSE;
12204
12205       sprintf (*stats, _("linker stubs in %u group%s\n"
12206                          "  branch       %lu\n"
12207                          "  toc adjust   %lu\n"
12208                          "  long branch  %lu\n"
12209                          "  long toc adj %lu\n"
12210                          "  plt call     %lu\n"
12211                          "  plt call toc %lu"),
12212                stub_sec_count,
12213                stub_sec_count == 1 ? "" : "s",
12214                htab->stub_count[ppc_stub_long_branch - 1],
12215                htab->stub_count[ppc_stub_long_branch_r2off - 1],
12216                htab->stub_count[ppc_stub_plt_branch - 1],
12217                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12218                htab->stub_count[ppc_stub_plt_call - 1],
12219                htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12220     }
12221   return TRUE;
12222 }
12223
12224 /* This function undoes the changes made by add_symbol_adjust.  */
12225
12226 static bfd_boolean
12227 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12228 {
12229   struct ppc_link_hash_entry *eh;
12230
12231   if (h->root.type == bfd_link_hash_indirect)
12232     return TRUE;
12233
12234   eh = (struct ppc_link_hash_entry *) h;
12235   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12236     return TRUE;
12237
12238   eh->elf.root.type = bfd_link_hash_undefined;
12239   return TRUE;
12240 }
12241
12242 void
12243 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12244 {
12245   struct ppc_link_hash_table *htab = ppc_hash_table (info);
12246
12247   if (htab != NULL)
12248     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12249 }
12250
12251 /* What to do when ld finds relocations against symbols defined in
12252    discarded sections.  */
12253
12254 static unsigned int
12255 ppc64_elf_action_discarded (asection *sec)
12256 {
12257   if (strcmp (".opd", sec->name) == 0)
12258     return 0;
12259
12260   if (strcmp (".toc", sec->name) == 0)
12261     return 0;
12262
12263   if (strcmp (".toc1", sec->name) == 0)
12264     return 0;
12265
12266   return _bfd_elf_default_action_discarded (sec);
12267 }
12268
12269 /* The RELOCATE_SECTION function is called by the ELF backend linker
12270    to handle the relocations for a section.
12271
12272    The relocs are always passed as Rela structures; if the section
12273    actually uses Rel structures, the r_addend field will always be
12274    zero.
12275
12276    This function is responsible for adjust the section contents as
12277    necessary, and (if using Rela relocs and generating a
12278    relocatable output file) adjusting the reloc addend as
12279    necessary.
12280
12281    This function does not have to worry about setting the reloc
12282    address or the reloc symbol index.
12283
12284    LOCAL_SYMS is a pointer to the swapped in local symbols.
12285
12286    LOCAL_SECTIONS is an array giving the section in the input file
12287    corresponding to the st_shndx field of each local symbol.
12288
12289    The global hash table entry for the global symbols can be found
12290    via elf_sym_hashes (input_bfd).
12291
12292    When generating relocatable output, this function must handle
12293    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
12294    going to be the section symbol corresponding to the output
12295    section, which means that the addend must be adjusted
12296    accordingly.  */
12297
12298 static bfd_boolean
12299 ppc64_elf_relocate_section (bfd *output_bfd,
12300                             struct bfd_link_info *info,
12301                             bfd *input_bfd,
12302                             asection *input_section,
12303                             bfd_byte *contents,
12304                             Elf_Internal_Rela *relocs,
12305                             Elf_Internal_Sym *local_syms,
12306                             asection **local_sections)
12307 {
12308   struct ppc_link_hash_table *htab;
12309   Elf_Internal_Shdr *symtab_hdr;
12310   struct elf_link_hash_entry **sym_hashes;
12311   Elf_Internal_Rela *rel;
12312   Elf_Internal_Rela *relend;
12313   Elf_Internal_Rela outrel;
12314   bfd_byte *loc;
12315   struct got_entry **local_got_ents;
12316   bfd_vma TOCstart;
12317   bfd_boolean ret = TRUE;
12318   bfd_boolean is_opd;
12319   /* Assume 'at' branch hints.  */
12320   bfd_boolean is_isa_v2 = TRUE;
12321   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12322
12323   /* Initialize howto table if needed.  */
12324   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12325     ppc_howto_init ();
12326
12327   htab = ppc_hash_table (info);
12328   if (htab == NULL)
12329     return FALSE;
12330
12331   /* Don't relocate stub sections.  */
12332   if (input_section->owner == htab->stub_bfd)
12333     return TRUE;
12334
12335   BFD_ASSERT (is_ppc64_elf (input_bfd));
12336
12337   local_got_ents = elf_local_got_ents (input_bfd);
12338   TOCstart = elf_gp (output_bfd);
12339   symtab_hdr = &elf_symtab_hdr (input_bfd);
12340   sym_hashes = elf_sym_hashes (input_bfd);
12341   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12342
12343   rel = relocs;
12344   relend = relocs + input_section->reloc_count;
12345   for (; rel < relend; rel++)
12346     {
12347       enum elf_ppc64_reloc_type r_type;
12348       bfd_vma addend;
12349       bfd_reloc_status_type r;
12350       Elf_Internal_Sym *sym;
12351       asection *sec;
12352       struct elf_link_hash_entry *h_elf;
12353       struct ppc_link_hash_entry *h;
12354       struct ppc_link_hash_entry *fdh;
12355       const char *sym_name;
12356       unsigned long r_symndx, toc_symndx;
12357       bfd_vma toc_addend;
12358       unsigned char tls_mask, tls_gd, tls_type;
12359       unsigned char sym_type;
12360       bfd_vma relocation;
12361       bfd_boolean unresolved_reloc;
12362       bfd_boolean warned;
12363       enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12364       unsigned int insn;
12365       unsigned int mask;
12366       struct ppc_stub_hash_entry *stub_entry;
12367       bfd_vma max_br_offset;
12368       bfd_vma from;
12369       const Elf_Internal_Rela orig_rel = *rel;
12370
12371       r_type = ELF64_R_TYPE (rel->r_info);
12372       r_symndx = ELF64_R_SYM (rel->r_info);
12373
12374       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12375          symbol of the previous ADDR64 reloc.  The symbol gives us the
12376          proper TOC base to use.  */
12377       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12378           && rel != relocs
12379           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12380           && is_opd)
12381         r_symndx = ELF64_R_SYM (rel[-1].r_info);
12382
12383       sym = NULL;
12384       sec = NULL;
12385       h_elf = NULL;
12386       sym_name = NULL;
12387       unresolved_reloc = FALSE;
12388       warned = FALSE;
12389
12390       if (r_symndx < symtab_hdr->sh_info)
12391         {
12392           /* It's a local symbol.  */
12393           struct _opd_sec_data *opd;
12394
12395           sym = local_syms + r_symndx;
12396           sec = local_sections[r_symndx];
12397           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12398           sym_type = ELF64_ST_TYPE (sym->st_info);
12399           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12400           opd = get_opd_info (sec);
12401           if (opd != NULL && opd->adjust != NULL)
12402             {
12403               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12404               if (adjust == -1)
12405                 relocation = 0;
12406               else
12407                 {
12408                   /* If this is a relocation against the opd section sym
12409                      and we have edited .opd, adjust the reloc addend so
12410                      that ld -r and ld --emit-relocs output is correct.
12411                      If it is a reloc against some other .opd symbol,
12412                      then the symbol value will be adjusted later.  */
12413                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12414                     rel->r_addend += adjust;
12415                   else
12416                     relocation += adjust;
12417                 }
12418             }
12419         }
12420       else
12421         {
12422           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12423                                    r_symndx, symtab_hdr, sym_hashes,
12424                                    h_elf, sec, relocation,
12425                                    unresolved_reloc, warned);
12426           sym_name = h_elf->root.root.string;
12427           sym_type = h_elf->type;
12428           if (sec != NULL
12429               && sec->owner == output_bfd
12430               && strcmp (sec->name, ".opd") == 0)
12431             {
12432               /* This is a symbol defined in a linker script.  All
12433                  such are defined in output sections, even those
12434                  defined by simple assignment from a symbol defined in
12435                  an input section.  Transfer the symbol to an
12436                  appropriate input .opd section, so that a branch to
12437                  this symbol will be mapped to the location specified
12438                  by the opd entry.  */
12439               struct bfd_link_order *lo;
12440               for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12441                 if (lo->type == bfd_indirect_link_order)
12442                   {
12443                     asection *isec = lo->u.indirect.section;
12444                     if (h_elf->root.u.def.value >= isec->output_offset
12445                         && h_elf->root.u.def.value < (isec->output_offset
12446                                                       + isec->size))
12447                       {
12448                         h_elf->root.u.def.value -= isec->output_offset;
12449                         h_elf->root.u.def.section = isec;
12450                         sec = isec;
12451                         break;
12452                       }
12453                   }
12454             }
12455           if (h_elf == &htab->dot_toc_dot->elf)
12456             {
12457               relocation = (TOCstart
12458                             + htab->stub_group[input_section->id].toc_off);
12459               sec = bfd_abs_section_ptr;
12460               unresolved_reloc = FALSE;
12461             }
12462         }
12463       h = (struct ppc_link_hash_entry *) h_elf;
12464
12465       if (sec != NULL && discarded_section (sec))
12466         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12467                                          rel, 1, relend,
12468                                          ppc64_elf_howto_table[r_type], 0,
12469                                          contents);
12470
12471       if (info->relocatable)
12472         continue;
12473
12474       /* TLS optimizations.  Replace instruction sequences and relocs
12475          based on information we collected in tls_optimize.  We edit
12476          RELOCS so that --emit-relocs will output something sensible
12477          for the final instruction stream.  */
12478       tls_mask = 0;
12479       tls_gd = 0;
12480       toc_symndx = 0;
12481       if (h != NULL)
12482         tls_mask = h->tls_mask;
12483       else if (local_got_ents != NULL)
12484         {
12485           struct plt_entry **local_plt = (struct plt_entry **)
12486             (local_got_ents + symtab_hdr->sh_info);
12487           unsigned char *lgot_masks = (unsigned char *)
12488             (local_plt + symtab_hdr->sh_info);
12489           tls_mask = lgot_masks[r_symndx];
12490         }
12491       if (tls_mask == 0
12492           && (r_type == R_PPC64_TLS
12493               || r_type == R_PPC64_TLSGD
12494               || r_type == R_PPC64_TLSLD))
12495         {
12496           /* Check for toc tls entries.  */
12497           unsigned char *toc_tls;
12498
12499           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12500                              &local_syms, rel, input_bfd))
12501             return FALSE;
12502
12503           if (toc_tls)
12504             tls_mask = *toc_tls;
12505         }
12506
12507       /* Check that tls relocs are used with tls syms, and non-tls
12508          relocs are used with non-tls syms.  */
12509       if (r_symndx != STN_UNDEF
12510           && r_type != R_PPC64_NONE
12511           && (h == NULL
12512               || h->elf.root.type == bfd_link_hash_defined
12513               || h->elf.root.type == bfd_link_hash_defweak)
12514           && (IS_PPC64_TLS_RELOC (r_type)
12515               != (sym_type == STT_TLS
12516                   || (sym_type == STT_SECTION
12517                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12518         {
12519           if (tls_mask != 0
12520               && (r_type == R_PPC64_TLS
12521                   || r_type == R_PPC64_TLSGD
12522                   || r_type == R_PPC64_TLSLD))
12523             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
12524             ;
12525           else
12526             info->callbacks->einfo
12527               (!IS_PPC64_TLS_RELOC (r_type)
12528                ? _("%P: %H: %s used with TLS symbol `%T'\n")
12529                : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12530                input_bfd, input_section, rel->r_offset,
12531                ppc64_elf_howto_table[r_type]->name,
12532                sym_name);
12533         }
12534
12535       /* Ensure reloc mapping code below stays sane.  */
12536       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12537           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12538           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
12539           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12540           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12541           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12542           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
12543           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12544           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12545           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12546         abort ();
12547
12548       switch (r_type)
12549         {
12550         default:
12551           break;
12552
12553         case R_PPC64_LO_DS_OPT:
12554           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12555           if ((insn & (0x3f << 26)) != 58u << 26)
12556             abort ();
12557           insn += (14u << 26) - (58u << 26);
12558           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12559           r_type = R_PPC64_TOC16_LO;
12560           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12561           break;
12562
12563         case R_PPC64_TOC16:
12564         case R_PPC64_TOC16_LO:
12565         case R_PPC64_TOC16_DS:
12566         case R_PPC64_TOC16_LO_DS:
12567           {
12568             /* Check for toc tls entries.  */
12569             unsigned char *toc_tls;
12570             int retval;
12571
12572             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12573                                    &local_syms, rel, input_bfd);
12574             if (retval == 0)
12575               return FALSE;
12576
12577             if (toc_tls)
12578               {
12579                 tls_mask = *toc_tls;
12580                 if (r_type == R_PPC64_TOC16_DS
12581                     || r_type == R_PPC64_TOC16_LO_DS)
12582                   {
12583                     if (tls_mask != 0
12584                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12585                       goto toctprel;
12586                   }
12587                 else
12588                   {
12589                     /* If we found a GD reloc pair, then we might be
12590                        doing a GD->IE transition.  */
12591                     if (retval == 2)
12592                       {
12593                         tls_gd = TLS_TPRELGD;
12594                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12595                           goto tls_ldgd_opt;
12596                       }
12597                     else if (retval == 3)
12598                       {
12599                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12600                           goto tls_ldgd_opt;
12601                       }
12602                   }
12603               }
12604           }
12605           break;
12606
12607         case R_PPC64_GOT_TPREL16_HI:
12608         case R_PPC64_GOT_TPREL16_HA:
12609           if (tls_mask != 0
12610               && (tls_mask & TLS_TPREL) == 0)
12611             {
12612               rel->r_offset -= d_offset;
12613               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12614               r_type = R_PPC64_NONE;
12615               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12616             }
12617           break;
12618
12619         case R_PPC64_GOT_TPREL16_DS:
12620         case R_PPC64_GOT_TPREL16_LO_DS:
12621           if (tls_mask != 0
12622               && (tls_mask & TLS_TPREL) == 0)
12623             {
12624             toctprel:
12625               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12626               insn &= 31 << 21;
12627               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12628               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12629               r_type = R_PPC64_TPREL16_HA;
12630               if (toc_symndx != 0)
12631                 {
12632                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12633                   rel->r_addend = toc_addend;
12634                   /* We changed the symbol.  Start over in order to
12635                      get h, sym, sec etc. right.  */
12636                   rel--;
12637                   continue;
12638                 }
12639               else
12640                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12641             }
12642           break;
12643
12644         case R_PPC64_TLS:
12645           if (tls_mask != 0
12646               && (tls_mask & TLS_TPREL) == 0)
12647             {
12648               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12649               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12650               if (insn == 0)
12651                 abort ();
12652               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12653               /* Was PPC64_TLS which sits on insn boundary, now
12654                  PPC64_TPREL16_LO which is at low-order half-word.  */
12655               rel->r_offset += d_offset;
12656               r_type = R_PPC64_TPREL16_LO;
12657               if (toc_symndx != 0)
12658                 {
12659                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12660                   rel->r_addend = toc_addend;
12661                   /* We changed the symbol.  Start over in order to
12662                      get h, sym, sec etc. right.  */
12663                   rel--;
12664                   continue;
12665                 }
12666               else
12667                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12668             }
12669           break;
12670
12671         case R_PPC64_GOT_TLSGD16_HI:
12672         case R_PPC64_GOT_TLSGD16_HA:
12673           tls_gd = TLS_TPRELGD;
12674           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12675             goto tls_gdld_hi;
12676           break;
12677
12678         case R_PPC64_GOT_TLSLD16_HI:
12679         case R_PPC64_GOT_TLSLD16_HA:
12680           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12681             {
12682             tls_gdld_hi:
12683               if ((tls_mask & tls_gd) != 0)
12684                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12685                           + R_PPC64_GOT_TPREL16_DS);
12686               else
12687                 {
12688                   rel->r_offset -= d_offset;
12689                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12690                   r_type = R_PPC64_NONE;
12691                 }
12692               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12693             }
12694           break;
12695
12696         case R_PPC64_GOT_TLSGD16:
12697         case R_PPC64_GOT_TLSGD16_LO:
12698           tls_gd = TLS_TPRELGD;
12699           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12700             goto tls_ldgd_opt;
12701           break;
12702
12703         case R_PPC64_GOT_TLSLD16:
12704         case R_PPC64_GOT_TLSLD16_LO:
12705           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12706             {
12707               unsigned int insn1, insn2, insn3;
12708               bfd_vma offset;
12709
12710             tls_ldgd_opt:
12711               offset = (bfd_vma) -1;
12712               /* If not using the newer R_PPC64_TLSGD/LD to mark
12713                  __tls_get_addr calls, we must trust that the call
12714                  stays with its arg setup insns, ie. that the next
12715                  reloc is the __tls_get_addr call associated with
12716                  the current reloc.  Edit both insns.  */
12717               if (input_section->has_tls_get_addr_call
12718                   && rel + 1 < relend
12719                   && branch_reloc_hash_match (input_bfd, rel + 1,
12720                                               htab->tls_get_addr,
12721                                               htab->tls_get_addr_fd))
12722                 offset = rel[1].r_offset;
12723               if ((tls_mask & tls_gd) != 0)
12724                 {
12725                   /* IE */
12726                   insn1 = bfd_get_32 (output_bfd,
12727                                       contents + rel->r_offset - d_offset);
12728                   insn1 &= (1 << 26) - (1 << 2);
12729                   insn1 |= 58 << 26;    /* ld */
12730                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12731                   if (offset != (bfd_vma) -1)
12732                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12733                   if ((tls_mask & TLS_EXPLICIT) == 0)
12734                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12735                               + R_PPC64_GOT_TPREL16_DS);
12736                   else
12737                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12738                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12739                 }
12740               else
12741                 {
12742                   /* LE */
12743                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12744                   insn2 = 0x38630000;   /* addi 3,3,0 */
12745                   if (tls_gd == 0)
12746                     {
12747                       /* Was an LD reloc.  */
12748                       if (toc_symndx)
12749                         sec = local_sections[toc_symndx];
12750                       for (r_symndx = 0;
12751                            r_symndx < symtab_hdr->sh_info;
12752                            r_symndx++)
12753                         if (local_sections[r_symndx] == sec)
12754                           break;
12755                       if (r_symndx >= symtab_hdr->sh_info)
12756                         r_symndx = STN_UNDEF;
12757                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12758                       if (r_symndx != STN_UNDEF)
12759                         rel->r_addend -= (local_syms[r_symndx].st_value
12760                                           + sec->output_offset
12761                                           + sec->output_section->vma);
12762                     }
12763                   else if (toc_symndx != 0)
12764                     {
12765                       r_symndx = toc_symndx;
12766                       rel->r_addend = toc_addend;
12767                     }
12768                   r_type = R_PPC64_TPREL16_HA;
12769                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12770                   if (offset != (bfd_vma) -1)
12771                     {
12772                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12773                                                     R_PPC64_TPREL16_LO);
12774                       rel[1].r_offset = offset + d_offset;
12775                       rel[1].r_addend = rel->r_addend;
12776                     }
12777                 }
12778               bfd_put_32 (output_bfd, insn1,
12779                           contents + rel->r_offset - d_offset);
12780               if (offset != (bfd_vma) -1)
12781                 {
12782                   insn3 = bfd_get_32 (output_bfd,
12783                                       contents + offset + 4);
12784                   if (insn3 == NOP
12785                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12786                     {
12787                       rel[1].r_offset += 4;
12788                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12789                       insn2 = NOP;
12790                     }
12791                   bfd_put_32 (output_bfd, insn2, contents + offset);
12792                 }
12793               if ((tls_mask & tls_gd) == 0
12794                   && (tls_gd == 0 || toc_symndx != 0))
12795                 {
12796                   /* We changed the symbol.  Start over in order
12797                      to get h, sym, sec etc. right.  */
12798                   rel--;
12799                   continue;
12800                 }
12801             }
12802           break;
12803
12804         case R_PPC64_TLSGD:
12805           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12806             {
12807               unsigned int insn2, insn3;
12808               bfd_vma offset = rel->r_offset;
12809
12810               if ((tls_mask & TLS_TPRELGD) != 0)
12811                 {
12812                   /* IE */
12813                   r_type = R_PPC64_NONE;
12814                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12815                 }
12816               else
12817                 {
12818                   /* LE */
12819                   if (toc_symndx != 0)
12820                     {
12821                       r_symndx = toc_symndx;
12822                       rel->r_addend = toc_addend;
12823                     }
12824                   r_type = R_PPC64_TPREL16_LO;
12825                   rel->r_offset = offset + d_offset;
12826                   insn2 = 0x38630000;   /* addi 3,3,0 */
12827                 }
12828               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12829               /* Zap the reloc on the _tls_get_addr call too.  */
12830               BFD_ASSERT (offset == rel[1].r_offset);
12831               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12832               insn3 = bfd_get_32 (output_bfd,
12833                                   contents + offset + 4);
12834               if (insn3 == NOP
12835                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12836                 {
12837                   rel->r_offset += 4;
12838                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12839                   insn2 = NOP;
12840                 }
12841               bfd_put_32 (output_bfd, insn2, contents + offset);
12842               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12843                 {
12844                   rel--;
12845                   continue;
12846                 }
12847             }
12848           break;
12849
12850         case R_PPC64_TLSLD:
12851           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12852             {
12853               unsigned int insn2, insn3;
12854               bfd_vma offset = rel->r_offset;
12855
12856               if (toc_symndx)
12857                 sec = local_sections[toc_symndx];
12858               for (r_symndx = 0;
12859                    r_symndx < symtab_hdr->sh_info;
12860                    r_symndx++)
12861                 if (local_sections[r_symndx] == sec)
12862                   break;
12863               if (r_symndx >= symtab_hdr->sh_info)
12864                 r_symndx = STN_UNDEF;
12865               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12866               if (r_symndx != STN_UNDEF)
12867                 rel->r_addend -= (local_syms[r_symndx].st_value
12868                                   + sec->output_offset
12869                                   + sec->output_section->vma);
12870
12871               r_type = R_PPC64_TPREL16_LO;
12872               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12873               rel->r_offset = offset + d_offset;
12874               /* Zap the reloc on the _tls_get_addr call too.  */
12875               BFD_ASSERT (offset == rel[1].r_offset);
12876               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12877               insn2 = 0x38630000;       /* addi 3,3,0 */
12878               insn3 = bfd_get_32 (output_bfd,
12879                                   contents + offset + 4);
12880               if (insn3 == NOP
12881                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12882                 {
12883                   rel->r_offset += 4;
12884                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12885                   insn2 = NOP;
12886                 }
12887               bfd_put_32 (output_bfd, insn2, contents + offset);
12888               rel--;
12889               continue;
12890             }
12891           break;
12892
12893         case R_PPC64_DTPMOD64:
12894           if (rel + 1 < relend
12895               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12896               && rel[1].r_offset == rel->r_offset + 8)
12897             {
12898               if ((tls_mask & TLS_GD) == 0)
12899                 {
12900                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12901                   if ((tls_mask & TLS_TPRELGD) != 0)
12902                     r_type = R_PPC64_TPREL64;
12903                   else
12904                     {
12905                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12906                       r_type = R_PPC64_NONE;
12907                     }
12908                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12909                 }
12910             }
12911           else
12912             {
12913               if ((tls_mask & TLS_LD) == 0)
12914                 {
12915                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12916                   r_type = R_PPC64_NONE;
12917                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12918                 }
12919             }
12920           break;
12921
12922         case R_PPC64_TPREL64:
12923           if ((tls_mask & TLS_TPREL) == 0)
12924             {
12925               r_type = R_PPC64_NONE;
12926               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12927             }
12928           break;
12929         }
12930
12931       /* Handle other relocations that tweak non-addend part of insn.  */
12932       insn = 0;
12933       max_br_offset = 1 << 25;
12934       addend = rel->r_addend;
12935       reloc_dest = DEST_NORMAL;
12936       switch (r_type)
12937         {
12938         default:
12939           break;
12940
12941         case R_PPC64_TOCSAVE:
12942           if (relocation + addend == (rel->r_offset
12943                                       + input_section->output_offset
12944                                       + input_section->output_section->vma)
12945               && tocsave_find (htab, NO_INSERT,
12946                                &local_syms, rel, input_bfd))
12947             {
12948               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12949               if (insn == NOP
12950                   || insn == CROR_151515 || insn == CROR_313131)
12951                 bfd_put_32 (input_bfd, STD_R2_40R1,
12952                             contents + rel->r_offset);
12953             }
12954           break;
12955
12956           /* Branch taken prediction relocations.  */
12957         case R_PPC64_ADDR14_BRTAKEN:
12958         case R_PPC64_REL14_BRTAKEN:
12959           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12960           /* Fall thru.  */
12961
12962           /* Branch not taken prediction relocations.  */
12963         case R_PPC64_ADDR14_BRNTAKEN:
12964         case R_PPC64_REL14_BRNTAKEN:
12965           insn |= bfd_get_32 (output_bfd,
12966                               contents + rel->r_offset) & ~(0x01 << 21);
12967           /* Fall thru.  */
12968
12969         case R_PPC64_REL14:
12970           max_br_offset = 1 << 15;
12971           /* Fall thru.  */
12972
12973         case R_PPC64_REL24:
12974           /* Calls to functions with a different TOC, such as calls to
12975              shared objects, need to alter the TOC pointer.  This is
12976              done using a linkage stub.  A REL24 branching to these
12977              linkage stubs needs to be followed by a nop, as the nop
12978              will be replaced with an instruction to restore the TOC
12979              base pointer.  */
12980           fdh = h;
12981           if (h != NULL
12982               && h->oh != NULL
12983               && h->oh->is_func_descriptor)
12984             fdh = ppc_follow_link (h->oh);
12985           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
12986                                            htab);
12987           if (stub_entry != NULL
12988               && (stub_entry->stub_type == ppc_stub_plt_call
12989                   || stub_entry->stub_type == ppc_stub_plt_call_r2save
12990                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12991                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12992             {
12993               bfd_boolean can_plt_call = FALSE;
12994
12995               if (rel->r_offset + 8 <= input_section->size)
12996                 {
12997                   unsigned long nop;
12998                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12999                   if (nop == NOP
13000                       || nop == CROR_151515 || nop == CROR_313131)
13001                     {
13002                       if (h != NULL
13003                           && (h == htab->tls_get_addr_fd
13004                               || h == htab->tls_get_addr)
13005                           && !htab->no_tls_get_addr_opt)
13006                         {
13007                           /* Special stub used, leave nop alone.  */
13008                         }
13009                       else
13010                         bfd_put_32 (input_bfd, LD_R2_40R1,
13011                                     contents + rel->r_offset + 4);
13012                       can_plt_call = TRUE;
13013                     }
13014                 }
13015
13016               if (!can_plt_call)
13017                 {
13018                   if (stub_entry->stub_type == ppc_stub_plt_call
13019                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13020                     {
13021                       /* If this is a plain branch rather than a branch
13022                          and link, don't require a nop.  However, don't
13023                          allow tail calls in a shared library as they
13024                          will result in r2 being corrupted.  */
13025                       unsigned long br;
13026                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
13027                       if (info->executable && (br & 1) == 0)
13028                         can_plt_call = TRUE;
13029                       else
13030                         stub_entry = NULL;
13031                     }
13032                   else if (h != NULL
13033                            && strcmp (h->elf.root.root.string,
13034                                       ".__libc_start_main") == 0)
13035                     {
13036                       /* Allow crt1 branch to go via a toc adjusting stub.  */
13037                       can_plt_call = TRUE;
13038                     }
13039                   else
13040                     {
13041                       info->callbacks->einfo
13042                         (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13043                            "recompile with -fPIC"),
13044                            input_bfd, input_section, rel->r_offset, sym_name);
13045
13046                       bfd_set_error (bfd_error_bad_value);
13047                       ret = FALSE;
13048                     }
13049                 }
13050
13051               if (can_plt_call
13052                   && (stub_entry->stub_type == ppc_stub_plt_call
13053                       || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13054                 unresolved_reloc = FALSE;
13055             }
13056
13057           if ((stub_entry == NULL
13058                || stub_entry->stub_type == ppc_stub_long_branch
13059                || stub_entry->stub_type == ppc_stub_plt_branch)
13060               && get_opd_info (sec) != NULL)
13061             {
13062               /* The branch destination is the value of the opd entry. */
13063               bfd_vma off = (relocation + addend
13064                              - sec->output_section->vma
13065                              - sec->output_offset);
13066               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13067               if (dest != (bfd_vma) -1)
13068                 {
13069                   relocation = dest;
13070                   addend = 0;
13071                   reloc_dest = DEST_OPD;
13072                 }
13073             }
13074
13075           /* If the branch is out of reach we ought to have a long
13076              branch stub.  */
13077           from = (rel->r_offset
13078                   + input_section->output_offset
13079                   + input_section->output_section->vma);
13080
13081           if (stub_entry != NULL
13082               && (stub_entry->stub_type == ppc_stub_long_branch
13083                   || stub_entry->stub_type == ppc_stub_plt_branch)
13084               && (r_type == R_PPC64_ADDR14_BRTAKEN
13085                   || r_type == R_PPC64_ADDR14_BRNTAKEN
13086                   || (relocation + addend - from + max_br_offset
13087                       < 2 * max_br_offset)))
13088             /* Don't use the stub if this branch is in range.  */
13089             stub_entry = NULL;
13090
13091           if (stub_entry != NULL)
13092             {
13093               /* Munge up the value and addend so that we call the stub
13094                  rather than the procedure directly.  */
13095               relocation = (stub_entry->stub_offset
13096                             + stub_entry->stub_sec->output_offset
13097                             + stub_entry->stub_sec->output_section->vma);
13098               addend = 0;
13099               reloc_dest = DEST_STUB;
13100
13101               if ((stub_entry->stub_type == ppc_stub_plt_call
13102                    || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13103                   && (ALWAYS_EMIT_R2SAVE
13104                       || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13105                   && rel + 1 < relend
13106                   && rel[1].r_offset == rel->r_offset + 4
13107                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13108                 relocation += 4;
13109             }
13110
13111           if (insn != 0)
13112             {
13113               if (is_isa_v2)
13114                 {
13115                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
13116                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
13117                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
13118                   if ((insn & (0x14 << 21)) == (0x04 << 21))
13119                     insn |= 0x02 << 21;
13120                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
13121                     insn |= 0x08 << 21;
13122                   else
13123                     break;
13124                 }
13125               else
13126                 {
13127                   /* Invert 'y' bit if not the default.  */
13128                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
13129                     insn ^= 0x01 << 21;
13130                 }
13131
13132               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13133             }
13134
13135           /* NOP out calls to undefined weak functions.
13136              We can thus call a weak function without first
13137              checking whether the function is defined.  */
13138           else if (h != NULL
13139                    && h->elf.root.type == bfd_link_hash_undefweak
13140                    && h->elf.dynindx == -1
13141                    && r_type == R_PPC64_REL24
13142                    && relocation == 0
13143                    && addend == 0)
13144             {
13145               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13146               continue;
13147             }
13148           break;
13149         }
13150
13151       /* Set `addend'.  */
13152       tls_type = 0;
13153       switch (r_type)
13154         {
13155         default:
13156           info->callbacks->einfo
13157             (_("%P: %B: unknown relocation type %d for `%T'\n"),
13158              input_bfd, (int) r_type, sym_name);
13159
13160           bfd_set_error (bfd_error_bad_value);
13161           ret = FALSE;
13162           continue;
13163
13164         case R_PPC64_NONE:
13165         case R_PPC64_TLS:
13166         case R_PPC64_TLSGD:
13167         case R_PPC64_TLSLD:
13168         case R_PPC64_TOCSAVE:
13169         case R_PPC64_GNU_VTINHERIT:
13170         case R_PPC64_GNU_VTENTRY:
13171           continue;
13172
13173           /* GOT16 relocations.  Like an ADDR16 using the symbol's
13174              address in the GOT as relocation value instead of the
13175              symbol's value itself.  Also, create a GOT entry for the
13176              symbol and put the symbol value there.  */
13177         case R_PPC64_GOT_TLSGD16:
13178         case R_PPC64_GOT_TLSGD16_LO:
13179         case R_PPC64_GOT_TLSGD16_HI:
13180         case R_PPC64_GOT_TLSGD16_HA:
13181           tls_type = TLS_TLS | TLS_GD;
13182           goto dogot;
13183
13184         case R_PPC64_GOT_TLSLD16:
13185         case R_PPC64_GOT_TLSLD16_LO:
13186         case R_PPC64_GOT_TLSLD16_HI:
13187         case R_PPC64_GOT_TLSLD16_HA:
13188           tls_type = TLS_TLS | TLS_LD;
13189           goto dogot;
13190
13191         case R_PPC64_GOT_TPREL16_DS:
13192         case R_PPC64_GOT_TPREL16_LO_DS:
13193         case R_PPC64_GOT_TPREL16_HI:
13194         case R_PPC64_GOT_TPREL16_HA:
13195           tls_type = TLS_TLS | TLS_TPREL;
13196           goto dogot;
13197
13198         case R_PPC64_GOT_DTPREL16_DS:
13199         case R_PPC64_GOT_DTPREL16_LO_DS:
13200         case R_PPC64_GOT_DTPREL16_HI:
13201         case R_PPC64_GOT_DTPREL16_HA:
13202           tls_type = TLS_TLS | TLS_DTPREL;
13203           goto dogot;
13204
13205         case R_PPC64_GOT16:
13206         case R_PPC64_GOT16_LO:
13207         case R_PPC64_GOT16_HI:
13208         case R_PPC64_GOT16_HA:
13209         case R_PPC64_GOT16_DS:
13210         case R_PPC64_GOT16_LO_DS:
13211         dogot:
13212           {
13213             /* Relocation is to the entry for this symbol in the global
13214                offset table.  */
13215             asection *got;
13216             bfd_vma *offp;
13217             bfd_vma off;
13218             unsigned long indx = 0;
13219             struct got_entry *ent;
13220
13221             if (tls_type == (TLS_TLS | TLS_LD)
13222                 && (h == NULL
13223                     || !h->elf.def_dynamic))
13224               ent = ppc64_tlsld_got (input_bfd);
13225             else
13226               {
13227
13228                 if (h != NULL)
13229                   {
13230                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
13231                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13232                                                           &h->elf)
13233                         || (info->shared
13234                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13235                       /* This is actually a static link, or it is a
13236                          -Bsymbolic link and the symbol is defined
13237                          locally, or the symbol was forced to be local
13238                          because of a version file.  */
13239                       ;
13240                     else
13241                       {
13242                         BFD_ASSERT (h->elf.dynindx != -1);
13243                         indx = h->elf.dynindx;
13244                         unresolved_reloc = FALSE;
13245                       }
13246                     ent = h->elf.got.glist;
13247                   }
13248                 else
13249                   {
13250                     if (local_got_ents == NULL)
13251                       abort ();
13252                     ent = local_got_ents[r_symndx];
13253                   }
13254
13255                 for (; ent != NULL; ent = ent->next)
13256                   if (ent->addend == orig_rel.r_addend
13257                       && ent->owner == input_bfd
13258                       && ent->tls_type == tls_type)
13259                     break;
13260               }
13261
13262             if (ent == NULL)
13263               abort ();
13264             if (ent->is_indirect)
13265               ent = ent->got.ent;
13266             offp = &ent->got.offset;
13267             got = ppc64_elf_tdata (ent->owner)->got;
13268             if (got == NULL)
13269               abort ();
13270
13271             /* The offset must always be a multiple of 8.  We use the
13272                least significant bit to record whether we have already
13273                processed this entry.  */
13274             off = *offp;
13275             if ((off & 1) != 0)
13276               off &= ~1;
13277             else
13278               {
13279                 /* Generate relocs for the dynamic linker, except in
13280                    the case of TLSLD where we'll use one entry per
13281                    module.  */
13282                 asection *relgot;
13283                 bfd_boolean ifunc;
13284
13285                 *offp = off | 1;
13286                 relgot = NULL;
13287                 ifunc = (h != NULL
13288                          ? h->elf.type == STT_GNU_IFUNC
13289                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13290                 if (ifunc)
13291                   relgot = htab->reliplt;
13292                 else if ((info->shared || indx != 0)
13293                          && (h == NULL
13294                              || (tls_type == (TLS_TLS | TLS_LD)
13295                                  && !h->elf.def_dynamic)
13296                              || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13297                              || h->elf.root.type != bfd_link_hash_undefweak))
13298                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
13299                 if (relgot != NULL)
13300                   {
13301                     outrel.r_offset = (got->output_section->vma
13302                                        + got->output_offset
13303                                        + off);
13304                     outrel.r_addend = addend;
13305                     if (tls_type & (TLS_LD | TLS_GD))
13306                       {
13307                         outrel.r_addend = 0;
13308                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13309                         if (tls_type == (TLS_TLS | TLS_GD))
13310                           {
13311                             loc = relgot->contents;
13312                             loc += (relgot->reloc_count++
13313                                     * sizeof (Elf64_External_Rela));
13314                             bfd_elf64_swap_reloca_out (output_bfd,
13315                                                        &outrel, loc);
13316                             outrel.r_offset += 8;
13317                             outrel.r_addend = addend;
13318                             outrel.r_info
13319                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13320                           }
13321                       }
13322                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
13323                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13324                     else if (tls_type == (TLS_TLS | TLS_TPREL))
13325                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13326                     else if (indx != 0)
13327                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13328                     else
13329                       {
13330                         if (ifunc)
13331                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13332                         else
13333                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13334
13335                         /* Write the .got section contents for the sake
13336                            of prelink.  */
13337                         loc = got->contents + off;
13338                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13339                                     loc);
13340                       }
13341
13342                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13343                       {
13344                         outrel.r_addend += relocation;
13345                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13346                           outrel.r_addend -= htab->elf.tls_sec->vma;
13347                       }
13348                     loc = relgot->contents;
13349                     loc += (relgot->reloc_count++
13350                             * sizeof (Elf64_External_Rela));
13351                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13352                   }
13353
13354                 /* Init the .got section contents here if we're not
13355                    emitting a reloc.  */
13356                 else
13357                   {
13358                     relocation += addend;
13359                     if (tls_type == (TLS_TLS | TLS_LD))
13360                       relocation = 1;
13361                     else if (tls_type != 0)
13362                       {
13363                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13364                         if (tls_type == (TLS_TLS | TLS_TPREL))
13365                           relocation += DTP_OFFSET - TP_OFFSET;
13366
13367                         if (tls_type == (TLS_TLS | TLS_GD))
13368                           {
13369                             bfd_put_64 (output_bfd, relocation,
13370                                         got->contents + off + 8);
13371                             relocation = 1;
13372                           }
13373                       }
13374
13375                     bfd_put_64 (output_bfd, relocation,
13376                                 got->contents + off);
13377                   }
13378               }
13379
13380             if (off >= (bfd_vma) -2)
13381               abort ();
13382
13383             relocation = got->output_section->vma + got->output_offset + off;
13384             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13385           }
13386           break;
13387
13388         case R_PPC64_PLT16_HA:
13389         case R_PPC64_PLT16_HI:
13390         case R_PPC64_PLT16_LO:
13391         case R_PPC64_PLT32:
13392         case R_PPC64_PLT64:
13393           /* Relocation is to the entry for this symbol in the
13394              procedure linkage table.  */
13395
13396           /* Resolve a PLT reloc against a local symbol directly,
13397              without using the procedure linkage table.  */
13398           if (h == NULL)
13399             break;
13400
13401           /* It's possible that we didn't make a PLT entry for this
13402              symbol.  This happens when statically linking PIC code,
13403              or when using -Bsymbolic.  Go find a match if there is a
13404              PLT entry.  */
13405           if (htab->plt != NULL)
13406             {
13407               struct plt_entry *ent;
13408               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13409                 if (ent->addend == orig_rel.r_addend
13410                     && ent->plt.offset != (bfd_vma) -1)
13411                   {
13412                     relocation = (htab->plt->output_section->vma
13413                                   + htab->plt->output_offset
13414                                   + ent->plt.offset);
13415                     unresolved_reloc = FALSE;
13416                   }
13417             }
13418           break;
13419
13420         case R_PPC64_TOC:
13421           /* Relocation value is TOC base.  */
13422           relocation = TOCstart;
13423           if (r_symndx == STN_UNDEF)
13424             relocation += htab->stub_group[input_section->id].toc_off;
13425           else if (unresolved_reloc)
13426             ;
13427           else if (sec != NULL && sec->id <= htab->top_id)
13428             relocation += htab->stub_group[sec->id].toc_off;
13429           else
13430             unresolved_reloc = TRUE;
13431           goto dodyn;
13432
13433           /* TOC16 relocs.  We want the offset relative to the TOC base,
13434              which is the address of the start of the TOC plus 0x8000.
13435              The TOC consists of sections .got, .toc, .tocbss, and .plt,
13436              in this order.  */
13437         case R_PPC64_TOC16:
13438         case R_PPC64_TOC16_LO:
13439         case R_PPC64_TOC16_HI:
13440         case R_PPC64_TOC16_DS:
13441         case R_PPC64_TOC16_LO_DS:
13442         case R_PPC64_TOC16_HA:
13443           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13444           break;
13445
13446           /* Relocate against the beginning of the section.  */
13447         case R_PPC64_SECTOFF:
13448         case R_PPC64_SECTOFF_LO:
13449         case R_PPC64_SECTOFF_HI:
13450         case R_PPC64_SECTOFF_DS:
13451         case R_PPC64_SECTOFF_LO_DS:
13452         case R_PPC64_SECTOFF_HA:
13453           if (sec != NULL)
13454             addend -= sec->output_section->vma;
13455           break;
13456
13457         case R_PPC64_REL16:
13458         case R_PPC64_REL16_LO:
13459         case R_PPC64_REL16_HI:
13460         case R_PPC64_REL16_HA:
13461           break;
13462
13463         case R_PPC64_REL14:
13464         case R_PPC64_REL14_BRNTAKEN:
13465         case R_PPC64_REL14_BRTAKEN:
13466         case R_PPC64_REL24:
13467           break;
13468
13469         case R_PPC64_TPREL16:
13470         case R_PPC64_TPREL16_LO:
13471         case R_PPC64_TPREL16_HI:
13472         case R_PPC64_TPREL16_HA:
13473         case R_PPC64_TPREL16_DS:
13474         case R_PPC64_TPREL16_LO_DS:
13475         case R_PPC64_TPREL16_HIGHER:
13476         case R_PPC64_TPREL16_HIGHERA:
13477         case R_PPC64_TPREL16_HIGHEST:
13478         case R_PPC64_TPREL16_HIGHESTA:
13479           if (h != NULL
13480               && h->elf.root.type == bfd_link_hash_undefweak
13481               && h->elf.dynindx == -1)
13482             {
13483               /* Make this relocation against an undefined weak symbol
13484                  resolve to zero.  This is really just a tweak, since
13485                  code using weak externs ought to check that they are
13486                  defined before using them.  */
13487               bfd_byte *p = contents + rel->r_offset - d_offset;
13488
13489               insn = bfd_get_32 (output_bfd, p);
13490               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13491               if (insn != 0)
13492                 bfd_put_32 (output_bfd, insn, p);
13493               break;
13494             }
13495           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13496           if (info->shared)
13497             /* The TPREL16 relocs shouldn't really be used in shared
13498                libs as they will result in DT_TEXTREL being set, but
13499                support them anyway.  */
13500             goto dodyn;
13501           break;
13502
13503         case R_PPC64_DTPREL16:
13504         case R_PPC64_DTPREL16_LO:
13505         case R_PPC64_DTPREL16_HI:
13506         case R_PPC64_DTPREL16_HA:
13507         case R_PPC64_DTPREL16_DS:
13508         case R_PPC64_DTPREL16_LO_DS:
13509         case R_PPC64_DTPREL16_HIGHER:
13510         case R_PPC64_DTPREL16_HIGHERA:
13511         case R_PPC64_DTPREL16_HIGHEST:
13512         case R_PPC64_DTPREL16_HIGHESTA:
13513           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13514           break;
13515
13516         case R_PPC64_DTPMOD64:
13517           relocation = 1;
13518           addend = 0;
13519           goto dodyn;
13520
13521         case R_PPC64_TPREL64:
13522           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13523           goto dodyn;
13524
13525         case R_PPC64_DTPREL64:
13526           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13527           /* Fall thru */
13528
13529           /* Relocations that may need to be propagated if this is a
13530              dynamic object.  */
13531         case R_PPC64_REL30:
13532         case R_PPC64_REL32:
13533         case R_PPC64_REL64:
13534         case R_PPC64_ADDR14:
13535         case R_PPC64_ADDR14_BRNTAKEN:
13536         case R_PPC64_ADDR14_BRTAKEN:
13537         case R_PPC64_ADDR16:
13538         case R_PPC64_ADDR16_DS:
13539         case R_PPC64_ADDR16_HA:
13540         case R_PPC64_ADDR16_HI:
13541         case R_PPC64_ADDR16_HIGHER:
13542         case R_PPC64_ADDR16_HIGHERA:
13543         case R_PPC64_ADDR16_HIGHEST:
13544         case R_PPC64_ADDR16_HIGHESTA:
13545         case R_PPC64_ADDR16_LO:
13546         case R_PPC64_ADDR16_LO_DS:
13547         case R_PPC64_ADDR24:
13548         case R_PPC64_ADDR32:
13549         case R_PPC64_ADDR64:
13550         case R_PPC64_UADDR16:
13551         case R_PPC64_UADDR32:
13552         case R_PPC64_UADDR64:
13553         dodyn:
13554           if ((input_section->flags & SEC_ALLOC) == 0)
13555             break;
13556
13557           if (NO_OPD_RELOCS && is_opd)
13558             break;
13559
13560           if ((info->shared
13561                && (h == NULL
13562                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13563                    || h->elf.root.type != bfd_link_hash_undefweak)
13564                && (must_be_dyn_reloc (info, r_type)
13565                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13566               || (ELIMINATE_COPY_RELOCS
13567                   && !info->shared
13568                   && h != NULL
13569                   && h->elf.dynindx != -1
13570                   && !h->elf.non_got_ref
13571                   && !h->elf.def_regular)
13572               || (!info->shared
13573                   && (h != NULL
13574                       ? h->elf.type == STT_GNU_IFUNC
13575                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13576             {
13577               bfd_boolean skip, relocate;
13578               asection *sreloc;
13579               bfd_vma out_off;
13580
13581               /* When generating a dynamic object, these relocations
13582                  are copied into the output file to be resolved at run
13583                  time.  */
13584
13585               skip = FALSE;
13586               relocate = FALSE;
13587
13588               out_off = _bfd_elf_section_offset (output_bfd, info,
13589                                                  input_section, rel->r_offset);
13590               if (out_off == (bfd_vma) -1)
13591                 skip = TRUE;
13592               else if (out_off == (bfd_vma) -2)
13593                 skip = TRUE, relocate = TRUE;
13594               out_off += (input_section->output_section->vma
13595                           + input_section->output_offset);
13596               outrel.r_offset = out_off;
13597               outrel.r_addend = rel->r_addend;
13598
13599               /* Optimize unaligned reloc use.  */
13600               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13601                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13602                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13603               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13604                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13605                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13606               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13607                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13608                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13609
13610               if (skip)
13611                 memset (&outrel, 0, sizeof outrel);
13612               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13613                        && !is_opd
13614                        && r_type != R_PPC64_TOC)
13615                 {
13616                   BFD_ASSERT (h->elf.dynindx != -1);
13617                   outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13618                 }
13619               else
13620                 {
13621                   /* This symbol is local, or marked to become local,
13622                      or this is an opd section reloc which must point
13623                      at a local function.  */
13624                   outrel.r_addend += relocation;
13625                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13626                     {
13627                       if (is_opd && h != NULL)
13628                         {
13629                           /* Lie about opd entries.  This case occurs
13630                              when building shared libraries and we
13631                              reference a function in another shared
13632                              lib.  The same thing happens for a weak
13633                              definition in an application that's
13634                              overridden by a strong definition in a
13635                              shared lib.  (I believe this is a generic
13636                              bug in binutils handling of weak syms.)
13637                              In these cases we won't use the opd
13638                              entry in this lib.  */
13639                           unresolved_reloc = FALSE;
13640                         }
13641                       if (!is_opd
13642                           && r_type == R_PPC64_ADDR64
13643                           && (h != NULL
13644                               ? h->elf.type == STT_GNU_IFUNC
13645                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13646                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13647                       else
13648                         {
13649                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13650
13651                           /* We need to relocate .opd contents for ld.so.
13652                              Prelink also wants simple and consistent rules
13653                              for relocs.  This make all RELATIVE relocs have
13654                              *r_offset equal to r_addend.  */
13655                           relocate = TRUE;
13656                         }
13657                     }
13658                   else
13659                     {
13660                       long indx = 0;
13661
13662                       if (h != NULL
13663                           ? h->elf.type == STT_GNU_IFUNC
13664                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13665                         {
13666                           info->callbacks->einfo
13667                             (_("%P: %H: %s for indirect "
13668                                "function `%T' unsupported\n"),
13669                              input_bfd, input_section, rel->r_offset,
13670                              ppc64_elf_howto_table[r_type]->name,
13671                              sym_name);
13672                           ret = FALSE;
13673                         }
13674                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13675                         ;
13676                       else if (sec == NULL || sec->owner == NULL)
13677                         {
13678                           bfd_set_error (bfd_error_bad_value);
13679                           return FALSE;
13680                         }
13681                       else
13682                         {
13683                           asection *osec;
13684
13685                           osec = sec->output_section;
13686                           indx = elf_section_data (osec)->dynindx;
13687
13688                           if (indx == 0)
13689                             {
13690                               if ((osec->flags & SEC_READONLY) == 0
13691                                   && htab->elf.data_index_section != NULL)
13692                                 osec = htab->elf.data_index_section;
13693                               else
13694                                 osec = htab->elf.text_index_section;
13695                               indx = elf_section_data (osec)->dynindx;
13696                             }
13697                           BFD_ASSERT (indx != 0);
13698
13699                           /* We are turning this relocation into one
13700                              against a section symbol, so subtract out
13701                              the output section's address but not the
13702                              offset of the input section in the output
13703                              section.  */
13704                           outrel.r_addend -= osec->vma;
13705                         }
13706
13707                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13708                     }
13709                 }
13710
13711               sreloc = elf_section_data (input_section)->sreloc;
13712               if (h != NULL
13713                   ? h->elf.type == STT_GNU_IFUNC
13714                   : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13715                 sreloc = htab->reliplt;
13716               if (sreloc == NULL)
13717                 abort ();
13718
13719               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13720                   >= sreloc->size)
13721                 abort ();
13722               loc = sreloc->contents;
13723               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13724               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13725
13726               /* If this reloc is against an external symbol, it will
13727                  be computed at runtime, so there's no need to do
13728                  anything now.  However, for the sake of prelink ensure
13729                  that the section contents are a known value.  */
13730               if (! relocate)
13731                 {
13732                   unresolved_reloc = FALSE;
13733                   /* The value chosen here is quite arbitrary as ld.so
13734                      ignores section contents except for the special
13735                      case of .opd where the contents might be accessed
13736                      before relocation.  Choose zero, as that won't
13737                      cause reloc overflow.  */
13738                   relocation = 0;
13739                   addend = 0;
13740                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13741                      to improve backward compatibility with older
13742                      versions of ld.  */
13743                   if (r_type == R_PPC64_ADDR64)
13744                     addend = outrel.r_addend;
13745                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13746                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13747                     addend = (input_section->output_section->vma
13748                               + input_section->output_offset
13749                               + rel->r_offset);
13750                 }
13751             }
13752           break;
13753
13754         case R_PPC64_COPY:
13755         case R_PPC64_GLOB_DAT:
13756         case R_PPC64_JMP_SLOT:
13757         case R_PPC64_JMP_IREL:
13758         case R_PPC64_RELATIVE:
13759           /* We shouldn't ever see these dynamic relocs in relocatable
13760              files.  */
13761           /* Fall through.  */
13762
13763         case R_PPC64_PLTGOT16:
13764         case R_PPC64_PLTGOT16_DS:
13765         case R_PPC64_PLTGOT16_HA:
13766         case R_PPC64_PLTGOT16_HI:
13767         case R_PPC64_PLTGOT16_LO:
13768         case R_PPC64_PLTGOT16_LO_DS:
13769         case R_PPC64_PLTREL32:
13770         case R_PPC64_PLTREL64:
13771           /* These ones haven't been implemented yet.  */
13772
13773           info->callbacks->einfo
13774             (_("%P: %B: %s is not supported for `%T'\n"),
13775              input_bfd,
13776              ppc64_elf_howto_table[r_type]->name, sym_name);
13777
13778           bfd_set_error (bfd_error_invalid_operation);
13779           ret = FALSE;
13780           continue;
13781         }
13782
13783       /* Multi-instruction sequences that access the TOC can be
13784          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13785          to             nop;           addi rb,r2,x;  */
13786       switch (r_type)
13787         {
13788         default:
13789           break;
13790
13791         case R_PPC64_GOT_TLSLD16_HI:
13792         case R_PPC64_GOT_TLSGD16_HI:
13793         case R_PPC64_GOT_TPREL16_HI:
13794         case R_PPC64_GOT_DTPREL16_HI:
13795         case R_PPC64_GOT16_HI:
13796         case R_PPC64_TOC16_HI:
13797           /* These relocs would only be useful if building up an
13798              offset to later add to r2, perhaps in an indexed
13799              addressing mode instruction.  Don't try to optimize.
13800              Unfortunately, the possibility of someone building up an
13801              offset like this or even with the HA relocs, means that
13802              we need to check the high insn when optimizing the low
13803              insn.  */
13804           break;
13805
13806         case R_PPC64_GOT_TLSLD16_HA:
13807         case R_PPC64_GOT_TLSGD16_HA:
13808         case R_PPC64_GOT_TPREL16_HA:
13809         case R_PPC64_GOT_DTPREL16_HA:
13810         case R_PPC64_GOT16_HA:
13811         case R_PPC64_TOC16_HA:
13812           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13813               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13814             {
13815               bfd_byte *p = contents + (rel->r_offset & ~3);
13816               bfd_put_32 (input_bfd, NOP, p);
13817             }
13818           break;
13819
13820         case R_PPC64_GOT_TLSLD16_LO:
13821         case R_PPC64_GOT_TLSGD16_LO:
13822         case R_PPC64_GOT_TPREL16_LO_DS:
13823         case R_PPC64_GOT_DTPREL16_LO_DS:
13824         case R_PPC64_GOT16_LO:
13825         case R_PPC64_GOT16_LO_DS:
13826         case R_PPC64_TOC16_LO:
13827         case R_PPC64_TOC16_LO_DS:
13828           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13829               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13830             {
13831               bfd_byte *p = contents + (rel->r_offset & ~3);
13832               insn = bfd_get_32 (input_bfd, p);
13833               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13834                 {
13835                   /* Transform addic to addi when we change reg.  */
13836                   insn &= ~((0x3f << 26) | (0x1f << 16));
13837                   insn |= (14u << 26) | (2 << 16);
13838                 }
13839               else
13840                 {
13841                   insn &= ~(0x1f << 16);
13842                   insn |= 2 << 16;
13843                 }
13844               bfd_put_32 (input_bfd, insn, p);
13845             }
13846           break;
13847         }
13848
13849       /* Do any further special processing.  */
13850       switch (r_type)
13851         {
13852         default:
13853           break;
13854
13855         case R_PPC64_ADDR16_HA:
13856         case R_PPC64_REL16_HA:
13857         case R_PPC64_ADDR16_HIGHERA:
13858         case R_PPC64_ADDR16_HIGHESTA:
13859         case R_PPC64_TOC16_HA:
13860         case R_PPC64_SECTOFF_HA:
13861         case R_PPC64_TPREL16_HA:
13862         case R_PPC64_DTPREL16_HA:
13863         case R_PPC64_TPREL16_HIGHER:
13864         case R_PPC64_TPREL16_HIGHERA:
13865         case R_PPC64_TPREL16_HIGHEST:
13866         case R_PPC64_TPREL16_HIGHESTA:
13867         case R_PPC64_DTPREL16_HIGHER:
13868         case R_PPC64_DTPREL16_HIGHERA:
13869         case R_PPC64_DTPREL16_HIGHEST:
13870         case R_PPC64_DTPREL16_HIGHESTA:
13871           /* It's just possible that this symbol is a weak symbol
13872              that's not actually defined anywhere. In that case,
13873              'sec' would be NULL, and we should leave the symbol
13874              alone (it will be set to zero elsewhere in the link).  */
13875           if (sec == NULL)
13876             break;
13877           /* Fall thru */
13878
13879         case R_PPC64_GOT16_HA:
13880         case R_PPC64_PLTGOT16_HA:
13881         case R_PPC64_PLT16_HA:
13882         case R_PPC64_GOT_TLSGD16_HA:
13883         case R_PPC64_GOT_TLSLD16_HA:
13884         case R_PPC64_GOT_TPREL16_HA:
13885         case R_PPC64_GOT_DTPREL16_HA:
13886           /* Add 0x10000 if sign bit in 0:15 is set.
13887              Bits 0:15 are not used.  */
13888           addend += 0x8000;
13889           break;
13890
13891         case R_PPC64_ADDR16_DS:
13892         case R_PPC64_ADDR16_LO_DS:
13893         case R_PPC64_GOT16_DS:
13894         case R_PPC64_GOT16_LO_DS:
13895         case R_PPC64_PLT16_LO_DS:
13896         case R_PPC64_SECTOFF_DS:
13897         case R_PPC64_SECTOFF_LO_DS:
13898         case R_PPC64_TOC16_DS:
13899         case R_PPC64_TOC16_LO_DS:
13900         case R_PPC64_PLTGOT16_DS:
13901         case R_PPC64_PLTGOT16_LO_DS:
13902         case R_PPC64_GOT_TPREL16_DS:
13903         case R_PPC64_GOT_TPREL16_LO_DS:
13904         case R_PPC64_GOT_DTPREL16_DS:
13905         case R_PPC64_GOT_DTPREL16_LO_DS:
13906         case R_PPC64_TPREL16_DS:
13907         case R_PPC64_TPREL16_LO_DS:
13908         case R_PPC64_DTPREL16_DS:
13909         case R_PPC64_DTPREL16_LO_DS:
13910           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13911           mask = 3;
13912           /* If this reloc is against an lq insn, then the value must be
13913              a multiple of 16.  This is somewhat of a hack, but the
13914              "correct" way to do this by defining _DQ forms of all the
13915              _DS relocs bloats all reloc switches in this file.  It
13916              doesn't seem to make much sense to use any of these relocs
13917              in data, so testing the insn should be safe.  */
13918           if ((insn & (0x3f << 26)) == (56u << 26))
13919             mask = 15;
13920           if (((relocation + addend) & mask) != 0)
13921             {
13922               info->callbacks->einfo
13923                 (_("%P: %H: error: %s not a multiple of %u\n"),
13924                  input_bfd, input_section, rel->r_offset,
13925                  ppc64_elf_howto_table[r_type]->name,
13926                  mask + 1);
13927               bfd_set_error (bfd_error_bad_value);
13928               ret = FALSE;
13929               continue;
13930             }
13931           break;
13932         }
13933
13934       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13935          because such sections are not SEC_ALLOC and thus ld.so will
13936          not process them.  */
13937       if (unresolved_reloc
13938           && !((input_section->flags & SEC_DEBUGGING) != 0
13939                && h->elf.def_dynamic)
13940           && _bfd_elf_section_offset (output_bfd, info, input_section,
13941                                       rel->r_offset) != (bfd_vma) -1)
13942         {
13943           info->callbacks->einfo
13944             (_("%P: %H: unresolvable %s against `%T'\n"),
13945              input_bfd, input_section, rel->r_offset,
13946              ppc64_elf_howto_table[(int) r_type]->name,
13947              h->elf.root.root.string);
13948           ret = FALSE;
13949         }
13950
13951       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13952                                     input_bfd,
13953                                     input_section,
13954                                     contents,
13955                                     rel->r_offset,
13956                                     relocation,
13957                                     addend);
13958
13959       if (r != bfd_reloc_ok)
13960         {
13961           char *more_info = NULL;
13962           const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
13963
13964           if (reloc_dest != DEST_NORMAL)
13965             {
13966               more_info = bfd_malloc (strlen (reloc_name) + 8);
13967               if (more_info != NULL)
13968                 {
13969                   strcpy (more_info, reloc_name);
13970                   strcat (more_info, (reloc_dest == DEST_OPD
13971                                       ? " (OPD)" : " (stub)"));
13972                   reloc_name = more_info;
13973                 }
13974             }
13975
13976           if (r == bfd_reloc_overflow)
13977             {
13978               if (warned)
13979                 continue;
13980               if (h != NULL
13981                   && h->elf.root.type == bfd_link_hash_undefweak
13982                   && ppc64_elf_howto_table[r_type]->pc_relative)
13983                 {
13984                   /* Assume this is a call protected by other code that
13985                      detects the symbol is undefined.  If this is the case,
13986                      we can safely ignore the overflow.  If not, the
13987                      program is hosed anyway, and a little warning isn't
13988                      going to help.  */
13989
13990                   continue;
13991                 }
13992
13993               if (!((*info->callbacks->reloc_overflow)
13994                     (info, &h->elf.root, sym_name,
13995                      reloc_name, orig_rel.r_addend,
13996                      input_bfd, input_section, rel->r_offset)))
13997                 return FALSE;
13998             }
13999           else
14000             {
14001               info->callbacks->einfo
14002                 (_("%P: %H: %s against `%T': error %d\n"),
14003                  input_bfd, input_section, rel->r_offset,
14004                  reloc_name, sym_name, (int) r);
14005               ret = FALSE;
14006             }
14007           if (more_info != NULL)
14008             free (more_info);
14009         }
14010     }
14011
14012   /* If we're emitting relocations, then shortly after this function
14013      returns, reloc offsets and addends for this section will be
14014      adjusted.  Worse, reloc symbol indices will be for the output
14015      file rather than the input.  Save a copy of the relocs for
14016      opd_entry_value.  */
14017   if (is_opd && (info->emitrelocations || info->relocatable))
14018     {
14019       bfd_size_type amt;
14020       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14021       rel = bfd_alloc (input_bfd, amt);
14022       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
14023       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
14024       if (rel == NULL)
14025         return FALSE;
14026       memcpy (rel, relocs, amt);
14027     }
14028   return ret;
14029 }
14030
14031 /* Adjust the value of any local symbols in opd sections.  */
14032
14033 static int
14034 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14035                               const char *name ATTRIBUTE_UNUSED,
14036                               Elf_Internal_Sym *elfsym,
14037                               asection *input_sec,
14038                               struct elf_link_hash_entry *h)
14039 {
14040   struct _opd_sec_data *opd;
14041   long adjust;
14042   bfd_vma value;
14043
14044   if (h != NULL)
14045     return 1;
14046
14047   opd = get_opd_info (input_sec);
14048   if (opd == NULL || opd->adjust == NULL)
14049     return 1;
14050
14051   value = elfsym->st_value - input_sec->output_offset;
14052   if (!info->relocatable)
14053     value -= input_sec->output_section->vma;
14054
14055   adjust = opd->adjust[value / 8];
14056   if (adjust == -1)
14057     return 2;
14058
14059   elfsym->st_value += adjust;
14060   return 1;
14061 }
14062
14063 /* Finish up dynamic symbol handling.  We set the contents of various
14064    dynamic sections here.  */
14065
14066 static bfd_boolean
14067 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14068                                  struct bfd_link_info *info,
14069                                  struct elf_link_hash_entry *h,
14070                                  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14071 {
14072   struct ppc_link_hash_table *htab;
14073   struct plt_entry *ent;
14074   Elf_Internal_Rela rela;
14075   bfd_byte *loc;
14076
14077   htab = ppc_hash_table (info);
14078   if (htab == NULL)
14079     return FALSE;
14080
14081   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14082     if (ent->plt.offset != (bfd_vma) -1)
14083       {
14084         /* This symbol has an entry in the procedure linkage
14085            table.  Set it up.  */
14086         if (!htab->elf.dynamic_sections_created
14087             || h->dynindx == -1)
14088           {
14089             BFD_ASSERT (h->type == STT_GNU_IFUNC
14090                         && h->def_regular
14091                         && (h->root.type == bfd_link_hash_defined
14092                             || h->root.type == bfd_link_hash_defweak));
14093             rela.r_offset = (htab->iplt->output_section->vma
14094                              + htab->iplt->output_offset
14095                              + ent->plt.offset);
14096             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14097             rela.r_addend = (h->root.u.def.value
14098                              + h->root.u.def.section->output_offset
14099                              + h->root.u.def.section->output_section->vma
14100                              + ent->addend);
14101             loc = (htab->reliplt->contents
14102                    + (htab->reliplt->reloc_count++
14103                       * sizeof (Elf64_External_Rela)));
14104           }
14105         else
14106           {
14107             rela.r_offset = (htab->plt->output_section->vma
14108                              + htab->plt->output_offset
14109                              + ent->plt.offset);
14110             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14111             rela.r_addend = ent->addend;
14112             loc = (htab->relplt->contents
14113                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14114                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14115           }
14116         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14117       }
14118
14119   if (h->needs_copy)
14120     {
14121       /* This symbol needs a copy reloc.  Set it up.  */
14122
14123       if (h->dynindx == -1
14124           || (h->root.type != bfd_link_hash_defined
14125               && h->root.type != bfd_link_hash_defweak)
14126           || htab->relbss == NULL)
14127         abort ();
14128
14129       rela.r_offset = (h->root.u.def.value
14130                        + h->root.u.def.section->output_section->vma
14131                        + h->root.u.def.section->output_offset);
14132       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14133       rela.r_addend = 0;
14134       loc = htab->relbss->contents;
14135       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14136       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14137     }
14138
14139   return TRUE;
14140 }
14141
14142 /* Used to decide how to sort relocs in an optimal manner for the
14143    dynamic linker, before writing them out.  */
14144
14145 static enum elf_reloc_type_class
14146 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14147                             const asection *rel_sec,
14148                             const Elf_Internal_Rela *rela)
14149 {
14150   enum elf_ppc64_reloc_type r_type;
14151   struct ppc_link_hash_table *htab = ppc_hash_table (info);
14152
14153   if (rel_sec == htab->reliplt)
14154     return reloc_class_ifunc;
14155
14156   r_type = ELF64_R_TYPE (rela->r_info);
14157   switch (r_type)
14158     {
14159     case R_PPC64_RELATIVE:
14160       return reloc_class_relative;
14161     case R_PPC64_JMP_SLOT:
14162       return reloc_class_plt;
14163     case R_PPC64_COPY:
14164       return reloc_class_copy;
14165     default:
14166       return reloc_class_normal;
14167     }
14168 }
14169
14170 /* Finish up the dynamic sections.  */
14171
14172 static bfd_boolean
14173 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14174                                    struct bfd_link_info *info)
14175 {
14176   struct ppc_link_hash_table *htab;
14177   bfd *dynobj;
14178   asection *sdyn;
14179
14180   htab = ppc_hash_table (info);
14181   if (htab == NULL)
14182     return FALSE;
14183
14184   dynobj = htab->elf.dynobj;
14185   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14186
14187   if (htab->elf.dynamic_sections_created)
14188     {
14189       Elf64_External_Dyn *dyncon, *dynconend;
14190
14191       if (sdyn == NULL || htab->got == NULL)
14192         abort ();
14193
14194       dyncon = (Elf64_External_Dyn *) sdyn->contents;
14195       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14196       for (; dyncon < dynconend; dyncon++)
14197         {
14198           Elf_Internal_Dyn dyn;
14199           asection *s;
14200
14201           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14202
14203           switch (dyn.d_tag)
14204             {
14205             default:
14206               continue;
14207
14208             case DT_PPC64_GLINK:
14209               s = htab->glink;
14210               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14211               /* We stupidly defined DT_PPC64_GLINK to be the start
14212                  of glink rather than the first entry point, which is
14213                  what ld.so needs, and now have a bigger stub to
14214                  support automatic multiple TOCs.  */
14215               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14216               break;
14217
14218             case DT_PPC64_OPD:
14219               s = bfd_get_section_by_name (output_bfd, ".opd");
14220               if (s == NULL)
14221                 continue;
14222               dyn.d_un.d_ptr = s->vma;
14223               break;
14224
14225             case DT_PPC64_OPDSZ:
14226               s = bfd_get_section_by_name (output_bfd, ".opd");
14227               if (s == NULL)
14228                 continue;
14229               dyn.d_un.d_val = s->size;
14230               break;
14231
14232             case DT_PLTGOT:
14233               s = htab->plt;
14234               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14235               break;
14236
14237             case DT_JMPREL:
14238               s = htab->relplt;
14239               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14240               break;
14241
14242             case DT_PLTRELSZ:
14243               dyn.d_un.d_val = htab->relplt->size;
14244               break;
14245
14246             case DT_RELASZ:
14247               /* Don't count procedure linkage table relocs in the
14248                  overall reloc count.  */
14249               s = htab->relplt;
14250               if (s == NULL)
14251                 continue;
14252               dyn.d_un.d_val -= s->size;
14253               break;
14254
14255             case DT_RELA:
14256               /* We may not be using the standard ELF linker script.
14257                  If .rela.plt is the first .rela section, we adjust
14258                  DT_RELA to not include it.  */
14259               s = htab->relplt;
14260               if (s == NULL)
14261                 continue;
14262               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14263                 continue;
14264               dyn.d_un.d_ptr += s->size;
14265               break;
14266             }
14267
14268           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14269         }
14270     }
14271
14272   if (htab->got != NULL && htab->got->size != 0)
14273     {
14274       /* Fill in the first entry in the global offset table.
14275          We use it to hold the link-time TOCbase.  */
14276       bfd_put_64 (output_bfd,
14277                   elf_gp (output_bfd) + TOC_BASE_OFF,
14278                   htab->got->contents);
14279
14280       /* Set .got entry size.  */
14281       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14282     }
14283
14284   if (htab->plt != NULL && htab->plt->size != 0)
14285     {
14286       /* Set .plt entry size.  */
14287       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14288         = PLT_ENTRY_SIZE;
14289     }
14290
14291   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14292      brlt ourselves if emitrelocations.  */
14293   if (htab->brlt != NULL
14294       && htab->brlt->reloc_count != 0
14295       && !_bfd_elf_link_output_relocs (output_bfd,
14296                                        htab->brlt,
14297                                        elf_section_data (htab->brlt)->rela.hdr,
14298                                        elf_section_data (htab->brlt)->relocs,
14299                                        NULL))
14300     return FALSE;
14301
14302   if (htab->glink != NULL
14303       && htab->glink->reloc_count != 0
14304       && !_bfd_elf_link_output_relocs (output_bfd,
14305                                        htab->glink,
14306                                        elf_section_data (htab->glink)->rela.hdr,
14307                                        elf_section_data (htab->glink)->relocs,
14308                                        NULL))
14309     return FALSE;
14310
14311
14312   if (htab->glink_eh_frame != NULL
14313       && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14314       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14315                                            htab->glink_eh_frame,
14316                                            htab->glink_eh_frame->contents))
14317     return FALSE;
14318
14319   /* We need to handle writing out multiple GOT sections ourselves,
14320      since we didn't add them to DYNOBJ.  We know dynobj is the first
14321      bfd.  */
14322   while ((dynobj = dynobj->link_next) != NULL)
14323     {
14324       asection *s;
14325
14326       if (!is_ppc64_elf (dynobj))
14327         continue;
14328
14329       s = ppc64_elf_tdata (dynobj)->got;
14330       if (s != NULL
14331           && s->size != 0
14332           && s->output_section != bfd_abs_section_ptr
14333           && !bfd_set_section_contents (output_bfd, s->output_section,
14334                                         s->contents, s->output_offset,
14335                                         s->size))
14336         return FALSE;
14337       s = ppc64_elf_tdata (dynobj)->relgot;
14338       if (s != NULL
14339           && s->size != 0
14340           && s->output_section != bfd_abs_section_ptr
14341           && !bfd_set_section_contents (output_bfd, s->output_section,
14342                                         s->contents, s->output_offset,
14343                                         s->size))
14344         return FALSE;
14345     }
14346
14347   return TRUE;
14348 }
14349
14350 #include "elf64-target.h"
14351
14352 /* FreeBSD support */
14353
14354 #undef  TARGET_LITTLE_SYM
14355 #undef  TARGET_LITTLE_NAME
14356
14357 #undef  TARGET_BIG_SYM
14358 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
14359 #undef  TARGET_BIG_NAME
14360 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14361
14362 #undef  ELF_OSABI
14363 #define ELF_OSABI       ELFOSABI_FREEBSD
14364
14365 #undef  elf64_bed
14366 #define elf64_bed       elf64_powerpc_fbsd_bed
14367
14368 #include "elf64-target.h"
14369