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 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 *);
  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_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 111 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 112 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 113 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 114 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 115 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 116 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 117 #define elf_backend_special_sections          ppc64_elf_special_sections
 118 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 119
 120 /* The name of the dynamic interpreter.  This is put in the .interp
 121    section.  */
 122 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 123
 124 /* The size in bytes of an entry in the procedure linkage table.  */
 125 #define PLT_ENTRY_SIZE 24
 126
 127 /* The initial size of the plt reserved for the dynamic linker.  */
 128 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 129
 130 /* TOC base pointers offset from start of TOC.  */
 131 #define TOC_BASE_OFF    0x8000
 132
 133 /* Offset of tp and dtp pointers from start of TLS block.  */
 134 #define TP_OFFSET       0x7000
 135 #define DTP_OFFSET      0x8000
 136
 137 /* .plt call stub instructions.  The normal stub is like this, but
 138    sometimes the .plt entry crosses a 64k boundary and we need to
 139    insert an addi to adjust r12.  */
 140 #define PLT_CALL_STUB_SIZE (7*4)
 141 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 142 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 143 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 144 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 145 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 146                                         /* ld    %r11,xxx+16@l(%r12) */
 147 #define BCTR            0x4e800420      /* bctr                      */
 148
 149
 150 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 151 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 152 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 153 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 154
 155 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 156 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 157
 158 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 159
 160 /* glink call stub instructions.  We enter with the index in R0.  */
 161 #define GLINK_CALL_STUB_SIZE (16*4)
 162                                         /* 0:                           */
 163                                         /*  .quad plt0-1f               */
 164                                         /* __glink:                     */
 165 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 166 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 167                                         /* 1:                           */
 168 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 169 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 170 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 171 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 172                                         /*  ld %11,0(%12)               */
 173                                         /*  ld %2,8(%12)                */
 174                                         /*  mtctr %11                   */
 175                                         /*  ld %11,16(%12)              */
 176                                         /*  bctr                        */
 177
 178 /* Pad with this.  */
 179 #define NOP             0x60000000
 180
 181 /* Some other nops.  */
 182 #define CROR_151515     0x4def7b82
 183 #define CROR_313131     0x4ffffb82
 184
 185 /* .glink entries for the first 32k functions are two instructions.  */
 186 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 187 #define B_DOT           0x48000000      /* b     .              */
 188
 189 /* After that, we need two instructions to load the index, followed by
 190    a branch.  */
 191 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 192 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 193
 194 /* Instructions used by the save and restore reg functions.  */
 195 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 196 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 197 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 198 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 199 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 200 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 201 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 202 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 203 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 204 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 205 #define BLR             0x4e800020      /* blr                  */
 206
 207 /* Since .opd is an array of descriptors and each entry will end up
 208    with identical R_PPC64_RELATIVE relocs, there is really no need to
 209    propagate .opd relocs;  The dynamic linker should be taught to
 210    relocate .opd without reloc entries.  */
 211 #ifndef NO_OPD_RELOCS
 212 #define NO_OPD_RELOCS 0
 213 #endif
 214 \f
 215 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 216
 217 /* Relocation HOWTO's.  */
 218 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 219
 220 static reloc_howto_type ppc64_elf_howto_raw[] = {
 221   /* This reloc does nothing.  */
 222   HOWTO (R_PPC64_NONE,          /* type */
 223          0,                     /* rightshift */
 224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          32,                    /* bitsize */
 226          FALSE,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_dont, /* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_PPC64_NONE",        /* name */
 231          FALSE,                 /* partial_inplace */
 232          0,                     /* src_mask */
 233          0,                     /* dst_mask */
 234          FALSE),                /* pcrel_offset */
 235
 236   /* A standard 32 bit relocation.  */
 237   HOWTO (R_PPC64_ADDR32,        /* type */
 238          0,                     /* rightshift */
 239          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 240          32,                    /* bitsize */
 241          FALSE,                 /* pc_relative */
 242          0,                     /* bitpos */
 243          complain_overflow_bitfield, /* complain_on_overflow */
 244          bfd_elf_generic_reloc, /* special_function */
 245          "R_PPC64_ADDR32",      /* name */
 246          FALSE,                 /* partial_inplace */
 247          0,                     /* src_mask */
 248          0xffffffff,            /* dst_mask */
 249          FALSE),                /* pcrel_offset */
 250
 251   /* An absolute 26 bit branch; the lower two bits must be zero.
 252      FIXME: we don't check that, we just clear them.  */
 253   HOWTO (R_PPC64_ADDR24,        /* type */
 254          0,                     /* rightshift */
 255          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          26,                    /* bitsize */
 257          FALSE,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_bitfield, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC64_ADDR24",      /* name */
 262          FALSE,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0x03fffffc,            /* dst_mask */
 265          FALSE),                /* pcrel_offset */
 266
 267   /* A standard 16 bit relocation.  */
 268   HOWTO (R_PPC64_ADDR16,        /* type */
 269          0,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          16,                    /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_bitfield, /* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_PPC64_ADDR16",      /* name */
 277          FALSE,                 /* partial_inplace */
 278          0,                     /* src_mask */
 279          0xffff,                /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281
 282   /* A 16 bit relocation without overflow.  */
 283   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 284          0,                     /* rightshift */
 285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          16,                    /* bitsize */
 287          FALSE,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_dont,/* complain_on_overflow */
 290          bfd_elf_generic_reloc, /* special_function */
 291          "R_PPC64_ADDR16_LO",   /* name */
 292          FALSE,                 /* partial_inplace */
 293          0,                     /* src_mask */
 294          0xffff,                /* dst_mask */
 295          FALSE),                /* pcrel_offset */
 296
 297   /* Bits 16-31 of an address.  */
 298   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 299          16,                    /* rightshift */
 300          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 301          16,                    /* bitsize */
 302          FALSE,                 /* pc_relative */
 303          0,                     /* bitpos */
 304          complain_overflow_dont, /* complain_on_overflow */
 305          bfd_elf_generic_reloc, /* special_function */
 306          "R_PPC64_ADDR16_HI",   /* name */
 307          FALSE,                 /* partial_inplace */
 308          0,                     /* src_mask */
 309          0xffff,                /* dst_mask */
 310          FALSE),                /* pcrel_offset */
 311
 312   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 313      bits, treated as a signed number, is negative.  */
 314   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 315          16,                    /* rightshift */
 316          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          16,                    /* bitsize */
 318          FALSE,                 /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_dont, /* complain_on_overflow */
 321          ppc64_elf_ha_reloc,    /* special_function */
 322          "R_PPC64_ADDR16_HA",   /* name */
 323          FALSE,                 /* partial_inplace */
 324          0,                     /* src_mask */
 325          0xffff,                /* dst_mask */
 326          FALSE),                /* pcrel_offset */
 327
 328   /* An absolute 16 bit branch; the lower two bits must be zero.
 329      FIXME: we don't check that, we just clear them.  */
 330   HOWTO (R_PPC64_ADDR14,        /* type */
 331          0,                     /* rightshift */
 332          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_bitfield, /* complain_on_overflow */
 337          ppc64_elf_branch_reloc, /* special_function */
 338          "R_PPC64_ADDR14",      /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0x0000fffc,            /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* An absolute 16 bit branch, for which bit 10 should be set to
 345      indicate that the branch is expected to be taken.  The lower two
 346      bits must be zero.  */
 347   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 348          0,                     /* rightshift */
 349          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          16,                    /* bitsize */
 351          FALSE,                 /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_bitfield, /* complain_on_overflow */
 354          ppc64_elf_brtaken_reloc, /* special_function */
 355          "R_PPC64_ADDR14_BRTAKEN",/* name */
 356          FALSE,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0x0000fffc,            /* dst_mask */
 359          FALSE),                /* pcrel_offset */
 360
 361   /* An absolute 16 bit branch, for which bit 10 should be set to
 362      indicate that the branch is not expected to be taken.  The lower
 363      two bits must be zero.  */
 364   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 365          0,                     /* rightshift */
 366          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 367          16,                    /* bitsize */
 368          FALSE,                 /* pc_relative */
 369          0,                     /* bitpos */
 370          complain_overflow_bitfield, /* complain_on_overflow */
 371          ppc64_elf_brtaken_reloc, /* special_function */
 372          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 373          FALSE,                 /* partial_inplace */
 374          0,                     /* src_mask */
 375          0x0000fffc,            /* dst_mask */
 376          FALSE),                /* pcrel_offset */
 377
 378   /* A relative 26 bit branch; the lower two bits must be zero.  */
 379   HOWTO (R_PPC64_REL24,         /* type */
 380          0,                     /* rightshift */
 381          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          26,                    /* bitsize */
 383          TRUE,                  /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_signed, /* complain_on_overflow */
 386          ppc64_elf_branch_reloc, /* special_function */
 387          "R_PPC64_REL24",       /* name */
 388          FALSE,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0x03fffffc,            /* dst_mask */
 391          TRUE),                 /* pcrel_offset */
 392
 393   /* A relative 16 bit branch; the lower two bits must be zero.  */
 394   HOWTO (R_PPC64_REL14,         /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_branch_reloc, /* special_function */
 402          "R_PPC64_REL14",       /* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 409      the branch is expected to be taken.  The lower two bits must be
 410      zero.  */
 411   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          TRUE,                  /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_REL14_BRTAKEN", /* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          TRUE),                 /* pcrel_offset */
 424
 425   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 426      the branch is not expected to be taken.  The lower two bits must
 427      be zero.  */
 428   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 429          0,                     /* rightshift */
 430          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 431          16,                    /* bitsize */
 432          TRUE,                  /* pc_relative */
 433          0,                     /* bitpos */
 434          complain_overflow_signed, /* complain_on_overflow */
 435          ppc64_elf_brtaken_reloc, /* special_function */
 436          "R_PPC64_REL14_BRNTAKEN",/* name */
 437          FALSE,                 /* partial_inplace */
 438          0,                     /* src_mask */
 439          0x0000fffc,            /* dst_mask */
 440          TRUE),                 /* pcrel_offset */
 441
 442   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 443      symbol.  */
 444   HOWTO (R_PPC64_GOT16,         /* type */
 445          0,                     /* rightshift */
 446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 447          16,                    /* bitsize */
 448          FALSE,                 /* pc_relative */
 449          0,                     /* bitpos */
 450          complain_overflow_signed, /* complain_on_overflow */
 451          ppc64_elf_unhandled_reloc, /* special_function */
 452          "R_PPC64_GOT16",       /* name */
 453          FALSE,                 /* partial_inplace */
 454          0,                     /* src_mask */
 455          0xffff,                /* dst_mask */
 456          FALSE),                /* pcrel_offset */
 457
 458   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 459      the symbol.  */
 460   HOWTO (R_PPC64_GOT16_LO,      /* type */
 461          0,                     /* rightshift */
 462          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 463          16,                    /* bitsize */
 464          FALSE,                 /* pc_relative */
 465          0,                     /* bitpos */
 466          complain_overflow_dont, /* complain_on_overflow */
 467          ppc64_elf_unhandled_reloc, /* special_function */
 468          "R_PPC64_GOT16_LO",    /* name */
 469          FALSE,                 /* partial_inplace */
 470          0,                     /* src_mask */
 471          0xffff,                /* dst_mask */
 472          FALSE),                /* pcrel_offset */
 473
 474   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 475      the symbol.  */
 476   HOWTO (R_PPC64_GOT16_HI,      /* type */
 477          16,                    /* rightshift */
 478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          16,                    /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_dont,/* complain_on_overflow */
 483          ppc64_elf_unhandled_reloc, /* special_function */
 484          "R_PPC64_GOT16_HI",    /* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0xffff,                /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 491      the symbol.  */
 492   HOWTO (R_PPC64_GOT16_HA,      /* type */
 493          16,                    /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          16,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont,/* complain_on_overflow */
 499          ppc64_elf_unhandled_reloc, /* special_function */
 500          "R_PPC64_GOT16_HA",    /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          0xffff,                /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* This is used only by the dynamic linker.  The symbol should exist
 507      both in the object being run and in some shared library.  The
 508      dynamic linker copies the data addressed by the symbol from the
 509      shared library into the object, because the object being
 510      run has to have the data at some particular address.  */
 511   HOWTO (R_PPC64_COPY,          /* type */
 512          0,                     /* rightshift */
 513          0,                     /* this one is variable size */
 514          0,                     /* bitsize */
 515          FALSE,                 /* pc_relative */
 516          0,                     /* bitpos */
 517          complain_overflow_dont, /* complain_on_overflow */
 518          ppc64_elf_unhandled_reloc, /* special_function */
 519          "R_PPC64_COPY",        /* name */
 520          FALSE,                 /* partial_inplace */
 521          0,                     /* src_mask */
 522          0,                     /* dst_mask */
 523          FALSE),                /* pcrel_offset */
 524
 525   /* Like R_PPC64_ADDR64, but used when setting global offset table
 526      entries.  */
 527   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 528          0,                     /* rightshift */
 529          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 530          64,                    /* bitsize */
 531          FALSE,                 /* pc_relative */
 532          0,                     /* bitpos */
 533          complain_overflow_dont, /* complain_on_overflow */
 534          ppc64_elf_unhandled_reloc,  /* special_function */
 535          "R_PPC64_GLOB_DAT",    /* name */
 536          FALSE,                 /* partial_inplace */
 537          0,                     /* src_mask */
 538          ONES (64),             /* dst_mask */
 539          FALSE),                /* pcrel_offset */
 540
 541   /* Created by the link editor.  Marks a procedure linkage table
 542      entry for a symbol.  */
 543   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 544          0,                     /* rightshift */
 545          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          0,                     /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_dont, /* complain_on_overflow */
 550          ppc64_elf_unhandled_reloc, /* special_function */
 551          "R_PPC64_JMP_SLOT",    /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          0,                     /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* Used only by the dynamic linker.  When the object is run, this
 558      doubleword64 is set to the load address of the object, plus the
 559      addend.  */
 560   HOWTO (R_PPC64_RELATIVE,      /* type */
 561          0,                     /* rightshift */
 562          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 563          64,                    /* bitsize */
 564          FALSE,                 /* pc_relative */
 565          0,                     /* bitpos */
 566          complain_overflow_dont, /* complain_on_overflow */
 567          bfd_elf_generic_reloc, /* special_function */
 568          "R_PPC64_RELATIVE",    /* name */
 569          FALSE,                 /* partial_inplace */
 570          0,                     /* src_mask */
 571          ONES (64),             /* dst_mask */
 572          FALSE),                /* pcrel_offset */
 573
 574   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 575   HOWTO (R_PPC64_UADDR32,       /* type */
 576          0,                     /* rightshift */
 577          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 578          32,                    /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          0,                     /* bitpos */
 581          complain_overflow_bitfield, /* complain_on_overflow */
 582          bfd_elf_generic_reloc, /* special_function */
 583          "R_PPC64_UADDR32",     /* name */
 584          FALSE,                 /* partial_inplace */
 585          0,                     /* src_mask */
 586          0xffffffff,            /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 590   HOWTO (R_PPC64_UADDR16,       /* type */
 591          0,                     /* rightshift */
 592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          16,                    /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_bitfield, /* complain_on_overflow */
 597          bfd_elf_generic_reloc, /* special_function */
 598          "R_PPC64_UADDR16",     /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0xffff,                /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* 32-bit PC relative.  */
 605   HOWTO (R_PPC64_REL32,         /* type */
 606          0,                     /* rightshift */
 607          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 608          32,                    /* bitsize */
 609          TRUE,                  /* pc_relative */
 610          0,                     /* bitpos */
 611          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 612          complain_overflow_signed, /* complain_on_overflow */
 613          bfd_elf_generic_reloc, /* special_function */
 614          "R_PPC64_REL32",       /* name */
 615          FALSE,                 /* partial_inplace */
 616          0,                     /* src_mask */
 617          0xffffffff,            /* dst_mask */
 618          TRUE),                 /* pcrel_offset */
 619
 620   /* 32-bit relocation to the symbol's procedure linkage table.  */
 621   HOWTO (R_PPC64_PLT32,         /* type */
 622          0,                     /* rightshift */
 623          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 624          32,                    /* bitsize */
 625          FALSE,                 /* pc_relative */
 626          0,                     /* bitpos */
 627          complain_overflow_bitfield, /* complain_on_overflow */
 628          ppc64_elf_unhandled_reloc, /* special_function */
 629          "R_PPC64_PLT32",       /* name */
 630          FALSE,                 /* partial_inplace */
 631          0,                     /* src_mask */
 632          0xffffffff,            /* dst_mask */
 633          FALSE),                /* pcrel_offset */
 634
 635   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 636      FIXME: R_PPC64_PLTREL32 not supported.  */
 637   HOWTO (R_PPC64_PLTREL32,      /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          32,                    /* bitsize */
 641          TRUE,                  /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_signed, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_PLTREL32",    /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffffffff,            /* dst_mask */
 649          TRUE),                 /* pcrel_offset */
 650
 651   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 652      the symbol.  */
 653   HOWTO (R_PPC64_PLT16_LO,      /* type */
 654          0,                     /* rightshift */
 655          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          16,                    /* bitsize */
 657          FALSE,                 /* pc_relative */
 658          0,                     /* bitpos */
 659          complain_overflow_dont, /* complain_on_overflow */
 660          ppc64_elf_unhandled_reloc, /* special_function */
 661          "R_PPC64_PLT16_LO",    /* name */
 662          FALSE,                 /* partial_inplace */
 663          0,                     /* src_mask */
 664          0xffff,                /* dst_mask */
 665          FALSE),                /* pcrel_offset */
 666
 667   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 668      the symbol.  */
 669   HOWTO (R_PPC64_PLT16_HI,      /* type */
 670          16,                    /* rightshift */
 671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 672          16,                    /* bitsize */
 673          FALSE,                 /* pc_relative */
 674          0,                     /* bitpos */
 675          complain_overflow_dont, /* complain_on_overflow */
 676          ppc64_elf_unhandled_reloc, /* special_function */
 677          "R_PPC64_PLT16_HI",    /* name */
 678          FALSE,                 /* partial_inplace */
 679          0,                     /* src_mask */
 680          0xffff,                /* dst_mask */
 681          FALSE),                /* pcrel_offset */
 682
 683   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 684      the symbol.  */
 685   HOWTO (R_PPC64_PLT16_HA,      /* type */
 686          16,                    /* rightshift */
 687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 688          16,                    /* bitsize */
 689          FALSE,                 /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_dont, /* complain_on_overflow */
 692          ppc64_elf_unhandled_reloc, /* special_function */
 693          "R_PPC64_PLT16_HA",    /* name */
 694          FALSE,                 /* partial_inplace */
 695          0,                     /* src_mask */
 696          0xffff,                /* dst_mask */
 697          FALSE),                /* pcrel_offset */
 698
 699   /* 16-bit section relative relocation.  */
 700   HOWTO (R_PPC64_SECTOFF,       /* type */
 701          0,                     /* rightshift */
 702          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          16,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_bitfield, /* complain_on_overflow */
 707          ppc64_elf_sectoff_reloc, /* special_function */
 708          "R_PPC64_SECTOFF",     /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffff,                /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 715   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 716          0,                     /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_dont, /* complain_on_overflow */
 722          ppc64_elf_sectoff_reloc, /* special_function */
 723          "R_PPC64_SECTOFF_LO",  /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* 16-bit upper half section relative relocation.  */
 730   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 731          16,                    /* rightshift */
 732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 733          16,                    /* bitsize */
 734          FALSE,                 /* pc_relative */
 735          0,                     /* bitpos */
 736          complain_overflow_dont, /* complain_on_overflow */
 737          ppc64_elf_sectoff_reloc, /* special_function */
 738          "R_PPC64_SECTOFF_HI",  /* name */
 739          FALSE,                 /* partial_inplace */
 740          0,                     /* src_mask */
 741          0xffff,                /* dst_mask */
 742          FALSE),                /* pcrel_offset */
 743
 744   /* 16-bit upper half adjusted section relative relocation.  */
 745   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 746          16,                    /* rightshift */
 747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          16,                    /* bitsize */
 749          FALSE,                 /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_dont, /* complain_on_overflow */
 752          ppc64_elf_sectoff_ha_reloc, /* special_function */
 753          "R_PPC64_SECTOFF_HA",  /* name */
 754          FALSE,                 /* partial_inplace */
 755          0,                     /* src_mask */
 756          0xffff,                /* dst_mask */
 757          FALSE),                /* pcrel_offset */
 758
 759   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 760   HOWTO (R_PPC64_REL30,         /* type */
 761          2,                     /* rightshift */
 762          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          30,                    /* bitsize */
 764          TRUE,                  /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_dont, /* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_PPC64_REL30",       /* name */
 769          FALSE,                 /* partial_inplace */
 770          0,                     /* src_mask */
 771          0xfffffffc,            /* dst_mask */
 772          TRUE),                 /* pcrel_offset */
 773
 774   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 775
 776   /* A standard 64-bit relocation.  */
 777   HOWTO (R_PPC64_ADDR64,        /* type */
 778          0,                     /* rightshift */
 779          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 780          64,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_dont, /* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_PPC64_ADDR64",      /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          ONES (64),             /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   /* The bits 32-47 of an address.  */
 792   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 793          32,                    /* rightshift */
 794          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          FALSE,                 /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_dont, /* complain_on_overflow */
 799          bfd_elf_generic_reloc, /* special_function */
 800          "R_PPC64_ADDR16_HIGHER", /* name */
 801          FALSE,                 /* partial_inplace */
 802          0,                     /* src_mask */
 803          0xffff,                /* dst_mask */
 804          FALSE),                /* pcrel_offset */
 805
 806   /* The bits 32-47 of an address, plus 1 if the contents of the low
 807      16 bits, treated as a signed number, is negative.  */
 808   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 809          32,                    /* rightshift */
 810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 811          16,                    /* bitsize */
 812          FALSE,                 /* pc_relative */
 813          0,                     /* bitpos */
 814          complain_overflow_dont, /* complain_on_overflow */
 815          ppc64_elf_ha_reloc,    /* special_function */
 816          "R_PPC64_ADDR16_HIGHERA", /* name */
 817          FALSE,                 /* partial_inplace */
 818          0,                     /* src_mask */
 819          0xffff,                /* dst_mask */
 820          FALSE),                /* pcrel_offset */
 821
 822   /* The bits 48-63 of an address.  */
 823   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 824          48,                    /* rightshift */
 825          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 826          16,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR16_HIGHEST", /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          0xffff,                /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 48-63 of an address, plus 1 if the contents of the low
 838      16 bits, treated as a signed number, is negative.  */
 839   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 840          48,                    /* rightshift */
 841          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 842          16,                    /* bitsize */
 843          FALSE,                 /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          ppc64_elf_ha_reloc,    /* special_function */
 847          "R_PPC64_ADDR16_HIGHESTA", /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          0xffff,                /* dst_mask */
 851          FALSE),                /* pcrel_offset */
 852
 853   /* Like ADDR64, but may be unaligned.  */
 854   HOWTO (R_PPC64_UADDR64,       /* type */
 855          0,                     /* rightshift */
 856          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 857          64,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          bfd_elf_generic_reloc, /* special_function */
 862          "R_PPC64_UADDR64",     /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          ONES (64),             /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* 64-bit relative relocation.  */
 869   HOWTO (R_PPC64_REL64,         /* type */
 870          0,                     /* rightshift */
 871          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 872          64,                    /* bitsize */
 873          TRUE,                  /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_REL64",       /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          ONES (64),             /* dst_mask */
 881          TRUE),                 /* pcrel_offset */
 882
 883   /* 64-bit relocation to the symbol's procedure linkage table.  */
 884   HOWTO (R_PPC64_PLT64,         /* type */
 885          0,                     /* rightshift */
 886          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 887          64,                    /* bitsize */
 888          FALSE,                 /* pc_relative */
 889          0,                     /* bitpos */
 890          complain_overflow_dont, /* complain_on_overflow */
 891          ppc64_elf_unhandled_reloc, /* special_function */
 892          "R_PPC64_PLT64",       /* name */
 893          FALSE,                 /* partial_inplace */
 894          0,                     /* src_mask */
 895          ONES (64),             /* dst_mask */
 896          FALSE),                /* pcrel_offset */
 897
 898   /* 64-bit PC relative relocation to the symbol's procedure linkage
 899      table.  */
 900   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 901   HOWTO (R_PPC64_PLTREL64,      /* type */
 902          0,                     /* rightshift */
 903          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 904          64,                    /* bitsize */
 905          TRUE,                  /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_dont, /* complain_on_overflow */
 908          ppc64_elf_unhandled_reloc, /* special_function */
 909          "R_PPC64_PLTREL64",    /* name */
 910          FALSE,                 /* partial_inplace */
 911          0,                     /* src_mask */
 912          ONES (64),             /* dst_mask */
 913          TRUE),                 /* pcrel_offset */
 914
 915   /* 16 bit TOC-relative relocation.  */
 916
 917   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 918   HOWTO (R_PPC64_TOC16,         /* type */
 919          0,                     /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          FALSE,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_signed, /* complain_on_overflow */
 925          ppc64_elf_toc_reloc,   /* special_function */
 926          "R_PPC64_TOC16",       /* name */
 927          FALSE,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          FALSE),                /* pcrel_offset */
 931
 932   /* 16 bit TOC-relative relocation without overflow.  */
 933
 934   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 935   HOWTO (R_PPC64_TOC16_LO,      /* type */
 936          0,                     /* rightshift */
 937          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 938          16,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_toc_reloc,   /* special_function */
 943          "R_PPC64_TOC16_LO",    /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          0xffff,                /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 16 bit TOC-relative relocation, high 16 bits.  */
 950
 951   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 952   HOWTO (R_PPC64_TOC16_HI,      /* type */
 953          16,                    /* rightshift */
 954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 955          16,                    /* bitsize */
 956          FALSE,                 /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_toc_reloc,   /* special_function */
 960          "R_PPC64_TOC16_HI",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          0xffff,                /* dst_mask */
 964          FALSE),                /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 967      contents of the low 16 bits, treated as a signed number, is
 968      negative.  */
 969
 970   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_HA,      /* type */
 972          16,                    /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_ha_reloc, /* special_function */
 979          "R_PPC64_TOC16_HA",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 986
 987   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 988   HOWTO (R_PPC64_TOC,           /* type */
 989          0,                     /* rightshift */
 990          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 991          64,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_bitfield, /* complain_on_overflow */
 995          ppc64_elf_toc64_reloc, /* special_function */
 996          "R_PPC64_TOC",         /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          ONES (64),             /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* Like R_PPC64_GOT16, but also informs the link editor that the
1003      value to relocate may (!) refer to a PLT entry which the link
1004      editor (a) may replace with the symbol value.  If the link editor
1005      is unable to fully resolve the symbol, it may (b) create a PLT
1006      entry and store the address to the new PLT entry in the GOT.
1007      This permits lazy resolution of function symbols at run time.
1008      The link editor may also skip all of this and just (c) emit a
1009      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1010   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1011     HOWTO (R_PPC64_PLTGOT16,    /* type */
1012          0,                     /* rightshift */
1013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1014          16,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_signed, /* complain_on_overflow */
1018          ppc64_elf_unhandled_reloc, /* special_function */
1019          "R_PPC64_PLTGOT16",    /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          0xffff,                /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1026   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1027   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1028          0,                     /* rightshift */
1029          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1030          16,                    /* bitsize */
1031          FALSE,                 /* pc_relative */
1032          0,                     /* bitpos */
1033          complain_overflow_dont, /* complain_on_overflow */
1034          ppc64_elf_unhandled_reloc, /* special_function */
1035          "R_PPC64_PLTGOT16_LO", /* name */
1036          FALSE,                 /* partial_inplace */
1037          0,                     /* src_mask */
1038          0xffff,                /* dst_mask */
1039          FALSE),                /* pcrel_offset */
1040
1041   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1042   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1043   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1044          16,                    /* rightshift */
1045          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1046          16,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_unhandled_reloc, /* special_function */
1051          "R_PPC64_PLTGOT16_HI", /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          0xffff,                /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1058      1 if the contents of the low 16 bits, treated as a signed number,
1059      is negative.  */
1060   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1061   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1062          16,                    /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_dont,/* complain_on_overflow */
1068          ppc64_elf_unhandled_reloc, /* special_function */
1069          "R_PPC64_PLTGOT16_HA", /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xffff,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1076   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1077          0,                     /* rightshift */
1078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          16,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          0,                     /* bitpos */
1082          complain_overflow_bitfield, /* complain_on_overflow */
1083          bfd_elf_generic_reloc, /* special_function */
1084          "R_PPC64_ADDR16_DS",   /* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0xfffc,                /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1091   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1092          0,                     /* rightshift */
1093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          16,                    /* bitsize */
1095          FALSE,                 /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_dont,/* complain_on_overflow */
1098          bfd_elf_generic_reloc, /* special_function */
1099          "R_PPC64_ADDR16_LO_DS",/* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0xfffc,                /* dst_mask */
1103          FALSE),                /* pcrel_offset */
1104
1105   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1106   HOWTO (R_PPC64_GOT16_DS,      /* type */
1107          0,                     /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_signed, /* complain_on_overflow */
1113          ppc64_elf_unhandled_reloc, /* special_function */
1114          "R_PPC64_GOT16_DS",    /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xfffc,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1121   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1122          0,                     /* rightshift */
1123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1124          16,                    /* bitsize */
1125          FALSE,                 /* pc_relative */
1126          0,                     /* bitpos */
1127          complain_overflow_dont, /* complain_on_overflow */
1128          ppc64_elf_unhandled_reloc, /* special_function */
1129          "R_PPC64_GOT16_LO_DS", /* name */
1130          FALSE,                 /* partial_inplace */
1131          0,                     /* src_mask */
1132          0xfffc,                /* dst_mask */
1133          FALSE),                /* pcrel_offset */
1134
1135   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1136   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1137          0,                     /* rightshift */
1138          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1139          16,                    /* bitsize */
1140          FALSE,                 /* pc_relative */
1141          0,                     /* bitpos */
1142          complain_overflow_dont, /* complain_on_overflow */
1143          ppc64_elf_unhandled_reloc, /* special_function */
1144          "R_PPC64_PLT16_LO_DS", /* name */
1145          FALSE,                 /* partial_inplace */
1146          0,                     /* src_mask */
1147          0xfffc,                /* dst_mask */
1148          FALSE),                /* pcrel_offset */
1149
1150   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1151   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1152          0,                     /* rightshift */
1153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1154          16,                    /* bitsize */
1155          FALSE,                 /* pc_relative */
1156          0,                     /* bitpos */
1157          complain_overflow_bitfield, /* complain_on_overflow */
1158          ppc64_elf_sectoff_reloc, /* special_function */
1159          "R_PPC64_SECTOFF_DS",  /* name */
1160          FALSE,                 /* partial_inplace */
1161          0,                     /* src_mask */
1162          0xfffc,                /* dst_mask */
1163          FALSE),                /* pcrel_offset */
1164
1165   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1166   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1167          0,                     /* rightshift */
1168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1169          16,                    /* bitsize */
1170          FALSE,                 /* pc_relative */
1171          0,                     /* bitpos */
1172          complain_overflow_dont, /* complain_on_overflow */
1173          ppc64_elf_sectoff_reloc, /* special_function */
1174          "R_PPC64_SECTOFF_LO_DS",/* name */
1175          FALSE,                 /* partial_inplace */
1176          0,                     /* src_mask */
1177          0xfffc,                /* dst_mask */
1178          FALSE),                /* pcrel_offset */
1179
1180   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1181   HOWTO (R_PPC64_TOC16_DS,      /* type */
1182          0,                     /* rightshift */
1183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1184          16,                    /* bitsize */
1185          FALSE,                 /* pc_relative */
1186          0,                     /* bitpos */
1187          complain_overflow_signed, /* complain_on_overflow */
1188          ppc64_elf_toc_reloc,   /* special_function */
1189          "R_PPC64_TOC16_DS",    /* name */
1190          FALSE,                 /* partial_inplace */
1191          0,                     /* src_mask */
1192          0xfffc,                /* dst_mask */
1193          FALSE),                /* pcrel_offset */
1194
1195   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1196   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1197          0,                     /* rightshift */
1198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1199          16,                    /* bitsize */
1200          FALSE,                 /* pc_relative */
1201          0,                     /* bitpos */
1202          complain_overflow_dont, /* complain_on_overflow */
1203          ppc64_elf_toc_reloc,   /* special_function */
1204          "R_PPC64_TOC16_LO_DS", /* name */
1205          FALSE,                 /* partial_inplace */
1206          0,                     /* src_mask */
1207          0xfffc,                /* dst_mask */
1208          FALSE),                /* pcrel_offset */
1209
1210   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1211   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1212   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_signed, /* complain_on_overflow */
1219          ppc64_elf_unhandled_reloc, /* special_function */
1220          "R_PPC64_PLTGOT16_DS", /* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1227   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1228   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1229          0,                     /* rightshift */
1230          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1231          16,                    /* bitsize */
1232          FALSE,                 /* pc_relative */
1233          0,                     /* bitpos */
1234          complain_overflow_dont, /* complain_on_overflow */
1235          ppc64_elf_unhandled_reloc, /* special_function */
1236          "R_PPC64_PLTGOT16_LO_DS",/* name */
1237          FALSE,                 /* partial_inplace */
1238          0,                     /* src_mask */
1239          0xfffc,                /* dst_mask */
1240          FALSE),                /* pcrel_offset */
1241
1242   /* Marker relocs for TLS.  */
1243   HOWTO (R_PPC64_TLS,
1244          0,                     /* rightshift */
1245          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1246          32,                    /* bitsize */
1247          FALSE,                 /* pc_relative */
1248          0,                     /* bitpos */
1249          complain_overflow_dont, /* complain_on_overflow */
1250          bfd_elf_generic_reloc, /* special_function */
1251          "R_PPC64_TLS",         /* name */
1252          FALSE,                 /* partial_inplace */
1253          0,                     /* src_mask */
1254          0,                     /* dst_mask */
1255          FALSE),                /* pcrel_offset */
1256
1257   HOWTO (R_PPC64_TLSGD,
1258          0,                     /* rightshift */
1259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1260          32,                    /* bitsize */
1261          FALSE,                 /* pc_relative */
1262          0,                     /* bitpos */
1263          complain_overflow_dont, /* complain_on_overflow */
1264          bfd_elf_generic_reloc, /* special_function */
1265          "R_PPC64_TLSGD",       /* name */
1266          FALSE,                 /* partial_inplace */
1267          0,                     /* src_mask */
1268          0,                     /* dst_mask */
1269          FALSE),                /* pcrel_offset */
1270
1271   HOWTO (R_PPC64_TLSLD,
1272          0,                     /* rightshift */
1273          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1274          32,                    /* bitsize */
1275          FALSE,                 /* pc_relative */
1276          0,                     /* bitpos */
1277          complain_overflow_dont, /* complain_on_overflow */
1278          bfd_elf_generic_reloc, /* special_function */
1279          "R_PPC64_TLSLD",       /* name */
1280          FALSE,                 /* partial_inplace */
1281          0,                     /* src_mask */
1282          0,                     /* dst_mask */
1283          FALSE),                /* pcrel_offset */
1284
1285   /* Computes the load module index of the load module that contains the
1286      definition of its TLS sym.  */
1287   HOWTO (R_PPC64_DTPMOD64,
1288          0,                     /* rightshift */
1289          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1290          64,                    /* bitsize */
1291          FALSE,                 /* pc_relative */
1292          0,                     /* bitpos */
1293          complain_overflow_dont, /* complain_on_overflow */
1294          ppc64_elf_unhandled_reloc, /* special_function */
1295          "R_PPC64_DTPMOD64",    /* name */
1296          FALSE,                 /* partial_inplace */
1297          0,                     /* src_mask */
1298          ONES (64),             /* dst_mask */
1299          FALSE),                /* pcrel_offset */
1300
1301   /* Computes a dtv-relative displacement, the difference between the value
1302      of sym+add and the base address of the thread-local storage block that
1303      contains the definition of sym, minus 0x8000.  */
1304   HOWTO (R_PPC64_DTPREL64,
1305          0,                     /* rightshift */
1306          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1307          64,                    /* bitsize */
1308          FALSE,                 /* pc_relative */
1309          0,                     /* bitpos */
1310          complain_overflow_dont, /* complain_on_overflow */
1311          ppc64_elf_unhandled_reloc, /* special_function */
1312          "R_PPC64_DTPREL64",    /* name */
1313          FALSE,                 /* partial_inplace */
1314          0,                     /* src_mask */
1315          ONES (64),             /* dst_mask */
1316          FALSE),                /* pcrel_offset */
1317
1318   /* A 16 bit dtprel reloc.  */
1319   HOWTO (R_PPC64_DTPREL16,
1320          0,                     /* rightshift */
1321          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1322          16,                    /* bitsize */
1323          FALSE,                 /* pc_relative */
1324          0,                     /* bitpos */
1325          complain_overflow_signed, /* complain_on_overflow */
1326          ppc64_elf_unhandled_reloc, /* special_function */
1327          "R_PPC64_DTPREL16",    /* name */
1328          FALSE,                 /* partial_inplace */
1329          0,                     /* src_mask */
1330          0xffff,                /* dst_mask */
1331          FALSE),                /* pcrel_offset */
1332
1333   /* Like DTPREL16, but no overflow.  */
1334   HOWTO (R_PPC64_DTPREL16_LO,
1335          0,                     /* rightshift */
1336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1337          16,                    /* bitsize */
1338          FALSE,                 /* pc_relative */
1339          0,                     /* bitpos */
1340          complain_overflow_dont, /* complain_on_overflow */
1341          ppc64_elf_unhandled_reloc, /* special_function */
1342          "R_PPC64_DTPREL16_LO", /* name */
1343          FALSE,                 /* partial_inplace */
1344          0,                     /* src_mask */
1345          0xffff,                /* dst_mask */
1346          FALSE),                /* pcrel_offset */
1347
1348   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1349   HOWTO (R_PPC64_DTPREL16_HI,
1350          16,                    /* rightshift */
1351          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1352          16,                    /* bitsize */
1353          FALSE,                 /* pc_relative */
1354          0,                     /* bitpos */
1355          complain_overflow_dont, /* complain_on_overflow */
1356          ppc64_elf_unhandled_reloc, /* special_function */
1357          "R_PPC64_DTPREL16_HI", /* name */
1358          FALSE,                 /* partial_inplace */
1359          0,                     /* src_mask */
1360          0xffff,                /* dst_mask */
1361          FALSE),                /* pcrel_offset */
1362
1363   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1364   HOWTO (R_PPC64_DTPREL16_HA,
1365          16,                    /* rightshift */
1366          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          16,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL16_HA", /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          0xffff,                /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1379   HOWTO (R_PPC64_DTPREL16_HIGHER,
1380          32,                    /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_dont, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16_HIGHER", /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1394   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1395          32,                    /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_HIGHERA", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1410          48,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_dont, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HIGHEST", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1425          48,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_dont, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16, but for insns with a DS field.  */
1439   HOWTO (R_PPC64_DTPREL16_DS,
1440          0,                     /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_signed, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_DS", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xfffc,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_DS, but no overflow.  */
1454   HOWTO (R_PPC64_DTPREL16_LO_DS,
1455          0,                     /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_LO_DS", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xfffc,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Computes a tp-relative displacement, the difference between the value of
1469      sym+add and the value of the thread pointer (r13).  */
1470   HOWTO (R_PPC64_TPREL64,
1471          0,                     /* rightshift */
1472          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1473          64,                    /* bitsize */
1474          FALSE,                 /* pc_relative */
1475          0,                     /* bitpos */
1476          complain_overflow_dont, /* complain_on_overflow */
1477          ppc64_elf_unhandled_reloc, /* special_function */
1478          "R_PPC64_TPREL64",     /* name */
1479          FALSE,                 /* partial_inplace */
1480          0,                     /* src_mask */
1481          ONES (64),             /* dst_mask */
1482          FALSE),                /* pcrel_offset */
1483
1484   /* A 16 bit tprel reloc.  */
1485   HOWTO (R_PPC64_TPREL16,
1486          0,                     /* rightshift */
1487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1488          16,                    /* bitsize */
1489          FALSE,                 /* pc_relative */
1490          0,                     /* bitpos */
1491          complain_overflow_signed, /* complain_on_overflow */
1492          ppc64_elf_unhandled_reloc, /* special_function */
1493          "R_PPC64_TPREL16",     /* name */
1494          FALSE,                 /* partial_inplace */
1495          0,                     /* src_mask */
1496          0xffff,                /* dst_mask */
1497          FALSE),                /* pcrel_offset */
1498
1499   /* Like TPREL16, but no overflow.  */
1500   HOWTO (R_PPC64_TPREL16_LO,
1501          0,                     /* rightshift */
1502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1503          16,                    /* bitsize */
1504          FALSE,                 /* pc_relative */
1505          0,                     /* bitpos */
1506          complain_overflow_dont, /* complain_on_overflow */
1507          ppc64_elf_unhandled_reloc, /* special_function */
1508          "R_PPC64_TPREL16_LO",  /* name */
1509          FALSE,                 /* partial_inplace */
1510          0,                     /* src_mask */
1511          0xffff,                /* dst_mask */
1512          FALSE),                /* pcrel_offset */
1513
1514   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1515   HOWTO (R_PPC64_TPREL16_HI,
1516          16,                    /* rightshift */
1517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1518          16,                    /* bitsize */
1519          FALSE,                 /* pc_relative */
1520          0,                     /* bitpos */
1521          complain_overflow_dont, /* complain_on_overflow */
1522          ppc64_elf_unhandled_reloc, /* special_function */
1523          "R_PPC64_TPREL16_HI",  /* name */
1524          FALSE,                 /* partial_inplace */
1525          0,                     /* src_mask */
1526          0xffff,                /* dst_mask */
1527          FALSE),                /* pcrel_offset */
1528
1529   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1530   HOWTO (R_PPC64_TPREL16_HA,
1531          16,                    /* rightshift */
1532          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          16,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL16_HA",  /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          0xffff,                /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1545   HOWTO (R_PPC64_TPREL16_HIGHER,
1546          32,                    /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_dont, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16_HIGHER",      /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1560   HOWTO (R_PPC64_TPREL16_HIGHERA,
1561          32,                    /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_HIGHERA", /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HIGHEST,
1576          48,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_dont, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HIGHEST", /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1591          48,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_dont, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HIGHESTA", /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16, but for insns with a DS field.  */
1605   HOWTO (R_PPC64_TPREL16_DS,
1606          0,                     /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_signed, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_DS",  /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xfffc,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_DS, but no overflow.  */
1620   HOWTO (R_PPC64_TPREL16_LO_DS,
1621          0,                     /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_LO_DS", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xfffc,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1635      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1636      to the first entry relative to the TOC base (r2).  */
1637   HOWTO (R_PPC64_GOT_TLSGD16,
1638          0,                     /* rightshift */
1639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1640          16,                    /* bitsize */
1641          FALSE,                 /* pc_relative */
1642          0,                     /* bitpos */
1643          complain_overflow_signed, /* complain_on_overflow */
1644          ppc64_elf_unhandled_reloc, /* special_function */
1645          "R_PPC64_GOT_TLSGD16", /* name */
1646          FALSE,                 /* partial_inplace */
1647          0,                     /* src_mask */
1648          0xffff,                /* dst_mask */
1649          FALSE),                /* pcrel_offset */
1650
1651   /* Like GOT_TLSGD16, but no overflow.  */
1652   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1653          0,                     /* rightshift */
1654          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1655          16,                    /* bitsize */
1656          FALSE,                 /* pc_relative */
1657          0,                     /* bitpos */
1658          complain_overflow_dont, /* complain_on_overflow */
1659          ppc64_elf_unhandled_reloc, /* special_function */
1660          "R_PPC64_GOT_TLSGD16_LO", /* name */
1661          FALSE,                 /* partial_inplace */
1662          0,                     /* src_mask */
1663          0xffff,                /* dst_mask */
1664          FALSE),                /* pcrel_offset */
1665
1666   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1667   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1668          16,                    /* rightshift */
1669          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1670          16,                    /* bitsize */
1671          FALSE,                 /* pc_relative */
1672          0,                     /* bitpos */
1673          complain_overflow_dont, /* complain_on_overflow */
1674          ppc64_elf_unhandled_reloc, /* special_function */
1675          "R_PPC64_GOT_TLSGD16_HI", /* name */
1676          FALSE,                 /* partial_inplace */
1677          0,                     /* src_mask */
1678          0xffff,                /* dst_mask */
1679          FALSE),                /* pcrel_offset */
1680
1681   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1682   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1683          16,                    /* rightshift */
1684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1685          16,                    /* bitsize */
1686          FALSE,                 /* pc_relative */
1687          0,                     /* bitpos */
1688          complain_overflow_dont, /* complain_on_overflow */
1689          ppc64_elf_unhandled_reloc, /* special_function */
1690          "R_PPC64_GOT_TLSGD16_HA", /* name */
1691          FALSE,                 /* partial_inplace */
1692          0,                     /* src_mask */
1693          0xffff,                /* dst_mask */
1694          FALSE),                /* pcrel_offset */
1695
1696   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1697      with values (sym+add)@dtpmod and zero, and computes the offset to the
1698      first entry relative to the TOC base (r2).  */
1699   HOWTO (R_PPC64_GOT_TLSLD16,
1700          0,                     /* rightshift */
1701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1702          16,                    /* bitsize */
1703          FALSE,                 /* pc_relative */
1704          0,                     /* bitpos */
1705          complain_overflow_signed, /* complain_on_overflow */
1706          ppc64_elf_unhandled_reloc, /* special_function */
1707          "R_PPC64_GOT_TLSLD16", /* name */
1708          FALSE,                 /* partial_inplace */
1709          0,                     /* src_mask */
1710          0xffff,                /* dst_mask */
1711          FALSE),                /* pcrel_offset */
1712
1713   /* Like GOT_TLSLD16, but no overflow.  */
1714   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1715          0,                     /* rightshift */
1716          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1717          16,                    /* bitsize */
1718          FALSE,                 /* pc_relative */
1719          0,                     /* bitpos */
1720          complain_overflow_dont, /* complain_on_overflow */
1721          ppc64_elf_unhandled_reloc, /* special_function */
1722          "R_PPC64_GOT_TLSLD16_LO", /* name */
1723          FALSE,                 /* partial_inplace */
1724          0,                     /* src_mask */
1725          0xffff,                /* dst_mask */
1726          FALSE),                /* pcrel_offset */
1727
1728   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1729   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1730          16,                    /* rightshift */
1731          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1732          16,                    /* bitsize */
1733          FALSE,                 /* pc_relative */
1734          0,                     /* bitpos */
1735          complain_overflow_dont, /* complain_on_overflow */
1736          ppc64_elf_unhandled_reloc, /* special_function */
1737          "R_PPC64_GOT_TLSLD16_HI", /* name */
1738          FALSE,                 /* partial_inplace */
1739          0,                     /* src_mask */
1740          0xffff,                /* dst_mask */
1741          FALSE),                /* pcrel_offset */
1742
1743   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1744   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1745          16,                    /* rightshift */
1746          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1747          16,                    /* bitsize */
1748          FALSE,                 /* pc_relative */
1749          0,                     /* bitpos */
1750          complain_overflow_dont, /* complain_on_overflow */
1751          ppc64_elf_unhandled_reloc, /* special_function */
1752          "R_PPC64_GOT_TLSLD16_HA", /* name */
1753          FALSE,                 /* partial_inplace */
1754          0,                     /* src_mask */
1755          0xffff,                /* dst_mask */
1756          FALSE),                /* pcrel_offset */
1757
1758   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1759      the offset to the entry relative to the TOC base (r2).  */
1760   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1761          0,                     /* rightshift */
1762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1763          16,                    /* bitsize */
1764          FALSE,                 /* pc_relative */
1765          0,                     /* bitpos */
1766          complain_overflow_signed, /* complain_on_overflow */
1767          ppc64_elf_unhandled_reloc, /* special_function */
1768          "R_PPC64_GOT_DTPREL16_DS", /* name */
1769          FALSE,                 /* partial_inplace */
1770          0,                     /* src_mask */
1771          0xfffc,                /* dst_mask */
1772          FALSE),                /* pcrel_offset */
1773
1774   /* Like GOT_DTPREL16_DS, but no overflow.  */
1775   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1776          0,                     /* rightshift */
1777          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1778          16,                    /* bitsize */
1779          FALSE,                 /* pc_relative */
1780          0,                     /* bitpos */
1781          complain_overflow_dont, /* complain_on_overflow */
1782          ppc64_elf_unhandled_reloc, /* special_function */
1783          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1784          FALSE,                 /* partial_inplace */
1785          0,                     /* src_mask */
1786          0xfffc,                /* dst_mask */
1787          FALSE),                /* pcrel_offset */
1788
1789   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1790   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1791          16,                    /* rightshift */
1792          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1793          16,                    /* bitsize */
1794          FALSE,                 /* pc_relative */
1795          0,                     /* bitpos */
1796          complain_overflow_dont, /* complain_on_overflow */
1797          ppc64_elf_unhandled_reloc, /* special_function */
1798          "R_PPC64_GOT_DTPREL16_HI", /* name */
1799          FALSE,                 /* partial_inplace */
1800          0,                     /* src_mask */
1801          0xffff,                /* dst_mask */
1802          FALSE),                /* pcrel_offset */
1803
1804   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1805   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1806          16,                    /* rightshift */
1807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1808          16,                    /* bitsize */
1809          FALSE,                 /* pc_relative */
1810          0,                     /* bitpos */
1811          complain_overflow_dont, /* complain_on_overflow */
1812          ppc64_elf_unhandled_reloc, /* special_function */
1813          "R_PPC64_GOT_DTPREL16_HA", /* name */
1814          FALSE,                 /* partial_inplace */
1815          0,                     /* src_mask */
1816          0xffff,                /* dst_mask */
1817          FALSE),                /* pcrel_offset */
1818
1819   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1820      offset to the entry relative to the TOC base (r2).  */
1821   HOWTO (R_PPC64_GOT_TPREL16_DS,
1822          0,                     /* rightshift */
1823          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1824          16,                    /* bitsize */
1825          FALSE,                 /* pc_relative */
1826          0,                     /* bitpos */
1827          complain_overflow_signed, /* complain_on_overflow */
1828          ppc64_elf_unhandled_reloc, /* special_function */
1829          "R_PPC64_GOT_TPREL16_DS", /* name */
1830          FALSE,                 /* partial_inplace */
1831          0,                     /* src_mask */
1832          0xfffc,                /* dst_mask */
1833          FALSE),                /* pcrel_offset */
1834
1835   /* Like GOT_TPREL16_DS, but no overflow.  */
1836   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1837          0,                     /* rightshift */
1838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1839          16,                    /* bitsize */
1840          FALSE,                 /* pc_relative */
1841          0,                     /* bitpos */
1842          complain_overflow_dont, /* complain_on_overflow */
1843          ppc64_elf_unhandled_reloc, /* special_function */
1844          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1845          FALSE,                 /* partial_inplace */
1846          0,                     /* src_mask */
1847          0xfffc,                /* dst_mask */
1848          FALSE),                /* pcrel_offset */
1849
1850   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1851   HOWTO (R_PPC64_GOT_TPREL16_HI,
1852          16,                    /* rightshift */
1853          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1854          16,                    /* bitsize */
1855          FALSE,                 /* pc_relative */
1856          0,                     /* bitpos */
1857          complain_overflow_dont, /* complain_on_overflow */
1858          ppc64_elf_unhandled_reloc, /* special_function */
1859          "R_PPC64_GOT_TPREL16_HI", /* name */
1860          FALSE,                 /* partial_inplace */
1861          0,                     /* src_mask */
1862          0xffff,                /* dst_mask */
1863          FALSE),                /* pcrel_offset */
1864
1865   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1866   HOWTO (R_PPC64_GOT_TPREL16_HA,
1867          16,                    /* rightshift */
1868          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1869          16,                    /* bitsize */
1870          FALSE,                 /* pc_relative */
1871          0,                     /* bitpos */
1872          complain_overflow_dont, /* complain_on_overflow */
1873          ppc64_elf_unhandled_reloc, /* special_function */
1874          "R_PPC64_GOT_TPREL16_HA", /* name */
1875          FALSE,                 /* partial_inplace */
1876          0,                     /* src_mask */
1877          0xffff,                /* dst_mask */
1878          FALSE),                /* pcrel_offset */
1879
1880   HOWTO (R_PPC64_JMP_IREL,      /* type */
1881          0,                     /* rightshift */
1882          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1883          0,                     /* bitsize */
1884          FALSE,                 /* pc_relative */
1885          0,                     /* bitpos */
1886          complain_overflow_dont, /* complain_on_overflow */
1887          ppc64_elf_unhandled_reloc, /* special_function */
1888          "R_PPC64_JMP_IREL",    /* name */
1889          FALSE,                 /* partial_inplace */
1890          0,                     /* src_mask */
1891          0,                     /* dst_mask */
1892          FALSE),                /* pcrel_offset */
1893
1894   HOWTO (R_PPC64_IRELATIVE,     /* type */
1895          0,                     /* rightshift */
1896          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1897          64,                    /* bitsize */
1898          FALSE,                 /* pc_relative */
1899          0,                     /* bitpos */
1900          complain_overflow_dont, /* complain_on_overflow */
1901          bfd_elf_generic_reloc, /* special_function */
1902          "R_PPC64_IRELATIVE",   /* name */
1903          FALSE,                 /* partial_inplace */
1904          0,                     /* src_mask */
1905          ONES (64),             /* dst_mask */
1906          FALSE),                /* pcrel_offset */
1907
1908   /* A 16 bit relative relocation.  */
1909   HOWTO (R_PPC64_REL16,         /* type */
1910          0,                     /* rightshift */
1911          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1912          16,                    /* bitsize */
1913          TRUE,                  /* pc_relative */
1914          0,                     /* bitpos */
1915          complain_overflow_bitfield, /* complain_on_overflow */
1916          bfd_elf_generic_reloc, /* special_function */
1917          "R_PPC64_REL16",       /* name */
1918          FALSE,                 /* partial_inplace */
1919          0,                     /* src_mask */
1920          0xffff,                /* dst_mask */
1921          TRUE),                 /* pcrel_offset */
1922
1923   /* A 16 bit relative relocation without overflow.  */
1924   HOWTO (R_PPC64_REL16_LO,      /* type */
1925          0,                     /* rightshift */
1926          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1927          16,                    /* bitsize */
1928          TRUE,                  /* pc_relative */
1929          0,                     /* bitpos */
1930          complain_overflow_dont,/* complain_on_overflow */
1931          bfd_elf_generic_reloc, /* special_function */
1932          "R_PPC64_REL16_LO",    /* name */
1933          FALSE,                 /* partial_inplace */
1934          0,                     /* src_mask */
1935          0xffff,                /* dst_mask */
1936          TRUE),                 /* pcrel_offset */
1937
1938   /* The high order 16 bits of a relative address.  */
1939   HOWTO (R_PPC64_REL16_HI,      /* type */
1940          16,                    /* rightshift */
1941          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1942          16,                    /* bitsize */
1943          TRUE,                  /* pc_relative */
1944          0,                     /* bitpos */
1945          complain_overflow_dont, /* complain_on_overflow */
1946          bfd_elf_generic_reloc, /* special_function */
1947          "R_PPC64_REL16_HI",    /* name */
1948          FALSE,                 /* partial_inplace */
1949          0,                     /* src_mask */
1950          0xffff,                /* dst_mask */
1951          TRUE),                 /* pcrel_offset */
1952
1953   /* The high order 16 bits of a relative address, plus 1 if the contents of
1954      the low 16 bits, treated as a signed number, is negative.  */
1955   HOWTO (R_PPC64_REL16_HA,      /* type */
1956          16,                    /* rightshift */
1957          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1958          16,                    /* bitsize */
1959          TRUE,                  /* pc_relative */
1960          0,                     /* bitpos */
1961          complain_overflow_dont, /* complain_on_overflow */
1962          ppc64_elf_ha_reloc,    /* special_function */
1963          "R_PPC64_REL16_HA",    /* name */
1964          FALSE,                 /* partial_inplace */
1965          0,                     /* src_mask */
1966          0xffff,                /* dst_mask */
1967          TRUE),                 /* pcrel_offset */
1968
1969   /* GNU extension to record C++ vtable hierarchy.  */
1970   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1971          0,                     /* rightshift */
1972          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1973          0,                     /* bitsize */
1974          FALSE,                 /* pc_relative */
1975          0,                     /* bitpos */
1976          complain_overflow_dont, /* complain_on_overflow */
1977          NULL,                  /* special_function */
1978          "R_PPC64_GNU_VTINHERIT", /* name */
1979          FALSE,                 /* partial_inplace */
1980          0,                     /* src_mask */
1981          0,                     /* dst_mask */
1982          FALSE),                /* pcrel_offset */
1983
1984   /* GNU extension to record C++ vtable member usage.  */
1985   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1986          0,                     /* rightshift */
1987          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1988          0,                     /* bitsize */
1989          FALSE,                 /* pc_relative */
1990          0,                     /* bitpos */
1991          complain_overflow_dont, /* complain_on_overflow */
1992          NULL,                  /* special_function */
1993          "R_PPC64_GNU_VTENTRY", /* name */
1994          FALSE,                 /* partial_inplace */
1995          0,                     /* src_mask */
1996          0,                     /* dst_mask */
1997          FALSE),                /* pcrel_offset */
1998 };
1999
2000 \f
2001 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2002    be done.  */
2003
2004 static void
2005 ppc_howto_init (void)
2006 {
2007   unsigned int i, type;
2008
2009   for (i = 0;
2010        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2011        i++)
2012     {
2013       type = ppc64_elf_howto_raw[i].type;
2014       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2015                           / sizeof (ppc64_elf_howto_table[0])));
2016       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2017     }
2018 }
2019
2020 static reloc_howto_type *
2021 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2022                              bfd_reloc_code_real_type code)
2023 {
2024   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2025
2026   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2027     /* Initialize howto table if needed.  */
2028     ppc_howto_init ();
2029
2030   switch (code)
2031     {
2032     default:
2033       return NULL;
2034
2035     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2036       break;
2037     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2038       break;
2039     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2040       break;
2041     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2042       break;
2043     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2044       break;
2045     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2046       break;
2047     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2048       break;
2049     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2050       break;
2051     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2052       break;
2053     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2054       break;
2055     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2056       break;
2057     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2058       break;
2059     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2060       break;
2061     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2062       break;
2063     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2064       break;
2065     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2066       break;
2067     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2068       break;
2069     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2070       break;
2071     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2072       break;
2073     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2074       break;
2075     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2076       break;
2077     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2078       break;
2079     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2080       break;
2081     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2082       break;
2083     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2084       break;
2085     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2086       break;
2087     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2088       break;
2089     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2090       break;
2091     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2092       break;
2093     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2094       break;
2095     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2096       break;
2097     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2098       break;
2099     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2100       break;
2101     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2102       break;
2103     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2104       break;
2105     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2106       break;
2107     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2108       break;
2109     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2110       break;
2111     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2112       break;
2113     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2114       break;
2115     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2116       break;
2117     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2118       break;
2119     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2120       break;
2121     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2122       break;
2123     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2124       break;
2125     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2126       break;
2127     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2128       break;
2129     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2130       break;
2131     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2132       break;
2133     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2134       break;
2135     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2136       break;
2137     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2138       break;
2139     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2140       break;
2141     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2142       break;
2143     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2144       break;
2145     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2146       break;
2147     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2148       break;
2149     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2150       break;
2151     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2152       break;
2153     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2154       break;
2155     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2156       break;
2157     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2158       break;
2159     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2160       break;
2161     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2162       break;
2163     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2164       break;
2165     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2166       break;
2167     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2168       break;
2169     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2170       break;
2171     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2172       break;
2173     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2174       break;
2175     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2176       break;
2177     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2178       break;
2179     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2180       break;
2181     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2182       break;
2183     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2184       break;
2185     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2186       break;
2187     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2188       break;
2189     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2190       break;
2191     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2192       break;
2193     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2194       break;
2195     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2196       break;
2197     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2198       break;
2199     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2200       break;
2201     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2204       break;
2205     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2206       break;
2207     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2208       break;
2209     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2210       break;
2211     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2212       break;
2213     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2214       break;
2215     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2216       break;
2217     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2218       break;
2219     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2220       break;
2221     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2222       break;
2223     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2224       break;
2225     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2226       break;
2227     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2228       break;
2229     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2230       break;
2231     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2232       break;
2233     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2234       break;
2235     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2236       break;
2237     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2238       break;
2239     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2240       break;
2241     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2242       break;
2243     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2244       break;
2245     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2246       break;
2247     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2248       break;
2249     }
2250
2251   return ppc64_elf_howto_table[r];
2252 };
2253
2254 static reloc_howto_type *
2255 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2256                              const char *r_name)
2257 {
2258   unsigned int i;
2259
2260   for (i = 0;
2261        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2262        i++)
2263     if (ppc64_elf_howto_raw[i].name != NULL
2264         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2265       return &ppc64_elf_howto_raw[i];
2266
2267   return NULL;
2268 }
2269
2270 /* Set the howto pointer for a PowerPC ELF reloc.  */
2271
2272 static void
2273 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2274                          Elf_Internal_Rela *dst)
2275 {
2276   unsigned int type;
2277
2278   /* Initialize howto table if needed.  */
2279   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2280     ppc_howto_init ();
2281
2282   type = ELF64_R_TYPE (dst->r_info);
2283   if (type >= (sizeof (ppc64_elf_howto_table)
2284                / sizeof (ppc64_elf_howto_table[0])))
2285     {
2286       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2287                              abfd, (int) type);
2288       type = R_PPC64_NONE;
2289     }
2290   cache_ptr->howto = ppc64_elf_howto_table[type];
2291 }
2292
2293 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2294
2295 static bfd_reloc_status_type
2296 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2297                     void *data, asection *input_section,
2298                     bfd *output_bfd, char **error_message)
2299 {
2300   /* If this is a relocatable link (output_bfd test tells us), just
2301      call the generic function.  Any adjustment will be done at final
2302      link time.  */
2303   if (output_bfd != NULL)
2304     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2305                                   input_section, output_bfd, error_message);
2306
2307   /* Adjust the addend for sign extension of the low 16 bits.
2308      We won't actually be using the low 16 bits, so trashing them
2309      doesn't matter.  */
2310   reloc_entry->addend += 0x8000;
2311   return bfd_reloc_continue;
2312 }
2313
2314 static bfd_reloc_status_type
2315 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2316                         void *data, asection *input_section,
2317                         bfd *output_bfd, char **error_message)
2318 {
2319   if (output_bfd != NULL)
2320     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2321                                   input_section, output_bfd, error_message);
2322
2323   if (strcmp (symbol->section->name, ".opd") == 0
2324       && (symbol->section->owner->flags & DYNAMIC) == 0)
2325     {
2326       bfd_vma dest = opd_entry_value (symbol->section,
2327                                       symbol->value + reloc_entry->addend,
2328                                       NULL, NULL);
2329       if (dest != (bfd_vma) -1)
2330         reloc_entry->addend = dest - (symbol->value
2331                                       + symbol->section->output_section->vma
2332                                       + symbol->section->output_offset);
2333     }
2334   return bfd_reloc_continue;
2335 }
2336
2337 static bfd_reloc_status_type
2338 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2339                          void *data, asection *input_section,
2340                          bfd *output_bfd, char **error_message)
2341 {
2342   long insn;
2343   enum elf_ppc64_reloc_type r_type;
2344   bfd_size_type octets;
2345   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2346   bfd_boolean is_power4 = FALSE;
2347
2348   /* If this is a relocatable link (output_bfd test tells us), just
2349      call the generic function.  Any adjustment will be done at final
2350      link time.  */
2351   if (output_bfd != NULL)
2352     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2353                                   input_section, output_bfd, error_message);
2354
2355   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2356   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2357   insn &= ~(0x01 << 21);
2358   r_type = reloc_entry->howto->type;
2359   if (r_type == R_PPC64_ADDR14_BRTAKEN
2360       || r_type == R_PPC64_REL14_BRTAKEN)
2361     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2362
2363   if (is_power4)
2364     {
2365       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2366          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2367          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2368       if ((insn & (0x14 << 21)) == (0x04 << 21))
2369         insn |= 0x02 << 21;
2370       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2371         insn |= 0x08 << 21;
2372       else
2373         goto out;
2374     }
2375   else
2376     {
2377       bfd_vma target = 0;
2378       bfd_vma from;
2379
2380       if (!bfd_is_com_section (symbol->section))
2381         target = symbol->value;
2382       target += symbol->section->output_section->vma;
2383       target += symbol->section->output_offset;
2384       target += reloc_entry->addend;
2385
2386       from = (reloc_entry->address
2387               + input_section->output_offset
2388               + input_section->output_section->vma);
2389
2390       /* Invert 'y' bit if not the default.  */
2391       if ((bfd_signed_vma) (target - from) < 0)
2392         insn ^= 0x01 << 21;
2393     }
2394   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2395  out:
2396   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2397                                  input_section, output_bfd, error_message);
2398 }
2399
2400 static bfd_reloc_status_type
2401 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2402                          void *data, asection *input_section,
2403                          bfd *output_bfd, char **error_message)
2404 {
2405   /* If this is a relocatable link (output_bfd test tells us), just
2406      call the generic function.  Any adjustment will be done at final
2407      link time.  */
2408   if (output_bfd != NULL)
2409     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2410                                   input_section, output_bfd, error_message);
2411
2412   /* Subtract the symbol section base address.  */
2413   reloc_entry->addend -= symbol->section->output_section->vma;
2414   return bfd_reloc_continue;
2415 }
2416
2417 static bfd_reloc_status_type
2418 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2419                             void *data, asection *input_section,
2420                             bfd *output_bfd, char **error_message)
2421 {
2422   /* If this is a relocatable link (output_bfd test tells us), just
2423      call the generic function.  Any adjustment will be done at final
2424      link time.  */
2425   if (output_bfd != NULL)
2426     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2427                                   input_section, output_bfd, error_message);
2428
2429   /* Subtract the symbol section base address.  */
2430   reloc_entry->addend -= symbol->section->output_section->vma;
2431
2432   /* Adjust the addend for sign extension of the low 16 bits.  */
2433   reloc_entry->addend += 0x8000;
2434   return bfd_reloc_continue;
2435 }
2436
2437 static bfd_reloc_status_type
2438 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2439                      void *data, asection *input_section,
2440                      bfd *output_bfd, char **error_message)
2441 {
2442   bfd_vma TOCstart;
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   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2452   if (TOCstart == 0)
2453     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2454
2455   /* Subtract the TOC base address.  */
2456   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2457   return bfd_reloc_continue;
2458 }
2459
2460 static bfd_reloc_status_type
2461 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2462                         void *data, asection *input_section,
2463                         bfd *output_bfd, char **error_message)
2464 {
2465   bfd_vma TOCstart;
2466
2467   /* If this is a relocatable link (output_bfd test tells us), just
2468      call the generic function.  Any adjustment will be done at final
2469      link time.  */
2470   if (output_bfd != NULL)
2471     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2472                                   input_section, output_bfd, error_message);
2473
2474   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2475   if (TOCstart == 0)
2476     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2477
2478   /* Subtract the TOC base address.  */
2479   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2480
2481   /* Adjust the addend for sign extension of the low 16 bits.  */
2482   reloc_entry->addend += 0x8000;
2483   return bfd_reloc_continue;
2484 }
2485
2486 static bfd_reloc_status_type
2487 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2488                        void *data, asection *input_section,
2489                        bfd *output_bfd, char **error_message)
2490 {
2491   bfd_vma TOCstart;
2492   bfd_size_type octets;
2493
2494   /* If this is a relocatable link (output_bfd test tells us), just
2495      call the generic function.  Any adjustment will be done at final
2496      link time.  */
2497   if (output_bfd != NULL)
2498     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2499                                   input_section, output_bfd, error_message);
2500
2501   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2502   if (TOCstart == 0)
2503     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2504
2505   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2506   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2507   return bfd_reloc_ok;
2508 }
2509
2510 static bfd_reloc_status_type
2511 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2512                            void *data, asection *input_section,
2513                            bfd *output_bfd, char **error_message)
2514 {
2515   /* If this is a relocatable link (output_bfd test tells us), just
2516      call the generic function.  Any adjustment will be done at final
2517      link time.  */
2518   if (output_bfd != NULL)
2519     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2520                                   input_section, output_bfd, error_message);
2521
2522   if (error_message != NULL)
2523     {
2524       static char buf[60];
2525       sprintf (buf, "generic linker can't handle %s",
2526                reloc_entry->howto->name);
2527       *error_message = buf;
2528     }
2529   return bfd_reloc_dangerous;
2530 }
2531
2532 /* Track GOT entries needed for a given symbol.  We might need more
2533    than one got entry per symbol.  */
2534 struct got_entry
2535 {
2536   struct got_entry *next;
2537
2538   /* The symbol addend that we'll be placing in the GOT.  */
2539   bfd_vma addend;
2540
2541   /* Unlike other ELF targets, we use separate GOT entries for the same
2542      symbol referenced from different input files.  This is to support
2543      automatic multiple TOC/GOT sections, where the TOC base can vary
2544      from one input file to another.  After partitioning into TOC groups
2545      we merge entries within the group.
2546
2547      Point to the BFD owning this GOT entry.  */
2548   bfd *owner;
2549
2550   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2551      TLS_TPREL or TLS_DTPREL for tls entries.  */
2552   unsigned char tls_type;
2553
2554   /* Non-zero if got.ent points to real entry.  */
2555   unsigned char is_indirect;
2556
2557   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2558   union
2559     {
2560       bfd_signed_vma refcount;
2561       bfd_vma offset;
2562       struct got_entry *ent;
2563     } got;
2564 };
2565
2566 /* The same for PLT.  */
2567 struct plt_entry
2568 {
2569   struct plt_entry *next;
2570
2571   bfd_vma addend;
2572
2573   union
2574     {
2575       bfd_signed_vma refcount;
2576       bfd_vma offset;
2577     } plt;
2578 };
2579
2580 struct ppc64_elf_obj_tdata
2581 {
2582   struct elf_obj_tdata elf;
2583
2584   /* Shortcuts to dynamic linker sections.  */
2585   asection *got;
2586   asection *relgot;
2587
2588   /* Used during garbage collection.  We attach global symbols defined
2589      on removed .opd entries to this section so that the sym is removed.  */
2590   asection *deleted_section;
2591
2592   /* TLS local dynamic got entry handling.  Support for multiple GOT
2593      sections means we potentially need one of these for each input bfd.  */
2594   struct got_entry tlsld_got;
2595
2596   /* A copy of relocs before they are modified for --emit-relocs.  */
2597   Elf_Internal_Rela *opd_relocs;
2598
2599   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2600      the reloc to be in the range -32768 to 32767.  */
2601   unsigned int has_small_toc_reloc;
2602 };
2603
2604 #define ppc64_elf_tdata(bfd) \
2605   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2606
2607 #define ppc64_tlsld_got(bfd) \
2608   (&ppc64_elf_tdata (bfd)->tlsld_got)
2609
2610 #define is_ppc64_elf(bfd) \
2611   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2612    && elf_object_id (bfd) == PPC64_ELF_DATA)
2613
2614 /* Override the generic function because we store some extras.  */
2615
2616 static bfd_boolean
2617 ppc64_elf_mkobject (bfd *abfd)
2618 {
2619   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2620                                   PPC64_ELF_DATA);
2621 }
2622
2623 /* Fix bad default arch selected for a 64 bit input bfd when the
2624    default is 32 bit.  */
2625
2626 static bfd_boolean
2627 ppc64_elf_object_p (bfd *abfd)
2628 {
2629   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2630     {
2631       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2632
2633       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2634         {
2635           /* Relies on arch after 32 bit default being 64 bit default.  */
2636           abfd->arch_info = abfd->arch_info->next;
2637           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2638         }
2639     }
2640   return TRUE;
2641 }
2642
2643 /* Support for core dump NOTE sections.  */
2644
2645 static bfd_boolean
2646 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2647 {
2648   size_t offset, size;
2649
2650   if (note->descsz != 504)
2651     return FALSE;
2652
2653   /* pr_cursig */
2654   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2655
2656   /* pr_pid */
2657   elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2658
2659   /* pr_reg */
2660   offset = 112;
2661   size = 384;
2662
2663   /* Make a ".reg/999" section.  */
2664   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2665                                           size, note->descpos + offset);
2666 }
2667
2668 static bfd_boolean
2669 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2670 {
2671   if (note->descsz != 136)
2672     return FALSE;
2673
2674   elf_tdata (abfd)->core_pid
2675     = bfd_get_32 (abfd, note->descdata + 24);
2676   elf_tdata (abfd)->core_program
2677     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2678   elf_tdata (abfd)->core_command
2679     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2680
2681   return TRUE;
2682 }
2683
2684 static char *
2685 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2686                            ...)
2687 {
2688   switch (note_type)
2689     {
2690     default:
2691       return NULL;
2692
2693     case NT_PRPSINFO:
2694       {
2695         char data[136];
2696         va_list ap;
2697
2698         va_start (ap, note_type);
2699         memset (data, 0, 40);
2700         strncpy (data + 40, va_arg (ap, const char *), 16);
2701         strncpy (data + 56, va_arg (ap, const char *), 80);
2702         va_end (ap);
2703         return elfcore_write_note (abfd, buf, bufsiz,
2704                                    "CORE", note_type, data, sizeof (data));
2705       }
2706
2707     case NT_PRSTATUS:
2708       {
2709         char data[504];
2710         va_list ap;
2711         long pid;
2712         int cursig;
2713         const void *greg;
2714
2715         va_start (ap, note_type);
2716         memset (data, 0, 112);
2717         pid = va_arg (ap, long);
2718         bfd_put_32 (abfd, pid, data + 32);
2719         cursig = va_arg (ap, int);
2720         bfd_put_16 (abfd, cursig, data + 12);
2721         greg = va_arg (ap, const void *);
2722         memcpy (data + 112, greg, 384);
2723         memset (data + 496, 0, 8);
2724         va_end (ap);
2725         return elfcore_write_note (abfd, buf, bufsiz,
2726                                    "CORE", note_type, data, sizeof (data));
2727       }
2728     }
2729 }
2730
2731 /* Add extra PPC sections.  */
2732
2733 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2734 {
2735   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2736   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2737   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2738   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2739   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2740   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2741   { NULL,                     0,  0, 0,            0 }
2742 };
2743
2744 enum _ppc64_sec_type {
2745   sec_normal = 0,
2746   sec_opd = 1,
2747   sec_toc = 2
2748 };
2749
2750 struct _ppc64_elf_section_data
2751 {
2752   struct bfd_elf_section_data elf;
2753
2754   union
2755   {
2756     /* An array with one entry for each opd function descriptor.  */
2757     struct _opd_sec_data
2758     {
2759       /* Points to the function code section for local opd entries.  */
2760       asection **func_sec;
2761
2762       /* After editing .opd, adjust references to opd local syms.  */
2763       long *adjust;
2764     } opd;
2765
2766     /* An array for toc sections, indexed by offset/8.  */
2767     struct _toc_sec_data
2768     {
2769       /* Specifies the relocation symbol index used at a given toc offset.  */
2770       unsigned *symndx;
2771
2772       /* And the relocation addend.  */
2773       bfd_vma *add;
2774     } toc;
2775   } u;
2776
2777   enum _ppc64_sec_type sec_type:2;
2778
2779   /* Flag set when small branches are detected.  Used to
2780      select suitable defaults for the stub group size.  */
2781   unsigned int has_14bit_branch:1;
2782 };
2783
2784 #define ppc64_elf_section_data(sec) \
2785   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2786
2787 static bfd_boolean
2788 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2789 {
2790   if (!sec->used_by_bfd)
2791     {
2792       struct _ppc64_elf_section_data *sdata;
2793       bfd_size_type amt = sizeof (*sdata);
2794
2795       sdata = bfd_zalloc (abfd, amt);
2796       if (sdata == NULL)
2797         return FALSE;
2798       sec->used_by_bfd = sdata;
2799     }
2800
2801   return _bfd_elf_new_section_hook (abfd, sec);
2802 }
2803
2804 static struct _opd_sec_data *
2805 get_opd_info (asection * sec)
2806 {
2807   if (sec != NULL
2808       && ppc64_elf_section_data (sec) != NULL
2809       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2810     return &ppc64_elf_section_data (sec)->u.opd;
2811   return NULL;
2812 }
2813 \f
2814 /* Parameters for the qsort hook.  */
2815 static bfd_boolean synthetic_relocatable;
2816
2817 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2818
2819 static int
2820 compare_symbols (const void *ap, const void *bp)
2821 {
2822   const asymbol *a = * (const asymbol **) ap;
2823   const asymbol *b = * (const asymbol **) bp;
2824
2825   /* Section symbols first.  */
2826   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2827     return -1;
2828   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2829     return 1;
2830
2831   /* then .opd symbols.  */
2832   if (strcmp (a->section->name, ".opd") == 0
2833       && strcmp (b->section->name, ".opd") != 0)
2834     return -1;
2835   if (strcmp (a->section->name, ".opd") != 0
2836       && strcmp (b->section->name, ".opd") == 0)
2837     return 1;
2838
2839   /* then other code symbols.  */
2840   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2841       == (SEC_CODE | SEC_ALLOC)
2842       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2843          != (SEC_CODE | SEC_ALLOC))
2844     return -1;
2845
2846   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2847       != (SEC_CODE | SEC_ALLOC)
2848       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2849          == (SEC_CODE | SEC_ALLOC))
2850     return 1;
2851
2852   if (synthetic_relocatable)
2853     {
2854       if (a->section->id < b->section->id)
2855         return -1;
2856
2857       if (a->section->id > b->section->id)
2858         return 1;
2859     }
2860
2861   if (a->value + a->section->vma < b->value + b->section->vma)
2862     return -1;
2863
2864   if (a->value + a->section->vma > b->value + b->section->vma)
2865     return 1;
2866
2867   /* For syms with the same value, prefer strong dynamic global function
2868      syms over other syms.  */
2869   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2870     return -1;
2871
2872   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2873     return 1;
2874
2875   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2876     return -1;
2877
2878   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2879     return 1;
2880
2881   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2882     return -1;
2883
2884   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2885     return 1;
2886
2887   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2888     return -1;
2889
2890   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2891     return 1;
2892
2893   return 0;
2894 }
2895
2896 /* Search SYMS for a symbol of the given VALUE.  */
2897
2898 static asymbol *
2899 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2900 {
2901   long mid;
2902
2903   if (id == -1)
2904     {
2905       while (lo < hi)
2906         {
2907           mid = (lo + hi) >> 1;
2908           if (syms[mid]->value + syms[mid]->section->vma < value)
2909             lo = mid + 1;
2910           else if (syms[mid]->value + syms[mid]->section->vma > value)
2911             hi = mid;
2912           else
2913             return syms[mid];
2914         }
2915     }
2916   else
2917     {
2918       while (lo < hi)
2919         {
2920           mid = (lo + hi) >> 1;
2921           if (syms[mid]->section->id < id)
2922             lo = mid + 1;
2923           else if (syms[mid]->section->id > id)
2924             hi = mid;
2925           else if (syms[mid]->value < value)
2926             lo = mid + 1;
2927           else if (syms[mid]->value > value)
2928             hi = mid;
2929           else
2930             return syms[mid];
2931         }
2932     }
2933   return NULL;
2934 }
2935
2936 static bfd_boolean
2937 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2938 {
2939   bfd_vma vma = *(bfd_vma *) ptr;
2940   return ((section->flags & SEC_ALLOC) != 0
2941           && section->vma <= vma
2942           && vma < section->vma + section->size);
2943 }
2944
2945 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2946    entry syms.  Also generate @plt symbols for the glink branch table.  */
2947
2948 static long
2949 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2950                                 long static_count, asymbol **static_syms,
2951                                 long dyn_count, asymbol **dyn_syms,
2952                                 asymbol **ret)
2953 {
2954   asymbol *s;
2955   long i;
2956   long count;
2957   char *names;
2958   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2959   asection *opd;
2960   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2961   asymbol **syms;
2962
2963   *ret = NULL;
2964
2965   opd = bfd_get_section_by_name (abfd, ".opd");
2966   if (opd == NULL)
2967     return 0;
2968
2969   symcount = static_count;
2970   if (!relocatable)
2971     symcount += dyn_count;
2972   if (symcount == 0)
2973     return 0;
2974
2975   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2976   if (syms == NULL)
2977     return -1;
2978
2979   if (!relocatable && static_count != 0 && dyn_count != 0)
2980     {
2981       /* Use both symbol tables.  */
2982       memcpy (syms, static_syms, static_count * sizeof (*syms));
2983       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2984     }
2985   else if (!relocatable && static_count == 0)
2986     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2987   else
2988     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2989
2990   synthetic_relocatable = relocatable;
2991   qsort (syms, symcount, sizeof (*syms), compare_symbols);
2992
2993   if (!relocatable && symcount > 1)
2994     {
2995       long j;
2996       /* Trim duplicate syms, since we may have merged the normal and
2997          dynamic symbols.  Actually, we only care about syms that have
2998          different values, so trim any with the same value.  */
2999       for (i = 1, j = 1; i < symcount; ++i)
3000         if (syms[i - 1]->value + syms[i - 1]->section->vma
3001             != syms[i]->value + syms[i]->section->vma)
3002           syms[j++] = syms[i];
3003       symcount = j;
3004     }
3005
3006   i = 0;
3007   if (strcmp (syms[i]->section->name, ".opd") == 0)
3008     ++i;
3009   codesecsym = i;
3010
3011   for (; i < symcount; ++i)
3012     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3013          != (SEC_CODE | SEC_ALLOC))
3014         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3015       break;
3016   codesecsymend = i;
3017
3018   for (; i < symcount; ++i)
3019     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3020       break;
3021   secsymend = i;
3022
3023   for (; i < symcount; ++i)
3024     if (strcmp (syms[i]->section->name, ".opd") != 0)
3025       break;
3026   opdsymend = i;
3027
3028   for (; i < symcount; ++i)
3029     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3030         != (SEC_CODE | SEC_ALLOC))
3031       break;
3032   symcount = i;
3033
3034   count = 0;
3035
3036   if (relocatable)
3037     {
3038       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3039       arelent *r;
3040       size_t size;
3041       long relcount;
3042
3043       if (opdsymend == secsymend)
3044         goto done;
3045
3046       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3047       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3048       if (relcount == 0)
3049         goto done;
3050
3051       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3052         {
3053           count = -1;
3054           goto done;
3055         }
3056
3057       size = 0;
3058       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3059         {
3060           asymbol *sym;
3061
3062           while (r < opd->relocation + relcount
3063                  && r->address < syms[i]->value + opd->vma)
3064             ++r;
3065
3066           if (r == opd->relocation + relcount)
3067             break;
3068
3069           if (r->address != syms[i]->value + opd->vma)
3070             continue;
3071
3072           if (r->howto->type != R_PPC64_ADDR64)
3073             continue;
3074
3075           sym = *r->sym_ptr_ptr;
3076           if (!sym_exists_at (syms, opdsymend, symcount,
3077                               sym->section->id, sym->value + r->addend))
3078             {
3079               ++count;
3080               size += sizeof (asymbol);
3081               size += strlen (syms[i]->name) + 2;
3082             }
3083         }
3084
3085       s = *ret = bfd_malloc (size);
3086       if (s == NULL)
3087         {
3088           count = -1;
3089           goto done;
3090         }
3091
3092       names = (char *) (s + count);
3093
3094       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3095         {
3096           asymbol *sym;
3097
3098           while (r < opd->relocation + relcount
3099                  && r->address < syms[i]->value + opd->vma)
3100             ++r;
3101
3102           if (r == opd->relocation + relcount)
3103             break;
3104
3105           if (r->address != syms[i]->value + opd->vma)
3106             continue;
3107
3108           if (r->howto->type != R_PPC64_ADDR64)
3109             continue;
3110
3111           sym = *r->sym_ptr_ptr;
3112           if (!sym_exists_at (syms, opdsymend, symcount,
3113                               sym->section->id, sym->value + r->addend))
3114             {
3115               size_t len;
3116
3117               *s = *syms[i];
3118               s->flags |= BSF_SYNTHETIC;
3119               s->section = sym->section;
3120               s->value = sym->value + r->addend;
3121               s->name = names;
3122               *names++ = '.';
3123               len = strlen (syms[i]->name);
3124               memcpy (names, syms[i]->name, len + 1);
3125               names += len + 1;
3126               /* Have udata.p point back to the original symbol this
3127                  synthetic symbol was derived from.  */
3128               s->udata.p = syms[i];
3129               s++;
3130             }
3131         }
3132     }
3133   else
3134     {
3135       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3136       bfd_byte *contents;
3137       size_t size;
3138       long plt_count = 0;
3139       bfd_vma glink_vma = 0, resolv_vma = 0;
3140       asection *dynamic, *glink = NULL, *relplt = NULL;
3141       arelent *p;
3142
3143       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3144         {
3145           if (contents)
3146             {
3147             free_contents_and_exit:
3148               free (contents);
3149             }
3150           count = -1;
3151           goto done;
3152         }
3153
3154       size = 0;
3155       for (i = secsymend; i < opdsymend; ++i)
3156         {
3157           bfd_vma ent;
3158
3159           /* Ignore bogus symbols.  */
3160           if (syms[i]->value > opd->size - 8)
3161             continue;
3162
3163           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3164           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3165             {
3166               ++count;
3167               size += sizeof (asymbol);
3168               size += strlen (syms[i]->name) + 2;
3169             }
3170         }
3171
3172       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3173       if (dyn_count != 0
3174           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3175         {
3176           bfd_byte *dynbuf, *extdyn, *extdynend;
3177           size_t extdynsize;
3178           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3179
3180           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3181             goto free_contents_and_exit;
3182
3183           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3184           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3185
3186           extdyn = dynbuf;
3187           extdynend = extdyn + dynamic->size;
3188           for (; extdyn < extdynend; extdyn += extdynsize)
3189             {
3190               Elf_Internal_Dyn dyn;
3191               (*swap_dyn_in) (abfd, extdyn, &dyn);
3192
3193               if (dyn.d_tag == DT_NULL)
3194                 break;
3195
3196               if (dyn.d_tag == DT_PPC64_GLINK)
3197                 {
3198                   /* The first glink stub starts at offset 32; see comment in
3199                      ppc64_elf_finish_dynamic_sections. */
3200                   glink_vma = dyn.d_un.d_val + 32;
3201                   /* The .glink section usually does not survive the final
3202                      link; search for the section (usually .text) where the
3203                      glink stubs now reside.  */
3204                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3205                                                 &glink_vma);
3206                   break;
3207                 }
3208             }
3209
3210           free (dynbuf);
3211         }
3212
3213       if (glink != NULL)
3214         {
3215           /* Determine __glink trampoline by reading the relative branch
3216              from the first glink stub.  */
3217           bfd_byte buf[4];
3218           if (bfd_get_section_contents (abfd, glink, buf,
3219                                         glink_vma + 4 - glink->vma, 4))
3220             {
3221               unsigned int insn = bfd_get_32 (abfd, buf);
3222               insn ^= B_DOT;
3223               if ((insn & ~0x3fffffc) == 0)
3224                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3225             }
3226
3227           if (resolv_vma)
3228             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3229
3230           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3231           if (relplt != NULL)
3232             {
3233               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3234               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3235                 goto free_contents_and_exit;
3236
3237               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3238               size += plt_count * sizeof (asymbol);
3239
3240               p = relplt->relocation;
3241               for (i = 0; i < plt_count; i++, p++)
3242                 {
3243                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3244                   if (p->addend != 0)
3245                     size += sizeof ("+0x") - 1 + 16;
3246                 }
3247             }
3248         }
3249
3250       s = *ret = bfd_malloc (size);
3251       if (s == NULL)
3252         goto free_contents_and_exit;
3253
3254       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3255
3256       for (i = secsymend; i < opdsymend; ++i)
3257         {
3258           bfd_vma ent;
3259
3260           if (syms[i]->value > opd->size - 8)
3261             continue;
3262
3263           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3264           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3265             {
3266               long lo, hi;
3267               size_t len;
3268               asection *sec = abfd->sections;
3269
3270               *s = *syms[i];
3271               lo = codesecsym;
3272               hi = codesecsymend;
3273               while (lo < hi)
3274                 {
3275                   long mid = (lo + hi) >> 1;
3276                   if (syms[mid]->section->vma < ent)
3277                     lo = mid + 1;
3278                   else if (syms[mid]->section->vma > ent)
3279                     hi = mid;
3280                   else
3281                     {
3282                       sec = syms[mid]->section;
3283                       break;
3284                     }
3285                 }
3286
3287               if (lo >= hi && lo > codesecsym)
3288                 sec = syms[lo - 1]->section;
3289
3290               for (; sec != NULL; sec = sec->next)
3291                 {
3292                   if (sec->vma > ent)
3293                     break;
3294                   /* SEC_LOAD may not be set if SEC is from a separate debug
3295                      info file.  */
3296                   if ((sec->flags & SEC_ALLOC) == 0)
3297                     break;
3298                   if ((sec->flags & SEC_CODE) != 0)
3299                     s->section = sec;
3300                 }
3301               s->flags |= BSF_SYNTHETIC;
3302               s->value = ent - s->section->vma;
3303               s->name = names;
3304               *names++ = '.';
3305               len = strlen (syms[i]->name);
3306               memcpy (names, syms[i]->name, len + 1);
3307               names += len + 1;
3308               /* Have udata.p point back to the original symbol this
3309                  synthetic symbol was derived from.  */
3310               s->udata.p = syms[i];
3311               s++;
3312             }
3313         }
3314       free (contents);
3315
3316       if (glink != NULL && relplt != NULL)
3317         {
3318           if (resolv_vma)
3319             {
3320               /* Add a symbol for the main glink trampoline.  */
3321               memset (s, 0, sizeof *s);
3322               s->the_bfd = abfd;
3323               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3324               s->section = glink;
3325               s->value = resolv_vma - glink->vma;
3326               s->name = names;
3327               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3328               names += sizeof ("__glink_PLTresolve");
3329               s++;
3330               count++;
3331             }
3332
3333           /* FIXME: It would be very much nicer to put sym@plt on the
3334              stub rather than on the glink branch table entry.  The
3335              objdump disassembler would then use a sensible symbol
3336              name on plt calls.  The difficulty in doing so is
3337              a) finding the stubs, and,
3338              b) matching stubs against plt entries, and,
3339              c) there can be multiple stubs for a given plt entry.
3340
3341              Solving (a) could be done by code scanning, but older
3342              ppc64 binaries used different stubs to current code.
3343              (b) is the tricky one since you need to known the toc
3344              pointer for at least one function that uses a pic stub to
3345              be able to calculate the plt address referenced.
3346              (c) means gdb would need to set multiple breakpoints (or
3347              find the glink branch itself) when setting breakpoints
3348              for pending shared library loads.  */
3349           p = relplt->relocation;
3350           for (i = 0; i < plt_count; i++, p++)
3351             {
3352               size_t len;
3353
3354               *s = **p->sym_ptr_ptr;
3355               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3356                  we are defining a symbol, ensure one of them is set.  */
3357               if ((s->flags & BSF_LOCAL) == 0)
3358                 s->flags |= BSF_GLOBAL;
3359               s->flags |= BSF_SYNTHETIC;
3360               s->section = glink;
3361               s->value = glink_vma - glink->vma;
3362               s->name = names;
3363               s->udata.p = NULL;
3364               len = strlen ((*p->sym_ptr_ptr)->name);
3365               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3366               names += len;
3367               if (p->addend != 0)
3368                 {
3369                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3370                   names += sizeof ("+0x") - 1;
3371                   bfd_sprintf_vma (abfd, names, p->addend);
3372                   names += strlen (names);
3373                 }
3374               memcpy (names, "@plt", sizeof ("@plt"));
3375               names += sizeof ("@plt");
3376               s++;
3377               glink_vma += 8;
3378               if (i >= 0x8000)
3379                 glink_vma += 4;
3380             }
3381           count += plt_count;
3382         }
3383     }
3384
3385  done:
3386   free (syms);
3387   return count;
3388 }
3389 \f
3390 /* The following functions are specific to the ELF linker, while
3391    functions above are used generally.  Those named ppc64_elf_* are
3392    called by the main ELF linker code.  They appear in this file more
3393    or less in the order in which they are called.  eg.
3394    ppc64_elf_check_relocs is called early in the link process,
3395    ppc64_elf_finish_dynamic_sections is one of the last functions
3396    called.
3397
3398    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3399    functions have both a function code symbol and a function descriptor
3400    symbol.  A call to foo in a relocatable object file looks like:
3401
3402    .            .text
3403    .    x:
3404    .            bl      .foo
3405    .            nop
3406
3407    The function definition in another object file might be:
3408
3409    .            .section .opd
3410    .    foo:    .quad   .foo
3411    .            .quad   .TOC.@tocbase
3412    .            .quad   0
3413    .
3414    .            .text
3415    .    .foo:   blr
3416
3417    When the linker resolves the call during a static link, the branch
3418    unsurprisingly just goes to .foo and the .opd information is unused.
3419    If the function definition is in a shared library, things are a little
3420    different:  The call goes via a plt call stub, the opd information gets
3421    copied to the plt, and the linker patches the nop.
3422
3423    .    x:
3424    .            bl      .foo_stub
3425    .            ld      2,40(1)
3426    .
3427    .
3428    .    .foo_stub:
3429    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3430    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3431    .            std     2,40(1)                 # this is the general idea
3432    .            ld      11,0(12)
3433    .            ld      2,8(12)
3434    .            mtctr   11
3435    .            ld      11,16(12)
3436    .            bctr
3437    .
3438    .            .section .plt
3439    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3440
3441    The "reloc ()" notation is supposed to indicate that the linker emits
3442    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3443    copying.
3444
3445    What are the difficulties here?  Well, firstly, the relocations
3446    examined by the linker in check_relocs are against the function code
3447    sym .foo, while the dynamic relocation in the plt is emitted against
3448    the function descriptor symbol, foo.  Somewhere along the line, we need
3449    to carefully copy dynamic link information from one symbol to the other.
3450    Secondly, the generic part of the elf linker will make .foo a dynamic
3451    symbol as is normal for most other backends.  We need foo dynamic
3452    instead, at least for an application final link.  However, when
3453    creating a shared library containing foo, we need to have both symbols
3454    dynamic so that references to .foo are satisfied during the early
3455    stages of linking.  Otherwise the linker might decide to pull in a
3456    definition from some other object, eg. a static library.
3457
3458    Update: As of August 2004, we support a new convention.  Function
3459    calls may use the function descriptor symbol, ie. "bl foo".  This
3460    behaves exactly as "bl .foo".  */
3461
3462 /* Of those relocs that might be copied as dynamic relocs, this function
3463    selects those that must be copied when linking a shared library,
3464    even when the symbol is local.  */
3465
3466 static int
3467 must_be_dyn_reloc (struct bfd_link_info *info,
3468                    enum elf_ppc64_reloc_type r_type)
3469 {
3470   switch (r_type)
3471     {
3472     default:
3473       return 1;
3474
3475     case R_PPC64_REL32:
3476     case R_PPC64_REL64:
3477     case R_PPC64_REL30:
3478       return 0;
3479
3480     case R_PPC64_TPREL16:
3481     case R_PPC64_TPREL16_LO:
3482     case R_PPC64_TPREL16_HI:
3483     case R_PPC64_TPREL16_HA:
3484     case R_PPC64_TPREL16_DS:
3485     case R_PPC64_TPREL16_LO_DS:
3486     case R_PPC64_TPREL16_HIGHER:
3487     case R_PPC64_TPREL16_HIGHERA:
3488     case R_PPC64_TPREL16_HIGHEST:
3489     case R_PPC64_TPREL16_HIGHESTA:
3490     case R_PPC64_TPREL64:
3491       return !info->executable;
3492     }
3493 }
3494
3495 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3496    copying dynamic variables from a shared lib into an app's dynbss
3497    section, and instead use a dynamic relocation to point into the
3498    shared lib.  With code that gcc generates, it's vital that this be
3499    enabled;  In the PowerPC64 ABI, the address of a function is actually
3500    the address of a function descriptor, which resides in the .opd
3501    section.  gcc uses the descriptor directly rather than going via the
3502    GOT as some other ABI's do, which means that initialized function
3503    pointers must reference the descriptor.  Thus, a function pointer
3504    initialized to the address of a function in a shared library will
3505    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3506    redefines the function descriptor symbol to point to the copy.  This
3507    presents a problem as a plt entry for that function is also
3508    initialized from the function descriptor symbol and the copy reloc
3509    may not be initialized first.  */
3510 #define ELIMINATE_COPY_RELOCS 1
3511
3512 /* Section name for stubs is the associated section name plus this
3513    string.  */
3514 #define STUB_SUFFIX ".stub"
3515
3516 /* Linker stubs.
3517    ppc_stub_long_branch:
3518    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3519    destination, but a 24 bit branch in a stub section will reach.
3520    .    b       dest
3521
3522    ppc_stub_plt_branch:
3523    Similar to the above, but a 24 bit branch in the stub section won't
3524    reach its destination.
3525    .    addis   %r12,%r2,xxx@toc@ha
3526    .    ld      %r11,xxx@toc@l(%r12)
3527    .    mtctr   %r11
3528    .    bctr
3529
3530    ppc_stub_plt_call:
3531    Used to call a function in a shared library.  If it so happens that
3532    the plt entry referenced crosses a 64k boundary, then an extra
3533    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3534    .    addis   %r12,%r2,xxx@toc@ha
3535    .    std     %r2,40(%r1)
3536    .    ld      %r11,xxx+0@toc@l(%r12)
3537    .    mtctr   %r11
3538    .    ld      %r2,xxx+8@toc@l(%r12)
3539    .    ld      %r11,xxx+16@toc@l(%r12)
3540    .    bctr
3541
3542    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3543    code to adjust the value and save r2 to support multiple toc sections.
3544    A ppc_stub_long_branch with an r2 offset looks like:
3545    .    std     %r2,40(%r1)
3546    .    addis   %r2,%r2,off@ha
3547    .    addi    %r2,%r2,off@l
3548    .    b       dest
3549
3550    A ppc_stub_plt_branch with an r2 offset looks like:
3551    .    std     %r2,40(%r1)
3552    .    addis   %r12,%r2,xxx@toc@ha
3553    .    ld      %r11,xxx@toc@l(%r12)
3554    .    addis   %r2,%r2,off@ha
3555    .    addi    %r2,%r2,off@l
3556    .    mtctr   %r11
3557    .    bctr
3558
3559    In cases where the "addis" instruction would add zero, the "addis" is
3560    omitted and following instructions modified slightly in some cases.
3561 */
3562
3563 enum ppc_stub_type {
3564   ppc_stub_none,
3565   ppc_stub_long_branch,
3566   ppc_stub_long_branch_r2off,
3567   ppc_stub_plt_branch,
3568   ppc_stub_plt_branch_r2off,
3569   ppc_stub_plt_call
3570 };
3571
3572 struct ppc_stub_hash_entry {
3573
3574   /* Base hash table entry structure.  */
3575   struct bfd_hash_entry root;
3576
3577   enum ppc_stub_type stub_type;
3578
3579   /* The stub section.  */
3580   asection *stub_sec;
3581
3582   /* Offset within stub_sec of the beginning of this stub.  */
3583   bfd_vma stub_offset;
3584
3585   /* Given the symbol's value and its section we can determine its final
3586      value when building the stubs (so the stub knows where to jump.  */
3587   bfd_vma target_value;
3588   asection *target_section;
3589
3590   /* The symbol table entry, if any, that this was derived from.  */
3591   struct ppc_link_hash_entry *h;
3592   struct plt_entry *plt_ent;
3593
3594   /* And the reloc addend that this was derived from.  */
3595   bfd_vma addend;
3596
3597   /* Where this stub is being called from, or, in the case of combined
3598      stub sections, the first input section in the group.  */
3599   asection *id_sec;
3600 };
3601
3602 struct ppc_branch_hash_entry {
3603
3604   /* Base hash table entry structure.  */
3605   struct bfd_hash_entry root;
3606
3607   /* Offset within branch lookup table.  */
3608   unsigned int offset;
3609
3610   /* Generation marker.  */
3611   unsigned int iter;
3612 };
3613
3614 struct ppc_link_hash_entry
3615 {
3616   struct elf_link_hash_entry elf;
3617
3618   union {
3619     /* A pointer to the most recently used stub hash entry against this
3620        symbol.  */
3621     struct ppc_stub_hash_entry *stub_cache;
3622
3623     /* A pointer to the next symbol starting with a '.'  */
3624     struct ppc_link_hash_entry *next_dot_sym;
3625   } u;
3626
3627   /* Track dynamic relocs copied for this symbol.  */
3628   struct elf_dyn_relocs *dyn_relocs;
3629
3630   /* Link between function code and descriptor symbols.  */
3631   struct ppc_link_hash_entry *oh;
3632
3633   /* Flag function code and descriptor symbols.  */
3634   unsigned int is_func:1;
3635   unsigned int is_func_descriptor:1;
3636   unsigned int fake:1;
3637
3638   /* Whether global opd/toc sym has been adjusted or not.
3639      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3640      should be set for all globals defined in any opd/toc section.  */
3641   unsigned int adjust_done:1;
3642
3643   /* Set if we twiddled this symbol to weak at some stage.  */
3644   unsigned int was_undefined:1;
3645
3646   /* Contexts in which symbol is used in the GOT (or TOC).
3647      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3648      corresponding relocs are encountered during check_relocs.
3649      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3650      indicate the corresponding GOT entry type is not needed.
3651      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3652      a TPREL one.  We use a separate flag rather than setting TPREL
3653      just for convenience in distinguishing the two cases.  */
3654 #define TLS_GD           1      /* GD reloc. */
3655 #define TLS_LD           2      /* LD reloc. */
3656 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3657 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3658 #define TLS_TLS         16      /* Any TLS reloc.  */
3659 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3660 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3661 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3662   unsigned char tls_mask;
3663 };
3664
3665 /* ppc64 ELF linker hash table.  */
3666
3667 struct ppc_link_hash_table
3668 {
3669   struct elf_link_hash_table elf;
3670
3671   /* The stub hash table.  */
3672   struct bfd_hash_table stub_hash_table;
3673
3674   /* Another hash table for plt_branch stubs.  */
3675   struct bfd_hash_table branch_hash_table;
3676
3677   /* Linker stub bfd.  */
3678   bfd *stub_bfd;
3679
3680   /* Linker call-backs.  */
3681   asection * (*add_stub_section) (const char *, asection *);
3682   void (*layout_sections_again) (void);
3683
3684   /* Array to keep track of which stub sections have been created, and
3685      information on stub grouping.  */
3686   struct map_stub {
3687     /* This is the section to which stubs in the group will be attached.  */
3688     asection *link_sec;
3689     /* The stub section.  */
3690     asection *stub_sec;
3691     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3692     bfd_vma toc_off;
3693   } *stub_group;
3694
3695   /* Temp used when calculating TOC pointers.  */
3696   bfd_vma toc_curr;
3697   bfd *toc_bfd;
3698   asection *toc_first_sec;
3699
3700   /* Highest input section id.  */
3701   int top_id;
3702
3703   /* Highest output section index.  */
3704   int top_index;
3705
3706   /* Used when adding symbols.  */
3707   struct ppc_link_hash_entry *dot_syms;
3708
3709   /* List of input sections for each output section.  */
3710   asection **input_list;
3711
3712   /* Short-cuts to get to dynamic linker sections.  */
3713   asection *got;
3714   asection *plt;
3715   asection *relplt;
3716   asection *iplt;
3717   asection *reliplt;
3718   asection *dynbss;
3719   asection *relbss;
3720   asection *glink;
3721   asection *sfpr;
3722   asection *brlt;
3723   asection *relbrlt;
3724   asection *glink_eh_frame;
3725
3726   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3727   struct ppc_link_hash_entry *tls_get_addr;
3728   struct ppc_link_hash_entry *tls_get_addr_fd;
3729
3730   /* The size of reliplt used by got entry relocs.  */
3731   bfd_size_type got_reli_size;
3732
3733   /* Statistics.  */
3734   unsigned long stub_count[ppc_stub_plt_call];
3735
3736   /* Number of stubs against global syms.  */
3737   unsigned long stub_globals;
3738
3739   /* Set if PLT call stubs should load r11.  */
3740   unsigned int plt_static_chain:1;
3741
3742   /* Set if we should emit symbols for stubs.  */
3743   unsigned int emit_stub_syms:1;
3744
3745   /* Set if __tls_get_addr optimization should not be done.  */
3746   unsigned int no_tls_get_addr_opt:1;
3747
3748   /* Support for multiple toc sections.  */
3749   unsigned int do_multi_toc:1;
3750   unsigned int multi_toc_needed:1;
3751   unsigned int second_toc_pass:1;
3752   unsigned int do_toc_opt:1;
3753
3754   /* Set on error.  */
3755   unsigned int stub_error:1;
3756
3757   /* Temp used by ppc64_elf_process_dot_syms.  */
3758   unsigned int twiddled_syms:1;
3759
3760   /* Incremented every time we size stubs.  */
3761   unsigned int stub_iteration;
3762
3763   /* Small local sym cache.  */
3764   struct sym_cache sym_cache;
3765 };
3766
3767 /* Rename some of the generic section flags to better document how they
3768    are used here.  */
3769
3770 /* Nonzero if this section has TLS related relocations.  */
3771 #define has_tls_reloc sec_flg0
3772
3773 /* Nonzero if this section has a call to __tls_get_addr.  */
3774 #define has_tls_get_addr_call sec_flg1
3775
3776 /* Nonzero if this section has any toc or got relocs.  */
3777 #define has_toc_reloc sec_flg2
3778
3779 /* Nonzero if this section has a call to another section that uses
3780    the toc or got.  */
3781 #define makes_toc_func_call sec_flg3
3782
3783 /* Recursion protection when determining above flag.  */
3784 #define call_check_in_progress sec_flg4
3785 #define call_check_done sec_flg5
3786
3787 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3788
3789 #define ppc_hash_table(p) \
3790   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3791   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3792
3793 #define ppc_stub_hash_lookup(table, string, create, copy) \
3794   ((struct ppc_stub_hash_entry *) \
3795    bfd_hash_lookup ((table), (string), (create), (copy)))
3796
3797 #define ppc_branch_hash_lookup(table, string, create, copy) \
3798   ((struct ppc_branch_hash_entry *) \
3799    bfd_hash_lookup ((table), (string), (create), (copy)))
3800
3801 /* Create an entry in the stub hash table.  */
3802
3803 static struct bfd_hash_entry *
3804 stub_hash_newfunc (struct bfd_hash_entry *entry,
3805                    struct bfd_hash_table *table,
3806                    const char *string)
3807 {
3808   /* Allocate the structure if it has not already been allocated by a
3809      subclass.  */
3810   if (entry == NULL)
3811     {
3812       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3813       if (entry == NULL)
3814         return entry;
3815     }
3816
3817   /* Call the allocation method of the superclass.  */
3818   entry = bfd_hash_newfunc (entry, table, string);
3819   if (entry != NULL)
3820     {
3821       struct ppc_stub_hash_entry *eh;
3822
3823       /* Initialize the local fields.  */
3824       eh = (struct ppc_stub_hash_entry *) entry;
3825       eh->stub_type = ppc_stub_none;
3826       eh->stub_sec = NULL;
3827       eh->stub_offset = 0;
3828       eh->target_value = 0;
3829       eh->target_section = NULL;
3830       eh->h = NULL;
3831       eh->id_sec = NULL;
3832     }
3833
3834   return entry;
3835 }
3836
3837 /* Create an entry in the branch hash table.  */
3838
3839 static struct bfd_hash_entry *
3840 branch_hash_newfunc (struct bfd_hash_entry *entry,
3841                      struct bfd_hash_table *table,
3842                      const char *string)
3843 {
3844   /* Allocate the structure if it has not already been allocated by a
3845      subclass.  */
3846   if (entry == NULL)
3847     {
3848       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3849       if (entry == NULL)
3850         return entry;
3851     }
3852
3853   /* Call the allocation method of the superclass.  */
3854   entry = bfd_hash_newfunc (entry, table, string);
3855   if (entry != NULL)
3856     {
3857       struct ppc_branch_hash_entry *eh;
3858
3859       /* Initialize the local fields.  */
3860       eh = (struct ppc_branch_hash_entry *) entry;
3861       eh->offset = 0;
3862       eh->iter = 0;
3863     }
3864
3865   return entry;
3866 }
3867
3868 /* Create an entry in a ppc64 ELF linker hash table.  */
3869
3870 static struct bfd_hash_entry *
3871 link_hash_newfunc (struct bfd_hash_entry *entry,
3872                    struct bfd_hash_table *table,
3873                    const char *string)
3874 {
3875   /* Allocate the structure if it has not already been allocated by a
3876      subclass.  */
3877   if (entry == NULL)
3878     {
3879       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3880       if (entry == NULL)
3881         return entry;
3882     }
3883
3884   /* Call the allocation method of the superclass.  */
3885   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3886   if (entry != NULL)
3887     {
3888       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3889
3890       memset (&eh->u.stub_cache, 0,
3891               (sizeof (struct ppc_link_hash_entry)
3892                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3893
3894       /* When making function calls, old ABI code references function entry
3895          points (dot symbols), while new ABI code references the function
3896          descriptor symbol.  We need to make any combination of reference and
3897          definition work together, without breaking archive linking.
3898
3899          For a defined function "foo" and an undefined call to "bar":
3900          An old object defines "foo" and ".foo", references ".bar" (possibly
3901          "bar" too).
3902          A new object defines "foo" and references "bar".
3903
3904          A new object thus has no problem with its undefined symbols being
3905          satisfied by definitions in an old object.  On the other hand, the
3906          old object won't have ".bar" satisfied by a new object.
3907
3908          Keep a list of newly added dot-symbols.  */
3909
3910       if (string[0] == '.')
3911         {
3912           struct ppc_link_hash_table *htab;
3913
3914           htab = (struct ppc_link_hash_table *) table;
3915           eh->u.next_dot_sym = htab->dot_syms;
3916           htab->dot_syms = eh;
3917         }
3918     }
3919
3920   return entry;
3921 }
3922
3923 /* Create a ppc64 ELF linker hash table.  */
3924
3925 static struct bfd_link_hash_table *
3926 ppc64_elf_link_hash_table_create (bfd *abfd)
3927 {
3928   struct ppc_link_hash_table *htab;
3929   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3930
3931   htab = bfd_zmalloc (amt);
3932   if (htab == NULL)
3933     return NULL;
3934
3935   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3936                                       sizeof (struct ppc_link_hash_entry),
3937                                       PPC64_ELF_DATA))
3938     {
3939       free (htab);
3940       return NULL;
3941     }
3942
3943   /* Init the stub hash table too.  */
3944   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3945                             sizeof (struct ppc_stub_hash_entry)))
3946     return NULL;
3947
3948   /* And the branch hash table.  */
3949   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3950                             sizeof (struct ppc_branch_hash_entry)))
3951     return NULL;
3952
3953   /* Initializing two fields of the union is just cosmetic.  We really
3954      only care about glist, but when compiled on a 32-bit host the
3955      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3956      debugger inspection of these fields look nicer.  */
3957   htab->elf.init_got_refcount.refcount = 0;
3958   htab->elf.init_got_refcount.glist = NULL;
3959   htab->elf.init_plt_refcount.refcount = 0;
3960   htab->elf.init_plt_refcount.glist = NULL;
3961   htab->elf.init_got_offset.offset = 0;
3962   htab->elf.init_got_offset.glist = NULL;
3963   htab->elf.init_plt_offset.offset = 0;
3964   htab->elf.init_plt_offset.glist = NULL;
3965
3966   return &htab->elf.root;
3967 }
3968
3969 /* Free the derived linker hash table.  */
3970
3971 static void
3972 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3973 {
3974   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3975
3976   bfd_hash_table_free (&ret->stub_hash_table);
3977   bfd_hash_table_free (&ret->branch_hash_table);
3978   _bfd_generic_link_hash_table_free (hash);
3979 }
3980
3981 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3982
3983 void
3984 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3985 {
3986   struct ppc_link_hash_table *htab;
3987
3988   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3989
3990 /* Always hook our dynamic sections into the first bfd, which is the
3991    linker created stub bfd.  This ensures that the GOT header is at
3992    the start of the output TOC section.  */
3993   htab = ppc_hash_table (info);
3994   if (htab == NULL)
3995     return;
3996   htab->stub_bfd = abfd;
3997   htab->elf.dynobj = abfd;
3998 }
3999
4000 /* Build a name for an entry in the stub hash table.  */
4001
4002 static char *
4003 ppc_stub_name (const asection *input_section,
4004                const asection *sym_sec,
4005                const struct ppc_link_hash_entry *h,
4006                const Elf_Internal_Rela *rel)
4007 {
4008   char *stub_name;
4009   bfd_size_type len;
4010
4011   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4012      offsets from a sym as a branch target?  In fact, we could
4013      probably assume the addend is always zero.  */
4014   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4015
4016   if (h)
4017     {
4018       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4019       stub_name = bfd_malloc (len);
4020       if (stub_name == NULL)
4021         return stub_name;
4022
4023       sprintf (stub_name, "%08x.%s+%x",
4024                input_section->id & 0xffffffff,
4025                h->elf.root.root.string,
4026                (int) rel->r_addend & 0xffffffff);
4027     }
4028   else
4029     {
4030       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4031       stub_name = bfd_malloc (len);
4032       if (stub_name == NULL)
4033         return stub_name;
4034
4035       sprintf (stub_name, "%08x.%x:%x+%x",
4036                input_section->id & 0xffffffff,
4037                sym_sec->id & 0xffffffff,
4038                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4039                (int) rel->r_addend & 0xffffffff);
4040     }
4041   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4042     stub_name[len - 2] = 0;
4043   return stub_name;
4044 }
4045
4046 /* Look up an entry in the stub hash.  Stub entries are cached because
4047    creating the stub name takes a bit of time.  */
4048
4049 static struct ppc_stub_hash_entry *
4050 ppc_get_stub_entry (const asection *input_section,
4051                     const asection *sym_sec,
4052                     struct ppc_link_hash_entry *h,
4053                     const Elf_Internal_Rela *rel,
4054                     struct ppc_link_hash_table *htab)
4055 {
4056   struct ppc_stub_hash_entry *stub_entry;
4057   const asection *id_sec;
4058
4059   /* If this input section is part of a group of sections sharing one
4060      stub section, then use the id of the first section in the group.
4061      Stub names need to include a section id, as there may well be
4062      more than one stub used to reach say, printf, and we need to
4063      distinguish between them.  */
4064   id_sec = htab->stub_group[input_section->id].link_sec;
4065
4066   if (h != NULL && h->u.stub_cache != NULL
4067       && h->u.stub_cache->h == h
4068       && h->u.stub_cache->id_sec == id_sec)
4069     {
4070       stub_entry = h->u.stub_cache;
4071     }
4072   else
4073     {
4074       char *stub_name;
4075
4076       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4077       if (stub_name == NULL)
4078         return NULL;
4079
4080       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4081                                          stub_name, FALSE, FALSE);
4082       if (h != NULL)
4083         h->u.stub_cache = stub_entry;
4084
4085       free (stub_name);
4086     }
4087
4088   return stub_entry;
4089 }
4090
4091 /* Add a new stub entry to the stub hash.  Not all fields of the new
4092    stub entry are initialised.  */
4093
4094 static struct ppc_stub_hash_entry *
4095 ppc_add_stub (const char *stub_name,
4096               asection *section,
4097               struct bfd_link_info *info)
4098 {
4099   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4100   asection *link_sec;
4101   asection *stub_sec;
4102   struct ppc_stub_hash_entry *stub_entry;
4103
4104   link_sec = htab->stub_group[section->id].link_sec;
4105   stub_sec = htab->stub_group[section->id].stub_sec;
4106   if (stub_sec == NULL)
4107     {
4108       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4109       if (stub_sec == NULL)
4110         {
4111           size_t namelen;
4112           bfd_size_type len;
4113           char *s_name;
4114
4115           namelen = strlen (link_sec->name);
4116           len = namelen + sizeof (STUB_SUFFIX);
4117           s_name = bfd_alloc (htab->stub_bfd, len);
4118           if (s_name == NULL)
4119             return NULL;
4120
4121           memcpy (s_name, link_sec->name, namelen);
4122           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4123           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4124           if (stub_sec == NULL)
4125             return NULL;
4126           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4127         }
4128       htab->stub_group[section->id].stub_sec = stub_sec;
4129     }
4130
4131   /* Enter this entry into the linker stub hash table.  */
4132   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4133                                      TRUE, FALSE);
4134   if (stub_entry == NULL)
4135     {
4136       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4137                               section->owner, stub_name);
4138       return NULL;
4139     }
4140
4141   stub_entry->stub_sec = stub_sec;
4142   stub_entry->stub_offset = 0;
4143   stub_entry->id_sec = link_sec;
4144   return stub_entry;
4145 }
4146
4147 /* Create sections for linker generated code.  */
4148
4149 static bfd_boolean
4150 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4151 {
4152   struct ppc_link_hash_table *htab;
4153   flagword flags;
4154
4155   htab = ppc_hash_table (info);
4156   if (htab == NULL)
4157     return FALSE;
4158
4159   /* Create .sfpr for code to save and restore fp regs.  */
4160   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4161            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4162   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4163                                                    flags);
4164   if (htab->sfpr == NULL
4165       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4166     return FALSE;
4167
4168   /* Create .glink for lazy dynamic linking support.  */
4169   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4170                                                     flags);
4171   if (htab->glink == NULL
4172       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4173     return FALSE;
4174
4175   if (!info->no_ld_generated_unwind_info)
4176     {
4177       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4178                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4179       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4180                                                                  ".eh_frame",
4181                                                                  flags);
4182       if (htab->glink_eh_frame == NULL
4183           || !bfd_set_section_alignment (abfd, htab->glink_eh_frame, 2))
4184         return FALSE;
4185     }
4186
4187   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4188   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4189   if (htab->iplt == NULL
4190       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4191     return FALSE;
4192
4193   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4194            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4195   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4196                                                       ".rela.iplt",
4197                                                       flags);
4198   if (htab->reliplt == NULL
4199       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4200     return FALSE;
4201
4202   /* Create branch lookup table for plt_branch stubs.  */
4203   flags = (SEC_ALLOC | SEC_LOAD
4204            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4205   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4206                                                    flags);
4207   if (htab->brlt == NULL
4208       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4209     return FALSE;
4210
4211   if (!info->shared)
4212     return TRUE;
4213
4214   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4215            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4216   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4217                                                       ".rela.branch_lt",
4218                                                       flags);
4219   if (htab->relbrlt == NULL
4220       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4221     return FALSE;
4222
4223   return TRUE;
4224 }
4225
4226 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4227    not already done.  */
4228
4229 static bfd_boolean
4230 create_got_section (bfd *abfd, struct bfd_link_info *info)
4231 {
4232   asection *got, *relgot;
4233   flagword flags;
4234   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4235
4236   if (!is_ppc64_elf (abfd))
4237     return FALSE;
4238   if (htab == NULL)
4239     return FALSE;
4240
4241   if (!htab->got)
4242     {
4243       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4244         return FALSE;
4245
4246       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4247       if (!htab->got)
4248         abort ();
4249     }
4250
4251   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4252            | SEC_LINKER_CREATED);
4253
4254   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4255   if (!got
4256       || !bfd_set_section_alignment (abfd, got, 3))
4257     return FALSE;
4258
4259   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4260                                                flags | SEC_READONLY);
4261   if (!relgot
4262       || ! bfd_set_section_alignment (abfd, relgot, 3))
4263     return FALSE;
4264
4265   ppc64_elf_tdata (abfd)->got = got;
4266   ppc64_elf_tdata (abfd)->relgot = relgot;
4267   return TRUE;
4268 }
4269
4270 /* Create the dynamic sections, and set up shortcuts.  */
4271
4272 static bfd_boolean
4273 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4274 {
4275   struct ppc_link_hash_table *htab;
4276
4277   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4278     return FALSE;
4279
4280   htab = ppc_hash_table (info);
4281   if (htab == NULL)
4282     return FALSE;
4283
4284   if (!htab->got)
4285     htab->got = bfd_get_section_by_name (dynobj, ".got");
4286   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4287   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4288   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4289   if (!info->shared)
4290     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4291
4292   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4293       || (!info->shared && !htab->relbss))
4294     abort ();
4295
4296   return TRUE;
4297 }
4298
4299 /* Follow indirect and warning symbol links.  */
4300
4301 static inline struct bfd_link_hash_entry *
4302 follow_link (struct bfd_link_hash_entry *h)
4303 {
4304   while (h->type == bfd_link_hash_indirect
4305          || h->type == bfd_link_hash_warning)
4306     h = h->u.i.link;
4307   return h;
4308 }
4309
4310 static inline struct elf_link_hash_entry *
4311 elf_follow_link (struct elf_link_hash_entry *h)
4312 {
4313   return (struct elf_link_hash_entry *) follow_link (&h->root);
4314 }
4315
4316 static inline struct ppc_link_hash_entry *
4317 ppc_follow_link (struct ppc_link_hash_entry *h)
4318 {
4319   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4320 }
4321
4322 /* Merge PLT info on FROM with that on TO.  */
4323
4324 static void
4325 move_plt_plist (struct ppc_link_hash_entry *from,
4326                 struct ppc_link_hash_entry *to)
4327 {
4328   if (from->elf.plt.plist != NULL)
4329     {
4330       if (to->elf.plt.plist != NULL)
4331         {
4332           struct plt_entry **entp;
4333           struct plt_entry *ent;
4334
4335           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4336             {
4337               struct plt_entry *dent;
4338
4339               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4340                 if (dent->addend == ent->addend)
4341                   {
4342                     dent->plt.refcount += ent->plt.refcount;
4343                     *entp = ent->next;
4344                     break;
4345                   }
4346               if (dent == NULL)
4347                 entp = &ent->next;
4348             }
4349           *entp = to->elf.plt.plist;
4350         }
4351
4352       to->elf.plt.plist = from->elf.plt.plist;
4353       from->elf.plt.plist = NULL;
4354     }
4355 }
4356
4357 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4358
4359 static void
4360 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4361                                 struct elf_link_hash_entry *dir,
4362                                 struct elf_link_hash_entry *ind)
4363 {
4364   struct ppc_link_hash_entry *edir, *eind;
4365
4366   edir = (struct ppc_link_hash_entry *) dir;
4367   eind = (struct ppc_link_hash_entry *) ind;
4368
4369   edir->is_func |= eind->is_func;
4370   edir->is_func_descriptor |= eind->is_func_descriptor;
4371   edir->tls_mask |= eind->tls_mask;
4372   if (eind->oh != NULL)
4373     edir->oh = ppc_follow_link (eind->oh);
4374
4375   /* If called to transfer flags for a weakdef during processing
4376      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4377      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4378   if (!(ELIMINATE_COPY_RELOCS
4379         && eind->elf.root.type != bfd_link_hash_indirect
4380         && edir->elf.dynamic_adjusted))
4381     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4382
4383   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4384   edir->elf.ref_regular |= eind->elf.ref_regular;
4385   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4386   edir->elf.needs_plt |= eind->elf.needs_plt;
4387
4388   /* If we were called to copy over info for a weak sym, that's all.  */
4389   if (eind->elf.root.type != bfd_link_hash_indirect)
4390     return;
4391
4392   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4393   if (eind->dyn_relocs != NULL)
4394     {
4395       if (edir->dyn_relocs != NULL)
4396         {
4397           struct elf_dyn_relocs **pp;
4398           struct elf_dyn_relocs *p;
4399
4400           /* Add reloc counts against the indirect sym to the direct sym
4401              list.  Merge any entries against the same section.  */
4402           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4403             {
4404               struct elf_dyn_relocs *q;
4405
4406               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4407                 if (q->sec == p->sec)
4408                   {
4409                     q->pc_count += p->pc_count;
4410                     q->count += p->count;
4411                     *pp = p->next;
4412                     break;
4413                   }
4414               if (q == NULL)
4415                 pp = &p->next;
4416             }
4417           *pp = edir->dyn_relocs;
4418         }
4419
4420       edir->dyn_relocs = eind->dyn_relocs;
4421       eind->dyn_relocs = NULL;
4422     }
4423
4424   /* Copy over got entries that we may have already seen to the
4425      symbol which just became indirect.  */
4426   if (eind->elf.got.glist != NULL)
4427     {
4428       if (edir->elf.got.glist != NULL)
4429         {
4430           struct got_entry **entp;
4431           struct got_entry *ent;
4432
4433           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4434             {
4435               struct got_entry *dent;
4436
4437               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4438                 if (dent->addend == ent->addend
4439                     && dent->owner == ent->owner
4440                     && dent->tls_type == ent->tls_type)
4441                   {
4442                     dent->got.refcount += ent->got.refcount;
4443                     *entp = ent->next;
4444                     break;
4445                   }
4446               if (dent == NULL)
4447                 entp = &ent->next;
4448             }
4449           *entp = edir->elf.got.glist;
4450         }
4451
4452       edir->elf.got.glist = eind->elf.got.glist;
4453       eind->elf.got.glist = NULL;
4454     }
4455
4456   /* And plt entries.  */
4457   move_plt_plist (eind, edir);
4458
4459   if (eind->elf.dynindx != -1)
4460     {
4461       if (edir->elf.dynindx != -1)
4462         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4463                                 edir->elf.dynstr_index);
4464       edir->elf.dynindx = eind->elf.dynindx;
4465       edir->elf.dynstr_index = eind->elf.dynstr_index;
4466       eind->elf.dynindx = -1;
4467       eind->elf.dynstr_index = 0;
4468     }
4469 }
4470
4471 /* Find the function descriptor hash entry from the given function code
4472    hash entry FH.  Link the entries via their OH fields.  */
4473
4474 static struct ppc_link_hash_entry *
4475 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4476 {
4477   struct ppc_link_hash_entry *fdh = fh->oh;
4478
4479   if (fdh == NULL)
4480     {
4481       const char *fd_name = fh->elf.root.root.string + 1;
4482
4483       fdh = (struct ppc_link_hash_entry *)
4484         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4485       if (fdh == NULL)
4486         return fdh;
4487
4488       fdh->is_func_descriptor = 1;
4489       fdh->oh = fh;
4490       fh->is_func = 1;
4491       fh->oh = fdh;
4492     }
4493
4494   return ppc_follow_link (fdh);
4495 }
4496
4497 /* Make a fake function descriptor sym for the code sym FH.  */
4498
4499 static struct ppc_link_hash_entry *
4500 make_fdh (struct bfd_link_info *info,
4501           struct ppc_link_hash_entry *fh)
4502 {
4503   bfd *abfd;
4504   asymbol *newsym;
4505   struct bfd_link_hash_entry *bh;
4506   struct ppc_link_hash_entry *fdh;
4507
4508   abfd = fh->elf.root.u.undef.abfd;
4509   newsym = bfd_make_empty_symbol (abfd);
4510   newsym->name = fh->elf.root.root.string + 1;
4511   newsym->section = bfd_und_section_ptr;
4512   newsym->value = 0;
4513   newsym->flags = BSF_WEAK;
4514
4515   bh = NULL;
4516   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4517                                          newsym->flags, newsym->section,
4518                                          newsym->value, NULL, FALSE, FALSE,
4519                                          &bh))
4520     return NULL;
4521
4522   fdh = (struct ppc_link_hash_entry *) bh;
4523   fdh->elf.non_elf = 0;
4524   fdh->fake = 1;
4525   fdh->is_func_descriptor = 1;
4526   fdh->oh = fh;
4527   fh->is_func = 1;
4528   fh->oh = fdh;
4529   return fdh;
4530 }
4531
4532 /* Fix function descriptor symbols defined in .opd sections to be
4533    function type.  */
4534
4535 static bfd_boolean
4536 ppc64_elf_add_symbol_hook (bfd *ibfd,
4537                            struct bfd_link_info *info,
4538                            Elf_Internal_Sym *isym,
4539                            const char **name ATTRIBUTE_UNUSED,
4540                            flagword *flags ATTRIBUTE_UNUSED,
4541                            asection **sec,
4542                            bfd_vma *value ATTRIBUTE_UNUSED)
4543 {
4544   if ((ibfd->flags & DYNAMIC) == 0
4545       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4546     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4547
4548   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4549     {
4550       if ((ibfd->flags & DYNAMIC) == 0)
4551         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4552     }
4553   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4554     ;
4555   else if (*sec != NULL
4556            && strcmp ((*sec)->name, ".opd") == 0)
4557     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4558
4559   return TRUE;
4560 }
4561
4562 /* This function makes an old ABI object reference to ".bar" cause the
4563    inclusion of a new ABI object archive that defines "bar".
4564    NAME is a symbol defined in an archive.  Return a symbol in the hash
4565    table that might be satisfied by the archive symbols.  */
4566
4567 static struct elf_link_hash_entry *
4568 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4569                                  struct bfd_link_info *info,
4570                                  const char *name)
4571 {
4572   struct elf_link_hash_entry *h;
4573   char *dot_name;
4574   size_t len;
4575
4576   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4577   if (h != NULL
4578       /* Don't return this sym if it is a fake function descriptor
4579          created by add_symbol_adjust.  */
4580       && !(h->root.type == bfd_link_hash_undefweak
4581            && ((struct ppc_link_hash_entry *) h)->fake))
4582     return h;
4583
4584   if (name[0] == '.')
4585     return h;
4586
4587   len = strlen (name);
4588   dot_name = bfd_alloc (abfd, len + 2);
4589   if (dot_name == NULL)
4590     return (struct elf_link_hash_entry *) 0 - 1;
4591   dot_name[0] = '.';
4592   memcpy (dot_name + 1, name, len + 1);
4593   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4594   bfd_release (abfd, dot_name);
4595   return h;
4596 }
4597
4598 /* This function satisfies all old ABI object references to ".bar" if a
4599    new ABI object defines "bar".  Well, at least, undefined dot symbols
4600    are made weak.  This stops later archive searches from including an
4601    object if we already have a function descriptor definition.  It also
4602    prevents the linker complaining about undefined symbols.
4603    We also check and correct mismatched symbol visibility here.  The
4604    most restrictive visibility of the function descriptor and the
4605    function entry symbol is used.  */
4606
4607 static bfd_boolean
4608 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4609 {
4610   struct ppc_link_hash_table *htab;
4611   struct ppc_link_hash_entry *fdh;
4612
4613   if (eh->elf.root.type == bfd_link_hash_indirect)
4614     return TRUE;
4615
4616   if (eh->elf.root.type == bfd_link_hash_warning)
4617     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4618
4619   if (eh->elf.root.root.string[0] != '.')
4620     abort ();
4621
4622   htab = ppc_hash_table (info);
4623   if (htab == NULL)
4624     return FALSE;
4625
4626   fdh = lookup_fdh (eh, htab);
4627   if (fdh == NULL)
4628     {
4629       if (!info->relocatable
4630           && (eh->elf.root.type == bfd_link_hash_undefined
4631               || eh->elf.root.type == bfd_link_hash_undefweak)
4632           && eh->elf.ref_regular)
4633         {
4634           /* Make an undefweak function descriptor sym, which is enough to
4635              pull in an --as-needed shared lib, but won't cause link
4636              errors.  Archives are handled elsewhere.  */
4637           fdh = make_fdh (info, eh);
4638           if (fdh == NULL)
4639             return FALSE;
4640           fdh->elf.ref_regular = 1;
4641         }
4642     }
4643   else
4644     {
4645       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4646       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4647       if (entry_vis < descr_vis)
4648         fdh->elf.other += entry_vis - descr_vis;
4649       else if (entry_vis > descr_vis)
4650         eh->elf.other += descr_vis - entry_vis;
4651
4652       if ((fdh->elf.root.type == bfd_link_hash_defined
4653            || fdh->elf.root.type == bfd_link_hash_defweak)
4654           && eh->elf.root.type == bfd_link_hash_undefined)
4655         {
4656           eh->elf.root.type = bfd_link_hash_undefweak;
4657           eh->was_undefined = 1;
4658           htab->twiddled_syms = 1;
4659         }
4660     }
4661
4662   return TRUE;
4663 }
4664
4665 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4666
4667 static bfd_boolean
4668 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4669 {
4670   struct ppc_link_hash_table *htab;
4671   struct ppc_link_hash_entry **p, *eh;
4672
4673   if (!is_ppc64_elf (info->output_bfd))
4674     return TRUE;
4675   htab = ppc_hash_table (info);
4676   if (htab == NULL)
4677     return FALSE;
4678
4679   if (is_ppc64_elf (ibfd))
4680     {
4681       p = &htab->dot_syms;
4682       while ((eh = *p) != NULL)
4683         {
4684           *p = NULL;
4685           if (!add_symbol_adjust (eh, info))
4686             return FALSE;
4687           p = &eh->u.next_dot_sym;
4688         }
4689     }
4690
4691   /* Clear the list for non-ppc64 input files.  */
4692   p = &htab->dot_syms;
4693   while ((eh = *p) != NULL)
4694     {
4695       *p = NULL;
4696       p = &eh->u.next_dot_sym;
4697     }
4698
4699   /* We need to fix the undefs list for any syms we have twiddled to
4700      undef_weak.  */
4701   if (htab->twiddled_syms)
4702     {
4703       bfd_link_repair_undef_list (&htab->elf.root);
4704       htab->twiddled_syms = 0;
4705     }
4706   return TRUE;
4707 }
4708
4709 /* Undo hash table changes when an --as-needed input file is determined
4710    not to be needed.  */
4711
4712 static bfd_boolean
4713 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4714                              struct bfd_link_info *info)
4715 {
4716   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4717
4718   if (htab == NULL)
4719     return FALSE;
4720
4721   htab->dot_syms = NULL;
4722   return TRUE;
4723 }
4724
4725 /* If --just-symbols against a final linked binary, then assume we need
4726    toc adjusting stubs when calling functions defined there.  */
4727
4728 static void
4729 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4730 {
4731   if ((sec->flags & SEC_CODE) != 0
4732       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4733       && is_ppc64_elf (sec->owner))
4734     {
4735       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4736       if (got != NULL
4737           && got->size >= elf_backend_got_header_size
4738           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4739         sec->has_toc_reloc = 1;
4740     }
4741   _bfd_elf_link_just_syms (sec, info);
4742 }
4743
4744 static struct plt_entry **
4745 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4746                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4747 {
4748   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4749   struct plt_entry **local_plt;
4750   unsigned char *local_got_tls_masks;
4751
4752   if (local_got_ents == NULL)
4753     {
4754       bfd_size_type size = symtab_hdr->sh_info;
4755
4756       size *= (sizeof (*local_got_ents)
4757                + sizeof (*local_plt)
4758                + sizeof (*local_got_tls_masks));
4759       local_got_ents = bfd_zalloc (abfd, size);
4760       if (local_got_ents == NULL)
4761         return NULL;
4762       elf_local_got_ents (abfd) = local_got_ents;
4763     }
4764
4765   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4766     {
4767       struct got_entry *ent;
4768
4769       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4770         if (ent->addend == r_addend
4771             && ent->owner == abfd
4772             && ent->tls_type == tls_type)
4773           break;
4774       if (ent == NULL)
4775         {
4776           bfd_size_type amt = sizeof (*ent);
4777           ent = bfd_alloc (abfd, amt);
4778           if (ent == NULL)
4779             return FALSE;
4780           ent->next = local_got_ents[r_symndx];
4781           ent->addend = r_addend;
4782           ent->owner = abfd;
4783           ent->tls_type = tls_type;
4784           ent->is_indirect = FALSE;
4785           ent->got.refcount = 0;
4786           local_got_ents[r_symndx] = ent;
4787         }
4788       ent->got.refcount += 1;
4789     }
4790
4791   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4792   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4793   local_got_tls_masks[r_symndx] |= tls_type;
4794
4795   return local_plt + r_symndx;
4796 }
4797
4798 static bfd_boolean
4799 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4800 {
4801   struct plt_entry *ent;
4802
4803   for (ent = *plist; ent != NULL; ent = ent->next)
4804     if (ent->addend == addend)
4805       break;
4806   if (ent == NULL)
4807     {
4808       bfd_size_type amt = sizeof (*ent);
4809       ent = bfd_alloc (abfd, amt);
4810       if (ent == NULL)
4811         return FALSE;
4812       ent->next = *plist;
4813       ent->addend = addend;
4814       ent->plt.refcount = 0;
4815       *plist = ent;
4816     }
4817   ent->plt.refcount += 1;
4818   return TRUE;
4819 }
4820
4821 static bfd_boolean
4822 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4823 {
4824   return (r_type == R_PPC64_REL24
4825           || r_type == R_PPC64_REL14
4826           || r_type == R_PPC64_REL14_BRTAKEN
4827           || r_type == R_PPC64_REL14_BRNTAKEN
4828           || r_type == R_PPC64_ADDR24
4829           || r_type == R_PPC64_ADDR14
4830           || r_type == R_PPC64_ADDR14_BRTAKEN
4831           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4832 }
4833
4834 /* Look through the relocs for a section during the first phase, and
4835    calculate needed space in the global offset table, procedure
4836    linkage table, and dynamic reloc sections.  */
4837
4838 static bfd_boolean
4839 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4840                         asection *sec, const Elf_Internal_Rela *relocs)
4841 {
4842   struct ppc_link_hash_table *htab;
4843   Elf_Internal_Shdr *symtab_hdr;
4844   struct elf_link_hash_entry **sym_hashes;
4845   const Elf_Internal_Rela *rel;
4846   const Elf_Internal_Rela *rel_end;
4847   asection *sreloc;
4848   asection **opd_sym_map;
4849   struct elf_link_hash_entry *tga, *dottga;
4850
4851   if (info->relocatable)
4852     return TRUE;
4853
4854   /* Don't do anything special with non-loaded, non-alloced sections.
4855      In particular, any relocs in such sections should not affect GOT
4856      and PLT reference counting (ie. we don't allow them to create GOT
4857      or PLT entries), there's no possibility or desire to optimize TLS
4858      relocs, and there's not much point in propagating relocs to shared
4859      libs that the dynamic linker won't relocate.  */
4860   if ((sec->flags & SEC_ALLOC) == 0)
4861     return TRUE;
4862
4863   BFD_ASSERT (is_ppc64_elf (abfd));
4864
4865   htab = ppc_hash_table (info);
4866   if (htab == NULL)
4867     return FALSE;
4868
4869   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4870                               FALSE, FALSE, TRUE);
4871   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4872                                  FALSE, FALSE, TRUE);
4873   symtab_hdr = &elf_symtab_hdr (abfd);
4874   sym_hashes = elf_sym_hashes (abfd);
4875   sreloc = NULL;
4876   opd_sym_map = NULL;
4877   if (strcmp (sec->name, ".opd") == 0)
4878     {
4879       /* Garbage collection needs some extra help with .opd sections.
4880          We don't want to necessarily keep everything referenced by
4881          relocs in .opd, as that would keep all functions.  Instead,
4882          if we reference an .opd symbol (a function descriptor), we
4883          want to keep the function code symbol's section.  This is
4884          easy for global symbols, but for local syms we need to keep
4885          information about the associated function section.  */
4886       bfd_size_type amt;
4887
4888       amt = sec->size * sizeof (*opd_sym_map) / 8;
4889       opd_sym_map = bfd_zalloc (abfd, amt);
4890       if (opd_sym_map == NULL)
4891         return FALSE;
4892       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4893       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4894       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4895     }
4896
4897   if (htab->sfpr == NULL
4898       && !create_linkage_sections (htab->elf.dynobj, info))
4899     return FALSE;
4900
4901   rel_end = relocs + sec->reloc_count;
4902   for (rel = relocs; rel < rel_end; rel++)
4903     {
4904       unsigned long r_symndx;
4905       struct elf_link_hash_entry *h;
4906       enum elf_ppc64_reloc_type r_type;
4907       int tls_type;
4908       struct _ppc64_elf_section_data *ppc64_sec;
4909       struct plt_entry **ifunc;
4910
4911       r_symndx = ELF64_R_SYM (rel->r_info);
4912       if (r_symndx < symtab_hdr->sh_info)
4913         h = NULL;
4914       else
4915         {
4916           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4917           h = elf_follow_link (h);
4918         }
4919
4920       tls_type = 0;
4921       ifunc = NULL;
4922       if (h != NULL)
4923         {
4924           if (h->type == STT_GNU_IFUNC)
4925             {
4926               h->needs_plt = 1;
4927               ifunc = &h->plt.plist;
4928             }
4929         }
4930       else
4931         {
4932           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4933                                                           abfd, r_symndx);
4934           if (isym == NULL)
4935             return FALSE;
4936
4937           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4938             {
4939               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4940                                              rel->r_addend, PLT_IFUNC);
4941               if (ifunc == NULL)
4942                 return FALSE;
4943             }
4944         }
4945       r_type = ELF64_R_TYPE (rel->r_info);
4946       if (is_branch_reloc (r_type))
4947         {
4948           if (h != NULL && (h == tga || h == dottga))
4949             {
4950               if (rel != relocs
4951                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4952                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4953                 /* We have a new-style __tls_get_addr call with a marker
4954                    reloc.  */
4955                 ;
4956               else
4957                 /* Mark this section as having an old-style call.  */
4958                 sec->has_tls_get_addr_call = 1;
4959             }
4960
4961           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4962           if (ifunc != NULL
4963               && !update_plt_info (abfd, ifunc, rel->r_addend))
4964             return FALSE;
4965         }
4966
4967       switch (r_type)
4968         {
4969         case R_PPC64_TLSGD:
4970         case R_PPC64_TLSLD:
4971           /* These special tls relocs tie a call to __tls_get_addr with
4972              its parameter symbol.  */
4973           break;
4974
4975         case R_PPC64_GOT_TLSLD16:
4976         case R_PPC64_GOT_TLSLD16_LO:
4977         case R_PPC64_GOT_TLSLD16_HI:
4978         case R_PPC64_GOT_TLSLD16_HA:
4979           tls_type = TLS_TLS | TLS_LD;
4980           goto dogottls;
4981
4982         case R_PPC64_GOT_TLSGD16:
4983         case R_PPC64_GOT_TLSGD16_LO:
4984         case R_PPC64_GOT_TLSGD16_HI:
4985         case R_PPC64_GOT_TLSGD16_HA:
4986           tls_type = TLS_TLS | TLS_GD;
4987           goto dogottls;
4988
4989         case R_PPC64_GOT_TPREL16_DS:
4990         case R_PPC64_GOT_TPREL16_LO_DS:
4991         case R_PPC64_GOT_TPREL16_HI:
4992         case R_PPC64_GOT_TPREL16_HA:
4993           if (!info->executable)
4994             info->flags |= DF_STATIC_TLS;
4995           tls_type = TLS_TLS | TLS_TPREL;
4996           goto dogottls;
4997
4998         case R_PPC64_GOT_DTPREL16_DS:
4999         case R_PPC64_GOT_DTPREL16_LO_DS:
5000         case R_PPC64_GOT_DTPREL16_HI:
5001         case R_PPC64_GOT_DTPREL16_HA:
5002           tls_type = TLS_TLS | TLS_DTPREL;
5003         dogottls:
5004           sec->has_tls_reloc = 1;
5005           /* Fall thru */
5006
5007         case R_PPC64_GOT16:
5008         case R_PPC64_GOT16_DS:
5009         case R_PPC64_GOT16_HA:
5010         case R_PPC64_GOT16_HI:
5011         case R_PPC64_GOT16_LO:
5012         case R_PPC64_GOT16_LO_DS:
5013           /* This symbol requires a global offset table entry.  */
5014           sec->has_toc_reloc = 1;
5015           if (r_type == R_PPC64_GOT_TLSLD16
5016               || r_type == R_PPC64_GOT_TLSGD16
5017               || r_type == R_PPC64_GOT_TPREL16_DS
5018               || r_type == R_PPC64_GOT_DTPREL16_DS
5019               || r_type == R_PPC64_GOT16
5020               || r_type == R_PPC64_GOT16_DS)
5021             {
5022               htab->do_multi_toc = 1;
5023               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5024             }
5025
5026           if (ppc64_elf_tdata (abfd)->got == NULL
5027               && !create_got_section (abfd, info))
5028             return FALSE;
5029
5030           if (h != NULL)
5031             {
5032               struct ppc_link_hash_entry *eh;
5033               struct got_entry *ent;
5034
5035               eh = (struct ppc_link_hash_entry *) h;
5036               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5037                 if (ent->addend == rel->r_addend
5038                     && ent->owner == abfd
5039                     && ent->tls_type == tls_type)
5040                   break;
5041               if (ent == NULL)
5042                 {
5043                   bfd_size_type amt = sizeof (*ent);
5044                   ent = bfd_alloc (abfd, amt);
5045                   if (ent == NULL)
5046                     return FALSE;
5047                   ent->next = eh->elf.got.glist;
5048                   ent->addend = rel->r_addend;
5049                   ent->owner = abfd;
5050                   ent->tls_type = tls_type;
5051                   ent->is_indirect = FALSE;
5052                   ent->got.refcount = 0;
5053                   eh->elf.got.glist = ent;
5054                 }
5055               ent->got.refcount += 1;
5056               eh->tls_mask |= tls_type;
5057             }
5058           else
5059             /* This is a global offset table entry for a local symbol.  */
5060             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5061                                         rel->r_addend, tls_type))
5062               return FALSE;
5063           break;
5064
5065         case R_PPC64_PLT16_HA:
5066         case R_PPC64_PLT16_HI:
5067         case R_PPC64_PLT16_LO:
5068         case R_PPC64_PLT32:
5069         case R_PPC64_PLT64:
5070           /* This symbol requires a procedure linkage table entry.  We
5071              actually build the entry in adjust_dynamic_symbol,
5072              because this might be a case of linking PIC code without
5073              linking in any dynamic objects, in which case we don't
5074              need to generate a procedure linkage table after all.  */
5075           if (h == NULL)
5076             {
5077               /* It does not make sense to have a procedure linkage
5078                  table entry for a local symbol.  */
5079               bfd_set_error (bfd_error_bad_value);
5080               return FALSE;
5081             }
5082           else
5083             {
5084               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5085                 return FALSE;
5086               h->needs_plt = 1;
5087               if (h->root.root.string[0] == '.'
5088                   && h->root.root.string[1] != '\0')
5089                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5090             }
5091           break;
5092
5093           /* The following relocations don't need to propagate the
5094              relocation if linking a shared object since they are
5095              section relative.  */
5096         case R_PPC64_SECTOFF:
5097         case R_PPC64_SECTOFF_LO:
5098         case R_PPC64_SECTOFF_HI:
5099         case R_PPC64_SECTOFF_HA:
5100         case R_PPC64_SECTOFF_DS:
5101         case R_PPC64_SECTOFF_LO_DS:
5102         case R_PPC64_DTPREL16:
5103         case R_PPC64_DTPREL16_LO:
5104         case R_PPC64_DTPREL16_HI:
5105         case R_PPC64_DTPREL16_HA:
5106         case R_PPC64_DTPREL16_DS:
5107         case R_PPC64_DTPREL16_LO_DS:
5108         case R_PPC64_DTPREL16_HIGHER:
5109         case R_PPC64_DTPREL16_HIGHERA:
5110         case R_PPC64_DTPREL16_HIGHEST:
5111         case R_PPC64_DTPREL16_HIGHESTA:
5112           break;
5113
5114           /* Nor do these.  */
5115         case R_PPC64_REL16:
5116         case R_PPC64_REL16_LO:
5117         case R_PPC64_REL16_HI:
5118         case R_PPC64_REL16_HA:
5119           break;
5120
5121         case R_PPC64_TOC16:
5122         case R_PPC64_TOC16_DS:
5123           htab->do_multi_toc = 1;
5124           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5125         case R_PPC64_TOC16_LO:
5126         case R_PPC64_TOC16_HI:
5127         case R_PPC64_TOC16_HA:
5128         case R_PPC64_TOC16_LO_DS:
5129           sec->has_toc_reloc = 1;
5130           break;
5131
5132           /* This relocation describes the C++ object vtable hierarchy.
5133              Reconstruct it for later use during GC.  */
5134         case R_PPC64_GNU_VTINHERIT:
5135           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5136             return FALSE;
5137           break;
5138
5139           /* This relocation describes which C++ vtable entries are actually
5140              used.  Record for later use during GC.  */
5141         case R_PPC64_GNU_VTENTRY:
5142           BFD_ASSERT (h != NULL);
5143           if (h != NULL
5144               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5145             return FALSE;
5146           break;
5147
5148         case R_PPC64_REL14:
5149         case R_PPC64_REL14_BRTAKEN:
5150         case R_PPC64_REL14_BRNTAKEN:
5151           {
5152             asection *dest = NULL;
5153
5154             /* Heuristic: If jumping outside our section, chances are
5155                we are going to need a stub.  */
5156             if (h != NULL)
5157               {
5158                 /* If the sym is weak it may be overridden later, so
5159                    don't assume we know where a weak sym lives.  */
5160                 if (h->root.type == bfd_link_hash_defined)
5161                   dest = h->root.u.def.section;
5162               }
5163             else
5164               {
5165                 Elf_Internal_Sym *isym;
5166
5167                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5168                                               abfd, r_symndx);
5169                 if (isym == NULL)
5170                   return FALSE;
5171
5172                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5173               }
5174
5175             if (dest != sec)
5176               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5177           }
5178           /* Fall through.  */
5179
5180         case R_PPC64_REL24:
5181           if (h != NULL && ifunc == NULL)
5182             {
5183               /* We may need a .plt entry if the function this reloc
5184                  refers to is in a shared lib.  */
5185               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5186                 return FALSE;
5187               h->needs_plt = 1;
5188               if (h->root.root.string[0] == '.'
5189                   && h->root.root.string[1] != '\0')
5190                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5191               if (h == tga || h == dottga)
5192                 sec->has_tls_reloc = 1;
5193             }
5194           break;
5195
5196         case R_PPC64_TPREL64:
5197           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5198           if (!info->executable)
5199             info->flags |= DF_STATIC_TLS;
5200           goto dotlstoc;
5201
5202         case R_PPC64_DTPMOD64:
5203           if (rel + 1 < rel_end
5204               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5205               && rel[1].r_offset == rel->r_offset + 8)
5206             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5207           else
5208             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5209           goto dotlstoc;
5210
5211         case R_PPC64_DTPREL64:
5212           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5213           if (rel != relocs
5214               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5215               && rel[-1].r_offset == rel->r_offset - 8)
5216             /* This is the second reloc of a dtpmod, dtprel pair.
5217                Don't mark with TLS_DTPREL.  */
5218             goto dodyn;
5219
5220         dotlstoc:
5221           sec->has_tls_reloc = 1;
5222           if (h != NULL)
5223             {
5224               struct ppc_link_hash_entry *eh;
5225               eh = (struct ppc_link_hash_entry *) h;
5226               eh->tls_mask |= tls_type;
5227             }
5228           else
5229             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5230                                         rel->r_addend, tls_type))
5231               return FALSE;
5232
5233           ppc64_sec = ppc64_elf_section_data (sec);
5234           if (ppc64_sec->sec_type != sec_toc)
5235             {
5236               bfd_size_type amt;
5237
5238               /* One extra to simplify get_tls_mask.  */
5239               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5240               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5241               if (ppc64_sec->u.toc.symndx == NULL)
5242                 return FALSE;
5243               amt = sec->size * sizeof (bfd_vma) / 8;
5244               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5245               if (ppc64_sec->u.toc.add == NULL)
5246                 return FALSE;
5247               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5248               ppc64_sec->sec_type = sec_toc;
5249             }
5250           BFD_ASSERT (rel->r_offset % 8 == 0);
5251           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5252           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5253
5254           /* Mark the second slot of a GD or LD entry.
5255              -1 to indicate GD and -2 to indicate LD.  */
5256           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5257             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5258           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5259             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5260           goto dodyn;
5261
5262         case R_PPC64_TPREL16:
5263         case R_PPC64_TPREL16_LO:
5264         case R_PPC64_TPREL16_HI:
5265         case R_PPC64_TPREL16_HA:
5266         case R_PPC64_TPREL16_DS:
5267         case R_PPC64_TPREL16_LO_DS:
5268         case R_PPC64_TPREL16_HIGHER:
5269         case R_PPC64_TPREL16_HIGHERA:
5270         case R_PPC64_TPREL16_HIGHEST:
5271         case R_PPC64_TPREL16_HIGHESTA:
5272           if (info->shared)
5273             {
5274               if (!info->executable)
5275                 info->flags |= DF_STATIC_TLS;
5276               goto dodyn;
5277             }
5278           break;
5279
5280         case R_PPC64_ADDR64:
5281           if (opd_sym_map != NULL
5282               && rel + 1 < rel_end
5283               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5284             {
5285               if (h != NULL)
5286                 {
5287                   if (h->root.root.string[0] == '.'
5288                       && h->root.root.string[1] != 0
5289                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5290                     ;
5291                   else
5292                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5293                 }
5294               else
5295                 {
5296                   asection *s;
5297                   Elf_Internal_Sym *isym;
5298
5299                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5300                                                 abfd, r_symndx);
5301                   if (isym == NULL)
5302                     return FALSE;
5303
5304                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5305                   if (s != NULL && s != sec)
5306                     opd_sym_map[rel->r_offset / 8] = s;
5307                 }
5308             }
5309           /* Fall through.  */
5310
5311         case R_PPC64_REL30:
5312         case R_PPC64_REL32:
5313         case R_PPC64_REL64:
5314         case R_PPC64_ADDR14:
5315         case R_PPC64_ADDR14_BRNTAKEN:
5316         case R_PPC64_ADDR14_BRTAKEN:
5317         case R_PPC64_ADDR16:
5318         case R_PPC64_ADDR16_DS:
5319         case R_PPC64_ADDR16_HA:
5320         case R_PPC64_ADDR16_HI:
5321         case R_PPC64_ADDR16_HIGHER:
5322         case R_PPC64_ADDR16_HIGHERA:
5323         case R_PPC64_ADDR16_HIGHEST:
5324         case R_PPC64_ADDR16_HIGHESTA:
5325         case R_PPC64_ADDR16_LO:
5326         case R_PPC64_ADDR16_LO_DS:
5327         case R_PPC64_ADDR24:
5328         case R_PPC64_ADDR32:
5329         case R_PPC64_UADDR16:
5330         case R_PPC64_UADDR32:
5331         case R_PPC64_UADDR64:
5332         case R_PPC64_TOC:
5333           if (h != NULL && !info->shared)
5334             /* We may need a copy reloc.  */
5335             h->non_got_ref = 1;
5336
5337           /* Don't propagate .opd relocs.  */
5338           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5339             break;
5340
5341           /* If we are creating a shared library, and this is a reloc
5342              against a global symbol, or a non PC relative reloc
5343              against a local symbol, then we need to copy the reloc
5344              into the shared library.  However, if we are linking with
5345              -Bsymbolic, we do not need to copy a reloc against a
5346              global symbol which is defined in an object we are
5347              including in the link (i.e., DEF_REGULAR is set).  At
5348              this point we have not seen all the input files, so it is
5349              possible that DEF_REGULAR is not set now but will be set
5350              later (it is never cleared).  In case of a weak definition,
5351              DEF_REGULAR may be cleared later by a strong definition in
5352              a shared library.  We account for that possibility below by
5353              storing information in the dyn_relocs field of the hash
5354              table entry.  A similar situation occurs when creating
5355              shared libraries and symbol visibility changes render the
5356              symbol local.
5357
5358              If on the other hand, we are creating an executable, we
5359              may need to keep relocations for symbols satisfied by a
5360              dynamic library if we manage to avoid copy relocs for the
5361              symbol.  */
5362         dodyn:
5363           if ((info->shared
5364                && (must_be_dyn_reloc (info, r_type)
5365                    || (h != NULL
5366                        && (! info->symbolic
5367                            || h->root.type == bfd_link_hash_defweak
5368                            || !h->def_regular))))
5369               || (ELIMINATE_COPY_RELOCS
5370                   && !info->shared
5371                   && h != NULL
5372                   && (h->root.type == bfd_link_hash_defweak
5373                       || !h->def_regular))
5374               || (!info->shared
5375                   && ifunc != NULL))
5376             {
5377               struct elf_dyn_relocs *p;
5378               struct elf_dyn_relocs **head;
5379
5380               /* We must copy these reloc types into the output file.
5381                  Create a reloc section in dynobj and make room for
5382                  this reloc.  */
5383               if (sreloc == NULL)
5384                 {
5385                   sreloc = _bfd_elf_make_dynamic_reloc_section
5386                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5387
5388                   if (sreloc == NULL)
5389                     return FALSE;
5390                 }
5391
5392               /* If this is a global symbol, we count the number of
5393                  relocations we need for this symbol.  */
5394               if (h != NULL)
5395                 {
5396                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5397                 }
5398               else
5399                 {
5400                   /* Track dynamic relocs needed for local syms too.
5401                      We really need local syms available to do this
5402                      easily.  Oh well.  */
5403                   asection *s;
5404                   void *vpp;
5405                   Elf_Internal_Sym *isym;
5406
5407                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5408                                                 abfd, r_symndx);
5409                   if (isym == NULL)
5410                     return FALSE;
5411
5412                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5413                   if (s == NULL)
5414                     s = sec;
5415
5416                   vpp = &elf_section_data (s)->local_dynrel;
5417                   head = (struct elf_dyn_relocs **) vpp;
5418                 }
5419
5420               p = *head;
5421               if (p == NULL || p->sec != sec)
5422                 {
5423                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5424                   if (p == NULL)
5425                     return FALSE;
5426                   p->next = *head;
5427                   *head = p;
5428                   p->sec = sec;
5429                   p->count = 0;
5430                   p->pc_count = 0;
5431                 }
5432
5433               p->count += 1;
5434               if (!must_be_dyn_reloc (info, r_type))
5435                 p->pc_count += 1;
5436             }
5437           break;
5438
5439         default:
5440           break;
5441         }
5442     }
5443
5444   return TRUE;
5445 }
5446
5447 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5448    of the code entry point, and its section.  */
5449
5450 static bfd_vma
5451 opd_entry_value (asection *opd_sec,
5452                  bfd_vma offset,
5453                  asection **code_sec,
5454                  bfd_vma *code_off)
5455 {
5456   bfd *opd_bfd = opd_sec->owner;
5457   Elf_Internal_Rela *relocs;
5458   Elf_Internal_Rela *lo, *hi, *look;
5459   bfd_vma val;
5460
5461   /* No relocs implies we are linking a --just-symbols object.  */
5462   if (opd_sec->reloc_count == 0)
5463     {
5464       char buf[8];
5465
5466       if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5467         return (bfd_vma) -1;
5468
5469       val = bfd_get_64 (opd_bfd, buf);
5470       if (code_sec != NULL)
5471         {
5472           asection *sec, *likely = NULL;
5473           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5474             if (sec->vma <= val
5475                 && (sec->flags & SEC_LOAD) != 0
5476                 && (sec->flags & SEC_ALLOC) != 0)
5477               likely = sec;
5478           if (likely != NULL)
5479             {
5480               *code_sec = likely;
5481               if (code_off != NULL)
5482                 *code_off = val - likely->vma;
5483             }
5484         }
5485       return val;
5486     }
5487
5488   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5489
5490   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5491   if (relocs == NULL)
5492     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5493
5494   /* Go find the opd reloc at the sym address.  */
5495   lo = relocs;
5496   BFD_ASSERT (lo != NULL);
5497   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5498   val = (bfd_vma) -1;
5499   while (lo < hi)
5500     {
5501       look = lo + (hi - lo) / 2;
5502       if (look->r_offset < offset)
5503         lo = look + 1;
5504       else if (look->r_offset > offset)
5505         hi = look;
5506       else
5507         {
5508           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5509
5510           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5511               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5512             {
5513               unsigned long symndx = ELF64_R_SYM (look->r_info);
5514               asection *sec;
5515
5516               if (symndx < symtab_hdr->sh_info)
5517                 {
5518                   Elf_Internal_Sym *sym;
5519
5520                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5521                   if (sym == NULL)
5522                     {
5523                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5524                                                   symtab_hdr->sh_info,
5525                                                   0, NULL, NULL, NULL);
5526                       if (sym == NULL)
5527                         break;
5528                       symtab_hdr->contents = (bfd_byte *) sym;
5529                     }
5530
5531                   sym += symndx;
5532                   val = sym->st_value;
5533                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5534                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5535                 }
5536               else
5537                 {
5538                   struct elf_link_hash_entry **sym_hashes;
5539                   struct elf_link_hash_entry *rh;
5540
5541                   sym_hashes = elf_sym_hashes (opd_bfd);
5542                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5543                   rh = elf_follow_link (rh);
5544                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5545                               || rh->root.type == bfd_link_hash_defweak);
5546                   val = rh->root.u.def.value;
5547                   sec = rh->root.u.def.section;
5548                 }
5549               val += look->r_addend;
5550               if (code_off != NULL)
5551                 *code_off = val;
5552               if (code_sec != NULL)
5553                 *code_sec = sec;
5554               if (sec != NULL && sec->output_section != NULL)
5555                 val += sec->output_section->vma + sec->output_offset;
5556             }
5557           break;
5558         }
5559     }
5560
5561   return val;
5562 }
5563
5564 /* Return true if symbol is defined in a regular object file.  */
5565
5566 static bfd_boolean
5567 is_static_defined (struct elf_link_hash_entry *h)
5568 {
5569   return ((h->root.type == bfd_link_hash_defined
5570            || h->root.type == bfd_link_hash_defweak)
5571           && h->root.u.def.section != NULL
5572           && h->root.u.def.section->output_section != NULL);
5573 }
5574
5575 /* If FDH is a function descriptor symbol, return the associated code
5576    entry symbol if it is defined.  Return NULL otherwise.  */
5577
5578 static struct ppc_link_hash_entry *
5579 defined_code_entry (struct ppc_link_hash_entry *fdh)
5580 {
5581   if (fdh->is_func_descriptor)
5582     {
5583       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5584       if (fh->elf.root.type == bfd_link_hash_defined
5585           || fh->elf.root.type == bfd_link_hash_defweak)
5586         return fh;
5587     }
5588   return NULL;
5589 }
5590
5591 /* If FH is a function code entry symbol, return the associated
5592    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5593
5594 static struct ppc_link_hash_entry *
5595 defined_func_desc (struct ppc_link_hash_entry *fh)
5596 {
5597   if (fh->oh != NULL
5598       && fh->oh->is_func_descriptor)
5599     {
5600       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5601       if (fdh->elf.root.type == bfd_link_hash_defined
5602           || fdh->elf.root.type == bfd_link_hash_defweak)
5603         return fdh;
5604     }
5605   return NULL;
5606 }
5607
5608 /* Mark all our entry sym sections, both opd and code section.  */
5609
5610 static void
5611 ppc64_elf_gc_keep (struct bfd_link_info *info)
5612 {
5613   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5614   struct bfd_sym_chain *sym;
5615
5616   if (htab == NULL)
5617     return;
5618
5619   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5620     {
5621       struct ppc_link_hash_entry *eh, *fh;
5622       asection *sec;
5623
5624       eh = (struct ppc_link_hash_entry *)
5625         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5626       if (eh == NULL)
5627         continue;
5628       if (eh->elf.root.type != bfd_link_hash_defined
5629           && eh->elf.root.type != bfd_link_hash_defweak)
5630         continue;
5631
5632       fh = defined_code_entry (eh);
5633       if (fh != NULL)
5634         {
5635           sec = fh->elf.root.u.def.section;
5636           sec->flags |= SEC_KEEP;
5637         }
5638       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5639                && opd_entry_value (eh->elf.root.u.def.section,
5640                                    eh->elf.root.u.def.value,
5641                                    &sec, NULL) != (bfd_vma) -1)
5642         sec->flags |= SEC_KEEP;
5643
5644       sec = eh->elf.root.u.def.section;
5645       sec->flags |= SEC_KEEP;
5646     }
5647 }
5648
5649 /* Mark sections containing dynamically referenced symbols.  When
5650    building shared libraries, we must assume that any visible symbol is
5651    referenced.  */
5652
5653 static bfd_boolean
5654 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5655 {
5656   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5657   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5658   struct ppc_link_hash_entry *fdh;
5659
5660   /* Dynamic linking info is on the func descriptor sym.  */
5661   fdh = defined_func_desc (eh);
5662   if (fdh != NULL)
5663     eh = fdh;
5664
5665   if ((eh->elf.root.type == bfd_link_hash_defined
5666        || eh->elf.root.type == bfd_link_hash_defweak)
5667       && (eh->elf.ref_dynamic
5668           || (!info->executable
5669               && eh->elf.def_regular
5670               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5671               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5672     {
5673       asection *code_sec;
5674       struct ppc_link_hash_entry *fh;
5675
5676       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5677
5678       /* Function descriptor syms cause the associated
5679          function code sym section to be marked.  */
5680       fh = defined_code_entry (eh);
5681       if (fh != NULL)
5682         {
5683           code_sec = fh->elf.root.u.def.section;
5684           code_sec->flags |= SEC_KEEP;
5685         }
5686       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5687                && opd_entry_value (eh->elf.root.u.def.section,
5688                                    eh->elf.root.u.def.value,
5689                                    &code_sec, NULL) != (bfd_vma) -1)
5690         code_sec->flags |= SEC_KEEP;
5691     }
5692
5693   return TRUE;
5694 }
5695
5696 /* Return the section that should be marked against GC for a given
5697    relocation.  */
5698
5699 static asection *
5700 ppc64_elf_gc_mark_hook (asection *sec,
5701                         struct bfd_link_info *info,
5702                         Elf_Internal_Rela *rel,
5703                         struct elf_link_hash_entry *h,
5704                         Elf_Internal_Sym *sym)
5705 {
5706   asection *rsec;
5707
5708   /* Syms return NULL if we're marking .opd, so we avoid marking all
5709      function sections, as all functions are referenced in .opd.  */
5710   rsec = NULL;
5711   if (get_opd_info (sec) != NULL)
5712     return rsec;
5713
5714   if (h != NULL)
5715     {
5716       enum elf_ppc64_reloc_type r_type;
5717       struct ppc_link_hash_entry *eh, *fh, *fdh;
5718
5719       r_type = ELF64_R_TYPE (rel->r_info);
5720       switch (r_type)
5721         {
5722         case R_PPC64_GNU_VTINHERIT:
5723         case R_PPC64_GNU_VTENTRY:
5724           break;
5725
5726         default:
5727           switch (h->root.type)
5728             {
5729             case bfd_link_hash_defined:
5730             case bfd_link_hash_defweak:
5731               eh = (struct ppc_link_hash_entry *) h;
5732               fdh = defined_func_desc (eh);
5733               if (fdh != NULL)
5734                 eh = fdh;
5735
5736               /* Function descriptor syms cause the associated
5737                  function code sym section to be marked.  */
5738               fh = defined_code_entry (eh);
5739               if (fh != NULL)
5740                 {
5741                   /* They also mark their opd section.  */
5742                   eh->elf.root.u.def.section->gc_mark = 1;
5743
5744                   rsec = fh->elf.root.u.def.section;
5745                 }
5746               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5747                        && opd_entry_value (eh->elf.root.u.def.section,
5748                                            eh->elf.root.u.def.value,
5749                                            &rsec, NULL) != (bfd_vma) -1)
5750                 eh->elf.root.u.def.section->gc_mark = 1;
5751               else
5752                 rsec = h->root.u.def.section;
5753               break;
5754
5755             case bfd_link_hash_common:
5756               rsec = h->root.u.c.p->section;
5757               break;
5758
5759             default:
5760               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5761             }
5762         }
5763     }
5764   else
5765     {
5766       struct _opd_sec_data *opd;
5767
5768       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5769       opd = get_opd_info (rsec);
5770       if (opd != NULL && opd->func_sec != NULL)
5771         {
5772           rsec->gc_mark = 1;
5773
5774           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5775         }
5776     }
5777
5778   return rsec;
5779 }
5780
5781 /* Update the .got, .plt. and dynamic reloc reference counts for the
5782    section being removed.  */
5783
5784 static bfd_boolean
5785 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5786                          asection *sec, const Elf_Internal_Rela *relocs)
5787 {
5788   struct ppc_link_hash_table *htab;
5789   Elf_Internal_Shdr *symtab_hdr;
5790   struct elf_link_hash_entry **sym_hashes;
5791   struct got_entry **local_got_ents;
5792   const Elf_Internal_Rela *rel, *relend;
5793
5794   if (info->relocatable)
5795     return TRUE;
5796
5797   if ((sec->flags & SEC_ALLOC) == 0)
5798     return TRUE;
5799
5800   elf_section_data (sec)->local_dynrel = NULL;
5801
5802   htab = ppc_hash_table (info);
5803   if (htab == NULL)
5804     return FALSE;
5805
5806   symtab_hdr = &elf_symtab_hdr (abfd);
5807   sym_hashes = elf_sym_hashes (abfd);
5808   local_got_ents = elf_local_got_ents (abfd);
5809
5810   relend = relocs + sec->reloc_count;
5811   for (rel = relocs; rel < relend; rel++)
5812     {
5813       unsigned long r_symndx;
5814       enum elf_ppc64_reloc_type r_type;
5815       struct elf_link_hash_entry *h = NULL;
5816       unsigned char tls_type = 0;
5817
5818       r_symndx = ELF64_R_SYM (rel->r_info);
5819       r_type = ELF64_R_TYPE (rel->r_info);
5820       if (r_symndx >= symtab_hdr->sh_info)
5821         {
5822           struct ppc_link_hash_entry *eh;
5823           struct elf_dyn_relocs **pp;
5824           struct elf_dyn_relocs *p;
5825
5826           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5827           h = elf_follow_link (h);
5828           eh = (struct ppc_link_hash_entry *) h;
5829
5830           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5831             if (p->sec == sec)
5832               {
5833                 /* Everything must go for SEC.  */
5834                 *pp = p->next;
5835                 break;
5836               }
5837         }
5838
5839       if (is_branch_reloc (r_type))
5840         {
5841           struct plt_entry **ifunc = NULL;
5842           if (h != NULL)
5843             {
5844               if (h->type == STT_GNU_IFUNC)
5845                 ifunc = &h->plt.plist;
5846             }
5847           else if (local_got_ents != NULL)
5848             {
5849               struct plt_entry **local_plt = (struct plt_entry **)
5850                 (local_got_ents + symtab_hdr->sh_info);
5851               unsigned char *local_got_tls_masks = (unsigned char *)
5852                 (local_plt + symtab_hdr->sh_info);
5853               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5854                 ifunc = local_plt + r_symndx;
5855             }
5856           if (ifunc != NULL)
5857             {
5858               struct plt_entry *ent;
5859
5860               for (ent = *ifunc; ent != NULL; ent = ent->next)
5861                 if (ent->addend == rel->r_addend)
5862                   break;
5863               if (ent == NULL)
5864                 abort ();
5865               if (ent->plt.refcount > 0)
5866                 ent->plt.refcount -= 1;
5867               continue;
5868             }
5869         }
5870
5871       switch (r_type)
5872         {
5873         case R_PPC64_GOT_TLSLD16:
5874         case R_PPC64_GOT_TLSLD16_LO:
5875         case R_PPC64_GOT_TLSLD16_HI:
5876         case R_PPC64_GOT_TLSLD16_HA:
5877           tls_type = TLS_TLS | TLS_LD;
5878           goto dogot;
5879
5880         case R_PPC64_GOT_TLSGD16:
5881         case R_PPC64_GOT_TLSGD16_LO:
5882         case R_PPC64_GOT_TLSGD16_HI:
5883         case R_PPC64_GOT_TLSGD16_HA:
5884           tls_type = TLS_TLS | TLS_GD;
5885           goto dogot;
5886
5887         case R_PPC64_GOT_TPREL16_DS:
5888         case R_PPC64_GOT_TPREL16_LO_DS:
5889         case R_PPC64_GOT_TPREL16_HI:
5890         case R_PPC64_GOT_TPREL16_HA:
5891           tls_type = TLS_TLS | TLS_TPREL;
5892           goto dogot;
5893
5894         case R_PPC64_GOT_DTPREL16_DS:
5895         case R_PPC64_GOT_DTPREL16_LO_DS:
5896         case R_PPC64_GOT_DTPREL16_HI:
5897         case R_PPC64_GOT_DTPREL16_HA:
5898           tls_type = TLS_TLS | TLS_DTPREL;
5899           goto dogot;
5900
5901         case R_PPC64_GOT16:
5902         case R_PPC64_GOT16_DS:
5903         case R_PPC64_GOT16_HA:
5904         case R_PPC64_GOT16_HI:
5905         case R_PPC64_GOT16_LO:
5906         case R_PPC64_GOT16_LO_DS:
5907         dogot:
5908           {
5909             struct got_entry *ent;
5910
5911             if (h != NULL)
5912               ent = h->got.glist;
5913             else
5914               ent = local_got_ents[r_symndx];
5915
5916             for (; ent != NULL; ent = ent->next)
5917               if (ent->addend == rel->r_addend
5918                   && ent->owner == abfd
5919                   && ent->tls_type == tls_type)
5920                 break;
5921             if (ent == NULL)
5922               abort ();
5923             if (ent->got.refcount > 0)
5924               ent->got.refcount -= 1;
5925           }
5926           break;
5927
5928         case R_PPC64_PLT16_HA:
5929         case R_PPC64_PLT16_HI:
5930         case R_PPC64_PLT16_LO:
5931         case R_PPC64_PLT32:
5932         case R_PPC64_PLT64:
5933         case R_PPC64_REL14:
5934         case R_PPC64_REL14_BRNTAKEN:
5935         case R_PPC64_REL14_BRTAKEN:
5936         case R_PPC64_REL24:
5937           if (h != NULL)
5938             {
5939               struct plt_entry *ent;
5940
5941               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5942                 if (ent->addend == rel->r_addend)
5943                   break;
5944               if (ent != NULL && ent->plt.refcount > 0)
5945                 ent->plt.refcount -= 1;
5946             }
5947           break;
5948
5949         default:
5950           break;
5951         }
5952     }
5953   return TRUE;
5954 }
5955
5956 /* The maximum size of .sfpr.  */
5957 #define SFPR_MAX (218*4)
5958
5959 struct sfpr_def_parms
5960 {
5961   const char name[12];
5962   unsigned char lo, hi;
5963   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5964   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5965 };
5966
5967 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5968
5969 static bfd_boolean
5970 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5971 {
5972   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5973   unsigned int i;
5974   size_t len = strlen (parm->name);
5975   bfd_boolean writing = FALSE;
5976   char sym[16];
5977
5978   if (htab == NULL)
5979     return FALSE;
5980
5981   memcpy (sym, parm->name, len);
5982   sym[len + 2] = 0;
5983
5984   for (i = parm->lo; i <= parm->hi; i++)
5985     {
5986       struct elf_link_hash_entry *h;
5987
5988       sym[len + 0] = i / 10 + '0';
5989       sym[len + 1] = i % 10 + '0';
5990       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5991       if (h != NULL
5992           && !h->def_regular)
5993         {
5994           h->root.type = bfd_link_hash_defined;
5995           h->root.u.def.section = htab->sfpr;
5996           h->root.u.def.value = htab->sfpr->size;
5997           h->type = STT_FUNC;
5998           h->def_regular = 1;
5999           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6000           writing = TRUE;
6001           if (htab->sfpr->contents == NULL)
6002             {
6003               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6004               if (htab->sfpr->contents == NULL)
6005                 return FALSE;
6006             }
6007         }
6008       if (writing)
6009         {
6010           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6011           if (i != parm->hi)
6012             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6013           else
6014             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6015           htab->sfpr->size = p - htab->sfpr->contents;
6016         }
6017     }
6018
6019   return TRUE;
6020 }
6021
6022 static bfd_byte *
6023 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6024 {
6025   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6026   return p + 4;
6027 }
6028
6029 static bfd_byte *
6030 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6031 {
6032   p = savegpr0 (abfd, p, r);
6033   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6034   p = p + 4;
6035   bfd_put_32 (abfd, BLR, p);
6036   return p + 4;
6037 }
6038
6039 static bfd_byte *
6040 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6041 {
6042   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6043   return p + 4;
6044 }
6045
6046 static bfd_byte *
6047 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6048 {
6049   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6050   p = p + 4;
6051   p = restgpr0 (abfd, p, r);
6052   bfd_put_32 (abfd, MTLR_R0, p);
6053   p = p + 4;
6054   if (r == 29)
6055     {
6056       p = restgpr0 (abfd, p, 30);
6057       p = restgpr0 (abfd, p, 31);
6058     }
6059   bfd_put_32 (abfd, BLR, p);
6060   return p + 4;
6061 }
6062
6063 static bfd_byte *
6064 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6065 {
6066   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6067   return p + 4;
6068 }
6069
6070 static bfd_byte *
6071 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6072 {
6073   p = savegpr1 (abfd, p, r);
6074   bfd_put_32 (abfd, BLR, p);
6075   return p + 4;
6076 }
6077
6078 static bfd_byte *
6079 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6080 {
6081   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6082   return p + 4;
6083 }
6084
6085 static bfd_byte *
6086 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6087 {
6088   p = restgpr1 (abfd, p, r);
6089   bfd_put_32 (abfd, BLR, p);
6090   return p + 4;
6091 }
6092
6093 static bfd_byte *
6094 savefpr (bfd *abfd, bfd_byte *p, int r)
6095 {
6096   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6097   return p + 4;
6098 }
6099
6100 static bfd_byte *
6101 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6102 {
6103   p = savefpr (abfd, p, r);
6104   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6105   p = p + 4;
6106   bfd_put_32 (abfd, BLR, p);
6107   return p + 4;
6108 }
6109
6110 static bfd_byte *
6111 restfpr (bfd *abfd, bfd_byte *p, int r)
6112 {
6113   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6114   return p + 4;
6115 }
6116
6117 static bfd_byte *
6118 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6119 {
6120   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6121   p = p + 4;
6122   p = restfpr (abfd, p, r);
6123   bfd_put_32 (abfd, MTLR_R0, p);
6124   p = p + 4;
6125   if (r == 29)
6126     {
6127       p = restfpr (abfd, p, 30);
6128       p = restfpr (abfd, p, 31);
6129     }
6130   bfd_put_32 (abfd, BLR, p);
6131   return p + 4;
6132 }
6133
6134 static bfd_byte *
6135 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6136 {
6137   p = savefpr (abfd, p, r);
6138   bfd_put_32 (abfd, BLR, p);
6139   return p + 4;
6140 }
6141
6142 static bfd_byte *
6143 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6144 {
6145   p = restfpr (abfd, p, r);
6146   bfd_put_32 (abfd, BLR, p);
6147   return p + 4;
6148 }
6149
6150 static bfd_byte *
6151 savevr (bfd *abfd, bfd_byte *p, int r)
6152 {
6153   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6154   p = p + 4;
6155   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6156   return p + 4;
6157 }
6158
6159 static bfd_byte *
6160 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6161 {
6162   p = savevr (abfd, p, r);
6163   bfd_put_32 (abfd, BLR, p);
6164   return p + 4;
6165 }
6166
6167 static bfd_byte *
6168 restvr (bfd *abfd, bfd_byte *p, int r)
6169 {
6170   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6171   p = p + 4;
6172   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6173   return p + 4;
6174 }
6175
6176 static bfd_byte *
6177 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6178 {
6179   p = restvr (abfd, p, r);
6180   bfd_put_32 (abfd, BLR, p);
6181   return p + 4;
6182 }
6183
6184 /* Called via elf_link_hash_traverse to transfer dynamic linking
6185    information on function code symbol entries to their corresponding
6186    function descriptor symbol entries.  */
6187
6188 static bfd_boolean
6189 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6190 {
6191   struct bfd_link_info *info;
6192   struct ppc_link_hash_table *htab;
6193   struct plt_entry *ent;
6194   struct ppc_link_hash_entry *fh;
6195   struct ppc_link_hash_entry *fdh;
6196   bfd_boolean force_local;
6197
6198   fh = (struct ppc_link_hash_entry *) h;
6199   if (fh->elf.root.type == bfd_link_hash_indirect)
6200     return TRUE;
6201
6202   info = inf;
6203   htab = ppc_hash_table (info);
6204   if (htab == NULL)
6205     return FALSE;
6206
6207   /* Resolve undefined references to dot-symbols as the value
6208      in the function descriptor, if we have one in a regular object.
6209      This is to satisfy cases like ".quad .foo".  Calls to functions
6210      in dynamic objects are handled elsewhere.  */
6211   if (fh->elf.root.type == bfd_link_hash_undefweak
6212       && fh->was_undefined
6213       && (fdh = defined_func_desc (fh)) != NULL
6214       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6215       && opd_entry_value (fdh->elf.root.u.def.section,
6216                           fdh->elf.root.u.def.value,
6217                           &fh->elf.root.u.def.section,
6218                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6219     {
6220       fh->elf.root.type = fdh->elf.root.type;
6221       fh->elf.forced_local = 1;
6222       fh->elf.def_regular = fdh->elf.def_regular;
6223       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6224     }
6225
6226   /* If this is a function code symbol, transfer dynamic linking
6227      information to the function descriptor symbol.  */
6228   if (!fh->is_func)
6229     return TRUE;
6230
6231   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6232     if (ent->plt.refcount > 0)
6233       break;
6234   if (ent == NULL
6235       || fh->elf.root.root.string[0] != '.'
6236       || fh->elf.root.root.string[1] == '\0')
6237     return TRUE;
6238
6239   /* Find the corresponding function descriptor symbol.  Create it
6240      as undefined if necessary.  */
6241
6242   fdh = lookup_fdh (fh, htab);
6243   if (fdh == NULL
6244       && !info->executable
6245       && (fh->elf.root.type == bfd_link_hash_undefined
6246           || fh->elf.root.type == bfd_link_hash_undefweak))
6247     {
6248       fdh = make_fdh (info, fh);
6249       if (fdh == NULL)
6250         return FALSE;
6251     }
6252
6253   /* Fake function descriptors are made undefweak.  If the function
6254      code symbol is strong undefined, make the fake sym the same.
6255      If the function code symbol is defined, then force the fake
6256      descriptor local;  We can't support overriding of symbols in a
6257      shared library on a fake descriptor.  */
6258
6259   if (fdh != NULL
6260       && fdh->fake
6261       && fdh->elf.root.type == bfd_link_hash_undefweak)
6262     {
6263       if (fh->elf.root.type == bfd_link_hash_undefined)
6264         {
6265           fdh->elf.root.type = bfd_link_hash_undefined;
6266           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6267         }
6268       else if (fh->elf.root.type == bfd_link_hash_defined
6269                || fh->elf.root.type == bfd_link_hash_defweak)
6270         {
6271           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6272         }
6273     }
6274
6275   if (fdh != NULL
6276       && !fdh->elf.forced_local
6277       && (!info->executable
6278           || fdh->elf.def_dynamic
6279           || fdh->elf.ref_dynamic
6280           || (fdh->elf.root.type == bfd_link_hash_undefweak
6281               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6282     {
6283       if (fdh->elf.dynindx == -1)
6284         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6285           return FALSE;
6286       fdh->elf.ref_regular |= fh->elf.ref_regular;
6287       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6288       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6289       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6290       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6291         {
6292           move_plt_plist (fh, fdh);
6293           fdh->elf.needs_plt = 1;
6294         }
6295       fdh->is_func_descriptor = 1;
6296       fdh->oh = fh;
6297       fh->oh = fdh;
6298     }
6299
6300   /* Now that the info is on the function descriptor, clear the
6301      function code sym info.  Any function code syms for which we
6302      don't have a definition in a regular file, we force local.
6303      This prevents a shared library from exporting syms that have
6304      been imported from another library.  Function code syms that
6305      are really in the library we must leave global to prevent the
6306      linker dragging in a definition from a static library.  */
6307   force_local = (!fh->elf.def_regular
6308                  || fdh == NULL
6309                  || !fdh->elf.def_regular
6310                  || fdh->elf.forced_local);
6311   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6312
6313   return TRUE;
6314 }
6315
6316 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6317    this hook to a) provide some gcc support functions, and b) transfer
6318    dynamic linking information gathered so far on function code symbol
6319    entries, to their corresponding function descriptor symbol entries.  */
6320
6321 static bfd_boolean
6322 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6323                             struct bfd_link_info *info)
6324 {
6325   struct ppc_link_hash_table *htab;
6326   unsigned int i;
6327   const struct sfpr_def_parms funcs[] =
6328     {
6329       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6330       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6331       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6332       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6333       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6334       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6335       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6336       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6337       { "._savef", 14, 31, savefpr, savefpr1_tail },
6338       { "._restf", 14, 31, restfpr, restfpr1_tail },
6339       { "_savevr_", 20, 31, savevr, savevr_tail },
6340       { "_restvr_", 20, 31, restvr, restvr_tail }
6341     };
6342
6343   htab = ppc_hash_table (info);
6344   if (htab == NULL)
6345     return FALSE;
6346
6347   if (htab->sfpr == NULL)
6348     /* We don't have any relocs.  */
6349     return TRUE;
6350
6351   /* Provide any missing _save* and _rest* functions.  */
6352   htab->sfpr->size = 0;
6353   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6354     if (!sfpr_define (info, &funcs[i]))
6355       return FALSE;
6356
6357   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6358
6359   if (htab->sfpr->size == 0)
6360     htab->sfpr->flags |= SEC_EXCLUDE;
6361
6362   return TRUE;
6363 }
6364
6365 /* Adjust a symbol defined by a dynamic object and referenced by a
6366    regular object.  The current definition is in some section of the
6367    dynamic object, but we're not including those sections.  We have to
6368    change the definition to something the rest of the link can
6369    understand.  */
6370
6371 static bfd_boolean
6372 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6373                                  struct elf_link_hash_entry *h)
6374 {
6375   struct ppc_link_hash_table *htab;
6376   asection *s;
6377
6378   htab = ppc_hash_table (info);
6379   if (htab == NULL)
6380     return FALSE;
6381
6382   /* Deal with function syms.  */
6383   if (h->type == STT_FUNC
6384       || h->type == STT_GNU_IFUNC
6385       || h->needs_plt)
6386     {
6387       /* Clear procedure linkage table information for any symbol that
6388          won't need a .plt entry.  */
6389       struct plt_entry *ent;
6390       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6391         if (ent->plt.refcount > 0)
6392           break;
6393       if (ent == NULL
6394           || (h->type != STT_GNU_IFUNC
6395               && (SYMBOL_CALLS_LOCAL (info, h)
6396                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6397                       && h->root.type == bfd_link_hash_undefweak))))
6398         {
6399           h->plt.plist = NULL;
6400           h->needs_plt = 0;
6401         }
6402     }
6403   else
6404     h->plt.plist = NULL;
6405
6406   /* If this is a weak symbol, and there is a real definition, the
6407      processor independent code will have arranged for us to see the
6408      real definition first, and we can just use the same value.  */
6409   if (h->u.weakdef != NULL)
6410     {
6411       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6412                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6413       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6414       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6415       if (ELIMINATE_COPY_RELOCS)
6416         h->non_got_ref = h->u.weakdef->non_got_ref;
6417       return TRUE;
6418     }
6419
6420   /* If we are creating a shared library, we must presume that the
6421      only references to the symbol are via the global offset table.
6422      For such cases we need not do anything here; the relocations will
6423      be handled correctly by relocate_section.  */
6424   if (info->shared)
6425     return TRUE;
6426
6427   /* If there are no references to this symbol that do not use the
6428      GOT, we don't need to generate a copy reloc.  */
6429   if (!h->non_got_ref)
6430     return TRUE;
6431
6432   /* Don't generate a copy reloc for symbols defined in the executable.  */
6433   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6434     return TRUE;
6435
6436   if (ELIMINATE_COPY_RELOCS)
6437     {
6438       struct ppc_link_hash_entry * eh;
6439       struct elf_dyn_relocs *p;
6440
6441       eh = (struct ppc_link_hash_entry *) h;
6442       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6443         {
6444           s = p->sec->output_section;
6445           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6446             break;
6447         }
6448
6449       /* If we didn't find any dynamic relocs in read-only sections, then
6450          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6451       if (p == NULL)
6452         {
6453           h->non_got_ref = 0;
6454           return TRUE;
6455         }
6456     }
6457
6458   if (h->plt.plist != NULL)
6459     {
6460       /* We should never get here, but unfortunately there are versions
6461          of gcc out there that improperly (for this ABI) put initialized
6462          function pointers, vtable refs and suchlike in read-only
6463          sections.  Allow them to proceed, but warn that this might
6464          break at runtime.  */
6465       info->callbacks->einfo
6466         (_("%P: copy reloc against `%s' requires lazy plt linking; "
6467            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6468          h->root.root.string);
6469     }
6470
6471   /* This is a reference to a symbol defined by a dynamic object which
6472      is not a function.  */
6473
6474   if (h->size == 0)
6475     {
6476       info->callbacks->einfo (_("%P: dynamic variable `%s' is zero size\n"),
6477                               h->root.root.string);
6478       return TRUE;
6479     }
6480
6481   /* We must allocate the symbol in our .dynbss section, which will
6482      become part of the .bss section of the executable.  There will be
6483      an entry for this symbol in the .dynsym section.  The dynamic
6484      object will contain position independent code, so all references
6485      from the dynamic object to this symbol will go through the global
6486      offset table.  The dynamic linker will use the .dynsym entry to
6487      determine the address it must put in the global offset table, so
6488      both the dynamic object and the regular object will refer to the
6489      same memory location for the variable.  */
6490
6491   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6492      to copy the initial value out of the dynamic object and into the
6493      runtime process image.  We need to remember the offset into the
6494      .rela.bss section we are going to use.  */
6495   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6496     {
6497       htab->relbss->size += sizeof (Elf64_External_Rela);
6498       h->needs_copy = 1;
6499     }
6500
6501   s = htab->dynbss;
6502
6503   return _bfd_elf_adjust_dynamic_copy (h, s);
6504 }
6505
6506 /* If given a function descriptor symbol, hide both the function code
6507    sym and the descriptor.  */
6508 static void
6509 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6510                        struct elf_link_hash_entry *h,
6511                        bfd_boolean force_local)
6512 {
6513   struct ppc_link_hash_entry *eh;
6514   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6515
6516   eh = (struct ppc_link_hash_entry *) h;
6517   if (eh->is_func_descriptor)
6518     {
6519       struct ppc_link_hash_entry *fh = eh->oh;
6520
6521       if (fh == NULL)
6522         {
6523           const char *p, *q;
6524           struct ppc_link_hash_table *htab;
6525           char save;
6526
6527           /* We aren't supposed to use alloca in BFD because on
6528              systems which do not have alloca the version in libiberty
6529              calls xmalloc, which might cause the program to crash
6530              when it runs out of memory.  This function doesn't have a
6531              return status, so there's no way to gracefully return an
6532              error.  So cheat.  We know that string[-1] can be safely
6533              accessed;  It's either a string in an ELF string table,
6534              or allocated in an objalloc structure.  */
6535
6536           p = eh->elf.root.root.string - 1;
6537           save = *p;
6538           *(char *) p = '.';
6539           htab = ppc_hash_table (info);
6540           if (htab == NULL)
6541             return;
6542
6543           fh = (struct ppc_link_hash_entry *)
6544             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6545           *(char *) p = save;
6546
6547           /* Unfortunately, if it so happens that the string we were
6548              looking for was allocated immediately before this string,
6549              then we overwrote the string terminator.  That's the only
6550              reason the lookup should fail.  */
6551           if (fh == NULL)
6552             {
6553               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6554               while (q >= eh->elf.root.root.string && *q == *p)
6555                 --q, --p;
6556               if (q < eh->elf.root.root.string && *p == '.')
6557                 fh = (struct ppc_link_hash_entry *)
6558                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6559             }
6560           if (fh != NULL)
6561             {
6562               eh->oh = fh;
6563               fh->oh = eh;
6564             }
6565         }
6566       if (fh != NULL)
6567         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6568     }
6569 }
6570
6571 static bfd_boolean
6572 get_sym_h (struct elf_link_hash_entry **hp,
6573            Elf_Internal_Sym **symp,
6574            asection **symsecp,
6575            unsigned char **tls_maskp,
6576            Elf_Internal_Sym **locsymsp,
6577            unsigned long r_symndx,
6578            bfd *ibfd)
6579 {
6580   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6581
6582   if (r_symndx >= symtab_hdr->sh_info)
6583     {
6584       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6585       struct elf_link_hash_entry *h;
6586
6587       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6588       h = elf_follow_link (h);
6589
6590       if (hp != NULL)
6591         *hp = h;
6592
6593       if (symp != NULL)
6594         *symp = NULL;
6595
6596       if (symsecp != NULL)
6597         {
6598           asection *symsec = NULL;
6599           if (h->root.type == bfd_link_hash_defined
6600               || h->root.type == bfd_link_hash_defweak)
6601             symsec = h->root.u.def.section;
6602           *symsecp = symsec;
6603         }
6604
6605       if (tls_maskp != NULL)
6606         {
6607           struct ppc_link_hash_entry *eh;
6608
6609           eh = (struct ppc_link_hash_entry *) h;
6610           *tls_maskp = &eh->tls_mask;
6611         }
6612     }
6613   else
6614     {
6615       Elf_Internal_Sym *sym;
6616       Elf_Internal_Sym *locsyms = *locsymsp;
6617
6618       if (locsyms == NULL)
6619         {
6620           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6621           if (locsyms == NULL)
6622             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6623                                             symtab_hdr->sh_info,
6624                                             0, NULL, NULL, NULL);
6625           if (locsyms == NULL)
6626             return FALSE;
6627           *locsymsp = locsyms;
6628         }
6629       sym = locsyms + r_symndx;
6630
6631       if (hp != NULL)
6632         *hp = NULL;
6633
6634       if (symp != NULL)
6635         *symp = sym;
6636
6637       if (symsecp != NULL)
6638         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6639
6640       if (tls_maskp != NULL)
6641         {
6642           struct got_entry **lgot_ents;
6643           unsigned char *tls_mask;
6644
6645           tls_mask = NULL;
6646           lgot_ents = elf_local_got_ents (ibfd);
6647           if (lgot_ents != NULL)
6648             {
6649               struct plt_entry **local_plt = (struct plt_entry **)
6650                 (lgot_ents + symtab_hdr->sh_info);
6651               unsigned char *lgot_masks = (unsigned char *)
6652                 (local_plt + symtab_hdr->sh_info);
6653               tls_mask = &lgot_masks[r_symndx];
6654             }
6655           *tls_maskp = tls_mask;
6656         }
6657     }
6658   return TRUE;
6659 }
6660
6661 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6662    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6663    type suitable for optimization, and 1 otherwise.  */
6664
6665 static int
6666 get_tls_mask (unsigned char **tls_maskp,
6667               unsigned long *toc_symndx,
6668               bfd_vma *toc_addend,
6669               Elf_Internal_Sym **locsymsp,
6670               const Elf_Internal_Rela *rel,
6671               bfd *ibfd)
6672 {
6673   unsigned long r_symndx;
6674   int next_r;
6675   struct elf_link_hash_entry *h;
6676   Elf_Internal_Sym *sym;
6677   asection *sec;
6678   bfd_vma off;
6679
6680   r_symndx = ELF64_R_SYM (rel->r_info);
6681   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6682     return 0;
6683
6684   if ((*tls_maskp != NULL && **tls_maskp != 0)
6685       || sec == NULL
6686       || ppc64_elf_section_data (sec) == NULL
6687       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6688     return 1;
6689
6690   /* Look inside a TOC section too.  */
6691   if (h != NULL)
6692     {
6693       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6694       off = h->root.u.def.value;
6695     }
6696   else
6697     off = sym->st_value;
6698   off += rel->r_addend;
6699   BFD_ASSERT (off % 8 == 0);
6700   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6701   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6702   if (toc_symndx != NULL)
6703     *toc_symndx = r_symndx;
6704   if (toc_addend != NULL)
6705     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6706   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6707     return 0;
6708   if ((h == NULL || is_static_defined (h))
6709       && (next_r == -1 || next_r == -2))
6710     return 1 - next_r;
6711   return 1;
6712 }
6713
6714 /* Adjust all global syms defined in opd sections.  In gcc generated
6715    code for the old ABI, these will already have been done.  */
6716
6717 static bfd_boolean
6718 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6719 {
6720   struct ppc_link_hash_entry *eh;
6721   asection *sym_sec;
6722   struct _opd_sec_data *opd;
6723
6724   if (h->root.type == bfd_link_hash_indirect)
6725     return TRUE;
6726
6727   if (h->root.type != bfd_link_hash_defined
6728       && h->root.type != bfd_link_hash_defweak)
6729     return TRUE;
6730
6731   eh = (struct ppc_link_hash_entry *) h;
6732   if (eh->adjust_done)
6733     return TRUE;
6734
6735   sym_sec = eh->elf.root.u.def.section;
6736   opd = get_opd_info (sym_sec);
6737   if (opd != NULL && opd->adjust != NULL)
6738     {
6739       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6740       if (adjust == -1)
6741         {
6742           /* This entry has been deleted.  */
6743           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6744           if (dsec == NULL)
6745             {
6746               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6747                 if (elf_discarded_section (dsec))
6748                   {
6749                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6750                     break;
6751                   }
6752             }
6753           eh->elf.root.u.def.value = 0;
6754           eh->elf.root.u.def.section = dsec;
6755         }
6756       else
6757         eh->elf.root.u.def.value += adjust;
6758       eh->adjust_done = 1;
6759     }
6760   return TRUE;
6761 }
6762
6763 /* Handles decrementing dynamic reloc counts for the reloc specified by
6764    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6765    have already been determined.  */
6766
6767 static bfd_boolean
6768 dec_dynrel_count (bfd_vma r_info,
6769                   asection *sec,
6770                   struct bfd_link_info *info,
6771                   Elf_Internal_Sym **local_syms,
6772                   struct elf_link_hash_entry *h,
6773                   asection *sym_sec)
6774 {
6775   enum elf_ppc64_reloc_type r_type;
6776   struct elf_dyn_relocs *p;
6777   struct elf_dyn_relocs **pp;
6778
6779   /* Can this reloc be dynamic?  This switch, and later tests here
6780      should be kept in sync with the code in check_relocs.  */
6781   r_type = ELF64_R_TYPE (r_info);
6782   switch (r_type)
6783     {
6784     default:
6785       return TRUE;
6786
6787     case R_PPC64_TPREL16:
6788     case R_PPC64_TPREL16_LO:
6789     case R_PPC64_TPREL16_HI:
6790     case R_PPC64_TPREL16_HA:
6791     case R_PPC64_TPREL16_DS:
6792     case R_PPC64_TPREL16_LO_DS:
6793     case R_PPC64_TPREL16_HIGHER:
6794     case R_PPC64_TPREL16_HIGHERA:
6795     case R_PPC64_TPREL16_HIGHEST:
6796     case R_PPC64_TPREL16_HIGHESTA:
6797       if (!info->shared)
6798         return TRUE;
6799
6800     case R_PPC64_TPREL64:
6801     case R_PPC64_DTPMOD64:
6802     case R_PPC64_DTPREL64:
6803     case R_PPC64_ADDR64:
6804     case R_PPC64_REL30:
6805     case R_PPC64_REL32:
6806     case R_PPC64_REL64:
6807     case R_PPC64_ADDR14:
6808     case R_PPC64_ADDR14_BRNTAKEN:
6809     case R_PPC64_ADDR14_BRTAKEN:
6810     case R_PPC64_ADDR16:
6811     case R_PPC64_ADDR16_DS:
6812     case R_PPC64_ADDR16_HA:
6813     case R_PPC64_ADDR16_HI:
6814     case R_PPC64_ADDR16_HIGHER:
6815     case R_PPC64_ADDR16_HIGHERA:
6816     case R_PPC64_ADDR16_HIGHEST:
6817     case R_PPC64_ADDR16_HIGHESTA:
6818     case R_PPC64_ADDR16_LO:
6819     case R_PPC64_ADDR16_LO_DS:
6820     case R_PPC64_ADDR24:
6821     case R_PPC64_ADDR32:
6822     case R_PPC64_UADDR16:
6823     case R_PPC64_UADDR32:
6824     case R_PPC64_UADDR64:
6825     case R_PPC64_TOC:
6826       break;
6827     }
6828
6829   if (local_syms != NULL)
6830     {
6831       unsigned long r_symndx;
6832       Elf_Internal_Sym *sym;
6833       bfd *ibfd = sec->owner;
6834
6835       r_symndx = ELF64_R_SYM (r_info);
6836       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6837         return FALSE;
6838     }
6839
6840   if ((info->shared
6841        && (must_be_dyn_reloc (info, r_type)
6842            || (h != NULL
6843                && (!info->symbolic
6844                    || h->root.type == bfd_link_hash_defweak
6845                    || !h->def_regular))))
6846       || (ELIMINATE_COPY_RELOCS
6847           && !info->shared
6848           && h != NULL
6849           && (h->root.type == bfd_link_hash_defweak
6850               || !h->def_regular)))
6851     ;
6852   else
6853     return TRUE;
6854
6855   if (h != NULL)
6856     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6857   else
6858     {
6859       if (sym_sec != NULL)
6860         {
6861           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6862           pp = (struct elf_dyn_relocs **) vpp;
6863         }
6864       else
6865         {
6866           void *vpp = &elf_section_data (sec)->local_dynrel;
6867           pp = (struct elf_dyn_relocs **) vpp;
6868         }
6869
6870       /* elf_gc_sweep may have already removed all dyn relocs associated
6871          with local syms for a given section.  Don't report a dynreloc
6872          miscount.  */
6873       if (*pp == NULL)
6874         return TRUE;
6875     }
6876
6877   while ((p = *pp) != NULL)
6878     {
6879       if (p->sec == sec)
6880         {
6881           if (!must_be_dyn_reloc (info, r_type))
6882             p->pc_count -= 1;
6883           p->count -= 1;
6884           if (p->count == 0)
6885             *pp = p->next;
6886           return TRUE;
6887         }
6888       pp = &p->next;
6889     }
6890
6891   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
6892                           sec->owner, sec);
6893   bfd_set_error (bfd_error_bad_value);
6894   return FALSE;
6895 }
6896
6897 /* Remove unused Official Procedure Descriptor entries.  Currently we
6898    only remove those associated with functions in discarded link-once
6899    sections, or weakly defined functions that have been overridden.  It
6900    would be possible to remove many more entries for statically linked
6901    applications.  */
6902
6903 bfd_boolean
6904 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
6905 {
6906   bfd *ibfd;
6907   bfd_boolean some_edited = FALSE;
6908   asection *need_pad = NULL;
6909
6910   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6911     {
6912       asection *sec;
6913       Elf_Internal_Rela *relstart, *rel, *relend;
6914       Elf_Internal_Shdr *symtab_hdr;
6915       Elf_Internal_Sym *local_syms;
6916       bfd_vma offset;
6917       struct _opd_sec_data *opd;
6918       bfd_boolean need_edit, add_aux_fields;
6919       bfd_size_type cnt_16b = 0;
6920
6921       if (!is_ppc64_elf (ibfd))
6922         continue;
6923
6924       sec = bfd_get_section_by_name (ibfd, ".opd");
6925       if (sec == NULL || sec->size == 0)
6926         continue;
6927
6928       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6929         continue;
6930
6931       if (sec->output_section == bfd_abs_section_ptr)
6932         continue;
6933
6934       /* Look through the section relocs.  */
6935       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6936         continue;
6937
6938       local_syms = NULL;
6939       symtab_hdr = &elf_symtab_hdr (ibfd);
6940
6941       /* Read the relocations.  */
6942       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6943                                             info->keep_memory);
6944       if (relstart == NULL)
6945         return FALSE;
6946
6947       /* First run through the relocs to check they are sane, and to
6948          determine whether we need to edit this opd section.  */
6949       need_edit = FALSE;
6950       need_pad = sec;
6951       offset = 0;
6952       relend = relstart + sec->reloc_count;
6953       for (rel = relstart; rel < relend; )
6954         {
6955           enum elf_ppc64_reloc_type r_type;
6956           unsigned long r_symndx;
6957           asection *sym_sec;
6958           struct elf_link_hash_entry *h;
6959           Elf_Internal_Sym *sym;
6960
6961           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6962              only interested in the reloc pointing to a function entry
6963              point.  */
6964           if (rel->r_offset != offset
6965               || rel + 1 >= relend
6966               || (rel + 1)->r_offset != offset + 8)
6967             {
6968               /* If someone messes with .opd alignment then after a
6969                  "ld -r" we might have padding in the middle of .opd.
6970                  Also, there's nothing to prevent someone putting
6971                  something silly in .opd with the assembler.  No .opd
6972                  optimization for them!  */
6973             broken_opd:
6974               (*_bfd_error_handler)
6975                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6976               need_edit = FALSE;
6977               break;
6978             }
6979
6980           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6981               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6982             {
6983               (*_bfd_error_handler)
6984                 (_("%B: unexpected reloc type %u in .opd section"),
6985                  ibfd, r_type);
6986               need_edit = FALSE;
6987               break;
6988             }
6989
6990           r_symndx = ELF64_R_SYM (rel->r_info);
6991           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6992                           r_symndx, ibfd))
6993             goto error_ret;
6994
6995           if (sym_sec == NULL || sym_sec->owner == NULL)
6996             {
6997               const char *sym_name;
6998               if (h != NULL)
6999                 sym_name = h->root.root.string;
7000               else
7001                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7002                                              sym_sec);
7003
7004               (*_bfd_error_handler)
7005                 (_("%B: undefined sym `%s' in .opd section"),
7006                  ibfd, sym_name);
7007               need_edit = FALSE;
7008               break;
7009             }
7010
7011           /* opd entries are always for functions defined in the
7012              current input bfd.  If the symbol isn't defined in the
7013              input bfd, then we won't be using the function in this
7014              bfd;  It must be defined in a linkonce section in another
7015              bfd, or is weak.  It's also possible that we are
7016              discarding the function due to a linker script /DISCARD/,
7017              which we test for via the output_section.  */
7018           if (sym_sec->owner != ibfd
7019               || sym_sec->output_section == bfd_abs_section_ptr)
7020             need_edit = TRUE;
7021
7022           rel += 2;
7023           if (rel == relend
7024               || (rel + 1 == relend && rel->r_offset == offset + 16))
7025             {
7026               if (sec->size == offset + 24)
7027                 {
7028                   need_pad = NULL;
7029                   break;
7030                 }
7031               if (rel == relend && sec->size == offset + 16)
7032                 {
7033                   cnt_16b++;
7034                   break;
7035                 }
7036               goto broken_opd;
7037             }
7038
7039           if (rel->r_offset == offset + 24)
7040             offset += 24;
7041           else if (rel->r_offset != offset + 16)
7042             goto broken_opd;
7043           else if (rel + 1 < relend
7044                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7045                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7046             {
7047               offset += 16;
7048               cnt_16b++;
7049             }
7050           else if (rel + 2 < relend
7051                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7052                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7053             {
7054               offset += 24;
7055               rel += 1;
7056             }
7057           else
7058             goto broken_opd;
7059         }
7060
7061       add_aux_fields = non_overlapping && cnt_16b > 0;
7062
7063       if (need_edit || add_aux_fields)
7064         {
7065           Elf_Internal_Rela *write_rel;
7066           Elf_Internal_Shdr *rel_hdr;
7067           bfd_byte *rptr, *wptr;
7068           bfd_byte *new_contents;
7069           bfd_boolean skip;
7070           long opd_ent_size;
7071           bfd_size_type amt;
7072
7073           new_contents = NULL;
7074           amt = sec->size * sizeof (long) / 8;
7075           opd = &ppc64_elf_section_data (sec)->u.opd;
7076           opd->adjust = bfd_zalloc (sec->owner, amt);
7077           if (opd->adjust == NULL)
7078             return FALSE;
7079           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7080
7081           /* This seems a waste of time as input .opd sections are all
7082              zeros as generated by gcc, but I suppose there's no reason
7083              this will always be so.  We might start putting something in
7084              the third word of .opd entries.  */
7085           if ((sec->flags & SEC_IN_MEMORY) == 0)
7086             {
7087               bfd_byte *loc;
7088               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7089                 {
7090                   if (loc != NULL)
7091                     free (loc);
7092                 error_ret:
7093                   if (local_syms != NULL
7094                       && symtab_hdr->contents != (unsigned char *) local_syms)
7095                     free (local_syms);
7096                   if (elf_section_data (sec)->relocs != relstart)
7097                     free (relstart);
7098                   return FALSE;
7099                 }
7100               sec->contents = loc;
7101               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7102             }
7103
7104           elf_section_data (sec)->relocs = relstart;
7105
7106           new_contents = sec->contents;
7107           if (add_aux_fields)
7108             {
7109               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7110               if (new_contents == NULL)
7111                 return FALSE;
7112               need_pad = FALSE;
7113             }
7114           wptr = new_contents;
7115           rptr = sec->contents;
7116
7117           write_rel = relstart;
7118           skip = FALSE;
7119           offset = 0;
7120           opd_ent_size = 0;
7121           for (rel = relstart; rel < relend; rel++)
7122             {
7123               unsigned long r_symndx;
7124               asection *sym_sec;
7125               struct elf_link_hash_entry *h;
7126               Elf_Internal_Sym *sym;
7127
7128               r_symndx = ELF64_R_SYM (rel->r_info);
7129               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7130                               r_symndx, ibfd))
7131                 goto error_ret;
7132
7133               if (rel->r_offset == offset)
7134                 {
7135                   struct ppc_link_hash_entry *fdh = NULL;
7136
7137                   /* See if the .opd entry is full 24 byte or
7138                      16 byte (with fd_aux entry overlapped with next
7139                      fd_func).  */
7140                   opd_ent_size = 24;
7141                   if ((rel + 2 == relend && sec->size == offset + 16)
7142                       || (rel + 3 < relend
7143                           && rel[2].r_offset == offset + 16
7144                           && rel[3].r_offset == offset + 24
7145                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7146                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7147                     opd_ent_size = 16;
7148
7149                   if (h != NULL
7150                       && h->root.root.string[0] == '.')
7151                     {
7152                       struct ppc_link_hash_table *htab;
7153
7154                       htab = ppc_hash_table (info);
7155                       if (htab != NULL)
7156                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7157                                           htab);
7158                       if (fdh != NULL
7159                           && fdh->elf.root.type != bfd_link_hash_defined
7160                           && fdh->elf.root.type != bfd_link_hash_defweak)
7161                         fdh = NULL;
7162                     }
7163
7164                   skip = (sym_sec->owner != ibfd
7165                           || sym_sec->output_section == bfd_abs_section_ptr);
7166                   if (skip)
7167                     {
7168                       if (fdh != NULL && sym_sec->owner == ibfd)
7169                         {
7170                           /* Arrange for the function descriptor sym
7171                              to be dropped.  */
7172                           fdh->elf.root.u.def.value = 0;
7173                           fdh->elf.root.u.def.section = sym_sec;
7174                         }
7175                       opd->adjust[rel->r_offset / 8] = -1;
7176                     }
7177                   else
7178                     {
7179                       /* We'll be keeping this opd entry.  */
7180
7181                       if (fdh != NULL)
7182                         {
7183                           /* Redefine the function descriptor symbol to
7184                              this location in the opd section.  It is
7185                              necessary to update the value here rather
7186                              than using an array of adjustments as we do
7187                              for local symbols, because various places
7188                              in the generic ELF code use the value
7189                              stored in u.def.value.  */
7190                           fdh->elf.root.u.def.value = wptr - new_contents;
7191                           fdh->adjust_done = 1;
7192                         }
7193
7194                       /* Local syms are a bit tricky.  We could
7195                          tweak them as they can be cached, but
7196                          we'd need to look through the local syms
7197                          for the function descriptor sym which we
7198                          don't have at the moment.  So keep an
7199                          array of adjustments.  */
7200                       opd->adjust[rel->r_offset / 8]
7201                         = (wptr - new_contents) - (rptr - sec->contents);
7202
7203                       if (wptr != rptr)
7204                         memcpy (wptr, rptr, opd_ent_size);
7205                       wptr += opd_ent_size;
7206                       if (add_aux_fields && opd_ent_size == 16)
7207                         {
7208                           memset (wptr, '\0', 8);
7209                           wptr += 8;
7210                         }
7211                     }
7212                   rptr += opd_ent_size;
7213                   offset += opd_ent_size;
7214                 }
7215
7216               if (skip)
7217                 {
7218                   if (!NO_OPD_RELOCS
7219                       && !info->relocatable
7220                       && !dec_dynrel_count (rel->r_info, sec, info,
7221                                             NULL, h, sym_sec))
7222                     goto error_ret;
7223                 }
7224               else
7225                 {
7226                   /* We need to adjust any reloc offsets to point to the
7227                      new opd entries.  While we're at it, we may as well
7228                      remove redundant relocs.  */
7229                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7230                   if (write_rel != rel)
7231                     memcpy (write_rel, rel, sizeof (*rel));
7232                   ++write_rel;
7233                 }
7234             }
7235
7236           sec->size = wptr - new_contents;
7237           sec->reloc_count = write_rel - relstart;
7238           if (add_aux_fields)
7239             {
7240               free (sec->contents);
7241               sec->contents = new_contents;
7242             }
7243
7244           /* Fudge the header size too, as this is used later in
7245              elf_bfd_final_link if we are emitting relocs.  */
7246           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7247           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7248           some_edited = TRUE;
7249         }
7250       else if (elf_section_data (sec)->relocs != relstart)
7251         free (relstart);
7252
7253       if (local_syms != NULL
7254           && symtab_hdr->contents != (unsigned char *) local_syms)
7255         {
7256           if (!info->keep_memory)
7257             free (local_syms);
7258           else
7259             symtab_hdr->contents = (unsigned char *) local_syms;
7260         }
7261     }
7262
7263   if (some_edited)
7264     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7265
7266   /* If we are doing a final link and the last .opd entry is just 16 byte
7267      long, add a 8 byte padding after it.  */
7268   if (need_pad != NULL && !info->relocatable)
7269     {
7270       bfd_byte *p;
7271
7272       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7273         {
7274           BFD_ASSERT (need_pad->size > 0);
7275
7276           p = bfd_malloc (need_pad->size + 8);
7277           if (p == NULL)
7278             return FALSE;
7279
7280           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7281                                           p, 0, need_pad->size))
7282             return FALSE;
7283
7284           need_pad->contents = p;
7285           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7286         }
7287       else
7288         {
7289           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7290           if (p == NULL)
7291             return FALSE;
7292
7293           need_pad->contents = p;
7294         }
7295
7296       memset (need_pad->contents + need_pad->size, 0, 8);
7297       need_pad->size += 8;
7298     }
7299
7300   return TRUE;
7301 }
7302
7303 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7304
7305 asection *
7306 ppc64_elf_tls_setup (struct bfd_link_info *info,
7307                      int no_tls_get_addr_opt,
7308                      int *no_multi_toc)
7309 {
7310   struct ppc_link_hash_table *htab;
7311
7312   htab = ppc_hash_table (info);
7313   if (htab == NULL)
7314     return NULL;
7315
7316   if (*no_multi_toc)
7317     htab->do_multi_toc = 0;
7318   else if (!htab->do_multi_toc)
7319     *no_multi_toc = 1;
7320
7321   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7322                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7323                                               FALSE, FALSE, TRUE));
7324   /* Move dynamic linking info to the function descriptor sym.  */
7325   if (htab->tls_get_addr != NULL)
7326     func_desc_adjust (&htab->tls_get_addr->elf, info);
7327   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7328                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7329                                                  FALSE, FALSE, TRUE));
7330   if (!no_tls_get_addr_opt)
7331     {
7332       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7333
7334       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7335                                   FALSE, FALSE, TRUE);
7336       if (opt != NULL)
7337         func_desc_adjust (opt, info);
7338       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7339                                      FALSE, FALSE, TRUE);
7340       if (opt_fd != NULL
7341           && (opt_fd->root.type == bfd_link_hash_defined
7342               || opt_fd->root.type == bfd_link_hash_defweak))
7343         {
7344           /* If glibc supports an optimized __tls_get_addr call stub,
7345              signalled by the presence of __tls_get_addr_opt, and we'll
7346              be calling __tls_get_addr via a plt call stub, then
7347              make __tls_get_addr point to __tls_get_addr_opt.  */
7348           tga_fd = &htab->tls_get_addr_fd->elf;
7349           if (htab->elf.dynamic_sections_created
7350               && tga_fd != NULL
7351               && (tga_fd->type == STT_FUNC
7352                   || tga_fd->needs_plt)
7353               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7354                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7355                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7356             {
7357               struct plt_entry *ent;
7358
7359               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7360                 if (ent->plt.refcount > 0)
7361                   break;
7362               if (ent != NULL)
7363                 {
7364                   tga_fd->root.type = bfd_link_hash_indirect;
7365                   tga_fd->root.u.i.link = &opt_fd->root;
7366                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7367                   if (opt_fd->dynindx != -1)
7368                     {
7369                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7370                       opt_fd->dynindx = -1;
7371                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7372                                               opt_fd->dynstr_index);
7373                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7374                         return NULL;
7375                     }
7376                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7377                   tga = &htab->tls_get_addr->elf;
7378                   if (opt != NULL && tga != NULL)
7379                     {
7380                       tga->root.type = bfd_link_hash_indirect;
7381                       tga->root.u.i.link = &opt->root;
7382                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7383                       _bfd_elf_link_hash_hide_symbol (info, opt,
7384                                                       tga->forced_local);
7385                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7386                     }
7387                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7388                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7389                   if (htab->tls_get_addr != NULL)
7390                     {
7391                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7392                       htab->tls_get_addr->is_func = 1;
7393                     }
7394                 }
7395             }
7396         }
7397       else
7398         no_tls_get_addr_opt = TRUE;
7399     }
7400   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7401   return _bfd_elf_tls_setup (info->output_bfd, info);
7402 }
7403
7404 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7405    HASH1 or HASH2.  */
7406
7407 static bfd_boolean
7408 branch_reloc_hash_match (const bfd *ibfd,
7409                          const Elf_Internal_Rela *rel,
7410                          const struct ppc_link_hash_entry *hash1,
7411                          const struct ppc_link_hash_entry *hash2)
7412 {
7413   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7414   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7415   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7416
7417   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7418     {
7419       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7420       struct elf_link_hash_entry *h;
7421
7422       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7423       h = elf_follow_link (h);
7424       if (h == &hash1->elf || h == &hash2->elf)
7425         return TRUE;
7426     }
7427   return FALSE;
7428 }
7429
7430 /* Run through all the TLS relocs looking for optimization
7431    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7432    a preliminary section layout so that we know the TLS segment
7433    offsets.  We can't optimize earlier because some optimizations need
7434    to know the tp offset, and we need to optimize before allocating
7435    dynamic relocations.  */
7436
7437 bfd_boolean
7438 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7439 {
7440   bfd *ibfd;
7441   asection *sec;
7442   struct ppc_link_hash_table *htab;
7443   unsigned char *toc_ref;
7444   int pass;
7445
7446   if (info->relocatable || !info->executable)
7447     return TRUE;
7448
7449   htab = ppc_hash_table (info);
7450   if (htab == NULL)
7451     return FALSE;
7452
7453   /* Make two passes over the relocs.  On the first pass, mark toc
7454      entries involved with tls relocs, and check that tls relocs
7455      involved in setting up a tls_get_addr call are indeed followed by
7456      such a call.  If they are not, we can't do any tls optimization.
7457      On the second pass twiddle tls_mask flags to notify
7458      relocate_section that optimization can be done, and adjust got
7459      and plt refcounts.  */
7460   toc_ref = NULL;
7461   for (pass = 0; pass < 2; ++pass)
7462     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7463       {
7464         Elf_Internal_Sym *locsyms = NULL;
7465         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7466
7467         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7468           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7469             {
7470               Elf_Internal_Rela *relstart, *rel, *relend;
7471               bfd_boolean found_tls_get_addr_arg = 0;
7472
7473               /* Read the relocations.  */
7474               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7475                                                     info->keep_memory);
7476               if (relstart == NULL)
7477                 return FALSE;
7478
7479               relend = relstart + sec->reloc_count;
7480               for (rel = relstart; rel < relend; rel++)
7481                 {
7482                   enum elf_ppc64_reloc_type r_type;
7483                   unsigned long r_symndx;
7484                   struct elf_link_hash_entry *h;
7485                   Elf_Internal_Sym *sym;
7486                   asection *sym_sec;
7487                   unsigned char *tls_mask;
7488                   unsigned char tls_set, tls_clear, tls_type = 0;
7489                   bfd_vma value;
7490                   bfd_boolean ok_tprel, is_local;
7491                   long toc_ref_index = 0;
7492                   int expecting_tls_get_addr = 0;
7493                   bfd_boolean ret = FALSE;
7494
7495                   r_symndx = ELF64_R_SYM (rel->r_info);
7496                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7497                                   r_symndx, ibfd))
7498                     {
7499                     err_free_rel:
7500                       if (elf_section_data (sec)->relocs != relstart)
7501                         free (relstart);
7502                       if (toc_ref != NULL)
7503                         free (toc_ref);
7504                       if (locsyms != NULL
7505                           && (elf_symtab_hdr (ibfd).contents
7506                               != (unsigned char *) locsyms))
7507                         free (locsyms);
7508                       return ret;
7509                     }
7510
7511                   if (h != NULL)
7512                     {
7513                       if (h->root.type == bfd_link_hash_defined
7514                           || h->root.type == bfd_link_hash_defweak)
7515                         value = h->root.u.def.value;
7516                       else if (h->root.type == bfd_link_hash_undefweak)
7517                         value = 0;
7518                       else
7519                         {
7520                           found_tls_get_addr_arg = 0;
7521                           continue;
7522                         }
7523                     }
7524                   else
7525                     /* Symbols referenced by TLS relocs must be of type
7526                        STT_TLS.  So no need for .opd local sym adjust.  */
7527                     value = sym->st_value;
7528
7529                   ok_tprel = FALSE;
7530                   is_local = FALSE;
7531                   if (h == NULL
7532                       || !h->def_dynamic)
7533                     {
7534                       is_local = TRUE;
7535                       if (h != NULL
7536                           && h->root.type == bfd_link_hash_undefweak)
7537                         ok_tprel = TRUE;
7538                       else
7539                         {
7540                           value += sym_sec->output_offset;
7541                           value += sym_sec->output_section->vma;
7542                           value -= htab->elf.tls_sec->vma;
7543                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7544                                       < (bfd_vma) 1 << 32);
7545                         }
7546                     }
7547
7548                   r_type = ELF64_R_TYPE (rel->r_info);
7549                   /* If this section has old-style __tls_get_addr calls
7550                      without marker relocs, then check that each
7551                      __tls_get_addr call reloc is preceded by a reloc
7552                      that conceivably belongs to the __tls_get_addr arg
7553                      setup insn.  If we don't find matching arg setup
7554                      relocs, don't do any tls optimization.  */
7555                   if (pass == 0
7556                       && sec->has_tls_get_addr_call
7557                       && h != NULL
7558                       && (h == &htab->tls_get_addr->elf
7559                           || h == &htab->tls_get_addr_fd->elf)
7560                       && !found_tls_get_addr_arg
7561                       && is_branch_reloc (r_type))
7562                     {
7563                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7564                                                 "TLS optimization disabled\n"),
7565                                               ibfd, sec, rel->r_offset);
7566                       ret = TRUE;
7567                       goto err_free_rel;
7568                     }
7569
7570                   found_tls_get_addr_arg = 0;
7571                   switch (r_type)
7572                     {
7573                     case R_PPC64_GOT_TLSLD16:
7574                     case R_PPC64_GOT_TLSLD16_LO:
7575                       expecting_tls_get_addr = 1;
7576                       found_tls_get_addr_arg = 1;
7577                       /* Fall thru */
7578
7579                     case R_PPC64_GOT_TLSLD16_HI:
7580                     case R_PPC64_GOT_TLSLD16_HA:
7581                       /* These relocs should never be against a symbol
7582                          defined in a shared lib.  Leave them alone if
7583                          that turns out to be the case.  */
7584                       if (!is_local)
7585                         continue;
7586
7587                       /* LD -> LE */
7588                       tls_set = 0;
7589                       tls_clear = TLS_LD;
7590                       tls_type = TLS_TLS | TLS_LD;
7591                       break;
7592
7593                     case R_PPC64_GOT_TLSGD16:
7594                     case R_PPC64_GOT_TLSGD16_LO:
7595                       expecting_tls_get_addr = 1;
7596                       found_tls_get_addr_arg = 1;
7597                       /* Fall thru */
7598
7599                     case R_PPC64_GOT_TLSGD16_HI:
7600                     case R_PPC64_GOT_TLSGD16_HA:
7601                       if (ok_tprel)
7602                         /* GD -> LE */
7603                         tls_set = 0;
7604                       else
7605                         /* GD -> IE */
7606                         tls_set = TLS_TLS | TLS_TPRELGD;
7607                       tls_clear = TLS_GD;
7608                       tls_type = TLS_TLS | TLS_GD;
7609                       break;
7610
7611                     case R_PPC64_GOT_TPREL16_DS:
7612                     case R_PPC64_GOT_TPREL16_LO_DS:
7613                     case R_PPC64_GOT_TPREL16_HI:
7614                     case R_PPC64_GOT_TPREL16_HA:
7615                       if (ok_tprel)
7616                         {
7617                           /* IE -> LE */
7618                           tls_set = 0;
7619                           tls_clear = TLS_TPREL;
7620                           tls_type = TLS_TLS | TLS_TPREL;
7621                           break;
7622                         }
7623                       continue;
7624
7625                     case R_PPC64_TLSGD:
7626                     case R_PPC64_TLSLD:
7627                       found_tls_get_addr_arg = 1;
7628                       /* Fall thru */
7629
7630                     case R_PPC64_TLS:
7631                     case R_PPC64_TOC16:
7632                     case R_PPC64_TOC16_LO:
7633                       if (sym_sec == NULL || sym_sec != toc)
7634                         continue;
7635
7636                       /* Mark this toc entry as referenced by a TLS
7637                          code sequence.  We can do that now in the
7638                          case of R_PPC64_TLS, and after checking for
7639                          tls_get_addr for the TOC16 relocs.  */
7640                       if (toc_ref == NULL)
7641                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7642                       if (toc_ref == NULL)
7643                         goto err_free_rel;
7644
7645                       if (h != NULL)
7646                         value = h->root.u.def.value;
7647                       else
7648                         value = sym->st_value;
7649                       value += rel->r_addend;
7650                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7651                       toc_ref_index = (value + toc->output_offset) / 8;
7652                       if (r_type == R_PPC64_TLS
7653                           || r_type == R_PPC64_TLSGD
7654                           || r_type == R_PPC64_TLSLD)
7655                         {
7656                           toc_ref[toc_ref_index] = 1;
7657                           continue;
7658                         }
7659
7660                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7661                         continue;
7662
7663                       tls_set = 0;
7664                       tls_clear = 0;
7665                       expecting_tls_get_addr = 2;
7666                       break;
7667
7668                     case R_PPC64_TPREL64:
7669                       if (pass == 0
7670                           || sec != toc
7671                           || toc_ref == NULL
7672                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7673                         continue;
7674                       if (ok_tprel)
7675                         {
7676                           /* IE -> LE */
7677                           tls_set = TLS_EXPLICIT;
7678                           tls_clear = TLS_TPREL;
7679                           break;
7680                         }
7681                       continue;
7682
7683                     case R_PPC64_DTPMOD64:
7684                       if (pass == 0
7685                           || sec != toc
7686                           || toc_ref == NULL
7687                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7688                         continue;
7689                       if (rel + 1 < relend
7690                           && (rel[1].r_info
7691                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7692                           && rel[1].r_offset == rel->r_offset + 8)
7693                         {
7694                           if (ok_tprel)
7695                             /* GD -> LE */
7696                             tls_set = TLS_EXPLICIT | TLS_GD;
7697                           else
7698                             /* GD -> IE */
7699                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7700                           tls_clear = TLS_GD;
7701                         }
7702                       else
7703                         {
7704                           if (!is_local)
7705                             continue;
7706
7707                           /* LD -> LE */
7708                           tls_set = TLS_EXPLICIT;
7709                           tls_clear = TLS_LD;
7710                         }
7711                       break;
7712
7713                     default:
7714                       continue;
7715                     }
7716
7717                   if (pass == 0)
7718                     {
7719                       if (!expecting_tls_get_addr
7720                           || !sec->has_tls_get_addr_call)
7721                         continue;
7722
7723                       if (rel + 1 < relend
7724                           && branch_reloc_hash_match (ibfd, rel + 1,
7725                                                       htab->tls_get_addr,
7726                                                       htab->tls_get_addr_fd))
7727                         {
7728                           if (expecting_tls_get_addr == 2)
7729                             {
7730                               /* Check for toc tls entries.  */
7731                               unsigned char *toc_tls;
7732                               int retval;
7733
7734                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7735                                                      &locsyms,
7736                                                      rel, ibfd);
7737                               if (retval == 0)
7738                                 goto err_free_rel;
7739                               if (toc_tls != NULL)
7740                                 {
7741                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7742                                     found_tls_get_addr_arg = 1;
7743                                   if (retval > 1)
7744                                     toc_ref[toc_ref_index] = 1;
7745                                 }
7746                             }
7747                           continue;
7748                         }
7749
7750                       if (expecting_tls_get_addr != 1)
7751                         continue;
7752
7753                       /* Uh oh, we didn't find the expected call.  We
7754                          could just mark this symbol to exclude it
7755                          from tls optimization but it's safer to skip
7756                          the entire optimization.  */
7757                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
7758                                                 "TLS optimization disabled\n"),
7759                                               ibfd, sec, rel->r_offset);
7760                       ret = TRUE;
7761                       goto err_free_rel;
7762                     }
7763
7764                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7765                     {
7766                       struct plt_entry *ent;
7767                       for (ent = htab->tls_get_addr->elf.plt.plist;
7768                            ent != NULL;
7769                            ent = ent->next)
7770                         if (ent->addend == 0)
7771                           {
7772                             if (ent->plt.refcount > 0)
7773                               {
7774                                 ent->plt.refcount -= 1;
7775                                 expecting_tls_get_addr = 0;
7776                               }
7777                             break;
7778                           }
7779                     }
7780
7781                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7782                     {
7783                       struct plt_entry *ent;
7784                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7785                            ent != NULL;
7786                            ent = ent->next)
7787                         if (ent->addend == 0)
7788                           {
7789                             if (ent->plt.refcount > 0)
7790                               ent->plt.refcount -= 1;
7791                             break;
7792                           }
7793                     }
7794
7795                   if (tls_clear == 0)
7796                     continue;
7797
7798                   if ((tls_set & TLS_EXPLICIT) == 0)
7799                     {
7800                       struct got_entry *ent;
7801
7802                       /* Adjust got entry for this reloc.  */
7803                       if (h != NULL)
7804                         ent = h->got.glist;
7805                       else
7806                         ent = elf_local_got_ents (ibfd)[r_symndx];
7807
7808                       for (; ent != NULL; ent = ent->next)
7809                         if (ent->addend == rel->r_addend
7810                             && ent->owner == ibfd
7811                             && ent->tls_type == tls_type)
7812                           break;
7813                       if (ent == NULL)
7814                         abort ();
7815
7816                       if (tls_set == 0)
7817                         {
7818                           /* We managed to get rid of a got entry.  */
7819                           if (ent->got.refcount > 0)
7820                             ent->got.refcount -= 1;
7821                         }
7822                     }
7823                   else
7824                     {
7825                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7826                          we'll lose one or two dyn relocs.  */
7827                       if (!dec_dynrel_count (rel->r_info, sec, info,
7828                                              NULL, h, sym_sec))
7829                         return FALSE;
7830
7831                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7832                         {
7833                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7834                                                  NULL, h, sym_sec))
7835                             return FALSE;
7836                         }
7837                     }
7838
7839                   *tls_mask |= tls_set;
7840                   *tls_mask &= ~tls_clear;
7841                 }
7842
7843               if (elf_section_data (sec)->relocs != relstart)
7844                 free (relstart);
7845             }
7846
7847         if (locsyms != NULL
7848             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7849           {
7850             if (!info->keep_memory)
7851               free (locsyms);
7852             else
7853               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7854           }
7855       }
7856
7857   if (toc_ref != NULL)
7858     free (toc_ref);
7859   return TRUE;
7860 }
7861
7862 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7863    the values of any global symbols in a toc section that has been
7864    edited.  Globals in toc sections should be a rarity, so this function
7865    sets a flag if any are found in toc sections other than the one just
7866    edited, so that futher hash table traversals can be avoided.  */
7867
7868 struct adjust_toc_info
7869 {
7870   asection *toc;
7871   unsigned long *skip;
7872   bfd_boolean global_toc_syms;
7873 };
7874
7875 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7876
7877 static bfd_boolean
7878 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7879 {
7880   struct ppc_link_hash_entry *eh;
7881   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7882   unsigned long i;
7883
7884   if (h->root.type == bfd_link_hash_indirect)
7885     return TRUE;
7886
7887   if (h->root.type != bfd_link_hash_defined
7888       && h->root.type != bfd_link_hash_defweak)
7889     return TRUE;
7890
7891   eh = (struct ppc_link_hash_entry *) h;
7892   if (eh->adjust_done)
7893     return TRUE;
7894
7895   if (eh->elf.root.u.def.section == toc_inf->toc)
7896     {
7897       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
7898         i = toc_inf->toc->rawsize >> 3;
7899       else
7900         i = eh->elf.root.u.def.value >> 3;
7901
7902       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
7903         {
7904           (*_bfd_error_handler)
7905             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
7906           do
7907             ++i;
7908           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
7909           eh->elf.root.u.def.value = (bfd_vma) i << 3;
7910         }
7911
7912       eh->elf.root.u.def.value -= toc_inf->skip[i];
7913       eh->adjust_done = 1;
7914     }
7915   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7916     toc_inf->global_toc_syms = TRUE;
7917
7918   return TRUE;
7919 }
7920
7921 /* Examine all relocs referencing .toc sections in order to remove
7922    unused .toc entries.  */
7923
7924 bfd_boolean
7925 ppc64_elf_edit_toc (struct bfd_link_info *info)
7926 {
7927   bfd *ibfd;
7928   struct adjust_toc_info toc_inf;
7929   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7930
7931   htab->do_toc_opt = 1;
7932   toc_inf.global_toc_syms = TRUE;
7933   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7934     {
7935       asection *toc, *sec;
7936       Elf_Internal_Shdr *symtab_hdr;
7937       Elf_Internal_Sym *local_syms;
7938       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
7939       unsigned long *skip, *drop;
7940       unsigned char *used;
7941       unsigned char *keep, last, some_unused;
7942
7943       if (!is_ppc64_elf (ibfd))
7944         continue;
7945
7946       toc = bfd_get_section_by_name (ibfd, ".toc");
7947       if (toc == NULL
7948           || toc->size == 0
7949           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7950           || elf_discarded_section (toc))
7951         continue;
7952
7953       toc_relocs = NULL;
7954       local_syms = NULL;
7955       symtab_hdr = &elf_symtab_hdr (ibfd);
7956
7957       /* Look at sections dropped from the final link.  */
7958       skip = NULL;
7959       relstart = NULL;
7960       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7961         {
7962           if (sec->reloc_count == 0
7963               || !elf_discarded_section (sec)
7964               || get_opd_info (sec)
7965               || (sec->flags & SEC_ALLOC) == 0
7966               || (sec->flags & SEC_DEBUGGING) != 0)
7967             continue;
7968
7969           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7970           if (relstart == NULL)
7971             goto error_ret;
7972
7973           /* Run through the relocs to see which toc entries might be
7974              unused.  */
7975           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7976             {
7977               enum elf_ppc64_reloc_type r_type;
7978               unsigned long r_symndx;
7979               asection *sym_sec;
7980               struct elf_link_hash_entry *h;
7981               Elf_Internal_Sym *sym;
7982               bfd_vma val;
7983
7984               r_type = ELF64_R_TYPE (rel->r_info);
7985               switch (r_type)
7986                 {
7987                 default:
7988                   continue;
7989
7990                 case R_PPC64_TOC16:
7991                 case R_PPC64_TOC16_LO:
7992                 case R_PPC64_TOC16_HI:
7993                 case R_PPC64_TOC16_HA:
7994                 case R_PPC64_TOC16_DS:
7995                 case R_PPC64_TOC16_LO_DS:
7996                   break;
7997                 }
7998
7999               r_symndx = ELF64_R_SYM (rel->r_info);
8000               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8001                               r_symndx, ibfd))
8002                 goto error_ret;
8003
8004               if (sym_sec != toc)
8005                 continue;
8006
8007               if (h != NULL)
8008                 val = h->root.u.def.value;
8009               else
8010                 val = sym->st_value;
8011               val += rel->r_addend;
8012
8013               if (val >= toc->size)
8014                 continue;
8015
8016               /* Anything in the toc ought to be aligned to 8 bytes.
8017                  If not, don't mark as unused.  */
8018               if (val & 7)
8019                 continue;
8020
8021               if (skip == NULL)
8022                 {
8023                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8024                   if (skip == NULL)
8025                     goto error_ret;
8026                 }
8027
8028               skip[val >> 3] = ref_from_discarded;
8029             }
8030
8031           if (elf_section_data (sec)->relocs != relstart)
8032             free (relstart);
8033         }
8034
8035       /* For largetoc loads of address constants, we can convert
8036          .  addis rx,2,addr@got@ha
8037          .  ld ry,addr@got@l(rx)
8038          to
8039          .  addis rx,2,addr@toc@ha
8040          .  addi ry,rx,addr@toc@l
8041          when addr is within 2G of the toc pointer.  This then means
8042          that the word storing "addr" in the toc is no longer needed.  */
8043
8044       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8045           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8046           && toc->reloc_count != 0)
8047         {
8048           /* Read toc relocs.  */
8049           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8050                                                   info->keep_memory);
8051           if (toc_relocs == NULL)
8052             goto error_ret;
8053
8054           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8055             {
8056               enum elf_ppc64_reloc_type r_type;
8057               unsigned long r_symndx;
8058               asection *sym_sec;
8059               struct elf_link_hash_entry *h;
8060               Elf_Internal_Sym *sym;
8061               bfd_vma val, addr;
8062
8063               r_type = ELF64_R_TYPE (rel->r_info);
8064               if (r_type != R_PPC64_ADDR64)
8065                 continue;
8066
8067               r_symndx = ELF64_R_SYM (rel->r_info);
8068               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8069                               r_symndx, ibfd))
8070                 goto error_ret;
8071
8072               if (sym_sec == NULL
8073                   || elf_discarded_section (sym_sec))
8074                 continue;
8075
8076               if (!SYMBOL_CALLS_LOCAL (info, h))
8077                 continue;
8078
8079               if (h != NULL)
8080                 {
8081                   if (h->type == STT_GNU_IFUNC)
8082                     continue;
8083                   val = h->root.u.def.value;
8084                 }
8085               else
8086                 {
8087                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8088                     continue;
8089                   val = sym->st_value;
8090                 }
8091               val += rel->r_addend;
8092               val += sym_sec->output_section->vma + sym_sec->output_offset;
8093
8094               /* We don't yet know the exact toc pointer value, but we
8095                  know it will be somewhere in the toc section.  Don't
8096                  optimize if the difference from any possible toc
8097                  pointer is outside [ff..f80008000, 7fff7fff].  */
8098               addr = toc->output_section->vma + TOC_BASE_OFF;
8099               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8100                 continue;
8101
8102               addr = toc->output_section->vma + toc->output_section->rawsize;
8103               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8104                 continue;
8105
8106               if (skip == NULL)
8107                 {
8108                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8109                   if (skip == NULL)
8110                     goto error_ret;
8111                 }
8112
8113               skip[rel->r_offset >> 3]
8114                 |= can_optimize | ((rel - toc_relocs) << 2);
8115             }
8116         }
8117
8118       if (skip == NULL)
8119         continue;
8120
8121       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8122       if (used == NULL)
8123         {
8124         error_ret:
8125           if (local_syms != NULL
8126               && symtab_hdr->contents != (unsigned char *) local_syms)
8127             free (local_syms);
8128           if (sec != NULL
8129               && relstart != NULL
8130               && elf_section_data (sec)->relocs != relstart)
8131             free (relstart);
8132           if (toc_relocs != NULL
8133               && elf_section_data (toc)->relocs != toc_relocs)
8134             free (toc_relocs);
8135           if (skip != NULL)
8136             free (skip);
8137           return FALSE;
8138         }
8139
8140       /* Now check all kept sections that might reference the toc.
8141          Check the toc itself last.  */
8142       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8143                   : ibfd->sections);
8144            sec != NULL;
8145            sec = (sec == toc ? NULL
8146                   : sec->next == NULL ? toc
8147                   : sec->next == toc && toc->next ? toc->next
8148                   : sec->next))
8149         {
8150           int repeat;
8151
8152           if (sec->reloc_count == 0
8153               || elf_discarded_section (sec)
8154               || get_opd_info (sec)
8155               || (sec->flags & SEC_ALLOC) == 0
8156               || (sec->flags & SEC_DEBUGGING) != 0)
8157             continue;
8158
8159           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8160                                                 info->keep_memory);
8161           if (relstart == NULL)
8162             goto error_ret;
8163
8164           /* Mark toc entries referenced as used.  */
8165           repeat = 0;
8166           do
8167             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8168               {
8169                 enum elf_ppc64_reloc_type r_type;
8170                 unsigned long r_symndx;
8171                 asection *sym_sec;
8172                 struct elf_link_hash_entry *h;
8173                 Elf_Internal_Sym *sym;
8174                 bfd_vma val;
8175
8176                 r_type = ELF64_R_TYPE (rel->r_info);
8177                 switch (r_type)
8178                   {
8179                   case R_PPC64_TOC16:
8180                   case R_PPC64_TOC16_LO:
8181                   case R_PPC64_TOC16_HI:
8182                   case R_PPC64_TOC16_HA:
8183                   case R_PPC64_TOC16_DS:
8184                   case R_PPC64_TOC16_LO_DS:
8185                     /* In case we're taking addresses of toc entries.  */
8186                   case R_PPC64_ADDR64:
8187                     break;
8188
8189                   default:
8190                     continue;
8191                   }
8192
8193                 r_symndx = ELF64_R_SYM (rel->r_info);
8194                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8195                                 r_symndx, ibfd))
8196                   {
8197                     free (used);
8198                     goto error_ret;
8199                   }
8200
8201                 if (sym_sec != toc)
8202                   continue;
8203
8204                 if (h != NULL)
8205                   val = h->root.u.def.value;
8206                 else
8207                   val = sym->st_value;
8208                 val += rel->r_addend;
8209
8210                 if (val >= toc->size)
8211                   continue;
8212
8213                 if ((skip[val >> 3] & can_optimize) != 0)
8214                   {
8215                     bfd_vma off;
8216                     unsigned char opc;
8217
8218                     switch (r_type)
8219                       {
8220                       case R_PPC64_TOC16_HA:
8221                         break;
8222
8223                       case R_PPC64_TOC16_LO_DS:
8224                         off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8225                         if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8226                           return FALSE;
8227                         if ((opc & (0x3f << 2)) == (58u << 2))
8228                           break;
8229                         /* Fall thru */
8230
8231                       default:
8232                         /* Wrong sort of reloc, or not a ld.  We may
8233                            as well clear ref_from_discarded too.  */
8234                         skip[val >> 3] = 0;
8235                       }
8236                   }
8237
8238                 /* For the toc section, we only mark as used if
8239                    this entry itself isn't unused.  */
8240                 if (sec == toc
8241                     && !used[val >> 3]
8242                     && (used[rel->r_offset >> 3]
8243                         || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8244                   /* Do all the relocs again, to catch reference
8245                      chains.  */
8246                   repeat = 1;
8247
8248                 used[val >> 3] = 1;
8249               }
8250           while (repeat);
8251
8252           if (elf_section_data (sec)->relocs != relstart)
8253             free (relstart);
8254         }
8255
8256       /* Merge the used and skip arrays.  Assume that TOC
8257          doublewords not appearing as either used or unused belong
8258          to to an entry more than one doubleword in size.  */
8259       for (drop = skip, keep = used, last = 0, some_unused = 0;
8260            drop < skip + (toc->size + 7) / 8;
8261            ++drop, ++keep)
8262         {
8263           if (*keep)
8264             {
8265               *drop &= ~ref_from_discarded;
8266               if ((*drop & can_optimize) != 0)
8267                 some_unused = 1;
8268               last = 0;
8269             }
8270           else if (*drop & ref_from_discarded)
8271             {
8272               some_unused = 1;
8273               last = ref_from_discarded;
8274             }
8275           else
8276             *drop = last;
8277         }
8278
8279       free (used);
8280
8281       if (some_unused)
8282         {
8283           bfd_byte *contents, *src;
8284           unsigned long off;
8285           Elf_Internal_Sym *sym;
8286           bfd_boolean local_toc_syms = FALSE;
8287
8288           /* Shuffle the toc contents, and at the same time convert the
8289              skip array from booleans into offsets.  */
8290           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8291             goto error_ret;
8292
8293           elf_section_data (toc)->this_hdr.contents = contents;
8294
8295           for (src = contents, off = 0, drop = skip;
8296                src < contents + toc->size;
8297                src += 8, ++drop)
8298             {
8299               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8300                 off += 8;
8301               else if (off != 0)
8302                 {
8303                   *drop = off;
8304                   memcpy (src - off, src, 8);
8305                 }
8306             }
8307           *drop = off;
8308           toc->rawsize = toc->size;
8309           toc->size = src - contents - off;
8310
8311           /* Adjust addends for relocs against the toc section sym,
8312              and optimize any accesses we can.  */
8313           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8314             {
8315               if (sec->reloc_count == 0
8316                   || elf_discarded_section (sec))
8317                 continue;
8318
8319               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8320                                                     info->keep_memory);
8321               if (relstart == NULL)
8322                 goto error_ret;
8323
8324               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8325                 {
8326                   enum elf_ppc64_reloc_type r_type;
8327                   unsigned long r_symndx;
8328                   asection *sym_sec;
8329                   struct elf_link_hash_entry *h;
8330                   bfd_vma val;
8331
8332                   r_type = ELF64_R_TYPE (rel->r_info);
8333                   switch (r_type)
8334                     {
8335                     default:
8336                       continue;
8337
8338                     case R_PPC64_TOC16:
8339                     case R_PPC64_TOC16_LO:
8340                     case R_PPC64_TOC16_HI:
8341                     case R_PPC64_TOC16_HA:
8342                     case R_PPC64_TOC16_DS:
8343                     case R_PPC64_TOC16_LO_DS:
8344                     case R_PPC64_ADDR64:
8345                       break;
8346                     }
8347
8348                   r_symndx = ELF64_R_SYM (rel->r_info);
8349                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8350                                   r_symndx, ibfd))
8351                     goto error_ret;
8352
8353                   if (sym_sec != toc)
8354                     continue;
8355
8356                   if (h != NULL)
8357                     val = h->root.u.def.value;
8358                   else
8359                     {
8360                       val = sym->st_value;
8361                       if (val != 0)
8362                         local_toc_syms = TRUE;
8363                     }
8364
8365                   val += rel->r_addend;
8366
8367                   if (val > toc->rawsize)
8368                     val = toc->rawsize;
8369                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8370                     continue;
8371                   else if ((skip[val >> 3] & can_optimize) != 0)
8372                     {
8373                       Elf_Internal_Rela *tocrel
8374                         = toc_relocs + (skip[val >> 3] >> 2);
8375                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8376
8377                       switch (r_type)
8378                         {
8379                         case R_PPC64_TOC16_HA:
8380                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8381                           break;
8382
8383                         case R_PPC64_TOC16_LO_DS:
8384                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8385                           break;
8386
8387                         default:
8388                           abort ();
8389                         }
8390                       rel->r_addend = tocrel->r_addend;
8391                       elf_section_data (sec)->relocs = relstart;
8392                       continue;
8393                     }
8394
8395                   if (h != NULL || sym->st_value != 0)
8396                     continue;
8397
8398                   rel->r_addend -= skip[val >> 3];
8399                   elf_section_data (sec)->relocs = relstart;
8400                 }
8401
8402               if (elf_section_data (sec)->relocs != relstart)
8403                 free (relstart);
8404             }
8405
8406           /* We shouldn't have local or global symbols defined in the TOC,
8407              but handle them anyway.  */
8408           if (local_syms != NULL)
8409             for (sym = local_syms;
8410                  sym < local_syms + symtab_hdr->sh_info;
8411                  ++sym)
8412               if (sym->st_value != 0
8413                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8414                 {
8415                   unsigned long i;
8416
8417                   if (sym->st_value > toc->rawsize)
8418                     i = toc->rawsize >> 3;
8419                   else
8420                     i = sym->st_value >> 3;
8421
8422                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8423                     {
8424                       if (local_toc_syms)
8425                         (*_bfd_error_handler)
8426                           (_("%s defined on removed toc entry"),
8427                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8428                       do
8429                         ++i;
8430                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8431                       sym->st_value = (bfd_vma) i << 3;
8432                     }
8433
8434                   sym->st_value -= skip[i];
8435                   symtab_hdr->contents = (unsigned char *) local_syms;
8436                 }
8437
8438           /* Adjust any global syms defined in this toc input section.  */
8439           if (toc_inf.global_toc_syms)
8440             {
8441               toc_inf.toc = toc;
8442               toc_inf.skip = skip;
8443               toc_inf.global_toc_syms = FALSE;
8444               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8445                                       &toc_inf);
8446             }
8447
8448           if (toc->reloc_count != 0)
8449             {
8450               Elf_Internal_Shdr *rel_hdr;
8451               Elf_Internal_Rela *wrel;
8452               bfd_size_type sz;
8453
8454               /* Remove unused toc relocs, and adjust those we keep.  */
8455               if (toc_relocs == NULL)
8456                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8457                                                         info->keep_memory);
8458               if (toc_relocs == NULL)
8459                 goto error_ret;
8460
8461               wrel = toc_relocs;
8462               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8463                 if ((skip[rel->r_offset >> 3]
8464                      & (ref_from_discarded | can_optimize)) == 0)
8465                   {
8466                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8467                     wrel->r_info = rel->r_info;
8468                     wrel->r_addend = rel->r_addend;
8469                     ++wrel;
8470                   }
8471                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8472                                             &local_syms, NULL, NULL))
8473                   goto error_ret;
8474
8475               elf_section_data (toc)->relocs = toc_relocs;
8476               toc->reloc_count = wrel - toc_relocs;
8477               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8478               sz = rel_hdr->sh_entsize;
8479               rel_hdr->sh_size = toc->reloc_count * sz;
8480             }
8481         }
8482       else if (toc_relocs != NULL
8483                && elf_section_data (toc)->relocs != toc_relocs)
8484         free (toc_relocs);
8485
8486       if (local_syms != NULL
8487           && symtab_hdr->contents != (unsigned char *) local_syms)
8488         {
8489           if (!info->keep_memory)
8490             free (local_syms);
8491           else
8492             symtab_hdr->contents = (unsigned char *) local_syms;
8493         }
8494       free (skip);
8495     }
8496
8497   return TRUE;
8498 }
8499
8500 /* Return true iff input section I references the TOC using
8501    instructions limited to +/-32k offsets.  */
8502
8503 bfd_boolean
8504 ppc64_elf_has_small_toc_reloc (asection *i)
8505 {
8506   return (is_ppc64_elf (i->owner)
8507           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8508 }
8509
8510 /* Allocate space for one GOT entry.  */
8511
8512 static void
8513 allocate_got (struct elf_link_hash_entry *h,
8514               struct bfd_link_info *info,
8515               struct got_entry *gent)
8516 {
8517   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8518   bfd_boolean dyn;
8519   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8520   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8521                  ? 16 : 8);
8522   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8523                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8524   asection *got = ppc64_elf_tdata (gent->owner)->got;
8525
8526   gent->got.offset = got->size;
8527   got->size += entsize;
8528
8529   dyn = htab->elf.dynamic_sections_created;
8530   if ((info->shared
8531        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8532             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8533                 || h->root.type != bfd_link_hash_undefweak))
8534     {
8535       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8536       relgot->size += rentsize;
8537     }
8538   else if (h->type == STT_GNU_IFUNC)
8539     {
8540       asection *relgot = htab->reliplt;
8541       relgot->size += rentsize;
8542       htab->got_reli_size += rentsize;
8543     }
8544 }
8545
8546 /* This function merges got entries in the same toc group.  */
8547
8548 static void
8549 merge_got_entries (struct got_entry **pent)
8550 {
8551   struct got_entry *ent, *ent2;
8552
8553   for (ent = *pent; ent != NULL; ent = ent->next)
8554     if (!ent->is_indirect)
8555       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8556         if (!ent2->is_indirect
8557             && ent2->addend == ent->addend
8558             && ent2->tls_type == ent->tls_type
8559             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8560           {
8561             ent2->is_indirect = TRUE;
8562             ent2->got.ent = ent;
8563           }
8564 }
8565
8566 /* Allocate space in .plt, .got and associated reloc sections for
8567    dynamic relocs.  */
8568
8569 static bfd_boolean
8570 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8571 {
8572   struct bfd_link_info *info;
8573   struct ppc_link_hash_table *htab;
8574   asection *s;
8575   struct ppc_link_hash_entry *eh;
8576   struct elf_dyn_relocs *p;
8577   struct got_entry **pgent, *gent;
8578
8579   if (h->root.type == bfd_link_hash_indirect)
8580     return TRUE;
8581
8582   info = (struct bfd_link_info *) inf;
8583   htab = ppc_hash_table (info);
8584   if (htab == NULL)
8585     return FALSE;
8586
8587   if ((htab->elf.dynamic_sections_created
8588        && h->dynindx != -1
8589        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8590       || h->type == STT_GNU_IFUNC)
8591     {
8592       struct plt_entry *pent;
8593       bfd_boolean doneone = FALSE;
8594       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8595         if (pent->plt.refcount > 0)
8596           {
8597             if (!htab->elf.dynamic_sections_created
8598                 || h->dynindx == -1)
8599               {
8600                 s = htab->iplt;
8601                 pent->plt.offset = s->size;
8602                 s->size += PLT_ENTRY_SIZE;
8603                 s = htab->reliplt;
8604               }
8605             else
8606               {
8607                 /* If this is the first .plt entry, make room for the special
8608                    first entry.  */
8609                 s = htab->plt;
8610                 if (s->size == 0)
8611                   s->size += PLT_INITIAL_ENTRY_SIZE;
8612
8613                 pent->plt.offset = s->size;
8614
8615                 /* Make room for this entry.  */
8616                 s->size += PLT_ENTRY_SIZE;
8617
8618                 /* Make room for the .glink code.  */
8619                 s = htab->glink;
8620                 if (s->size == 0)
8621                   s->size += GLINK_CALL_STUB_SIZE;
8622                 /* We need bigger stubs past index 32767.  */
8623                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8624                   s->size += 4;
8625                 s->size += 2*4;
8626
8627                 /* We also need to make an entry in the .rela.plt section.  */
8628                 s = htab->relplt;
8629               }
8630             s->size += sizeof (Elf64_External_Rela);
8631             doneone = TRUE;
8632           }
8633         else
8634           pent->plt.offset = (bfd_vma) -1;
8635       if (!doneone)
8636         {
8637           h->plt.plist = NULL;
8638           h->needs_plt = 0;
8639         }
8640     }
8641   else
8642     {
8643       h->plt.plist = NULL;
8644       h->needs_plt = 0;
8645     }
8646
8647   eh = (struct ppc_link_hash_entry *) h;
8648   /* Run through the TLS GD got entries first if we're changing them
8649      to TPREL.  */
8650   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8651     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8652       if (gent->got.refcount > 0
8653           && (gent->tls_type & TLS_GD) != 0)
8654         {
8655           /* This was a GD entry that has been converted to TPREL.  If
8656              there happens to be a TPREL entry we can use that one.  */
8657           struct got_entry *ent;
8658           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8659             if (ent->got.refcount > 0
8660                 && (ent->tls_type & TLS_TPREL) != 0
8661                 && ent->addend == gent->addend
8662                 && ent->owner == gent->owner)
8663               {
8664                 gent->got.refcount = 0;
8665                 break;
8666               }
8667
8668           /* If not, then we'll be using our own TPREL entry.  */
8669           if (gent->got.refcount != 0)
8670             gent->tls_type = TLS_TLS | TLS_TPREL;
8671         }
8672
8673   /* Remove any list entry that won't generate a word in the GOT before
8674      we call merge_got_entries.  Otherwise we risk merging to empty
8675      entries.  */
8676   pgent = &h->got.glist;
8677   while ((gent = *pgent) != NULL)
8678     if (gent->got.refcount > 0)
8679       {
8680         if ((gent->tls_type & TLS_LD) != 0
8681             && !h->def_dynamic)
8682           {
8683             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8684             *pgent = gent->next;
8685           }
8686         else
8687           pgent = &gent->next;
8688       }
8689     else
8690       *pgent = gent->next;
8691
8692   if (!htab->do_multi_toc)
8693     merge_got_entries (&h->got.glist);
8694
8695   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8696     if (!gent->is_indirect)
8697       {
8698         /* Make sure this symbol is output as a dynamic symbol.
8699            Undefined weak syms won't yet be marked as dynamic,
8700            nor will all TLS symbols.  */
8701         if (h->dynindx == -1
8702             && !h->forced_local
8703             && h->type != STT_GNU_IFUNC
8704             && htab->elf.dynamic_sections_created)
8705           {
8706             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8707               return FALSE;
8708           }
8709
8710         if (!is_ppc64_elf (gent->owner))
8711           abort ();
8712
8713         allocate_got (h, info, gent);
8714       }
8715
8716   if (eh->dyn_relocs == NULL
8717       || (!htab->elf.dynamic_sections_created
8718           && h->type != STT_GNU_IFUNC))
8719     return TRUE;
8720
8721   /* In the shared -Bsymbolic case, discard space allocated for
8722      dynamic pc-relative relocs against symbols which turn out to be
8723      defined in regular objects.  For the normal shared case, discard
8724      space for relocs that have become local due to symbol visibility
8725      changes.  */
8726
8727   if (info->shared)
8728     {
8729       /* Relocs that use pc_count are those that appear on a call insn,
8730          or certain REL relocs (see must_be_dyn_reloc) that can be
8731          generated via assembly.  We want calls to protected symbols to
8732          resolve directly to the function rather than going via the plt.
8733          If people want function pointer comparisons to work as expected
8734          then they should avoid writing weird assembly.  */
8735       if (SYMBOL_CALLS_LOCAL (info, h))
8736         {
8737           struct elf_dyn_relocs **pp;
8738
8739           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8740             {
8741               p->count -= p->pc_count;
8742               p->pc_count = 0;
8743               if (p->count == 0)
8744                 *pp = p->next;
8745               else
8746                 pp = &p->next;
8747             }
8748         }
8749
8750       /* Also discard relocs on undefined weak syms with non-default
8751          visibility.  */
8752       if (eh->dyn_relocs != NULL
8753           && h->root.type == bfd_link_hash_undefweak)
8754         {
8755           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8756             eh->dyn_relocs = NULL;
8757
8758           /* Make sure this symbol is output as a dynamic symbol.
8759              Undefined weak syms won't yet be marked as dynamic.  */
8760           else if (h->dynindx == -1
8761                    && !h->forced_local)
8762             {
8763               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8764                 return FALSE;
8765             }
8766         }
8767     }
8768   else if (h->type == STT_GNU_IFUNC)
8769     {
8770       if (!h->non_got_ref)
8771         eh->dyn_relocs = NULL;
8772     }
8773   else if (ELIMINATE_COPY_RELOCS)
8774     {
8775       /* For the non-shared case, discard space for relocs against
8776          symbols which turn out to need copy relocs or are not
8777          dynamic.  */
8778
8779       if (!h->non_got_ref
8780           && !h->def_regular)
8781         {
8782           /* Make sure this symbol is output as a dynamic symbol.
8783              Undefined weak syms won't yet be marked as dynamic.  */
8784           if (h->dynindx == -1
8785               && !h->forced_local)
8786             {
8787               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8788                 return FALSE;
8789             }
8790
8791           /* If that succeeded, we know we'll be keeping all the
8792              relocs.  */
8793           if (h->dynindx != -1)
8794             goto keep;
8795         }
8796
8797       eh->dyn_relocs = NULL;
8798
8799     keep: ;
8800     }
8801
8802   /* Finally, allocate space.  */
8803   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8804     {
8805       asection *sreloc = elf_section_data (p->sec)->sreloc;
8806       if (!htab->elf.dynamic_sections_created)
8807         sreloc = htab->reliplt;
8808       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8809     }
8810
8811   return TRUE;
8812 }
8813
8814 /* Find any dynamic relocs that apply to read-only sections.  */
8815
8816 static bfd_boolean
8817 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8818 {
8819   struct ppc_link_hash_entry *eh;
8820   struct elf_dyn_relocs *p;
8821
8822   eh = (struct ppc_link_hash_entry *) h;
8823   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8824     {
8825       asection *s = p->sec->output_section;
8826
8827       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8828         {
8829           struct bfd_link_info *info = inf;
8830
8831           info->flags |= DF_TEXTREL;
8832
8833           /* Not an error, just cut short the traversal.  */
8834           return FALSE;
8835         }
8836     }
8837   return TRUE;
8838 }
8839
8840 /* Set the sizes of the dynamic sections.  */
8841
8842 static bfd_boolean
8843 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8844                                  struct bfd_link_info *info)
8845 {
8846   struct ppc_link_hash_table *htab;
8847   bfd *dynobj;
8848   asection *s;
8849   bfd_boolean relocs;
8850   bfd *ibfd;
8851   struct got_entry *first_tlsld;
8852
8853   htab = ppc_hash_table (info);
8854   if (htab == NULL)
8855     return FALSE;
8856
8857   dynobj = htab->elf.dynobj;
8858   if (dynobj == NULL)
8859     abort ();
8860
8861   if (htab->elf.dynamic_sections_created)
8862     {
8863       /* Set the contents of the .interp section to the interpreter.  */
8864       if (info->executable)
8865         {
8866           s = bfd_get_section_by_name (dynobj, ".interp");
8867           if (s == NULL)
8868             abort ();
8869           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8870           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8871         }
8872     }
8873
8874   /* Set up .got offsets for local syms, and space for local dynamic
8875      relocs.  */
8876   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8877     {
8878       struct got_entry **lgot_ents;
8879       struct got_entry **end_lgot_ents;
8880       struct plt_entry **local_plt;
8881       struct plt_entry **end_local_plt;
8882       unsigned char *lgot_masks;
8883       bfd_size_type locsymcount;
8884       Elf_Internal_Shdr *symtab_hdr;
8885       asection *srel;
8886
8887       if (!is_ppc64_elf (ibfd))
8888         continue;
8889
8890       for (s = ibfd->sections; s != NULL; s = s->next)
8891         {
8892           struct elf_dyn_relocs *p;
8893
8894           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8895             {
8896               if (!bfd_is_abs_section (p->sec)
8897                   && bfd_is_abs_section (p->sec->output_section))
8898                 {
8899                   /* Input section has been discarded, either because
8900                      it is a copy of a linkonce section or due to
8901                      linker script /DISCARD/, so we'll be discarding
8902                      the relocs too.  */
8903                 }
8904               else if (p->count != 0)
8905                 {
8906                   srel = elf_section_data (p->sec)->sreloc;
8907                   if (!htab->elf.dynamic_sections_created)
8908                     srel = htab->reliplt;
8909                   srel->size += p->count * sizeof (Elf64_External_Rela);
8910                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8911                     info->flags |= DF_TEXTREL;
8912                 }
8913             }
8914         }
8915
8916       lgot_ents = elf_local_got_ents (ibfd);
8917       if (!lgot_ents)
8918         continue;
8919
8920       symtab_hdr = &elf_symtab_hdr (ibfd);
8921       locsymcount = symtab_hdr->sh_info;
8922       end_lgot_ents = lgot_ents + locsymcount;
8923       local_plt = (struct plt_entry **) end_lgot_ents;
8924       end_local_plt = local_plt + locsymcount;
8925       lgot_masks = (unsigned char *) end_local_plt;
8926       s = ppc64_elf_tdata (ibfd)->got;
8927       srel = ppc64_elf_tdata (ibfd)->relgot;
8928       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8929         {
8930           struct got_entry **pent, *ent;
8931
8932           pent = lgot_ents;
8933           while ((ent = *pent) != NULL)
8934             if (ent->got.refcount > 0)
8935               {
8936                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8937                   {
8938                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
8939                     *pent = ent->next;
8940                   }
8941                 else
8942                   {
8943                     unsigned int num = 1;
8944                     ent->got.offset = s->size;
8945                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8946                       num = 2;
8947                     s->size += num * 8;
8948                     if (info->shared)
8949                       srel->size += num * sizeof (Elf64_External_Rela);
8950                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8951                       {
8952                         htab->reliplt->size
8953                           += num * sizeof (Elf64_External_Rela);
8954                         htab->got_reli_size
8955                           += num * sizeof (Elf64_External_Rela);
8956                       }
8957                     pent = &ent->next;
8958                   }
8959               }
8960             else
8961               *pent = ent->next;
8962         }
8963
8964       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8965       for (; local_plt < end_local_plt; ++local_plt)
8966         {
8967           struct plt_entry *ent;
8968
8969           for (ent = *local_plt; ent != NULL; ent = ent->next)
8970             if (ent->plt.refcount > 0)
8971               {
8972                 s = htab->iplt;
8973                 ent->plt.offset = s->size;
8974                 s->size += PLT_ENTRY_SIZE;
8975
8976                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8977               }
8978             else
8979               ent->plt.offset = (bfd_vma) -1;
8980         }
8981     }
8982
8983   /* Allocate global sym .plt and .got entries, and space for global
8984      sym dynamic relocs.  */
8985   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8986
8987   first_tlsld = NULL;
8988   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8989     {
8990       struct got_entry *ent;
8991
8992       if (!is_ppc64_elf (ibfd))
8993         continue;
8994
8995       ent = ppc64_tlsld_got (ibfd);
8996       if (ent->got.refcount > 0)
8997         {
8998           if (!htab->do_multi_toc && first_tlsld != NULL)
8999             {
9000               ent->is_indirect = TRUE;
9001               ent->got.ent = first_tlsld;
9002             }
9003           else
9004             {
9005               if (first_tlsld == NULL)
9006                 first_tlsld = ent;
9007               s = ppc64_elf_tdata (ibfd)->got;
9008               ent->got.offset = s->size;
9009               ent->owner = ibfd;
9010               s->size += 16;
9011               if (info->shared)
9012                 {
9013                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9014                   srel->size += sizeof (Elf64_External_Rela);
9015                 }
9016             }
9017         }
9018       else
9019         ent->got.offset = (bfd_vma) -1;
9020     }
9021
9022   /* We now have determined the sizes of the various dynamic sections.
9023      Allocate memory for them.  */
9024   relocs = FALSE;
9025   for (s = dynobj->sections; s != NULL; s = s->next)
9026     {
9027       if ((s->flags & SEC_LINKER_CREATED) == 0)
9028         continue;
9029
9030       if (s == htab->brlt || s == htab->relbrlt)
9031         /* These haven't been allocated yet;  don't strip.  */
9032         continue;
9033       else if (s == htab->got
9034                || s == htab->plt
9035                || s == htab->iplt
9036                || s == htab->glink
9037                || s == htab->dynbss)
9038         {
9039           /* Strip this section if we don't need it; see the
9040              comment below.  */
9041         }
9042       else if (s == htab->glink_eh_frame)
9043         {
9044           if (!bfd_is_abs_section (s->output_section))
9045             /* Not sized yet.  */
9046             continue;
9047         }
9048       else if (CONST_STRNEQ (s->name, ".rela"))
9049         {
9050           if (s->size != 0)
9051             {
9052               if (s != htab->relplt)
9053                 relocs = TRUE;
9054
9055               /* We use the reloc_count field as a counter if we need
9056                  to copy relocs into the output file.  */
9057               s->reloc_count = 0;
9058             }
9059         }
9060       else
9061         {
9062           /* It's not one of our sections, so don't allocate space.  */
9063           continue;
9064         }
9065
9066       if (s->size == 0)
9067         {
9068           /* If we don't need this section, strip it from the
9069              output file.  This is mostly to handle .rela.bss and
9070              .rela.plt.  We must create both sections in
9071              create_dynamic_sections, because they must be created
9072              before the linker maps input sections to output
9073              sections.  The linker does that before
9074              adjust_dynamic_symbol is called, and it is that
9075              function which decides whether anything needs to go
9076              into these sections.  */
9077           s->flags |= SEC_EXCLUDE;
9078           continue;
9079         }
9080
9081       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9082         continue;
9083
9084       /* Allocate memory for the section contents.  We use bfd_zalloc
9085          here in case unused entries are not reclaimed before the
9086          section's contents are written out.  This should not happen,
9087          but this way if it does we get a R_PPC64_NONE reloc in .rela
9088          sections instead of garbage.
9089          We also rely on the section contents being zero when writing
9090          the GOT.  */
9091       s->contents = bfd_zalloc (dynobj, s->size);
9092       if (s->contents == NULL)
9093         return FALSE;
9094     }
9095
9096   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9097     {
9098       if (!is_ppc64_elf (ibfd))
9099         continue;
9100
9101       s = ppc64_elf_tdata (ibfd)->got;
9102       if (s != NULL && s != htab->got)
9103         {
9104           if (s->size == 0)
9105             s->flags |= SEC_EXCLUDE;
9106           else
9107             {
9108               s->contents = bfd_zalloc (ibfd, s->size);
9109               if (s->contents == NULL)
9110                 return FALSE;
9111             }
9112         }
9113       s = ppc64_elf_tdata (ibfd)->relgot;
9114       if (s != NULL)
9115         {
9116           if (s->size == 0)
9117             s->flags |= SEC_EXCLUDE;
9118           else
9119             {
9120               s->contents = bfd_zalloc (ibfd, s->size);
9121               if (s->contents == NULL)
9122                 return FALSE;
9123               relocs = TRUE;
9124               s->reloc_count = 0;
9125             }
9126         }
9127     }
9128
9129   if (htab->elf.dynamic_sections_created)
9130     {
9131       /* Add some entries to the .dynamic section.  We fill in the
9132          values later, in ppc64_elf_finish_dynamic_sections, but we
9133          must add the entries now so that we get the correct size for
9134          the .dynamic section.  The DT_DEBUG entry is filled in by the
9135          dynamic linker and used by the debugger.  */
9136 #define add_dynamic_entry(TAG, VAL) \
9137   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9138
9139       if (info->executable)
9140         {
9141           if (!add_dynamic_entry (DT_DEBUG, 0))
9142             return FALSE;
9143         }
9144
9145       if (htab->plt != NULL && htab->plt->size != 0)
9146         {
9147           if (!add_dynamic_entry (DT_PLTGOT, 0)
9148               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9149               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9150               || !add_dynamic_entry (DT_JMPREL, 0)
9151               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9152             return FALSE;
9153         }
9154
9155       if (NO_OPD_RELOCS)
9156         {
9157           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9158               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9159             return FALSE;
9160         }
9161
9162       if (!htab->no_tls_get_addr_opt
9163           && htab->tls_get_addr_fd != NULL
9164           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9165           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9166         return FALSE;
9167
9168       if (relocs)
9169         {
9170           if (!add_dynamic_entry (DT_RELA, 0)
9171               || !add_dynamic_entry (DT_RELASZ, 0)
9172               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9173             return FALSE;
9174
9175           /* If any dynamic relocs apply to a read-only section,
9176              then we need a DT_TEXTREL entry.  */
9177           if ((info->flags & DF_TEXTREL) == 0)
9178             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9179
9180           if ((info->flags & DF_TEXTREL) != 0)
9181             {
9182               if (!add_dynamic_entry (DT_TEXTREL, 0))
9183                 return FALSE;
9184             }
9185         }
9186     }
9187 #undef add_dynamic_entry
9188
9189   return TRUE;
9190 }
9191
9192 /* Determine the type of stub needed, if any, for a call.  */
9193
9194 static inline enum ppc_stub_type
9195 ppc_type_of_stub (asection *input_sec,
9196                   const Elf_Internal_Rela *rel,
9197                   struct ppc_link_hash_entry **hash,
9198                   struct plt_entry **plt_ent,
9199                   bfd_vma destination)
9200 {
9201   struct ppc_link_hash_entry *h = *hash;
9202   bfd_vma location;
9203   bfd_vma branch_offset;
9204   bfd_vma max_branch_offset;
9205   enum elf_ppc64_reloc_type r_type;
9206
9207   if (h != NULL)
9208     {
9209       struct plt_entry *ent;
9210       struct ppc_link_hash_entry *fdh = h;
9211       if (h->oh != NULL
9212           && h->oh->is_func_descriptor)
9213         {
9214           fdh = ppc_follow_link (h->oh);
9215           *hash = fdh;
9216         }
9217
9218       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9219         if (ent->addend == rel->r_addend
9220             && ent->plt.offset != (bfd_vma) -1)
9221           {
9222             *plt_ent = ent;
9223             return ppc_stub_plt_call;
9224           }
9225
9226       /* Here, we know we don't have a plt entry.  If we don't have a
9227          either a defined function descriptor or a defined entry symbol
9228          in a regular object file, then it is pointless trying to make
9229          any other type of stub.  */
9230       if (!is_static_defined (&fdh->elf)
9231           && !is_static_defined (&h->elf))
9232         return ppc_stub_none;
9233     }
9234   else if (elf_local_got_ents (input_sec->owner) != NULL)
9235     {
9236       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9237       struct plt_entry **local_plt = (struct plt_entry **)
9238         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9239       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9240
9241       if (local_plt[r_symndx] != NULL)
9242         {
9243           struct plt_entry *ent;
9244
9245           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9246             if (ent->addend == rel->r_addend
9247                 && ent->plt.offset != (bfd_vma) -1)
9248               {
9249                 *plt_ent = ent;
9250                 return ppc_stub_plt_call;
9251               }
9252         }
9253     }
9254
9255   /* Determine where the call point is.  */
9256   location = (input_sec->output_offset
9257               + input_sec->output_section->vma
9258               + rel->r_offset);
9259
9260   branch_offset = destination - location;
9261   r_type = ELF64_R_TYPE (rel->r_info);
9262
9263   /* Determine if a long branch stub is needed.  */
9264   max_branch_offset = 1 << 25;
9265   if (r_type != R_PPC64_REL24)
9266     max_branch_offset = 1 << 15;
9267
9268   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9269     /* We need a stub.  Figure out whether a long_branch or plt_branch
9270        is needed later.  */
9271     return ppc_stub_long_branch;
9272
9273   return ppc_stub_none;
9274 }
9275
9276 /* Build a .plt call stub.  */
9277
9278 static inline bfd_byte *
9279 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r,
9280                 bfd_boolean plt_static_chain)
9281 {
9282 #define PPC_LO(v) ((v) & 0xffff)
9283 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9284 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9285
9286   if (PPC_HA (offset) != 0)
9287     {
9288       if (r != NULL)
9289         {
9290           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9291           r[1].r_offset = r[0].r_offset + 8;
9292           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9293           r[1].r_addend = r[0].r_addend;
9294           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9295             {
9296               r[2].r_offset = r[1].r_offset + 4;
9297               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9298               r[2].r_addend = r[0].r_addend;
9299             }
9300           else
9301             {
9302               r[2].r_offset = r[1].r_offset + 8;
9303               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9304               r[2].r_addend = r[0].r_addend + 8;
9305               if (plt_static_chain)
9306                 {
9307                   r[3].r_offset = r[2].r_offset + 4;
9308                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9309                   r[3].r_addend = r[0].r_addend + 16;
9310                 }
9311             }
9312         }
9313       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9314       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9315       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9316       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9317         {
9318           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9319           offset = 0;
9320         }
9321       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9322       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9323       if (plt_static_chain)
9324         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9325       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9326     }
9327   else
9328     {
9329       if (r != NULL)
9330         {
9331           r[0].r_offset += 4;
9332           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9333           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9334             {
9335               r[1].r_offset = r[0].r_offset + 4;
9336               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9337               r[1].r_addend = r[0].r_addend;
9338             }
9339           else
9340             {
9341               r[1].r_offset = r[0].r_offset + 8;
9342               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9343               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9344               if (plt_static_chain)
9345                 {
9346                   r[2].r_offset = r[1].r_offset + 4;
9347                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9348                   r[2].r_addend = r[0].r_addend + 8;
9349                 }
9350             }
9351         }
9352       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9353       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9354       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9355         {
9356           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9357           offset = 0;
9358         }
9359       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9360       if (plt_static_chain)
9361         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9362       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9363       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9364     }
9365   return p;
9366 }
9367
9368 /* Build a special .plt call stub for __tls_get_addr.  */
9369
9370 #define LD_R11_0R3      0xe9630000
9371 #define LD_R12_0R3      0xe9830000
9372 #define MR_R0_R3        0x7c601b78
9373 #define CMPDI_R11_0     0x2c2b0000
9374 #define ADD_R3_R12_R13  0x7c6c6a14
9375 #define BEQLR           0x4d820020
9376 #define MR_R3_R0        0x7c030378
9377 #define MFLR_R11        0x7d6802a6
9378 #define STD_R11_0R1     0xf9610000
9379 #define BCTRL           0x4e800421
9380 #define LD_R11_0R1      0xe9610000
9381 #define LD_R2_0R1       0xe8410000
9382 #define MTLR_R11        0x7d6803a6
9383
9384 static inline bfd_byte *
9385 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9386                          Elf_Internal_Rela *r, bfd_boolean plt_static_chain)
9387 {
9388   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9389   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9390   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9391   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9392   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9393   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9394   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9395   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9396   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9397
9398   if (r != NULL)
9399     r[0].r_offset += 9 * 4;
9400   p = build_plt_stub (obfd, p, offset, r, plt_static_chain);
9401   bfd_put_32 (obfd, BCTRL, p - 4);
9402
9403   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9404   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9405   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9406   bfd_put_32 (obfd, BLR, p),                    p += 4;
9407
9408   return p;
9409 }
9410
9411 static Elf_Internal_Rela *
9412 get_relocs (asection *sec, int count)
9413 {
9414   Elf_Internal_Rela *relocs;
9415   struct bfd_elf_section_data *elfsec_data;
9416
9417   elfsec_data = elf_section_data (sec);
9418   relocs = elfsec_data->relocs;
9419   if (relocs == NULL)
9420     {
9421       bfd_size_type relsize;
9422       relsize = sec->reloc_count * sizeof (*relocs);
9423       relocs = bfd_alloc (sec->owner, relsize);
9424       if (relocs == NULL)
9425         return NULL;
9426       elfsec_data->relocs = relocs;
9427       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9428                                           sizeof (Elf_Internal_Shdr));
9429       if (elfsec_data->rela.hdr == NULL)
9430         return NULL;
9431       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9432                                         * sizeof (Elf64_External_Rela));
9433       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9434       sec->reloc_count = 0;
9435     }
9436   relocs += sec->reloc_count;
9437   sec->reloc_count += count;
9438   return relocs;
9439 }
9440
9441 static bfd_vma
9442 get_r2off (struct bfd_link_info *info,
9443            struct ppc_stub_hash_entry *stub_entry)
9444 {
9445   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9446   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9447
9448   if (r2off == 0)
9449     {
9450       /* Support linking -R objects.  Get the toc pointer from the
9451          opd entry.  */
9452       char buf[8];
9453       asection *opd = stub_entry->h->elf.root.u.def.section;
9454       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9455
9456       if (strcmp (opd->name, ".opd") != 0
9457           || opd->reloc_count != 0)
9458         {
9459           info->callbacks->einfo (_("%P: cannot find opd entry toc for %s\n"),
9460                                   stub_entry->h->elf.root.root.string);
9461           bfd_set_error (bfd_error_bad_value);
9462           return 0;
9463         }
9464       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9465         return 0;
9466       r2off = bfd_get_64 (opd->owner, buf);
9467       r2off -= elf_gp (info->output_bfd);
9468     }
9469   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9470   return r2off;
9471 }
9472
9473 static bfd_boolean
9474 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9475 {
9476   struct ppc_stub_hash_entry *stub_entry;
9477   struct ppc_branch_hash_entry *br_entry;
9478   struct bfd_link_info *info;
9479   struct ppc_link_hash_table *htab;
9480   bfd_byte *loc;
9481   bfd_byte *p;
9482   bfd_vma dest, off;
9483   int size;
9484   Elf_Internal_Rela *r;
9485   asection *plt;
9486
9487   /* Massage our args to the form they really have.  */
9488   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9489   info = in_arg;
9490
9491   htab = ppc_hash_table (info);
9492   if (htab == NULL)
9493     return FALSE;
9494
9495   /* Make a note of the offset within the stubs for this entry.  */
9496   stub_entry->stub_offset = stub_entry->stub_sec->size;
9497   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9498
9499   htab->stub_count[stub_entry->stub_type - 1] += 1;
9500   switch (stub_entry->stub_type)
9501     {
9502     case ppc_stub_long_branch:
9503     case ppc_stub_long_branch_r2off:
9504       /* Branches are relative.  This is where we are going to.  */
9505       off = dest = (stub_entry->target_value
9506                     + stub_entry->target_section->output_offset
9507                     + stub_entry->target_section->output_section->vma);
9508
9509       /* And this is where we are coming from.  */
9510       off -= (stub_entry->stub_offset
9511               + stub_entry->stub_sec->output_offset
9512               + stub_entry->stub_sec->output_section->vma);
9513
9514       size = 4;
9515       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9516         {
9517           bfd_vma r2off = get_r2off (info, stub_entry);
9518
9519           if (r2off == 0)
9520             {
9521               htab->stub_error = TRUE;
9522               return FALSE;
9523             }
9524           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9525           loc += 4;
9526           size = 12;
9527           if (PPC_HA (r2off) != 0)
9528             {
9529               size = 16;
9530               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9531               loc += 4;
9532             }
9533           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9534           loc += 4;
9535           off -= size - 4;
9536         }
9537       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9538
9539       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9540         {
9541           info->callbacks->einfo (_("%P: long branch stub `%s' offset overflow\n"),
9542                                   stub_entry->root.string);
9543           htab->stub_error = TRUE;
9544           return FALSE;
9545         }
9546
9547       if (info->emitrelocations)
9548         {
9549           r = get_relocs (stub_entry->stub_sec, 1);
9550           if (r == NULL)
9551             return FALSE;
9552           r->r_offset = loc - stub_entry->stub_sec->contents;
9553           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9554           r->r_addend = dest;
9555           if (stub_entry->h != NULL)
9556             {
9557               struct elf_link_hash_entry **hashes;
9558               unsigned long symndx;
9559               struct ppc_link_hash_entry *h;
9560
9561               hashes = elf_sym_hashes (htab->stub_bfd);
9562               if (hashes == NULL)
9563                 {
9564                   bfd_size_type hsize;
9565
9566                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9567                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9568                   if (hashes == NULL)
9569                     return FALSE;
9570                   elf_sym_hashes (htab->stub_bfd) = hashes;
9571                   htab->stub_globals = 1;
9572                 }
9573               symndx = htab->stub_globals++;
9574               h = stub_entry->h;
9575               hashes[symndx] = &h->elf;
9576               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9577               if (h->oh != NULL && h->oh->is_func)
9578                 h = ppc_follow_link (h->oh);
9579               if (h->elf.root.u.def.section != stub_entry->target_section)
9580                 /* H is an opd symbol.  The addend must be zero.  */
9581                 r->r_addend = 0;
9582               else
9583                 {
9584                   off = (h->elf.root.u.def.value
9585                          + h->elf.root.u.def.section->output_offset
9586                          + h->elf.root.u.def.section->output_section->vma);
9587                   r->r_addend -= off;
9588                 }
9589             }
9590         }
9591       break;
9592
9593     case ppc_stub_plt_branch:
9594     case ppc_stub_plt_branch_r2off:
9595       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9596                                          stub_entry->root.string + 9,
9597                                          FALSE, FALSE);
9598       if (br_entry == NULL)
9599         {
9600           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
9601                                   stub_entry->root.string);
9602           htab->stub_error = TRUE;
9603           return FALSE;
9604         }
9605
9606       dest = (stub_entry->target_value
9607               + stub_entry->target_section->output_offset
9608               + stub_entry->target_section->output_section->vma);
9609
9610       bfd_put_64 (htab->brlt->owner, dest,
9611                   htab->brlt->contents + br_entry->offset);
9612
9613       if (br_entry->iter == htab->stub_iteration)
9614         {
9615           br_entry->iter = 0;
9616
9617           if (htab->relbrlt != NULL)
9618             {
9619               /* Create a reloc for the branch lookup table entry.  */
9620               Elf_Internal_Rela rela;
9621               bfd_byte *rl;
9622
9623               rela.r_offset = (br_entry->offset
9624                                + htab->brlt->output_offset
9625                                + htab->brlt->output_section->vma);
9626               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9627               rela.r_addend = dest;
9628
9629               rl = htab->relbrlt->contents;
9630               rl += (htab->relbrlt->reloc_count++
9631                      * sizeof (Elf64_External_Rela));
9632               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9633             }
9634           else if (info->emitrelocations)
9635             {
9636               r = get_relocs (htab->brlt, 1);
9637               if (r == NULL)
9638                 return FALSE;
9639               /* brlt, being SEC_LINKER_CREATED does not go through the
9640                  normal reloc processing.  Symbols and offsets are not
9641                  translated from input file to output file form, so
9642                  set up the offset per the output file.  */
9643               r->r_offset = (br_entry->offset
9644                              + htab->brlt->output_offset
9645                              + htab->brlt->output_section->vma);
9646               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9647               r->r_addend = dest;
9648             }
9649         }
9650
9651       dest = (br_entry->offset
9652               + htab->brlt->output_offset
9653               + htab->brlt->output_section->vma);
9654
9655       off = (dest
9656              - elf_gp (htab->brlt->output_section->owner)
9657              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9658
9659       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9660         {
9661           info->callbacks->einfo
9662             (_("%P: linkage table error against `%s'\n"),
9663              stub_entry->root.string);
9664           bfd_set_error (bfd_error_bad_value);
9665           htab->stub_error = TRUE;
9666           return FALSE;
9667         }
9668
9669       if (info->emitrelocations)
9670         {
9671           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9672           if (r == NULL)
9673             return FALSE;
9674           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9675           if (bfd_big_endian (info->output_bfd))
9676             r[0].r_offset += 2;
9677           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9678             r[0].r_offset += 4;
9679           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9680           r[0].r_addend = dest;
9681           if (PPC_HA (off) != 0)
9682             {
9683               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9684               r[1].r_offset = r[0].r_offset + 4;
9685               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9686               r[1].r_addend = r[0].r_addend;
9687             }
9688         }
9689
9690       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9691         {
9692           if (PPC_HA (off) != 0)
9693             {
9694               size = 16;
9695               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9696               loc += 4;
9697               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9698             }
9699           else
9700             {
9701               size = 12;
9702               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9703             }
9704         }
9705       else
9706         {
9707           bfd_vma r2off = get_r2off (info, stub_entry);
9708
9709           if (r2off == 0)
9710             {
9711               htab->stub_error = TRUE;
9712               return FALSE;
9713             }
9714
9715           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9716           loc += 4;
9717           size = 20;
9718           if (PPC_HA (off) != 0)
9719             {
9720               size += 4;
9721               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9722               loc += 4;
9723               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9724               loc += 4;
9725             }
9726           else
9727             {
9728               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9729               loc += 4;
9730             }
9731
9732           if (PPC_HA (r2off) != 0)
9733             {
9734               size += 4;
9735               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9736               loc += 4;
9737             }
9738           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9739         }
9740       loc += 4;
9741       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9742       loc += 4;
9743       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9744       break;
9745
9746     case ppc_stub_plt_call:
9747       if (stub_entry->h != NULL
9748           && stub_entry->h->is_func_descriptor
9749           && stub_entry->h->oh != NULL)
9750         {
9751           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9752
9753           /* If the old-ABI "dot-symbol" is undefined make it weak so
9754              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9755              FIXME: We used to define the symbol on one of the call
9756              stubs instead, which is why we test symbol section id
9757              against htab->top_id in various places.  Likely all
9758              these checks could now disappear.  */
9759           if (fh->elf.root.type == bfd_link_hash_undefined)
9760             fh->elf.root.type = bfd_link_hash_undefweak;
9761           /* Stop undo_symbol_twiddle changing it back to undefined.  */
9762           fh->was_undefined = 0;
9763         }
9764
9765       /* Now build the stub.  */
9766       dest = stub_entry->plt_ent->plt.offset & ~1;
9767       if (dest >= (bfd_vma) -2)
9768         abort ();
9769
9770       plt = htab->plt;
9771       if (!htab->elf.dynamic_sections_created
9772           || stub_entry->h == NULL
9773           || stub_entry->h->elf.dynindx == -1)
9774         plt = htab->iplt;
9775
9776       dest += plt->output_offset + plt->output_section->vma;
9777
9778       if (stub_entry->h == NULL
9779           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9780         {
9781           Elf_Internal_Rela rela;
9782           bfd_byte *rl;
9783
9784           rela.r_offset = dest;
9785           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9786           rela.r_addend = (stub_entry->target_value
9787                            + stub_entry->target_section->output_offset
9788                            + stub_entry->target_section->output_section->vma);
9789
9790           rl = (htab->reliplt->contents
9791                 + (htab->reliplt->reloc_count++
9792                    * sizeof (Elf64_External_Rela)));
9793           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9794           stub_entry->plt_ent->plt.offset |= 1;
9795         }
9796
9797       off = (dest
9798              - elf_gp (plt->output_section->owner)
9799              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9800
9801       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9802         {
9803           info->callbacks->einfo
9804             (_("%P: linkage table error against `%s'\n"),
9805              stub_entry->h != NULL
9806              ? stub_entry->h->elf.root.root.string
9807              : "<local sym>");
9808           bfd_set_error (bfd_error_bad_value);
9809           htab->stub_error = TRUE;
9810           return FALSE;
9811         }
9812
9813       r = NULL;
9814       if (info->emitrelocations)
9815         {
9816           r = get_relocs (stub_entry->stub_sec,
9817                           (2
9818                            + (PPC_HA (off) != 0)
9819                            + (htab->plt_static_chain
9820                               && PPC_HA (off + 16) == PPC_HA (off))));
9821           if (r == NULL)
9822             return FALSE;
9823           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9824           if (bfd_big_endian (info->output_bfd))
9825             r[0].r_offset += 2;
9826           r[0].r_addend = dest;
9827         }
9828       if (stub_entry->h != NULL
9829           && (stub_entry->h == htab->tls_get_addr_fd
9830               || stub_entry->h == htab->tls_get_addr)
9831           && !htab->no_tls_get_addr_opt)
9832         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r,
9833                                      htab->plt_static_chain);
9834       else
9835         p = build_plt_stub (htab->stub_bfd, loc, off, r,
9836                             htab->plt_static_chain);
9837       size = p - loc;
9838       break;
9839
9840     default:
9841       BFD_FAIL ();
9842       return FALSE;
9843     }
9844
9845   stub_entry->stub_sec->size += size;
9846
9847   if (htab->emit_stub_syms)
9848     {
9849       struct elf_link_hash_entry *h;
9850       size_t len1, len2;
9851       char *name;
9852       const char *const stub_str[] = { "long_branch",
9853                                        "long_branch_r2off",
9854                                        "plt_branch",
9855                                        "plt_branch_r2off",
9856                                        "plt_call" };
9857
9858       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9859       len2 = strlen (stub_entry->root.string);
9860       name = bfd_malloc (len1 + len2 + 2);
9861       if (name == NULL)
9862         return FALSE;
9863       memcpy (name, stub_entry->root.string, 9);
9864       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9865       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9866       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9867       if (h == NULL)
9868         return FALSE;
9869       if (h->root.type == bfd_link_hash_new)
9870         {
9871           h->root.type = bfd_link_hash_defined;
9872           h->root.u.def.section = stub_entry->stub_sec;
9873           h->root.u.def.value = stub_entry->stub_offset;
9874           h->ref_regular = 1;
9875           h->def_regular = 1;
9876           h->ref_regular_nonweak = 1;
9877           h->forced_local = 1;
9878           h->non_elf = 0;
9879         }
9880     }
9881
9882   return TRUE;
9883 }
9884
9885 /* As above, but don't actually build the stub.  Just bump offset so
9886    we know stub section sizes, and select plt_branch stubs where
9887    long_branch stubs won't do.  */
9888
9889 static bfd_boolean
9890 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9891 {
9892   struct ppc_stub_hash_entry *stub_entry;
9893   struct bfd_link_info *info;
9894   struct ppc_link_hash_table *htab;
9895   bfd_vma off;
9896   int size;
9897
9898   /* Massage our args to the form they really have.  */
9899   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9900   info = in_arg;
9901
9902   htab = ppc_hash_table (info);
9903   if (htab == NULL)
9904     return FALSE;
9905
9906   if (stub_entry->stub_type == ppc_stub_plt_call)
9907     {
9908       asection *plt;
9909       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9910       if (off >= (bfd_vma) -2)
9911         abort ();
9912       plt = htab->plt;
9913       if (!htab->elf.dynamic_sections_created
9914           || stub_entry->h == NULL
9915           || stub_entry->h->elf.dynindx == -1)
9916         plt = htab->iplt;
9917       off += (plt->output_offset
9918               + plt->output_section->vma
9919               - elf_gp (plt->output_section->owner)
9920               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9921
9922       size = PLT_CALL_STUB_SIZE;
9923       if (!htab->plt_static_chain)
9924         size -= 4;
9925       if (PPC_HA (off) == 0)
9926         size -= 4;
9927       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9928         size += 4;
9929       if (stub_entry->h != NULL
9930           && (stub_entry->h == htab->tls_get_addr_fd
9931               || stub_entry->h == htab->tls_get_addr)
9932           && !htab->no_tls_get_addr_opt)
9933         size += 13 * 4;
9934       if (info->emitrelocations)
9935         {
9936           stub_entry->stub_sec->reloc_count
9937             += (2
9938                 + (PPC_HA (off) != 0)
9939                 + (htab->plt_static_chain
9940                    && PPC_HA (off + 16) == PPC_HA (off)));
9941           stub_entry->stub_sec->flags |= SEC_RELOC;
9942         }
9943     }
9944   else
9945     {
9946       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9947          variants.  */
9948       bfd_vma r2off = 0;
9949
9950       off = (stub_entry->target_value
9951              + stub_entry->target_section->output_offset
9952              + stub_entry->target_section->output_section->vma);
9953       off -= (stub_entry->stub_sec->size
9954               + stub_entry->stub_sec->output_offset
9955               + stub_entry->stub_sec->output_section->vma);
9956
9957       /* Reset the stub type from the plt variant in case we now
9958          can reach with a shorter stub.  */
9959       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9960         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9961
9962       size = 4;
9963       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9964         {
9965           r2off = get_r2off (info, stub_entry);
9966           if (r2off == 0)
9967             {
9968               htab->stub_error = TRUE;
9969               return FALSE;
9970             }
9971           size = 12;
9972           if (PPC_HA (r2off) != 0)
9973             size = 16;
9974           off -= size - 4;
9975         }
9976
9977       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9978       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9979         {
9980           struct ppc_branch_hash_entry *br_entry;
9981
9982           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9983                                              stub_entry->root.string + 9,
9984                                              TRUE, FALSE);
9985           if (br_entry == NULL)
9986             {
9987               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
9988                                       stub_entry->root.string);
9989               htab->stub_error = TRUE;
9990               return FALSE;
9991             }
9992
9993           if (br_entry->iter != htab->stub_iteration)
9994             {
9995               br_entry->iter = htab->stub_iteration;
9996               br_entry->offset = htab->brlt->size;
9997               htab->brlt->size += 8;
9998
9999               if (htab->relbrlt != NULL)
10000                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10001               else if (info->emitrelocations)
10002                 {
10003                   htab->brlt->reloc_count += 1;
10004                   htab->brlt->flags |= SEC_RELOC;
10005                 }
10006             }
10007
10008           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10009           off = (br_entry->offset
10010                  + htab->brlt->output_offset
10011                  + htab->brlt->output_section->vma
10012                  - elf_gp (htab->brlt->output_section->owner)
10013                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10014
10015           if (info->emitrelocations)
10016             {
10017               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10018               stub_entry->stub_sec->flags |= SEC_RELOC;
10019             }
10020
10021           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10022             {
10023               size = 12;
10024               if (PPC_HA (off) != 0)
10025                 size = 16;
10026             }
10027           else
10028             {
10029               size = 20;
10030               if (PPC_HA (off) != 0)
10031                 size += 4;
10032
10033               if (PPC_HA (r2off) != 0)
10034                 size += 4;
10035             }
10036         }
10037       else if (info->emitrelocations)
10038         {
10039           stub_entry->stub_sec->reloc_count += 1;
10040           stub_entry->stub_sec->flags |= SEC_RELOC;
10041         }
10042     }
10043
10044   stub_entry->stub_sec->size += size;
10045   return TRUE;
10046 }
10047
10048 /* Set up various things so that we can make a list of input sections
10049    for each output section included in the link.  Returns -1 on error,
10050    0 when no stubs will be needed, and 1 on success.  */
10051
10052 int
10053 ppc64_elf_setup_section_lists
10054   (struct bfd_link_info *info,
10055    asection *(*add_stub_section) (const char *, asection *),
10056    void (*layout_sections_again) (void))
10057 {
10058   bfd *input_bfd;
10059   int top_id, top_index, id;
10060   asection *section;
10061   asection **input_list;
10062   bfd_size_type amt;
10063   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10064
10065   if (htab == NULL)
10066     return -1;
10067   /* Stash our params away.  */
10068   htab->add_stub_section = add_stub_section;
10069   htab->layout_sections_again = layout_sections_again;
10070
10071   if (htab->brlt == NULL)
10072     return 0;
10073
10074   /* Find the top input section id.  */
10075   for (input_bfd = info->input_bfds, top_id = 3;
10076        input_bfd != NULL;
10077        input_bfd = input_bfd->link_next)
10078     {
10079       for (section = input_bfd->sections;
10080            section != NULL;
10081            section = section->next)
10082         {
10083           if (top_id < section->id)
10084             top_id = section->id;
10085         }
10086     }
10087
10088   htab->top_id = top_id;
10089   amt = sizeof (struct map_stub) * (top_id + 1);
10090   htab->stub_group = bfd_zmalloc (amt);
10091   if (htab->stub_group == NULL)
10092     return -1;
10093
10094   /* Set toc_off for com, und, abs and ind sections.  */
10095   for (id = 0; id < 3; id++)
10096     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10097
10098   /* We can't use output_bfd->section_count here to find the top output
10099      section index as some sections may have been removed, and
10100      strip_excluded_output_sections doesn't renumber the indices.  */
10101   for (section = info->output_bfd->sections, top_index = 0;
10102        section != NULL;
10103        section = section->next)
10104     {
10105       if (top_index < section->index)
10106         top_index = section->index;
10107     }
10108
10109   htab->top_index = top_index;
10110   amt = sizeof (asection *) * (top_index + 1);
10111   input_list = bfd_zmalloc (amt);
10112   htab->input_list = input_list;
10113   if (input_list == NULL)
10114     return -1;
10115
10116   return 1;
10117 }
10118
10119 /* Set up for first pass at multitoc partitioning.  */
10120
10121 void
10122 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10123 {
10124   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10125
10126   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10127   htab->toc_curr = elf_gp (info->output_bfd);
10128   htab->toc_bfd = NULL;
10129   htab->toc_first_sec = NULL;
10130 }
10131
10132 /* The linker repeatedly calls this function for each TOC input section
10133    and linker generated GOT section.  Group input bfds such that the toc
10134    within a group is less than 64k in size.  */
10135
10136 bfd_boolean
10137 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10138 {
10139   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10140   bfd_vma addr, off, limit;
10141
10142   if (htab == NULL)
10143     return FALSE;
10144
10145   if (!htab->second_toc_pass)
10146     {
10147       /* Keep track of the first .toc or .got section for this input bfd.  */
10148       if (htab->toc_bfd != isec->owner)
10149         {
10150           htab->toc_bfd = isec->owner;
10151           htab->toc_first_sec = isec;
10152         }
10153
10154       addr = isec->output_offset + isec->output_section->vma;
10155       off = addr - htab->toc_curr;
10156       limit = 0x80008000;
10157       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10158         limit = 0x10000;
10159       if (off + isec->size > limit)
10160         {
10161           addr = (htab->toc_first_sec->output_offset
10162                   + htab->toc_first_sec->output_section->vma);
10163           htab->toc_curr = addr;
10164         }
10165
10166       /* toc_curr is the base address of this toc group.  Set elf_gp
10167          for the input section to be the offset relative to the
10168          output toc base plus 0x8000.  Making the input elf_gp an
10169          offset allows us to move the toc as a whole without
10170          recalculating input elf_gp.  */
10171       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10172       off += TOC_BASE_OFF;
10173
10174       /* Die if someone uses a linker script that doesn't keep input
10175          file .toc and .got together.  */
10176       if (elf_gp (isec->owner) != 0
10177           && elf_gp (isec->owner) != off)
10178         return FALSE;
10179
10180       elf_gp (isec->owner) = off;
10181       return TRUE;
10182     }
10183
10184   /* During the second pass toc_first_sec points to the start of
10185      a toc group, and toc_curr is used to track the old elf_gp.
10186      We use toc_bfd to ensure we only look at each bfd once.  */
10187   if (htab->toc_bfd == isec->owner)
10188     return TRUE;
10189   htab->toc_bfd = isec->owner;
10190
10191   if (htab->toc_first_sec == NULL
10192       || htab->toc_curr != elf_gp (isec->owner))
10193     {
10194       htab->toc_curr = elf_gp (isec->owner);
10195       htab->toc_first_sec = isec;
10196     }
10197   addr = (htab->toc_first_sec->output_offset
10198           + htab->toc_first_sec->output_section->vma);
10199   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10200   elf_gp (isec->owner) = off;
10201
10202   return TRUE;
10203 }
10204
10205 /* Called via elf_link_hash_traverse to merge GOT entries for global
10206    symbol H.  */
10207
10208 static bfd_boolean
10209 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10210 {
10211   if (h->root.type == bfd_link_hash_indirect)
10212     return TRUE;
10213
10214   merge_got_entries (&h->got.glist);
10215
10216   return TRUE;
10217 }
10218
10219 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10220    symbol H.  */
10221
10222 static bfd_boolean
10223 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10224 {
10225   struct got_entry *gent;
10226
10227   if (h->root.type == bfd_link_hash_indirect)
10228     return TRUE;
10229
10230   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10231     if (!gent->is_indirect)
10232       allocate_got (h, (struct bfd_link_info *) inf, gent);
10233   return TRUE;
10234 }
10235
10236 /* Called on the first multitoc pass after the last call to
10237    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10238    entries.  */
10239
10240 bfd_boolean
10241 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10242 {
10243   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10244   struct bfd *ibfd, *ibfd2;
10245   bfd_boolean done_something;
10246
10247   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10248
10249   if (!htab->do_multi_toc)
10250     return FALSE;
10251
10252   /* Merge global sym got entries within a toc group.  */
10253   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10254
10255   /* And tlsld_got.  */
10256   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10257     {
10258       struct got_entry *ent, *ent2;
10259
10260       if (!is_ppc64_elf (ibfd))
10261         continue;
10262
10263       ent = ppc64_tlsld_got (ibfd);
10264       if (!ent->is_indirect
10265           && ent->got.offset != (bfd_vma) -1)
10266         {
10267           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10268             {
10269               if (!is_ppc64_elf (ibfd2))
10270                 continue;
10271
10272               ent2 = ppc64_tlsld_got (ibfd2);
10273               if (!ent2->is_indirect
10274                   && ent2->got.offset != (bfd_vma) -1
10275                   && elf_gp (ibfd2) == elf_gp (ibfd))
10276                 {
10277                   ent2->is_indirect = TRUE;
10278                   ent2->got.ent = ent;
10279                 }
10280             }
10281         }
10282     }
10283
10284   /* Zap sizes of got sections.  */
10285   htab->reliplt->rawsize = htab->reliplt->size;
10286   htab->reliplt->size -= htab->got_reli_size;
10287   htab->got_reli_size = 0;
10288
10289   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10290     {
10291       asection *got, *relgot;
10292
10293       if (!is_ppc64_elf (ibfd))
10294         continue;
10295
10296       got = ppc64_elf_tdata (ibfd)->got;
10297       if (got != NULL)
10298         {
10299           got->rawsize = got->size;
10300           got->size = 0;
10301           relgot = ppc64_elf_tdata (ibfd)->relgot;
10302           relgot->rawsize = relgot->size;
10303           relgot->size = 0;
10304         }
10305     }
10306
10307   /* Now reallocate the got, local syms first.  We don't need to
10308      allocate section contents again since we never increase size.  */
10309   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10310     {
10311       struct got_entry **lgot_ents;
10312       struct got_entry **end_lgot_ents;
10313       struct plt_entry **local_plt;
10314       struct plt_entry **end_local_plt;
10315       unsigned char *lgot_masks;
10316       bfd_size_type locsymcount;
10317       Elf_Internal_Shdr *symtab_hdr;
10318       asection *s, *srel;
10319
10320       if (!is_ppc64_elf (ibfd))
10321         continue;
10322
10323       lgot_ents = elf_local_got_ents (ibfd);
10324       if (!lgot_ents)
10325         continue;
10326
10327       symtab_hdr = &elf_symtab_hdr (ibfd);
10328       locsymcount = symtab_hdr->sh_info;
10329       end_lgot_ents = lgot_ents + locsymcount;
10330       local_plt = (struct plt_entry **) end_lgot_ents;
10331       end_local_plt = local_plt + locsymcount;
10332       lgot_masks = (unsigned char *) end_local_plt;
10333       s = ppc64_elf_tdata (ibfd)->got;
10334       srel = ppc64_elf_tdata (ibfd)->relgot;
10335       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10336         {
10337           struct got_entry *ent;
10338
10339           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10340             {
10341               unsigned int num = 1;
10342               ent->got.offset = s->size;
10343               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10344                 num = 2;
10345               s->size += num * 8;
10346               if (info->shared)
10347                 srel->size += num * sizeof (Elf64_External_Rela);
10348               else if ((*lgot_masks & PLT_IFUNC) != 0)
10349                 {
10350                   htab->reliplt->size
10351                     += num * sizeof (Elf64_External_Rela);
10352                   htab->got_reli_size
10353                     += num * sizeof (Elf64_External_Rela);
10354                 }
10355             }
10356         }
10357     }
10358
10359   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10360
10361   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10362     {
10363       struct got_entry *ent;
10364
10365       if (!is_ppc64_elf (ibfd))
10366         continue;
10367
10368       ent = ppc64_tlsld_got (ibfd);
10369       if (!ent->is_indirect
10370           && ent->got.offset != (bfd_vma) -1)
10371         {
10372           asection *s = ppc64_elf_tdata (ibfd)->got;
10373           ent->got.offset = s->size;
10374           s->size += 16;
10375           if (info->shared)
10376             {
10377               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10378               srel->size += sizeof (Elf64_External_Rela);
10379             }
10380         }
10381     }
10382
10383   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10384   if (!done_something)
10385     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10386       {
10387         asection *got;
10388
10389         if (!is_ppc64_elf (ibfd))
10390           continue;
10391
10392         got = ppc64_elf_tdata (ibfd)->got;
10393         if (got != NULL)
10394           {
10395             done_something = got->rawsize != got->size;
10396             if (done_something)
10397               break;
10398           }
10399       }
10400
10401   if (done_something)
10402     (*htab->layout_sections_again) ();
10403
10404   /* Set up for second pass over toc sections to recalculate elf_gp
10405      on input sections.  */
10406   htab->toc_bfd = NULL;
10407   htab->toc_first_sec = NULL;
10408   htab->second_toc_pass = TRUE;
10409   return done_something;
10410 }
10411
10412 /* Called after second pass of multitoc partitioning.  */
10413
10414 void
10415 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10416 {
10417   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10418
10419   /* After the second pass, toc_curr tracks the TOC offset used
10420      for code sections below in ppc64_elf_next_input_section.  */
10421   htab->toc_curr = TOC_BASE_OFF;
10422 }
10423
10424 /* No toc references were found in ISEC.  If the code in ISEC makes no
10425    calls, then there's no need to use toc adjusting stubs when branching
10426    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10427    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10428    needed, and 2 if a cyclical call-graph was found but no other reason
10429    for a stub was detected.  If called from the top level, a return of
10430    2 means the same as a return of 0.  */
10431
10432 static int
10433 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10434 {
10435   int ret;
10436
10437   /* Mark this section as checked.  */
10438   isec->call_check_done = 1;
10439
10440   /* We know none of our code bearing sections will need toc stubs.  */
10441   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10442     return 0;
10443
10444   if (isec->size == 0)
10445     return 0;
10446
10447   if (isec->output_section == NULL)
10448     return 0;
10449
10450   ret = 0;
10451   if (isec->reloc_count != 0)
10452     {
10453       Elf_Internal_Rela *relstart, *rel;
10454       Elf_Internal_Sym *local_syms;
10455       struct ppc_link_hash_table *htab;
10456
10457       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10458                                             info->keep_memory);
10459       if (relstart == NULL)
10460         return -1;
10461
10462       /* Look for branches to outside of this section.  */
10463       local_syms = NULL;
10464       htab = ppc_hash_table (info);
10465       if (htab == NULL)
10466         return -1;
10467
10468       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10469         {
10470           enum elf_ppc64_reloc_type r_type;
10471           unsigned long r_symndx;
10472           struct elf_link_hash_entry *h;
10473           struct ppc_link_hash_entry *eh;
10474           Elf_Internal_Sym *sym;
10475           asection *sym_sec;
10476           struct _opd_sec_data *opd;
10477           bfd_vma sym_value;
10478           bfd_vma dest;
10479
10480           r_type = ELF64_R_TYPE (rel->r_info);
10481           if (r_type != R_PPC64_REL24
10482               && r_type != R_PPC64_REL14
10483               && r_type != R_PPC64_REL14_BRTAKEN
10484               && r_type != R_PPC64_REL14_BRNTAKEN)
10485             continue;
10486
10487           r_symndx = ELF64_R_SYM (rel->r_info);
10488           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10489                           isec->owner))
10490             {
10491               ret = -1;
10492               break;
10493             }
10494
10495           /* Calls to dynamic lib functions go through a plt call stub
10496              that uses r2.  */
10497           eh = (struct ppc_link_hash_entry *) h;
10498           if (eh != NULL
10499               && (eh->elf.plt.plist != NULL
10500                   || (eh->oh != NULL
10501                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10502             {
10503               ret = 1;
10504               break;
10505             }
10506
10507           if (sym_sec == NULL)
10508             /* Ignore other undefined symbols.  */
10509             continue;
10510
10511           /* Assume branches to other sections not included in the
10512              link need stubs too, to cover -R and absolute syms.  */
10513           if (sym_sec->output_section == NULL)
10514             {
10515               ret = 1;
10516               break;
10517             }
10518
10519           if (h == NULL)
10520             sym_value = sym->st_value;
10521           else
10522             {
10523               if (h->root.type != bfd_link_hash_defined
10524                   && h->root.type != bfd_link_hash_defweak)
10525                 abort ();
10526               sym_value = h->root.u.def.value;
10527             }
10528           sym_value += rel->r_addend;
10529
10530           /* If this branch reloc uses an opd sym, find the code section.  */
10531           opd = get_opd_info (sym_sec);
10532           if (opd != NULL)
10533             {
10534               if (h == NULL && opd->adjust != NULL)
10535                 {
10536                   long adjust;
10537
10538                   adjust = opd->adjust[sym->st_value / 8];
10539                   if (adjust == -1)
10540                     /* Assume deleted functions won't ever be called.  */
10541                     continue;
10542                   sym_value += adjust;
10543                 }
10544
10545               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10546               if (dest == (bfd_vma) -1)
10547                 continue;
10548             }
10549           else
10550             dest = (sym_value
10551                     + sym_sec->output_offset
10552                     + sym_sec->output_section->vma);
10553
10554           /* Ignore branch to self.  */
10555           if (sym_sec == isec)
10556             continue;
10557
10558           /* If the called function uses the toc, we need a stub.  */
10559           if (sym_sec->has_toc_reloc
10560               || sym_sec->makes_toc_func_call)
10561             {
10562               ret = 1;
10563               break;
10564             }
10565
10566           /* Assume any branch that needs a long branch stub might in fact
10567              need a plt_branch stub.  A plt_branch stub uses r2.  */
10568           else if (dest - (isec->output_offset
10569                            + isec->output_section->vma
10570                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10571             {
10572               ret = 1;
10573               break;
10574             }
10575
10576           /* If calling back to a section in the process of being
10577              tested, we can't say for sure that no toc adjusting stubs
10578              are needed, so don't return zero.  */
10579           else if (sym_sec->call_check_in_progress)
10580             ret = 2;
10581
10582           /* Branches to another section that itself doesn't have any TOC
10583              references are OK.  Recursively call ourselves to check.  */
10584           else if (!sym_sec->call_check_done)
10585             {
10586               int recur;
10587
10588               /* Mark current section as indeterminate, so that other
10589                  sections that call back to current won't be marked as
10590                  known.  */
10591               isec->call_check_in_progress = 1;
10592               recur = toc_adjusting_stub_needed (info, sym_sec);
10593               isec->call_check_in_progress = 0;
10594
10595               if (recur != 0)
10596                 {
10597                   ret = recur;
10598                   if (recur != 2)
10599                     break;
10600                 }
10601             }
10602         }
10603
10604       if (local_syms != NULL
10605           && (elf_symtab_hdr (isec->owner).contents
10606               != (unsigned char *) local_syms))
10607         free (local_syms);
10608       if (elf_section_data (isec)->relocs != relstart)
10609         free (relstart);
10610     }
10611
10612   if ((ret & 1) == 0
10613       && isec->map_head.s != NULL
10614       && (strcmp (isec->output_section->name, ".init") == 0
10615           || strcmp (isec->output_section->name, ".fini") == 0))
10616     {
10617       if (isec->map_head.s->has_toc_reloc
10618           || isec->map_head.s->makes_toc_func_call)
10619         ret = 1;
10620       else if (!isec->map_head.s->call_check_done)
10621         {
10622           int recur;
10623           isec->call_check_in_progress = 1;
10624           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10625           isec->call_check_in_progress = 0;
10626           if (recur != 0)
10627             ret = recur;
10628         }
10629     }
10630
10631   if (ret == 1)
10632     isec->makes_toc_func_call = 1;
10633
10634   return ret;
10635 }
10636
10637 /* The linker repeatedly calls this function for each input section,
10638    in the order that input sections are linked into output sections.
10639    Build lists of input sections to determine groupings between which
10640    we may insert linker stubs.  */
10641
10642 bfd_boolean
10643 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10644 {
10645   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10646
10647   if (htab == NULL)
10648     return FALSE;
10649
10650   if ((isec->output_section->flags & SEC_CODE) != 0
10651       && isec->output_section->index <= htab->top_index)
10652     {
10653       asection **list = htab->input_list + isec->output_section->index;
10654       /* Steal the link_sec pointer for our list.  */
10655 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10656       /* This happens to make the list in reverse order,
10657          which is what we want.  */
10658       PREV_SEC (isec) = *list;
10659       *list = isec;
10660     }
10661
10662   if (htab->multi_toc_needed)
10663     {
10664       /* If a code section has a function that uses the TOC then we need
10665          to use the right TOC (obviously).  Also, make sure that .opd gets
10666          the correct TOC value for R_PPC64_TOC relocs that don't have or
10667          can't find their function symbol (shouldn't ever happen now).
10668          Also specially treat .fixup for the linux kernel.  .fixup
10669          contains branches, but only back to the function that hit an
10670          exception.  */
10671       if (isec->has_toc_reloc
10672           || (isec->flags & SEC_CODE) == 0
10673           || strcmp (isec->name, ".fixup") == 0)
10674         {
10675           if (elf_gp (isec->owner) != 0)
10676             htab->toc_curr = elf_gp (isec->owner);
10677         }
10678       else
10679         {
10680           if (!isec->call_check_done
10681               && toc_adjusting_stub_needed (info, isec) < 0)
10682             return FALSE;
10683           /* If we make a local call from this section, ie. a branch
10684              without a following nop, then we have no place to put a
10685              toc restoring insn.  We must use the same toc group as
10686              the callee.
10687              Testing makes_toc_func_call actually tests for *any*
10688              calls to functions that need a good toc pointer.  A more
10689              precise test would be better, as this one will set
10690              incorrect values for pasted .init/.fini fragments.
10691              (Fixed later in check_pasted_section.)  */
10692           if (isec->makes_toc_func_call
10693               && elf_gp (isec->owner) != 0)
10694             htab->toc_curr = elf_gp (isec->owner);
10695         }
10696     }
10697
10698   /* Functions that don't use the TOC can belong in any TOC group.
10699      Use the last TOC base.  */
10700   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10701   return TRUE;
10702 }
10703
10704 /* Check that all .init and .fini sections use the same toc, if they
10705    have toc relocs.  */
10706
10707 static bfd_boolean
10708 check_pasted_section (struct bfd_link_info *info, const char *name)
10709 {
10710   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10711
10712   if (o != NULL)
10713     {
10714       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10715       bfd_vma toc_off = 0;
10716       asection *i;
10717
10718       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10719         if (i->has_toc_reloc)
10720           {
10721             if (toc_off == 0)
10722               toc_off = htab->stub_group[i->id].toc_off;
10723             else if (toc_off != htab->stub_group[i->id].toc_off)
10724               return FALSE;
10725           }
10726
10727       if (toc_off == 0)
10728         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10729           if (i->makes_toc_func_call)
10730             {
10731               toc_off = htab->stub_group[i->id].toc_off;
10732               break;
10733             }
10734
10735       /* Make sure the whole pasted function uses the same toc offset.  */
10736       if (toc_off != 0)
10737         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10738           htab->stub_group[i->id].toc_off = toc_off;
10739     }
10740   return TRUE;
10741 }
10742
10743 bfd_boolean
10744 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10745 {
10746   return (check_pasted_section (info, ".init")
10747           & check_pasted_section (info, ".fini"));
10748 }
10749
10750 /* See whether we can group stub sections together.  Grouping stub
10751    sections may result in fewer stubs.  More importantly, we need to
10752    put all .init* and .fini* stubs at the beginning of the .init or
10753    .fini output sections respectively, because glibc splits the
10754    _init and _fini functions into multiple parts.  Putting a stub in
10755    the middle of a function is not a good idea.  */
10756
10757 static void
10758 group_sections (struct ppc_link_hash_table *htab,
10759                 bfd_size_type stub_group_size,
10760                 bfd_boolean stubs_always_before_branch)
10761 {
10762   asection **list;
10763   bfd_size_type stub14_group_size;
10764   bfd_boolean suppress_size_errors;
10765
10766   suppress_size_errors = FALSE;
10767   stub14_group_size = stub_group_size;
10768   if (stub_group_size == 1)
10769     {
10770       /* Default values.  */
10771       if (stubs_always_before_branch)
10772         {
10773           stub_group_size = 0x1e00000;
10774           stub14_group_size = 0x7800;
10775         }
10776       else
10777         {
10778           stub_group_size = 0x1c00000;
10779           stub14_group_size = 0x7000;
10780         }
10781       suppress_size_errors = TRUE;
10782     }
10783
10784   list = htab->input_list + htab->top_index;
10785   do
10786     {
10787       asection *tail = *list;
10788       while (tail != NULL)
10789         {
10790           asection *curr;
10791           asection *prev;
10792           bfd_size_type total;
10793           bfd_boolean big_sec;
10794           bfd_vma curr_toc;
10795
10796           curr = tail;
10797           total = tail->size;
10798           big_sec = total > (ppc64_elf_section_data (tail) != NULL
10799                              && ppc64_elf_section_data (tail)->has_14bit_branch
10800                              ? stub14_group_size : stub_group_size);
10801           if (big_sec && !suppress_size_errors)
10802             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10803                                      tail->owner, tail);
10804           curr_toc = htab->stub_group[tail->id].toc_off;
10805
10806           while ((prev = PREV_SEC (curr)) != NULL
10807                  && ((total += curr->output_offset - prev->output_offset)
10808                      < (ppc64_elf_section_data (prev) != NULL
10809                         && ppc64_elf_section_data (prev)->has_14bit_branch
10810                         ? stub14_group_size : stub_group_size))
10811                  && htab->stub_group[prev->id].toc_off == curr_toc)
10812             curr = prev;
10813
10814           /* OK, the size from the start of CURR to the end is less
10815              than stub_group_size and thus can be handled by one stub
10816              section.  (or the tail section is itself larger than
10817              stub_group_size, in which case we may be toast.)  We
10818              should really be keeping track of the total size of stubs
10819              added here, as stubs contribute to the final output
10820              section size.  That's a little tricky, and this way will
10821              only break if stubs added make the total size more than
10822              2^25, ie. for the default stub_group_size, if stubs total
10823              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10824           do
10825             {
10826               prev = PREV_SEC (tail);
10827               /* Set up this stub group.  */
10828               htab->stub_group[tail->id].link_sec = curr;
10829             }
10830           while (tail != curr && (tail = prev) != NULL);
10831
10832           /* But wait, there's more!  Input sections up to stub_group_size
10833              bytes before the stub section can be handled by it too.
10834              Don't do this if we have a really large section after the
10835              stubs, as adding more stubs increases the chance that
10836              branches may not reach into the stub section.  */
10837           if (!stubs_always_before_branch && !big_sec)
10838             {
10839               total = 0;
10840               while (prev != NULL
10841                      && ((total += tail->output_offset - prev->output_offset)
10842                          < (ppc64_elf_section_data (prev) != NULL
10843                             && ppc64_elf_section_data (prev)->has_14bit_branch
10844                             ? stub14_group_size : stub_group_size))
10845                      && htab->stub_group[prev->id].toc_off == curr_toc)
10846                 {
10847                   tail = prev;
10848                   prev = PREV_SEC (tail);
10849                   htab->stub_group[tail->id].link_sec = curr;
10850                 }
10851             }
10852           tail = prev;
10853         }
10854     }
10855   while (list-- != htab->input_list);
10856   free (htab->input_list);
10857 #undef PREV_SEC
10858 }
10859
10860 static const unsigned char glink_eh_frame_cie[] =
10861 {
10862   0, 0, 0, 16,                          /* length.  */
10863   0, 0, 0, 0,                           /* id.  */
10864   1,                                    /* CIE version.  */
10865   'z', 'R', 0,                          /* Augmentation string.  */
10866   4,                                    /* Code alignment.  */
10867   0x78,                                 /* Data alignment.  */
10868   65,                                   /* RA reg.  */
10869   1,                                    /* Augmentation size.  */
10870   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
10871   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
10872 };
10873
10874 /* Stripping output sections is normally done before dynamic section
10875    symbols have been allocated.  This function is called later, and
10876    handles cases like htab->brlt which is mapped to its own output
10877    section.  */
10878
10879 static void
10880 maybe_strip_output (struct bfd_link_info *info, asection *isec)
10881 {
10882   if (isec->size == 0
10883       && isec->output_section->size == 0
10884       && !bfd_section_removed_from_list (info->output_bfd,
10885                                          isec->output_section)
10886       && elf_section_data (isec->output_section)->dynindx == 0)
10887     {
10888       isec->output_section->flags |= SEC_EXCLUDE;
10889       bfd_section_list_remove (info->output_bfd, isec->output_section);
10890       info->output_bfd->section_count--;
10891     }
10892 }
10893
10894 /* Determine and set the size of the stub section for a final link.
10895
10896    The basic idea here is to examine all the relocations looking for
10897    PC-relative calls to a target that is unreachable with a "bl"
10898    instruction.  */
10899
10900 bfd_boolean
10901 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
10902                       bfd_boolean plt_static_chain)
10903 {
10904   bfd_size_type stub_group_size;
10905   bfd_boolean stubs_always_before_branch;
10906   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10907
10908   if (htab == NULL)
10909     return FALSE;
10910
10911   htab->plt_static_chain = plt_static_chain;
10912   stubs_always_before_branch = group_size < 0;
10913   if (group_size < 0)
10914     stub_group_size = -group_size;
10915   else
10916     stub_group_size = group_size;
10917
10918   group_sections (htab, stub_group_size, stubs_always_before_branch);
10919
10920   while (1)
10921     {
10922       bfd *input_bfd;
10923       unsigned int bfd_indx;
10924       asection *stub_sec;
10925
10926       htab->stub_iteration += 1;
10927
10928       for (input_bfd = info->input_bfds, bfd_indx = 0;
10929            input_bfd != NULL;
10930            input_bfd = input_bfd->link_next, bfd_indx++)
10931         {
10932           Elf_Internal_Shdr *symtab_hdr;
10933           asection *section;
10934           Elf_Internal_Sym *local_syms = NULL;
10935
10936           if (!is_ppc64_elf (input_bfd))
10937             continue;
10938
10939           /* We'll need the symbol table in a second.  */
10940           symtab_hdr = &elf_symtab_hdr (input_bfd);
10941           if (symtab_hdr->sh_info == 0)
10942             continue;
10943
10944           /* Walk over each section attached to the input bfd.  */
10945           for (section = input_bfd->sections;
10946                section != NULL;
10947                section = section->next)
10948             {
10949               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10950
10951               /* If there aren't any relocs, then there's nothing more
10952                  to do.  */
10953               if ((section->flags & SEC_RELOC) == 0
10954                   || (section->flags & SEC_ALLOC) == 0
10955                   || (section->flags & SEC_LOAD) == 0
10956                   || (section->flags & SEC_CODE) == 0
10957                   || section->reloc_count == 0)
10958                 continue;
10959
10960               /* If this section is a link-once section that will be
10961                  discarded, then don't create any stubs.  */
10962               if (section->output_section == NULL
10963                   || section->output_section->owner != info->output_bfd)
10964                 continue;
10965
10966               /* Get the relocs.  */
10967               internal_relocs
10968                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10969                                              info->keep_memory);
10970               if (internal_relocs == NULL)
10971                 goto error_ret_free_local;
10972
10973               /* Now examine each relocation.  */
10974               irela = internal_relocs;
10975               irelaend = irela + section->reloc_count;
10976               for (; irela < irelaend; irela++)
10977                 {
10978                   enum elf_ppc64_reloc_type r_type;
10979                   unsigned int r_indx;
10980                   enum ppc_stub_type stub_type;
10981                   struct ppc_stub_hash_entry *stub_entry;
10982                   asection *sym_sec, *code_sec;
10983                   bfd_vma sym_value, code_value;
10984                   bfd_vma destination;
10985                   bfd_boolean ok_dest;
10986                   struct ppc_link_hash_entry *hash;
10987                   struct ppc_link_hash_entry *fdh;
10988                   struct elf_link_hash_entry *h;
10989                   Elf_Internal_Sym *sym;
10990                   char *stub_name;
10991                   const asection *id_sec;
10992                   struct _opd_sec_data *opd;
10993                   struct plt_entry *plt_ent;
10994
10995                   r_type = ELF64_R_TYPE (irela->r_info);
10996                   r_indx = ELF64_R_SYM (irela->r_info);
10997
10998                   if (r_type >= R_PPC64_max)
10999                     {
11000                       bfd_set_error (bfd_error_bad_value);
11001                       goto error_ret_free_internal;
11002                     }
11003
11004                   /* Only look for stubs on branch instructions.  */
11005                   if (r_type != R_PPC64_REL24
11006                       && r_type != R_PPC64_REL14
11007                       && r_type != R_PPC64_REL14_BRTAKEN
11008                       && r_type != R_PPC64_REL14_BRNTAKEN)
11009                     continue;
11010
11011                   /* Now determine the call target, its name, value,
11012                      section.  */
11013                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11014                                   r_indx, input_bfd))
11015                     goto error_ret_free_internal;
11016                   hash = (struct ppc_link_hash_entry *) h;
11017
11018                   ok_dest = FALSE;
11019                   fdh = NULL;
11020                   sym_value = 0;
11021                   if (hash == NULL)
11022                     {
11023                       sym_value = sym->st_value;
11024                       ok_dest = TRUE;
11025                     }
11026                   else if (hash->elf.root.type == bfd_link_hash_defined
11027                            || hash->elf.root.type == bfd_link_hash_defweak)
11028                     {
11029                       sym_value = hash->elf.root.u.def.value;
11030                       if (sym_sec->output_section != NULL)
11031                         ok_dest = TRUE;
11032                     }
11033                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11034                            || hash->elf.root.type == bfd_link_hash_undefined)
11035                     {
11036                       /* Recognise an old ABI func code entry sym, and
11037                          use the func descriptor sym instead if it is
11038                          defined.  */
11039                       if (hash->elf.root.root.string[0] == '.'
11040                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11041                         {
11042                           if (fdh->elf.root.type == bfd_link_hash_defined
11043                               || fdh->elf.root.type == bfd_link_hash_defweak)
11044                             {
11045                               sym_sec = fdh->elf.root.u.def.section;
11046                               sym_value = fdh->elf.root.u.def.value;
11047                               if (sym_sec->output_section != NULL)
11048                                 ok_dest = TRUE;
11049                             }
11050                           else
11051                             fdh = NULL;
11052                         }
11053                     }
11054                   else
11055                     {
11056                       bfd_set_error (bfd_error_bad_value);
11057                       goto error_ret_free_internal;
11058                     }
11059
11060                   destination = 0;
11061                   if (ok_dest)
11062                     {
11063                       sym_value += irela->r_addend;
11064                       destination = (sym_value
11065                                      + sym_sec->output_offset
11066                                      + sym_sec->output_section->vma);
11067                     }
11068
11069                   code_sec = sym_sec;
11070                   code_value = sym_value;
11071                   opd = get_opd_info (sym_sec);
11072                   if (opd != NULL)
11073                     {
11074                       bfd_vma dest;
11075
11076                       if (hash == NULL && opd->adjust != NULL)
11077                         {
11078                           long adjust = opd->adjust[sym_value / 8];
11079                           if (adjust == -1)
11080                             continue;
11081                           code_value += adjust;
11082                           sym_value += adjust;
11083                         }
11084                       dest = opd_entry_value (sym_sec, sym_value,
11085                                               &code_sec, &code_value);
11086                       if (dest != (bfd_vma) -1)
11087                         {
11088                           destination = dest;
11089                           if (fdh != NULL)
11090                             {
11091                               /* Fixup old ABI sym to point at code
11092                                  entry.  */
11093                               hash->elf.root.type = bfd_link_hash_defweak;
11094                               hash->elf.root.u.def.section = code_sec;
11095                               hash->elf.root.u.def.value = code_value;
11096                             }
11097                         }
11098                     }
11099
11100                   /* Determine what (if any) linker stub is needed.  */
11101                   plt_ent = NULL;
11102                   stub_type = ppc_type_of_stub (section, irela, &hash,
11103                                                 &plt_ent, destination);
11104
11105                   if (stub_type != ppc_stub_plt_call)
11106                     {
11107                       /* Check whether we need a TOC adjusting stub.
11108                          Since the linker pastes together pieces from
11109                          different object files when creating the
11110                          _init and _fini functions, it may be that a
11111                          call to what looks like a local sym is in
11112                          fact a call needing a TOC adjustment.  */
11113                       if (code_sec != NULL
11114                           && code_sec->output_section != NULL
11115                           && (htab->stub_group[code_sec->id].toc_off
11116                               != htab->stub_group[section->id].toc_off)
11117                           && (code_sec->has_toc_reloc
11118                               || code_sec->makes_toc_func_call))
11119                         stub_type = ppc_stub_long_branch_r2off;
11120                     }
11121
11122                   if (stub_type == ppc_stub_none)
11123                     continue;
11124
11125                   /* __tls_get_addr calls might be eliminated.  */
11126                   if (stub_type != ppc_stub_plt_call
11127                       && hash != NULL
11128                       && (hash == htab->tls_get_addr
11129                           || hash == htab->tls_get_addr_fd)
11130                       && section->has_tls_reloc
11131                       && irela != internal_relocs)
11132                     {
11133                       /* Get tls info.  */
11134                       unsigned char *tls_mask;
11135
11136                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11137                                          irela - 1, input_bfd))
11138                         goto error_ret_free_internal;
11139                       if (*tls_mask != 0)
11140                         continue;
11141                     }
11142
11143                   /* Support for grouping stub sections.  */
11144                   id_sec = htab->stub_group[section->id].link_sec;
11145
11146                   /* Get the name of this stub.  */
11147                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11148                   if (!stub_name)
11149                     goto error_ret_free_internal;
11150
11151                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11152                                                      stub_name, FALSE, FALSE);
11153                   if (stub_entry != NULL)
11154                     {
11155                       /* The proper stub has already been created.  */
11156                       free (stub_name);
11157                       continue;
11158                     }
11159
11160                   stub_entry = ppc_add_stub (stub_name, section, info);
11161                   if (stub_entry == NULL)
11162                     {
11163                       free (stub_name);
11164                     error_ret_free_internal:
11165                       if (elf_section_data (section)->relocs == NULL)
11166                         free (internal_relocs);
11167                     error_ret_free_local:
11168                       if (local_syms != NULL
11169                           && (symtab_hdr->contents
11170                               != (unsigned char *) local_syms))
11171                         free (local_syms);
11172                       return FALSE;
11173                     }
11174
11175                   stub_entry->stub_type = stub_type;
11176                   if (stub_type != ppc_stub_plt_call)
11177                     {
11178                       stub_entry->target_value = code_value;
11179                       stub_entry->target_section = code_sec;
11180                     }
11181                   else
11182                     {
11183                       stub_entry->target_value = sym_value;
11184                       stub_entry->target_section = sym_sec;
11185                     }
11186                   stub_entry->h = hash;
11187                   stub_entry->plt_ent = plt_ent;
11188                   stub_entry->addend = irela->r_addend;
11189
11190                   if (stub_entry->h != NULL)
11191                     htab->stub_globals += 1;
11192                 }
11193
11194               /* We're done with the internal relocs, free them.  */
11195               if (elf_section_data (section)->relocs != internal_relocs)
11196                 free (internal_relocs);
11197             }
11198
11199           if (local_syms != NULL
11200               && symtab_hdr->contents != (unsigned char *) local_syms)
11201             {
11202               if (!info->keep_memory)
11203                 free (local_syms);
11204               else
11205                 symtab_hdr->contents = (unsigned char *) local_syms;
11206             }
11207         }
11208
11209       /* We may have added some stubs.  Find out the new size of the
11210          stub sections.  */
11211       for (stub_sec = htab->stub_bfd->sections;
11212            stub_sec != NULL;
11213            stub_sec = stub_sec->next)
11214         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11215           {
11216             stub_sec->rawsize = stub_sec->size;
11217             stub_sec->size = 0;
11218             stub_sec->reloc_count = 0;
11219             stub_sec->flags &= ~SEC_RELOC;
11220           }
11221
11222       htab->brlt->size = 0;
11223       htab->brlt->reloc_count = 0;
11224       htab->brlt->flags &= ~SEC_RELOC;
11225       if (htab->relbrlt != NULL)
11226         htab->relbrlt->size = 0;
11227
11228       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11229
11230       if (info->emitrelocations
11231           && htab->glink != NULL && htab->glink->size != 0)
11232         {
11233           htab->glink->reloc_count = 1;
11234           htab->glink->flags |= SEC_RELOC;
11235         }
11236
11237       if (htab->glink_eh_frame != NULL
11238           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11239           && (htab->glink_eh_frame->flags & SEC_EXCLUDE) == 0)
11240         {
11241           bfd_size_type size = 0;
11242
11243           for (stub_sec = htab->stub_bfd->sections;
11244                stub_sec != NULL;
11245                stub_sec = stub_sec->next)
11246             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11247               size += 20;
11248           if (htab->glink != NULL && htab->glink->size != 0)
11249             size += 24;
11250           if (size != 0)
11251             size += sizeof (glink_eh_frame_cie);
11252           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11253           htab->glink_eh_frame->size = size;
11254         }
11255
11256       for (stub_sec = htab->stub_bfd->sections;
11257            stub_sec != NULL;
11258            stub_sec = stub_sec->next)
11259         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11260             && stub_sec->rawsize != stub_sec->size)
11261           break;
11262
11263       /* Exit from this loop when no stubs have been added, and no stubs
11264          have changed size.  */
11265       if (stub_sec == NULL
11266           && (htab->glink_eh_frame == NULL
11267               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11268         break;
11269
11270       /* Ask the linker to do its stuff.  */
11271       (*htab->layout_sections_again) ();
11272     }
11273
11274   maybe_strip_output (info, htab->brlt);
11275   if (htab->glink_eh_frame != NULL)
11276     maybe_strip_output (info, htab->glink_eh_frame);
11277
11278   return TRUE;
11279 }
11280
11281 /* Called after we have determined section placement.  If sections
11282    move, we'll be called again.  Provide a value for TOCstart.  */
11283
11284 bfd_vma
11285 ppc64_elf_toc (bfd *obfd)
11286 {
11287   asection *s;
11288   bfd_vma TOCstart;
11289
11290   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11291      order.  The TOC starts where the first of these sections starts.  */
11292   s = bfd_get_section_by_name (obfd, ".got");
11293   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11294     s = bfd_get_section_by_name (obfd, ".toc");
11295   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11296     s = bfd_get_section_by_name (obfd, ".tocbss");
11297   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11298     s = bfd_get_section_by_name (obfd, ".plt");
11299   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11300     {
11301       /* This may happen for
11302          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11303          .toc directive
11304          o  bad linker script
11305          o --gc-sections and empty TOC sections
11306
11307          FIXME: Warn user?  */
11308
11309       /* Look for a likely section.  We probably won't even be
11310          using TOCstart.  */
11311       for (s = obfd->sections; s != NULL; s = s->next)
11312         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11313                          | SEC_EXCLUDE))
11314             == (SEC_ALLOC | SEC_SMALL_DATA))
11315           break;
11316       if (s == NULL)
11317         for (s = obfd->sections; s != NULL; s = s->next)
11318           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11319               == (SEC_ALLOC | SEC_SMALL_DATA))
11320             break;
11321       if (s == NULL)
11322         for (s = obfd->sections; s != NULL; s = s->next)
11323           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11324               == SEC_ALLOC)
11325             break;
11326       if (s == NULL)
11327         for (s = obfd->sections; s != NULL; s = s->next)
11328           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11329             break;
11330     }
11331
11332   TOCstart = 0;
11333   if (s != NULL)
11334     TOCstart = s->output_section->vma + s->output_offset;
11335
11336   return TOCstart;
11337 }
11338
11339 /* Build all the stubs associated with the current output file.
11340    The stubs are kept in a hash table attached to the main linker
11341    hash table.  This function is called via gldelf64ppc_finish.  */
11342
11343 bfd_boolean
11344 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11345                        struct bfd_link_info *info,
11346                        char **stats)
11347 {
11348   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11349   asection *stub_sec;
11350   bfd_byte *p;
11351   int stub_sec_count = 0;
11352
11353   if (htab == NULL)
11354     return FALSE;
11355
11356   htab->emit_stub_syms = emit_stub_syms;
11357
11358   /* Allocate memory to hold the linker stubs.  */
11359   for (stub_sec = htab->stub_bfd->sections;
11360        stub_sec != NULL;
11361        stub_sec = stub_sec->next)
11362     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11363         && stub_sec->size != 0)
11364       {
11365         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11366         if (stub_sec->contents == NULL)
11367           return FALSE;
11368         /* We want to check that built size is the same as calculated
11369            size.  rawsize is a convenient location to use.  */
11370         stub_sec->rawsize = stub_sec->size;
11371         stub_sec->size = 0;
11372       }
11373
11374   if (htab->glink != NULL && htab->glink->size != 0)
11375     {
11376       unsigned int indx;
11377       bfd_vma plt0;
11378
11379       /* Build the .glink plt call stub.  */
11380       if (htab->emit_stub_syms)
11381         {
11382           struct elf_link_hash_entry *h;
11383           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11384                                     TRUE, FALSE, FALSE);
11385           if (h == NULL)
11386             return FALSE;
11387           if (h->root.type == bfd_link_hash_new)
11388             {
11389               h->root.type = bfd_link_hash_defined;
11390               h->root.u.def.section = htab->glink;
11391               h->root.u.def.value = 8;
11392               h->ref_regular = 1;
11393               h->def_regular = 1;
11394               h->ref_regular_nonweak = 1;
11395               h->forced_local = 1;
11396               h->non_elf = 0;
11397             }
11398         }
11399       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11400       if (info->emitrelocations)
11401         {
11402           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11403           if (r == NULL)
11404             return FALSE;
11405           r->r_offset = (htab->glink->output_offset
11406                          + htab->glink->output_section->vma);
11407           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11408           r->r_addend = plt0;
11409         }
11410       p = htab->glink->contents;
11411       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11412       bfd_put_64 (htab->glink->owner, plt0, p);
11413       p += 8;
11414       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11415       p += 4;
11416       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11417       p += 4;
11418       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11419       p += 4;
11420       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11421       p += 4;
11422       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11423       p += 4;
11424       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11425       p += 4;
11426       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11427       p += 4;
11428       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11429       p += 4;
11430       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11431       p += 4;
11432       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11433       p += 4;
11434       bfd_put_32 (htab->glink->owner, BCTR, p);
11435       p += 4;
11436       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11437         {
11438           bfd_put_32 (htab->glink->owner, NOP, p);
11439           p += 4;
11440         }
11441
11442       /* Build the .glink lazy link call stubs.  */
11443       indx = 0;
11444       while (p < htab->glink->contents + htab->glink->size)
11445         {
11446           if (indx < 0x8000)
11447             {
11448               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11449               p += 4;
11450             }
11451           else
11452             {
11453               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11454               p += 4;
11455               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11456               p += 4;
11457             }
11458           bfd_put_32 (htab->glink->owner,
11459                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11460           indx++;
11461           p += 4;
11462         }
11463       htab->glink->rawsize = p - htab->glink->contents;
11464     }
11465
11466   if (htab->brlt->size != 0)
11467     {
11468       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11469                                          htab->brlt->size);
11470       if (htab->brlt->contents == NULL)
11471         return FALSE;
11472     }
11473   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11474     {
11475       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11476                                             htab->relbrlt->size);
11477       if (htab->relbrlt->contents == NULL)
11478         return FALSE;
11479     }
11480
11481   if (htab->glink_eh_frame != NULL
11482       && htab->glink_eh_frame->size != 0)
11483     {
11484       bfd_vma val;
11485
11486       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
11487       if (p == NULL)
11488         return FALSE;
11489       htab->glink_eh_frame->contents = p;
11490
11491       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11492
11493       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
11494       /* CIE length (rewrite in case little-endian).  */
11495       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
11496       p += sizeof (glink_eh_frame_cie);
11497
11498       for (stub_sec = htab->stub_bfd->sections;
11499            stub_sec != NULL;
11500            stub_sec = stub_sec->next)
11501         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11502           {
11503             /* FDE length.  */
11504             bfd_put_32 (htab->elf.dynobj, 16, p);
11505             p += 4;
11506             /* CIE pointer.  */
11507             val = p - htab->glink_eh_frame->contents;
11508             bfd_put_32 (htab->elf.dynobj, val, p);
11509             p += 4;
11510             /* Offset to stub section.  */
11511             val = (stub_sec->output_section->vma
11512                    + stub_sec->output_offset);
11513             val -= (htab->glink_eh_frame->output_section->vma
11514                     + htab->glink_eh_frame->output_offset);
11515             val -= p - htab->glink_eh_frame->contents;
11516             if (val + 0x80000000 > 0xffffffff)
11517               {
11518                 info->callbacks->einfo
11519                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11520                    stub_sec->name);
11521                 return FALSE;
11522               }
11523             bfd_put_32 (htab->elf.dynobj, val, p);
11524             p += 4;
11525             /* stub section size.  */
11526             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
11527             p += 4;
11528             /* Augmentation.  */
11529             p += 1;
11530             /* Pad.  */
11531             p += 3;
11532           }
11533       if (htab->glink != NULL && htab->glink->size != 0)
11534         {
11535           /* FDE length.  */
11536           bfd_put_32 (htab->elf.dynobj, 20, p);
11537           p += 4;
11538           /* CIE pointer.  */
11539           val = p - htab->glink_eh_frame->contents;
11540           bfd_put_32 (htab->elf.dynobj, val, p);
11541           p += 4;
11542           /* Offset to .glink.  */
11543           val = (htab->glink->output_section->vma
11544                  + htab->glink->output_offset
11545                  + 8);
11546           val -= (htab->glink_eh_frame->output_section->vma
11547                   + htab->glink_eh_frame->output_offset);
11548           val -= p - htab->glink_eh_frame->contents;
11549           if (val + 0x80000000 > 0xffffffff)
11550             {
11551               info->callbacks->einfo
11552                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11553                  htab->glink->name);
11554               return FALSE;
11555             }
11556           bfd_put_32 (htab->elf.dynobj, val, p);
11557           p += 4;
11558           /* .glink size.  */
11559           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
11560           p += 4;
11561           /* Augmentation.  */
11562           p += 1;
11563
11564           *p++ = DW_CFA_advance_loc + 1;
11565           *p++ = DW_CFA_register;
11566           *p++ = 65;
11567           *p++ = 12;
11568           *p++ = DW_CFA_advance_loc + 4;
11569           *p++ = DW_CFA_restore_extended;
11570           *p++ = 65;
11571         }
11572       htab->glink_eh_frame->size = p - htab->glink_eh_frame->contents;
11573     }
11574
11575   /* Build the stubs as directed by the stub hash table.  */
11576   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11577
11578   if (htab->relbrlt != NULL)
11579     htab->relbrlt->reloc_count = 0;
11580
11581   for (stub_sec = htab->stub_bfd->sections;
11582        stub_sec != NULL;
11583        stub_sec = stub_sec->next)
11584     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11585       {
11586         stub_sec_count += 1;
11587         if (stub_sec->rawsize != stub_sec->size)
11588           break;
11589       }
11590
11591   if (stub_sec != NULL
11592       || htab->glink->rawsize != htab->glink->size
11593       || (htab->glink_eh_frame != NULL
11594           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
11595     {
11596       htab->stub_error = TRUE;
11597       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
11598     }
11599
11600   if (htab->stub_error)
11601     return FALSE;
11602
11603   if (stats != NULL)
11604     {
11605       *stats = bfd_malloc (500);
11606       if (*stats == NULL)
11607         return FALSE;
11608
11609       sprintf (*stats, _("linker stubs in %u group%s\n"
11610                          "  branch       %lu\n"
11611                          "  toc adjust   %lu\n"
11612                          "  long branch  %lu\n"
11613                          "  long toc adj %lu\n"
11614                          "  plt call     %lu"),
11615                stub_sec_count,
11616                stub_sec_count == 1 ? "" : "s",
11617                htab->stub_count[ppc_stub_long_branch - 1],
11618                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11619                htab->stub_count[ppc_stub_plt_branch - 1],
11620                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11621                htab->stub_count[ppc_stub_plt_call - 1]);
11622     }
11623   return TRUE;
11624 }
11625
11626 /* This function undoes the changes made by add_symbol_adjust.  */
11627
11628 static bfd_boolean
11629 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11630 {
11631   struct ppc_link_hash_entry *eh;
11632
11633   if (h->root.type == bfd_link_hash_indirect)
11634     return TRUE;
11635
11636   eh = (struct ppc_link_hash_entry *) h;
11637   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11638     return TRUE;
11639
11640   eh->elf.root.type = bfd_link_hash_undefined;
11641   return TRUE;
11642 }
11643
11644 void
11645 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11646 {
11647   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11648
11649   if (htab != NULL)
11650     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11651 }
11652
11653 /* What to do when ld finds relocations against symbols defined in
11654    discarded sections.  */
11655
11656 static unsigned int
11657 ppc64_elf_action_discarded (asection *sec)
11658 {
11659   if (strcmp (".opd", sec->name) == 0)
11660     return 0;
11661
11662   if (strcmp (".toc", sec->name) == 0)
11663     return 0;
11664
11665   if (strcmp (".toc1", sec->name) == 0)
11666     return 0;
11667
11668   return _bfd_elf_default_action_discarded (sec);
11669 }
11670
11671 /* REL points to a low-part reloc on a largetoc instruction sequence.
11672    Find the matching high-part reloc instruction and verify that it
11673    is addis REG,x,imm.  If so, set *REG to x and return a pointer to
11674    the high-part reloc.  */
11675
11676 static const Elf_Internal_Rela *
11677 ha_reloc_match (const Elf_Internal_Rela *relocs,
11678                 const Elf_Internal_Rela *rel,
11679                 unsigned int *reg,
11680                 bfd_boolean match_addend,
11681                 const bfd *input_bfd,
11682                 const bfd_byte *contents)
11683 {
11684   enum elf_ppc64_reloc_type r_type, r_type_ha;
11685   bfd_vma r_info_ha, r_addend;
11686
11687   r_type = ELF64_R_TYPE (rel->r_info);
11688   switch (r_type)
11689     {
11690     case R_PPC64_GOT_TLSLD16_LO:
11691     case R_PPC64_GOT_TLSGD16_LO:
11692     case R_PPC64_GOT_TPREL16_LO_DS:
11693     case R_PPC64_GOT_DTPREL16_LO_DS:
11694     case R_PPC64_GOT16_LO:
11695     case R_PPC64_TOC16_LO:
11696       r_type_ha = r_type + 2;
11697       break;
11698     case R_PPC64_GOT16_LO_DS:
11699       r_type_ha = R_PPC64_GOT16_HA;
11700       break;
11701     case R_PPC64_TOC16_LO_DS:
11702       r_type_ha = R_PPC64_TOC16_HA;
11703       break;
11704     default:
11705       abort ();
11706     }
11707   r_info_ha = ELF64_R_INFO (ELF64_R_SYM (rel->r_info), r_type_ha);
11708   r_addend = rel->r_addend;
11709
11710   while (--rel >= relocs)
11711     if (rel->r_info == r_info_ha
11712         && (!match_addend
11713             || rel->r_addend == r_addend))
11714       {
11715         const bfd_byte *p = contents + (rel->r_offset & ~3);
11716         unsigned int insn = bfd_get_32 (input_bfd, p);
11717         if ((insn & (0x3f << 26)) == (15u << 26) /* addis rt,x,imm */
11718             && (insn & (0x1f << 21)) == (*reg << 21))
11719           {
11720             *reg = (insn >> 16) & 0x1f;
11721             return rel;
11722           }
11723         break;
11724       }
11725   return NULL;
11726 }
11727
11728 /* The RELOCATE_SECTION function is called by the ELF backend linker
11729    to handle the relocations for a section.
11730
11731    The relocs are always passed as Rela structures; if the section
11732    actually uses Rel structures, the r_addend field will always be
11733    zero.
11734
11735    This function is responsible for adjust the section contents as
11736    necessary, and (if using Rela relocs and generating a
11737    relocatable output file) adjusting the reloc addend as
11738    necessary.
11739
11740    This function does not have to worry about setting the reloc
11741    address or the reloc symbol index.
11742
11743    LOCAL_SYMS is a pointer to the swapped in local symbols.
11744
11745    LOCAL_SECTIONS is an array giving the section in the input file
11746    corresponding to the st_shndx field of each local symbol.
11747
11748    The global hash table entry for the global symbols can be found
11749    via elf_sym_hashes (input_bfd).
11750
11751    When generating relocatable output, this function must handle
11752    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11753    going to be the section symbol corresponding to the output
11754    section, which means that the addend must be adjusted
11755    accordingly.  */
11756
11757 static bfd_boolean
11758 ppc64_elf_relocate_section (bfd *output_bfd,
11759                             struct bfd_link_info *info,
11760                             bfd *input_bfd,
11761                             asection *input_section,
11762                             bfd_byte *contents,
11763                             Elf_Internal_Rela *relocs,
11764                             Elf_Internal_Sym *local_syms,
11765                             asection **local_sections)
11766 {
11767   struct ppc_link_hash_table *htab;
11768   Elf_Internal_Shdr *symtab_hdr;
11769   struct elf_link_hash_entry **sym_hashes;
11770   Elf_Internal_Rela *rel;
11771   Elf_Internal_Rela *relend;
11772   Elf_Internal_Rela outrel;
11773   bfd_byte *loc;
11774   struct got_entry **local_got_ents;
11775   unsigned char *ha_opt;
11776   bfd_vma TOCstart;
11777   bfd_boolean no_ha_opt;
11778   bfd_boolean ret = TRUE;
11779   bfd_boolean is_opd;
11780   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11781   bfd_boolean is_power4 = FALSE;
11782   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11783
11784   /* Initialize howto table if needed.  */
11785   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11786     ppc_howto_init ();
11787
11788   htab = ppc_hash_table (info);
11789   if (htab == NULL)
11790     return FALSE;
11791
11792   /* Don't relocate stub sections.  */
11793   if (input_section->owner == htab->stub_bfd)
11794     return TRUE;
11795
11796   BFD_ASSERT (is_ppc64_elf (input_bfd));
11797
11798   local_got_ents = elf_local_got_ents (input_bfd);
11799   TOCstart = elf_gp (output_bfd);
11800   symtab_hdr = &elf_symtab_hdr (input_bfd);
11801   sym_hashes = elf_sym_hashes (input_bfd);
11802   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11803   ha_opt = NULL;
11804   no_ha_opt = FALSE;
11805
11806   rel = relocs;
11807   relend = relocs + input_section->reloc_count;
11808   for (; rel < relend; rel++)
11809     {
11810       enum elf_ppc64_reloc_type r_type;
11811       bfd_vma addend, orig_addend;
11812       bfd_reloc_status_type r;
11813       Elf_Internal_Sym *sym;
11814       asection *sec;
11815       struct elf_link_hash_entry *h_elf;
11816       struct ppc_link_hash_entry *h;
11817       struct ppc_link_hash_entry *fdh;
11818       const char *sym_name;
11819       unsigned long r_symndx, toc_symndx;
11820       bfd_vma toc_addend;
11821       unsigned char tls_mask, tls_gd, tls_type;
11822       unsigned char sym_type;
11823       bfd_vma relocation;
11824       bfd_boolean unresolved_reloc;
11825       bfd_boolean warned;
11826       unsigned int insn;
11827       unsigned int mask;
11828       struct ppc_stub_hash_entry *stub_entry;
11829       bfd_vma max_br_offset;
11830       bfd_vma from;
11831
11832       r_type = ELF64_R_TYPE (rel->r_info);
11833       r_symndx = ELF64_R_SYM (rel->r_info);
11834
11835       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11836          symbol of the previous ADDR64 reloc.  The symbol gives us the
11837          proper TOC base to use.  */
11838       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11839           && rel != relocs
11840           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11841           && is_opd)
11842         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11843
11844       sym = NULL;
11845       sec = NULL;
11846       h_elf = NULL;
11847       sym_name = NULL;
11848       unresolved_reloc = FALSE;
11849       warned = FALSE;
11850       orig_addend = rel->r_addend;
11851
11852       if (r_symndx < symtab_hdr->sh_info)
11853         {
11854           /* It's a local symbol.  */
11855           struct _opd_sec_data *opd;
11856
11857           sym = local_syms + r_symndx;
11858           sec = local_sections[r_symndx];
11859           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11860           sym_type = ELF64_ST_TYPE (sym->st_info);
11861           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11862           opd = get_opd_info (sec);
11863           if (opd != NULL && opd->adjust != NULL)
11864             {
11865               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11866               if (adjust == -1)
11867                 relocation = 0;
11868               else
11869                 {
11870                   /* If this is a relocation against the opd section sym
11871                      and we have edited .opd, adjust the reloc addend so
11872                      that ld -r and ld --emit-relocs output is correct.
11873                      If it is a reloc against some other .opd symbol,
11874                      then the symbol value will be adjusted later.  */
11875                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11876                     rel->r_addend += adjust;
11877                   else
11878                     relocation += adjust;
11879                 }
11880             }
11881         }
11882       else
11883         {
11884           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11885                                    r_symndx, symtab_hdr, sym_hashes,
11886                                    h_elf, sec, relocation,
11887                                    unresolved_reloc, warned);
11888           sym_name = h_elf->root.root.string;
11889           sym_type = h_elf->type;
11890         }
11891       h = (struct ppc_link_hash_entry *) h_elf;
11892
11893       if (sec != NULL && elf_discarded_section (sec))
11894         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
11895                                          rel, relend,
11896                                          ppc64_elf_howto_table[r_type],
11897                                          contents);
11898
11899       if (info->relocatable)
11900         continue;
11901
11902       /* TLS optimizations.  Replace instruction sequences and relocs
11903          based on information we collected in tls_optimize.  We edit
11904          RELOCS so that --emit-relocs will output something sensible
11905          for the final instruction stream.  */
11906       tls_mask = 0;
11907       tls_gd = 0;
11908       toc_symndx = 0;
11909       if (h != NULL)
11910         tls_mask = h->tls_mask;
11911       else if (local_got_ents != NULL)
11912         {
11913           struct plt_entry **local_plt = (struct plt_entry **)
11914             (local_got_ents + symtab_hdr->sh_info);
11915           unsigned char *lgot_masks = (unsigned char *)
11916             (local_plt + symtab_hdr->sh_info);
11917           tls_mask = lgot_masks[r_symndx];
11918         }
11919       if (tls_mask == 0
11920           && (r_type == R_PPC64_TLS
11921               || r_type == R_PPC64_TLSGD
11922               || r_type == R_PPC64_TLSLD))
11923         {
11924           /* Check for toc tls entries.  */
11925           unsigned char *toc_tls;
11926
11927           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11928                              &local_syms, rel, input_bfd))
11929             return FALSE;
11930
11931           if (toc_tls)
11932             tls_mask = *toc_tls;
11933         }
11934
11935       /* Check that tls relocs are used with tls syms, and non-tls
11936          relocs are used with non-tls syms.  */
11937       if (r_symndx != STN_UNDEF
11938           && r_type != R_PPC64_NONE
11939           && (h == NULL
11940               || h->elf.root.type == bfd_link_hash_defined
11941               || h->elf.root.type == bfd_link_hash_defweak)
11942           && (IS_PPC64_TLS_RELOC (r_type)
11943               != (sym_type == STT_TLS
11944                   || (sym_type == STT_SECTION
11945                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11946         {
11947           if (tls_mask != 0
11948               && (r_type == R_PPC64_TLS
11949                   || r_type == R_PPC64_TLSGD
11950                   || r_type == R_PPC64_TLSLD))
11951             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
11952             ;
11953           else
11954             info->callbacks->einfo
11955               (!IS_PPC64_TLS_RELOC (r_type)
11956                ? _("%P: %H: %s used with TLS symbol %s\n")
11957                : _("%P: %H: %s used with non-TLS symbol %s\n"),
11958                input_bfd, input_section, rel->r_offset,
11959                ppc64_elf_howto_table[r_type]->name,
11960                sym_name);
11961         }
11962
11963       /* Ensure reloc mapping code below stays sane.  */
11964       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11965           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11966           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
11967           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11968           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11969           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11970           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
11971           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11972           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11973           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11974         abort ();
11975
11976       switch (r_type)
11977         {
11978         default:
11979           break;
11980
11981         case R_PPC64_LO_DS_OPT:
11982           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11983           if ((insn & (0x3f << 26)) != 58u << 26)
11984             abort ();
11985           insn += (14u << 26) - (58u << 26);
11986           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11987           r_type = R_PPC64_TOC16_LO;
11988           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11989           break;
11990
11991         case R_PPC64_TOC16:
11992         case R_PPC64_TOC16_LO:
11993         case R_PPC64_TOC16_DS:
11994         case R_PPC64_TOC16_LO_DS:
11995           {
11996             /* Check for toc tls entries.  */
11997             unsigned char *toc_tls;
11998             int retval;
11999
12000             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12001                                    &local_syms, rel, input_bfd);
12002             if (retval == 0)
12003               return FALSE;
12004
12005             if (toc_tls)
12006               {
12007                 tls_mask = *toc_tls;
12008                 if (r_type == R_PPC64_TOC16_DS
12009                     || r_type == R_PPC64_TOC16_LO_DS)
12010                   {
12011                     if (tls_mask != 0
12012                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12013                       goto toctprel;
12014                   }
12015                 else
12016                   {
12017                     /* If we found a GD reloc pair, then we might be
12018                        doing a GD->IE transition.  */
12019                     if (retval == 2)
12020                       {
12021                         tls_gd = TLS_TPRELGD;
12022                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12023                           goto tls_ldgd_opt;
12024                       }
12025                     else if (retval == 3)
12026                       {
12027                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12028                           goto tls_ldgd_opt;
12029                       }
12030                   }
12031               }
12032           }
12033           break;
12034
12035         case R_PPC64_GOT_TPREL16_HI:
12036         case R_PPC64_GOT_TPREL16_HA:
12037           if (tls_mask != 0
12038               && (tls_mask & TLS_TPREL) == 0)
12039             {
12040               rel->r_offset -= d_offset;
12041               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12042               r_type = R_PPC64_NONE;
12043               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12044             }
12045           break;
12046
12047         case R_PPC64_GOT_TPREL16_DS:
12048         case R_PPC64_GOT_TPREL16_LO_DS:
12049           if (tls_mask != 0
12050               && (tls_mask & TLS_TPREL) == 0)
12051             {
12052             toctprel:
12053               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12054               insn &= 31 << 21;
12055               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12056               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12057               r_type = R_PPC64_TPREL16_HA;
12058               if (toc_symndx != 0)
12059                 {
12060                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12061                   rel->r_addend = toc_addend;
12062                   /* We changed the symbol.  Start over in order to
12063                      get h, sym, sec etc. right.  */
12064                   rel--;
12065                   continue;
12066                 }
12067               else
12068                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12069             }
12070           break;
12071
12072         case R_PPC64_TLS:
12073           if (tls_mask != 0
12074               && (tls_mask & TLS_TPREL) == 0)
12075             {
12076               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12077               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12078               if (insn == 0)
12079                 abort ();
12080               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12081               /* Was PPC64_TLS which sits on insn boundary, now
12082                  PPC64_TPREL16_LO which is at low-order half-word.  */
12083               rel->r_offset += d_offset;
12084               r_type = R_PPC64_TPREL16_LO;
12085               if (toc_symndx != 0)
12086                 {
12087                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12088                   rel->r_addend = toc_addend;
12089                   /* We changed the symbol.  Start over in order to
12090                      get h, sym, sec etc. right.  */
12091                   rel--;
12092                   continue;
12093                 }
12094               else
12095                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12096             }
12097           break;
12098
12099         case R_PPC64_GOT_TLSGD16_HI:
12100         case R_PPC64_GOT_TLSGD16_HA:
12101           tls_gd = TLS_TPRELGD;
12102           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12103             goto tls_gdld_hi;
12104           break;
12105
12106         case R_PPC64_GOT_TLSLD16_HI:
12107         case R_PPC64_GOT_TLSLD16_HA:
12108           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12109             {
12110             tls_gdld_hi:
12111               if ((tls_mask & tls_gd) != 0)
12112                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12113                           + R_PPC64_GOT_TPREL16_DS);
12114               else
12115                 {
12116                   rel->r_offset -= d_offset;
12117                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12118                   r_type = R_PPC64_NONE;
12119                 }
12120               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12121             }
12122           break;
12123
12124         case R_PPC64_GOT_TLSGD16:
12125         case R_PPC64_GOT_TLSGD16_LO:
12126           tls_gd = TLS_TPRELGD;
12127           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12128             goto tls_ldgd_opt;
12129           break;
12130
12131         case R_PPC64_GOT_TLSLD16:
12132         case R_PPC64_GOT_TLSLD16_LO:
12133           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12134             {
12135               unsigned int insn1, insn2, insn3;
12136               bfd_vma offset;
12137
12138             tls_ldgd_opt:
12139               offset = (bfd_vma) -1;
12140               /* If not using the newer R_PPC64_TLSGD/LD to mark
12141                  __tls_get_addr calls, we must trust that the call
12142                  stays with its arg setup insns, ie. that the next
12143                  reloc is the __tls_get_addr call associated with
12144                  the current reloc.  Edit both insns.  */
12145               if (input_section->has_tls_get_addr_call
12146                   && rel + 1 < relend
12147                   && branch_reloc_hash_match (input_bfd, rel + 1,
12148                                               htab->tls_get_addr,
12149                                               htab->tls_get_addr_fd))
12150                 offset = rel[1].r_offset;
12151               if ((tls_mask & tls_gd) != 0)
12152                 {
12153                   /* IE */
12154                   insn1 = bfd_get_32 (output_bfd,
12155                                       contents + rel->r_offset - d_offset);
12156                   insn1 &= (1 << 26) - (1 << 2);
12157                   insn1 |= 58 << 26;    /* ld */
12158                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12159                   if (offset != (bfd_vma) -1)
12160                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12161                   if ((tls_mask & TLS_EXPLICIT) == 0)
12162                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12163                               + R_PPC64_GOT_TPREL16_DS);
12164                   else
12165                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12166                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12167                 }
12168               else
12169                 {
12170                   /* LE */
12171                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12172                   insn2 = 0x38630000;   /* addi 3,3,0 */
12173                   if (tls_gd == 0)
12174                     {
12175                       /* Was an LD reloc.  */
12176                       if (toc_symndx)
12177                         sec = local_sections[toc_symndx];
12178                       for (r_symndx = 0;
12179                            r_symndx < symtab_hdr->sh_info;
12180                            r_symndx++)
12181                         if (local_sections[r_symndx] == sec)
12182                           break;
12183                       if (r_symndx >= symtab_hdr->sh_info)
12184                         r_symndx = STN_UNDEF;
12185                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12186                       if (r_symndx != STN_UNDEF)
12187                         rel->r_addend -= (local_syms[r_symndx].st_value
12188                                           + sec->output_offset
12189                                           + sec->output_section->vma);
12190                     }
12191                   else if (toc_symndx != 0)
12192                     {
12193                       r_symndx = toc_symndx;
12194                       rel->r_addend = toc_addend;
12195                     }
12196                   r_type = R_PPC64_TPREL16_HA;
12197                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12198                   if (offset != (bfd_vma) -1)
12199                     {
12200                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12201                                                     R_PPC64_TPREL16_LO);
12202                       rel[1].r_offset = offset + d_offset;
12203                       rel[1].r_addend = rel->r_addend;
12204                     }
12205                 }
12206               bfd_put_32 (output_bfd, insn1,
12207                           contents + rel->r_offset - d_offset);
12208               if (offset != (bfd_vma) -1)
12209                 {
12210                   insn3 = bfd_get_32 (output_bfd,
12211                                       contents + offset + 4);
12212                   if (insn3 == NOP
12213                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12214                     {
12215                       rel[1].r_offset += 4;
12216                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12217                       insn2 = NOP;
12218                     }
12219                   bfd_put_32 (output_bfd, insn2, contents + offset);
12220                 }
12221               if ((tls_mask & tls_gd) == 0
12222                   && (tls_gd == 0 || toc_symndx != 0))
12223                 {
12224                   /* We changed the symbol.  Start over in order
12225                      to get h, sym, sec etc. right.  */
12226                   rel--;
12227                   continue;
12228                 }
12229             }
12230           break;
12231
12232         case R_PPC64_TLSGD:
12233           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12234             {
12235               unsigned int insn2, insn3;
12236               bfd_vma offset = rel->r_offset;
12237
12238               if ((tls_mask & TLS_TPRELGD) != 0)
12239                 {
12240                   /* IE */
12241                   r_type = R_PPC64_NONE;
12242                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12243                 }
12244               else
12245                 {
12246                   /* LE */
12247                   if (toc_symndx != 0)
12248                     {
12249                       r_symndx = toc_symndx;
12250                       rel->r_addend = toc_addend;
12251                     }
12252                   r_type = R_PPC64_TPREL16_LO;
12253                   rel->r_offset = offset + d_offset;
12254                   insn2 = 0x38630000;   /* addi 3,3,0 */
12255                 }
12256               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12257               /* Zap the reloc on the _tls_get_addr call too.  */
12258               BFD_ASSERT (offset == rel[1].r_offset);
12259               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12260               insn3 = bfd_get_32 (output_bfd,
12261                                   contents + offset + 4);
12262               if (insn3 == NOP
12263                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12264                 {
12265                   rel->r_offset += 4;
12266                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12267                   insn2 = NOP;
12268                 }
12269               bfd_put_32 (output_bfd, insn2, contents + offset);
12270               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12271                 {
12272                   rel--;
12273                   continue;
12274                 }
12275             }
12276           break;
12277
12278         case R_PPC64_TLSLD:
12279           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12280             {
12281               unsigned int insn2, insn3;
12282               bfd_vma offset = rel->r_offset;
12283
12284               if (toc_symndx)
12285                 sec = local_sections[toc_symndx];
12286               for (r_symndx = 0;
12287                    r_symndx < symtab_hdr->sh_info;
12288                    r_symndx++)
12289                 if (local_sections[r_symndx] == sec)
12290                   break;
12291               if (r_symndx >= symtab_hdr->sh_info)
12292                 r_symndx = STN_UNDEF;
12293               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12294               if (r_symndx != STN_UNDEF)
12295                 rel->r_addend -= (local_syms[r_symndx].st_value
12296                                   + sec->output_offset
12297                                   + sec->output_section->vma);
12298
12299               r_type = R_PPC64_TPREL16_LO;
12300               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12301               rel->r_offset = offset + d_offset;
12302               /* Zap the reloc on the _tls_get_addr call too.  */
12303               BFD_ASSERT (offset == rel[1].r_offset);
12304               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12305               insn2 = 0x38630000;       /* addi 3,3,0 */
12306               insn3 = bfd_get_32 (output_bfd,
12307                                   contents + offset + 4);
12308               if (insn3 == NOP
12309                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12310                 {
12311                   rel->r_offset += 4;
12312                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12313                   insn2 = NOP;
12314                 }
12315               bfd_put_32 (output_bfd, insn2, contents + offset);
12316               rel--;
12317               continue;
12318             }
12319           break;
12320
12321         case R_PPC64_DTPMOD64:
12322           if (rel + 1 < relend
12323               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12324               && rel[1].r_offset == rel->r_offset + 8)
12325             {
12326               if ((tls_mask & TLS_GD) == 0)
12327                 {
12328                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12329                   if ((tls_mask & TLS_TPRELGD) != 0)
12330                     r_type = R_PPC64_TPREL64;
12331                   else
12332                     {
12333                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12334                       r_type = R_PPC64_NONE;
12335                     }
12336                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12337                 }
12338             }
12339           else
12340             {
12341               if ((tls_mask & TLS_LD) == 0)
12342                 {
12343                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12344                   r_type = R_PPC64_NONE;
12345                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12346                 }
12347             }
12348           break;
12349
12350         case R_PPC64_TPREL64:
12351           if ((tls_mask & TLS_TPREL) == 0)
12352             {
12353               r_type = R_PPC64_NONE;
12354               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12355             }
12356           break;
12357         }
12358
12359       /* Handle other relocations that tweak non-addend part of insn.  */
12360       insn = 0;
12361       max_br_offset = 1 << 25;
12362       addend = rel->r_addend;
12363       switch (r_type)
12364         {
12365         default:
12366           break;
12367
12368           /* Branch taken prediction relocations.  */
12369         case R_PPC64_ADDR14_BRTAKEN:
12370         case R_PPC64_REL14_BRTAKEN:
12371           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12372           /* Fall thru.  */
12373
12374           /* Branch not taken prediction relocations.  */
12375         case R_PPC64_ADDR14_BRNTAKEN:
12376         case R_PPC64_REL14_BRNTAKEN:
12377           insn |= bfd_get_32 (output_bfd,
12378                               contents + rel->r_offset) & ~(0x01 << 21);
12379           /* Fall thru.  */
12380
12381         case R_PPC64_REL14:
12382           max_br_offset = 1 << 15;
12383           /* Fall thru.  */
12384
12385         case R_PPC64_REL24:
12386           /* Calls to functions with a different TOC, such as calls to
12387              shared objects, need to alter the TOC pointer.  This is
12388              done using a linkage stub.  A REL24 branching to these
12389              linkage stubs needs to be followed by a nop, as the nop
12390              will be replaced with an instruction to restore the TOC
12391              base pointer.  */
12392           fdh = h;
12393           if (h != NULL
12394               && h->oh != NULL
12395               && h->oh->is_func_descriptor)
12396             fdh = ppc_follow_link (h->oh);
12397           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12398           if (stub_entry != NULL
12399               && (stub_entry->stub_type == ppc_stub_plt_call
12400                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12401                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12402             {
12403               bfd_boolean can_plt_call = FALSE;
12404
12405               if (rel->r_offset + 8 <= input_section->size)
12406                 {
12407                   unsigned long nop;
12408                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12409                   if (nop == NOP
12410                       || nop == CROR_151515 || nop == CROR_313131)
12411                     {
12412                       if (h != NULL
12413                           && (h == htab->tls_get_addr_fd
12414                               || h == htab->tls_get_addr)
12415                           && !htab->no_tls_get_addr_opt)
12416                         {
12417                           /* Special stub used, leave nop alone.  */
12418                         }
12419                       else
12420                         bfd_put_32 (input_bfd, LD_R2_40R1,
12421                                     contents + rel->r_offset + 4);
12422                       can_plt_call = TRUE;
12423                     }
12424                 }
12425
12426               if (!can_plt_call)
12427                 {
12428                   if (stub_entry->stub_type == ppc_stub_plt_call)
12429                     {
12430                       /* If this is a plain branch rather than a branch
12431                          and link, don't require a nop.  However, don't
12432                          allow tail calls in a shared library as they
12433                          will result in r2 being corrupted.  */
12434                       unsigned long br;
12435                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12436                       if (info->executable && (br & 1) == 0)
12437                         can_plt_call = TRUE;
12438                       else
12439                         stub_entry = NULL;
12440                     }
12441                   else if (h != NULL
12442                            && strcmp (h->elf.root.root.string,
12443                                       ".__libc_start_main") == 0)
12444                     {
12445                       /* Allow crt1 branch to go via a toc adjusting stub.  */
12446                       can_plt_call = TRUE;
12447                     }
12448                   else
12449                     {
12450                       if (strcmp (input_section->output_section->name,
12451                                   ".init") == 0
12452                           || strcmp (input_section->output_section->name,
12453                                      ".fini") == 0)
12454                         info->callbacks->einfo
12455                           (_("%P: %H: automatic multiple TOCs "
12456                              "not supported using your crt files; "
12457                              "recompile with -mminimal-toc or upgrade gcc\n"),
12458                            input_bfd, input_section, rel->r_offset);
12459                       else
12460                         info->callbacks->einfo
12461                           (_("%P: %H: sibling call optimization to `%s' "
12462                              "does not allow automatic multiple TOCs; "
12463                              "recompile with -mminimal-toc or "
12464                              "-fno-optimize-sibling-calls, "
12465                              "or make `%s' extern\n"),
12466                            input_bfd, input_section, rel->r_offset,
12467                            sym_name,
12468                            sym_name);
12469                       bfd_set_error (bfd_error_bad_value);
12470                       ret = FALSE;
12471                     }
12472                 }
12473
12474               if (can_plt_call
12475                   && stub_entry->stub_type == ppc_stub_plt_call)
12476                 unresolved_reloc = FALSE;
12477             }
12478
12479           if ((stub_entry == NULL
12480                || stub_entry->stub_type == ppc_stub_long_branch
12481                || stub_entry->stub_type == ppc_stub_plt_branch)
12482               && get_opd_info (sec) != NULL)
12483             {
12484               /* The branch destination is the value of the opd entry. */
12485               bfd_vma off = (relocation + addend
12486                              - sec->output_section->vma
12487                              - sec->output_offset);
12488               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12489               if (dest != (bfd_vma) -1)
12490                 {
12491                   relocation = dest;
12492                   addend = 0;
12493                 }
12494             }
12495
12496           /* If the branch is out of reach we ought to have a long
12497              branch stub.  */
12498           from = (rel->r_offset
12499                   + input_section->output_offset
12500                   + input_section->output_section->vma);
12501
12502           if (stub_entry != NULL
12503               && (stub_entry->stub_type == ppc_stub_long_branch
12504                   || stub_entry->stub_type == ppc_stub_plt_branch)
12505               && (r_type == R_PPC64_ADDR14_BRTAKEN
12506                   || r_type == R_PPC64_ADDR14_BRNTAKEN
12507                   || (relocation + addend - from + max_br_offset
12508                       < 2 * max_br_offset)))
12509             /* Don't use the stub if this branch is in range.  */
12510             stub_entry = NULL;
12511
12512           if (stub_entry != NULL)
12513             {
12514               /* Munge up the value and addend so that we call the stub
12515                  rather than the procedure directly.  */
12516               relocation = (stub_entry->stub_offset
12517                             + stub_entry->stub_sec->output_offset
12518                             + stub_entry->stub_sec->output_section->vma);
12519               addend = 0;
12520             }
12521
12522           if (insn != 0)
12523             {
12524               if (is_power4)
12525                 {
12526                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12527                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12528                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12529                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12530                     insn |= 0x02 << 21;
12531                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12532                     insn |= 0x08 << 21;
12533                   else
12534                     break;
12535                 }
12536               else
12537                 {
12538                   /* Invert 'y' bit if not the default.  */
12539                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12540                     insn ^= 0x01 << 21;
12541                 }
12542
12543               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12544             }
12545
12546           /* NOP out calls to undefined weak functions.
12547              We can thus call a weak function without first
12548              checking whether the function is defined.  */
12549           else if (h != NULL
12550                    && h->elf.root.type == bfd_link_hash_undefweak
12551                    && h->elf.dynindx == -1
12552                    && r_type == R_PPC64_REL24
12553                    && relocation == 0
12554                    && addend == 0)
12555             {
12556               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12557               continue;
12558             }
12559           break;
12560         }
12561
12562       /* Set `addend'.  */
12563       tls_type = 0;
12564       switch (r_type)
12565         {
12566         default:
12567           info->callbacks->einfo
12568             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
12569              input_bfd, (int) r_type, sym_name);
12570
12571           bfd_set_error (bfd_error_bad_value);
12572           ret = FALSE;
12573           continue;
12574
12575         case R_PPC64_NONE:
12576         case R_PPC64_TLS:
12577         case R_PPC64_TLSGD:
12578         case R_PPC64_TLSLD:
12579         case R_PPC64_GNU_VTINHERIT:
12580         case R_PPC64_GNU_VTENTRY:
12581           continue;
12582
12583           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12584              address in the GOT as relocation value instead of the
12585              symbol's value itself.  Also, create a GOT entry for the
12586              symbol and put the symbol value there.  */
12587         case R_PPC64_GOT_TLSGD16:
12588         case R_PPC64_GOT_TLSGD16_LO:
12589         case R_PPC64_GOT_TLSGD16_HI:
12590         case R_PPC64_GOT_TLSGD16_HA:
12591           tls_type = TLS_TLS | TLS_GD;
12592           goto dogot;
12593
12594         case R_PPC64_GOT_TLSLD16:
12595         case R_PPC64_GOT_TLSLD16_LO:
12596         case R_PPC64_GOT_TLSLD16_HI:
12597         case R_PPC64_GOT_TLSLD16_HA:
12598           tls_type = TLS_TLS | TLS_LD;
12599           goto dogot;
12600
12601         case R_PPC64_GOT_TPREL16_DS:
12602         case R_PPC64_GOT_TPREL16_LO_DS:
12603         case R_PPC64_GOT_TPREL16_HI:
12604         case R_PPC64_GOT_TPREL16_HA:
12605           tls_type = TLS_TLS | TLS_TPREL;
12606           goto dogot;
12607
12608         case R_PPC64_GOT_DTPREL16_DS:
12609         case R_PPC64_GOT_DTPREL16_LO_DS:
12610         case R_PPC64_GOT_DTPREL16_HI:
12611         case R_PPC64_GOT_DTPREL16_HA:
12612           tls_type = TLS_TLS | TLS_DTPREL;
12613           goto dogot;
12614
12615         case R_PPC64_GOT16:
12616         case R_PPC64_GOT16_LO:
12617         case R_PPC64_GOT16_HI:
12618         case R_PPC64_GOT16_HA:
12619         case R_PPC64_GOT16_DS:
12620         case R_PPC64_GOT16_LO_DS:
12621         dogot:
12622           {
12623             /* Relocation is to the entry for this symbol in the global
12624                offset table.  */
12625             asection *got;
12626             bfd_vma *offp;
12627             bfd_vma off;
12628             unsigned long indx = 0;
12629             struct got_entry *ent;
12630
12631             if (tls_type == (TLS_TLS | TLS_LD)
12632                 && (h == NULL
12633                     || !h->elf.def_dynamic))
12634               ent = ppc64_tlsld_got (input_bfd);
12635             else
12636               {
12637
12638                 if (h != NULL)
12639                   {
12640                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12641                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12642                                                           &h->elf)
12643                         || (info->shared
12644                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12645                       /* This is actually a static link, or it is a
12646                          -Bsymbolic link and the symbol is defined
12647                          locally, or the symbol was forced to be local
12648                          because of a version file.  */
12649                       ;
12650                     else
12651                       {
12652                         indx = h->elf.dynindx;
12653                         unresolved_reloc = FALSE;
12654                       }
12655                     ent = h->elf.got.glist;
12656                   }
12657                 else
12658                   {
12659                     if (local_got_ents == NULL)
12660                       abort ();
12661                     ent = local_got_ents[r_symndx];
12662                   }
12663
12664                 for (; ent != NULL; ent = ent->next)
12665                   if (ent->addend == orig_addend
12666                       && ent->owner == input_bfd
12667                       && ent->tls_type == tls_type)
12668                     break;
12669               }
12670
12671             if (ent == NULL)
12672               abort ();
12673             if (ent->is_indirect)
12674               ent = ent->got.ent;
12675             offp = &ent->got.offset;
12676             got = ppc64_elf_tdata (ent->owner)->got;
12677             if (got == NULL)
12678               abort ();
12679
12680             /* The offset must always be a multiple of 8.  We use the
12681                least significant bit to record whether we have already
12682                processed this entry.  */
12683             off = *offp;
12684             if ((off & 1) != 0)
12685               off &= ~1;
12686             else
12687               {
12688                 /* Generate relocs for the dynamic linker, except in
12689                    the case of TLSLD where we'll use one entry per
12690                    module.  */
12691                 asection *relgot;
12692                 bfd_boolean ifunc;
12693
12694                 *offp = off | 1;
12695                 relgot = NULL;
12696                 ifunc = (h != NULL
12697                          ? h->elf.type == STT_GNU_IFUNC
12698                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12699                 if ((info->shared || indx != 0)
12700                     && (h == NULL
12701                         || (tls_type == (TLS_TLS | TLS_LD)
12702                             && !h->elf.def_dynamic)
12703                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12704                         || h->elf.root.type != bfd_link_hash_undefweak))
12705                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12706                 else if (ifunc)
12707                   relgot = htab->reliplt;
12708                 if (relgot != NULL)
12709                   {
12710                     outrel.r_offset = (got->output_section->vma
12711                                        + got->output_offset
12712                                        + off);
12713                     outrel.r_addend = addend;
12714                     if (tls_type & (TLS_LD | TLS_GD))
12715                       {
12716                         outrel.r_addend = 0;
12717                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12718                         if (tls_type == (TLS_TLS | TLS_GD))
12719                           {
12720                             loc = relgot->contents;
12721                             loc += (relgot->reloc_count++
12722                                     * sizeof (Elf64_External_Rela));
12723                             bfd_elf64_swap_reloca_out (output_bfd,
12724                                                        &outrel, loc);
12725                             outrel.r_offset += 8;
12726                             outrel.r_addend = addend;
12727                             outrel.r_info
12728                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12729                           }
12730                       }
12731                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12732                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12733                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12734                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12735                     else if (indx != 0)
12736                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12737                     else
12738                       {
12739                         if (ifunc)
12740                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12741                         else
12742                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12743
12744                         /* Write the .got section contents for the sake
12745                            of prelink.  */
12746                         loc = got->contents + off;
12747                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12748                                     loc);
12749                       }
12750
12751                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12752                       {
12753                         outrel.r_addend += relocation;
12754                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12755                           outrel.r_addend -= htab->elf.tls_sec->vma;
12756                       }
12757                     loc = relgot->contents;
12758                     loc += (relgot->reloc_count++
12759                             * sizeof (Elf64_External_Rela));
12760                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12761                   }
12762
12763                 /* Init the .got section contents here if we're not
12764                    emitting a reloc.  */
12765                 else
12766                   {
12767                     relocation += addend;
12768                     if (tls_type == (TLS_TLS | TLS_LD))
12769                       relocation = 1;
12770                     else if (tls_type != 0)
12771                       {
12772                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12773                         if (tls_type == (TLS_TLS | TLS_TPREL))
12774                           relocation += DTP_OFFSET - TP_OFFSET;
12775
12776                         if (tls_type == (TLS_TLS | TLS_GD))
12777                           {
12778                             bfd_put_64 (output_bfd, relocation,
12779                                         got->contents + off + 8);
12780                             relocation = 1;
12781                           }
12782                       }
12783
12784                     bfd_put_64 (output_bfd, relocation,
12785                                 got->contents + off);
12786                   }
12787               }
12788
12789             if (off >= (bfd_vma) -2)
12790               abort ();
12791
12792             relocation = got->output_section->vma + got->output_offset + off;
12793             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12794           }
12795           break;
12796
12797         case R_PPC64_PLT16_HA:
12798         case R_PPC64_PLT16_HI:
12799         case R_PPC64_PLT16_LO:
12800         case R_PPC64_PLT32:
12801         case R_PPC64_PLT64:
12802           /* Relocation is to the entry for this symbol in the
12803              procedure linkage table.  */
12804
12805           /* Resolve a PLT reloc against a local symbol directly,
12806              without using the procedure linkage table.  */
12807           if (h == NULL)
12808             break;
12809
12810           /* It's possible that we didn't make a PLT entry for this
12811              symbol.  This happens when statically linking PIC code,
12812              or when using -Bsymbolic.  Go find a match if there is a
12813              PLT entry.  */
12814           if (htab->plt != NULL)
12815             {
12816               struct plt_entry *ent;
12817               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12818                 if (ent->addend == orig_addend
12819                     && ent->plt.offset != (bfd_vma) -1)
12820                   {
12821                     relocation = (htab->plt->output_section->vma
12822                                   + htab->plt->output_offset
12823                                   + ent->plt.offset);
12824                     unresolved_reloc = FALSE;
12825                   }
12826             }
12827           break;
12828
12829         case R_PPC64_TOC:
12830           /* Relocation value is TOC base.  */
12831           relocation = TOCstart;
12832           if (r_symndx == STN_UNDEF)
12833             relocation += htab->stub_group[input_section->id].toc_off;
12834           else if (unresolved_reloc)
12835             ;
12836           else if (sec != NULL && sec->id <= htab->top_id)
12837             relocation += htab->stub_group[sec->id].toc_off;
12838           else
12839             unresolved_reloc = TRUE;
12840           goto dodyn;
12841
12842           /* TOC16 relocs.  We want the offset relative to the TOC base,
12843              which is the address of the start of the TOC plus 0x8000.
12844              The TOC consists of sections .got, .toc, .tocbss, and .plt,
12845              in this order.  */
12846         case R_PPC64_TOC16:
12847         case R_PPC64_TOC16_LO:
12848         case R_PPC64_TOC16_HI:
12849         case R_PPC64_TOC16_DS:
12850         case R_PPC64_TOC16_LO_DS:
12851         case R_PPC64_TOC16_HA:
12852           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12853           break;
12854
12855           /* Relocate against the beginning of the section.  */
12856         case R_PPC64_SECTOFF:
12857         case R_PPC64_SECTOFF_LO:
12858         case R_PPC64_SECTOFF_HI:
12859         case R_PPC64_SECTOFF_DS:
12860         case R_PPC64_SECTOFF_LO_DS:
12861         case R_PPC64_SECTOFF_HA:
12862           if (sec != NULL)
12863             addend -= sec->output_section->vma;
12864           break;
12865
12866         case R_PPC64_REL16:
12867         case R_PPC64_REL16_LO:
12868         case R_PPC64_REL16_HI:
12869         case R_PPC64_REL16_HA:
12870           break;
12871
12872         case R_PPC64_REL14:
12873         case R_PPC64_REL14_BRNTAKEN:
12874         case R_PPC64_REL14_BRTAKEN:
12875         case R_PPC64_REL24:
12876           break;
12877
12878         case R_PPC64_TPREL16:
12879         case R_PPC64_TPREL16_LO:
12880         case R_PPC64_TPREL16_HI:
12881         case R_PPC64_TPREL16_HA:
12882         case R_PPC64_TPREL16_DS:
12883         case R_PPC64_TPREL16_LO_DS:
12884         case R_PPC64_TPREL16_HIGHER:
12885         case R_PPC64_TPREL16_HIGHERA:
12886         case R_PPC64_TPREL16_HIGHEST:
12887         case R_PPC64_TPREL16_HIGHESTA:
12888           if (h != NULL
12889               && h->elf.root.type == bfd_link_hash_undefweak
12890               && h->elf.dynindx == -1)
12891             {
12892               /* Make this relocation against an undefined weak symbol
12893                  resolve to zero.  This is really just a tweak, since
12894                  code using weak externs ought to check that they are
12895                  defined before using them.  */
12896               bfd_byte *p = contents + rel->r_offset - d_offset;
12897
12898               insn = bfd_get_32 (output_bfd, p);
12899               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12900               if (insn != 0)
12901                 bfd_put_32 (output_bfd, insn, p);
12902               break;
12903             }
12904           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12905           if (info->shared)
12906             /* The TPREL16 relocs shouldn't really be used in shared
12907                libs as they will result in DT_TEXTREL being set, but
12908                support them anyway.  */
12909             goto dodyn;
12910           break;
12911
12912         case R_PPC64_DTPREL16:
12913         case R_PPC64_DTPREL16_LO:
12914         case R_PPC64_DTPREL16_HI:
12915         case R_PPC64_DTPREL16_HA:
12916         case R_PPC64_DTPREL16_DS:
12917         case R_PPC64_DTPREL16_LO_DS:
12918         case R_PPC64_DTPREL16_HIGHER:
12919         case R_PPC64_DTPREL16_HIGHERA:
12920         case R_PPC64_DTPREL16_HIGHEST:
12921         case R_PPC64_DTPREL16_HIGHESTA:
12922           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12923           break;
12924
12925         case R_PPC64_DTPMOD64:
12926           relocation = 1;
12927           addend = 0;
12928           goto dodyn;
12929
12930         case R_PPC64_TPREL64:
12931           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12932           goto dodyn;
12933
12934         case R_PPC64_DTPREL64:
12935           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12936           /* Fall thru */
12937
12938           /* Relocations that may need to be propagated if this is a
12939              dynamic object.  */
12940         case R_PPC64_REL30:
12941         case R_PPC64_REL32:
12942         case R_PPC64_REL64:
12943         case R_PPC64_ADDR14:
12944         case R_PPC64_ADDR14_BRNTAKEN:
12945         case R_PPC64_ADDR14_BRTAKEN:
12946         case R_PPC64_ADDR16:
12947         case R_PPC64_ADDR16_DS:
12948         case R_PPC64_ADDR16_HA:
12949         case R_PPC64_ADDR16_HI:
12950         case R_PPC64_ADDR16_HIGHER:
12951         case R_PPC64_ADDR16_HIGHERA:
12952         case R_PPC64_ADDR16_HIGHEST:
12953         case R_PPC64_ADDR16_HIGHESTA:
12954         case R_PPC64_ADDR16_LO:
12955         case R_PPC64_ADDR16_LO_DS:
12956         case R_PPC64_ADDR24:
12957         case R_PPC64_ADDR32:
12958         case R_PPC64_ADDR64:
12959         case R_PPC64_UADDR16:
12960         case R_PPC64_UADDR32:
12961         case R_PPC64_UADDR64:
12962         dodyn:
12963           if ((input_section->flags & SEC_ALLOC) == 0)
12964             break;
12965
12966           if (NO_OPD_RELOCS && is_opd)
12967             break;
12968
12969           if ((info->shared
12970                && (h == NULL
12971                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12972                    || h->elf.root.type != bfd_link_hash_undefweak)
12973                && (must_be_dyn_reloc (info, r_type)
12974                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12975               || (ELIMINATE_COPY_RELOCS
12976                   && !info->shared
12977                   && h != NULL
12978                   && h->elf.dynindx != -1
12979                   && !h->elf.non_got_ref
12980                   && !h->elf.def_regular)
12981               || (!info->shared
12982                   && (h != NULL
12983                       ? h->elf.type == STT_GNU_IFUNC
12984                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12985             {
12986               bfd_boolean skip, relocate;
12987               asection *sreloc;
12988               bfd_vma out_off;
12989
12990               /* When generating a dynamic object, these relocations
12991                  are copied into the output file to be resolved at run
12992                  time.  */
12993
12994               skip = FALSE;
12995               relocate = FALSE;
12996
12997               out_off = _bfd_elf_section_offset (output_bfd, info,
12998                                                  input_section, rel->r_offset);
12999               if (out_off == (bfd_vma) -1)
13000                 skip = TRUE;
13001               else if (out_off == (bfd_vma) -2)
13002                 skip = TRUE, relocate = TRUE;
13003               out_off += (input_section->output_section->vma
13004                           + input_section->output_offset);
13005               outrel.r_offset = out_off;
13006               outrel.r_addend = rel->r_addend;
13007
13008               /* Optimize unaligned reloc use.  */
13009               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13010                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13011                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13012               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13013                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13014                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13015               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13016                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13017                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13018
13019               if (skip)
13020                 memset (&outrel, 0, sizeof outrel);
13021               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13022                        && !is_opd
13023                        && r_type != R_PPC64_TOC)
13024                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13025               else
13026                 {
13027                   /* This symbol is local, or marked to become local,
13028                      or this is an opd section reloc which must point
13029                      at a local function.  */
13030                   outrel.r_addend += relocation;
13031                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13032                     {
13033                       if (is_opd && h != NULL)
13034                         {
13035                           /* Lie about opd entries.  This case occurs
13036                              when building shared libraries and we
13037                              reference a function in another shared
13038                              lib.  The same thing happens for a weak
13039                              definition in an application that's
13040                              overridden by a strong definition in a
13041                              shared lib.  (I believe this is a generic
13042                              bug in binutils handling of weak syms.)
13043                              In these cases we won't use the opd
13044                              entry in this lib.  */
13045                           unresolved_reloc = FALSE;
13046                         }
13047                       if (!is_opd
13048                           && r_type == R_PPC64_ADDR64
13049                           && (h != NULL
13050                               ? h->elf.type == STT_GNU_IFUNC
13051                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13052                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13053                       else
13054                         {
13055                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13056
13057                           /* We need to relocate .opd contents for ld.so.
13058                              Prelink also wants simple and consistent rules
13059                              for relocs.  This make all RELATIVE relocs have
13060                              *r_offset equal to r_addend.  */
13061                           relocate = TRUE;
13062                         }
13063                     }
13064                   else
13065                     {
13066                       long indx = 0;
13067
13068                       if (h != NULL
13069                           ? h->elf.type == STT_GNU_IFUNC
13070                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13071                         {
13072                           info->callbacks->einfo
13073                             (_("%P: %H: relocation %s for indirect "
13074                                "function %s unsupported\n"),
13075                              input_bfd, input_section, rel->r_offset,
13076                              ppc64_elf_howto_table[r_type]->name,
13077                              sym_name);
13078                           ret = FALSE;
13079                         }
13080                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13081                         ;
13082                       else if (sec == NULL || sec->owner == NULL)
13083                         {
13084                           bfd_set_error (bfd_error_bad_value);
13085                           return FALSE;
13086                         }
13087                       else
13088                         {
13089                           asection *osec;
13090
13091                           osec = sec->output_section;
13092                           indx = elf_section_data (osec)->dynindx;
13093
13094                           if (indx == 0)
13095                             {
13096                               if ((osec->flags & SEC_READONLY) == 0
13097                                   && htab->elf.data_index_section != NULL)
13098                                 osec = htab->elf.data_index_section;
13099                               else
13100                                 osec = htab->elf.text_index_section;
13101                               indx = elf_section_data (osec)->dynindx;
13102                             }
13103                           BFD_ASSERT (indx != 0);
13104
13105                           /* We are turning this relocation into one
13106                              against a section symbol, so subtract out
13107                              the output section's address but not the
13108                              offset of the input section in the output
13109                              section.  */
13110                           outrel.r_addend -= osec->vma;
13111                         }
13112
13113                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13114                     }
13115                 }
13116
13117               sreloc = elf_section_data (input_section)->sreloc;
13118               if (!htab->elf.dynamic_sections_created)
13119                 sreloc = htab->reliplt;
13120               if (sreloc == NULL)
13121                 abort ();
13122
13123               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13124                   >= sreloc->size)
13125                 abort ();
13126               loc = sreloc->contents;
13127               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13128               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13129
13130               /* If this reloc is against an external symbol, it will
13131                  be computed at runtime, so there's no need to do
13132                  anything now.  However, for the sake of prelink ensure
13133                  that the section contents are a known value.  */
13134               if (! relocate)
13135                 {
13136                   unresolved_reloc = FALSE;
13137                   /* The value chosen here is quite arbitrary as ld.so
13138                      ignores section contents except for the special
13139                      case of .opd where the contents might be accessed
13140                      before relocation.  Choose zero, as that won't
13141                      cause reloc overflow.  */
13142                   relocation = 0;
13143                   addend = 0;
13144                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13145                      to improve backward compatibility with older
13146                      versions of ld.  */
13147                   if (r_type == R_PPC64_ADDR64)
13148                     addend = outrel.r_addend;
13149                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13150                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13151                     addend = (input_section->output_section->vma
13152                               + input_section->output_offset
13153                               + rel->r_offset);
13154                 }
13155             }
13156           break;
13157
13158         case R_PPC64_COPY:
13159         case R_PPC64_GLOB_DAT:
13160         case R_PPC64_JMP_SLOT:
13161         case R_PPC64_JMP_IREL:
13162         case R_PPC64_RELATIVE:
13163           /* We shouldn't ever see these dynamic relocs in relocatable
13164              files.  */
13165           /* Fall through.  */
13166
13167         case R_PPC64_PLTGOT16:
13168         case R_PPC64_PLTGOT16_DS:
13169         case R_PPC64_PLTGOT16_HA:
13170         case R_PPC64_PLTGOT16_HI:
13171         case R_PPC64_PLTGOT16_LO:
13172         case R_PPC64_PLTGOT16_LO_DS:
13173         case R_PPC64_PLTREL32:
13174         case R_PPC64_PLTREL64:
13175           /* These ones haven't been implemented yet.  */
13176
13177           info->callbacks->einfo
13178             (_("%P: %B: relocation %s is not supported for symbol %s\n"),
13179              input_bfd,
13180              ppc64_elf_howto_table[r_type]->name, sym_name);
13181
13182           bfd_set_error (bfd_error_invalid_operation);
13183           ret = FALSE;
13184           continue;
13185         }
13186
13187       /* Multi-instruction sequences that access the TOC can be
13188          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13189          to             nop;           addi rb,r2,x;  */
13190       switch (r_type)
13191         {
13192         default:
13193           break;
13194
13195         case R_PPC64_GOT_TLSLD16_HI:
13196         case R_PPC64_GOT_TLSGD16_HI:
13197         case R_PPC64_GOT_TPREL16_HI:
13198         case R_PPC64_GOT_DTPREL16_HI:
13199         case R_PPC64_GOT16_HI:
13200         case R_PPC64_TOC16_HI:
13201           /* These relocs would only be useful if building up an
13202              offset to later add to r2, perhaps in an indexed
13203              addressing mode instruction.  Don't try to optimize.
13204              Unfortunately, the possibility of someone building up an
13205              offset like this or even with the HA relocs, means that
13206              we need to check the high insn when optimizing the low
13207              insn.  */
13208           break;
13209
13210         case R_PPC64_GOT_TLSLD16_HA:
13211         case R_PPC64_GOT_TLSGD16_HA:
13212         case R_PPC64_GOT_TPREL16_HA:
13213         case R_PPC64_GOT_DTPREL16_HA:
13214         case R_PPC64_GOT16_HA:
13215         case R_PPC64_TOC16_HA:
13216           /* nop is done later.  */
13217           break;
13218
13219         case R_PPC64_GOT_TLSLD16_LO:
13220         case R_PPC64_GOT_TLSGD16_LO:
13221         case R_PPC64_GOT_TPREL16_LO_DS:
13222         case R_PPC64_GOT_DTPREL16_LO_DS:
13223         case R_PPC64_GOT16_LO:
13224         case R_PPC64_GOT16_LO_DS:
13225         case R_PPC64_TOC16_LO:
13226         case R_PPC64_TOC16_LO_DS:
13227           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000)
13228             {
13229               bfd_byte *p = contents + (rel->r_offset & ~3);
13230               insn = bfd_get_32 (input_bfd, p);
13231               if ((insn & (0x3f << 26)) == 14u << 26 /* addi */
13232                   || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
13233                   || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
13234                   || (insn & (0x3f << 26)) == 36u << 26 /* stw */
13235                   || (insn & (0x3f << 26)) == 38u << 26 /* stb */
13236                   || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
13237                   || (insn & (0x3f << 26)) == 42u << 26 /* lha */
13238                   || (insn & (0x3f << 26)) == 44u << 26 /* sth */
13239                   || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
13240                   || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
13241                   || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
13242                   || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
13243                   || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
13244                   || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
13245                   || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
13246                       && (insn & 3) != 1)
13247                   || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
13248                       && ((insn & 3) == 0 || (insn & 3) == 3)))
13249                 {
13250                   unsigned int reg = (insn >> 16) & 0x1f;
13251                   const Elf_Internal_Rela *ha;
13252                   bfd_boolean match_addend;
13253
13254                   match_addend = (sym != NULL
13255                                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION);
13256                   ha = ha_reloc_match (relocs, rel, &reg, match_addend,
13257                                        input_bfd, contents);
13258                   if (ha != NULL)
13259                     {
13260                       insn &= ~(0x1f << 16);
13261                       insn |= reg << 16;
13262                       bfd_put_32 (input_bfd, insn, p);
13263                       if (ha_opt == NULL)
13264                         {
13265                           ha_opt = bfd_zmalloc (input_section->reloc_count);
13266                           if (ha_opt == NULL)
13267                             return FALSE;
13268                         }
13269                       ha_opt[ha - relocs] = 1;
13270                     }
13271                   else
13272                     /* If we don't find a matching high part insn,
13273                        something is fishy.  Refuse to nop any high
13274                        part insn in this section.  */
13275                     no_ha_opt = TRUE;
13276                 }
13277             }
13278           break;
13279         }
13280
13281       /* Do any further special processing.  */
13282       switch (r_type)
13283         {
13284         default:
13285           break;
13286
13287         case R_PPC64_ADDR16_HA:
13288         case R_PPC64_REL16_HA:
13289         case R_PPC64_ADDR16_HIGHERA:
13290         case R_PPC64_ADDR16_HIGHESTA:
13291         case R_PPC64_TOC16_HA:
13292         case R_PPC64_SECTOFF_HA:
13293         case R_PPC64_TPREL16_HA:
13294         case R_PPC64_DTPREL16_HA:
13295         case R_PPC64_TPREL16_HIGHER:
13296         case R_PPC64_TPREL16_HIGHERA:
13297         case R_PPC64_TPREL16_HIGHEST:
13298         case R_PPC64_TPREL16_HIGHESTA:
13299         case R_PPC64_DTPREL16_HIGHER:
13300         case R_PPC64_DTPREL16_HIGHERA:
13301         case R_PPC64_DTPREL16_HIGHEST:
13302         case R_PPC64_DTPREL16_HIGHESTA:
13303           /* It's just possible that this symbol is a weak symbol
13304              that's not actually defined anywhere. In that case,
13305              'sec' would be NULL, and we should leave the symbol
13306              alone (it will be set to zero elsewhere in the link).  */
13307           if (sec == NULL)
13308             break;
13309           /* Fall thru */
13310
13311         case R_PPC64_GOT16_HA:
13312         case R_PPC64_PLTGOT16_HA:
13313         case R_PPC64_PLT16_HA:
13314         case R_PPC64_GOT_TLSGD16_HA:
13315         case R_PPC64_GOT_TLSLD16_HA:
13316         case R_PPC64_GOT_TPREL16_HA:
13317         case R_PPC64_GOT_DTPREL16_HA:
13318           /* Add 0x10000 if sign bit in 0:15 is set.
13319              Bits 0:15 are not used.  */
13320           addend += 0x8000;
13321           break;
13322
13323         case R_PPC64_ADDR16_DS:
13324         case R_PPC64_ADDR16_LO_DS:
13325         case R_PPC64_GOT16_DS:
13326         case R_PPC64_GOT16_LO_DS:
13327         case R_PPC64_PLT16_LO_DS:
13328         case R_PPC64_SECTOFF_DS:
13329         case R_PPC64_SECTOFF_LO_DS:
13330         case R_PPC64_TOC16_DS:
13331         case R_PPC64_TOC16_LO_DS:
13332         case R_PPC64_PLTGOT16_DS:
13333         case R_PPC64_PLTGOT16_LO_DS:
13334         case R_PPC64_GOT_TPREL16_DS:
13335         case R_PPC64_GOT_TPREL16_LO_DS:
13336         case R_PPC64_GOT_DTPREL16_DS:
13337         case R_PPC64_GOT_DTPREL16_LO_DS:
13338         case R_PPC64_TPREL16_DS:
13339         case R_PPC64_TPREL16_LO_DS:
13340         case R_PPC64_DTPREL16_DS:
13341         case R_PPC64_DTPREL16_LO_DS:
13342           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13343           mask = 3;
13344           /* If this reloc is against an lq insn, then the value must be
13345              a multiple of 16.  This is somewhat of a hack, but the
13346              "correct" way to do this by defining _DQ forms of all the
13347              _DS relocs bloats all reloc switches in this file.  It
13348              doesn't seem to make much sense to use any of these relocs
13349              in data, so testing the insn should be safe.  */
13350           if ((insn & (0x3f << 26)) == (56u << 26))
13351             mask = 15;
13352           if (((relocation + addend) & mask) != 0)
13353             {
13354               info->callbacks->einfo
13355                 (_("%P: %H: error: %s not a multiple of %u\n"),
13356                  input_bfd, input_section, rel->r_offset,
13357                  ppc64_elf_howto_table[r_type]->name,
13358                  mask + 1);
13359               bfd_set_error (bfd_error_bad_value);
13360               ret = FALSE;
13361               continue;
13362             }
13363           break;
13364         }
13365
13366       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13367          because such sections are not SEC_ALLOC and thus ld.so will
13368          not process them.  */
13369       if (unresolved_reloc
13370           && !((input_section->flags & SEC_DEBUGGING) != 0
13371                && h->elf.def_dynamic))
13372         {
13373           info->callbacks->einfo
13374             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
13375              input_bfd, input_section, rel->r_offset,
13376              ppc64_elf_howto_table[(int) r_type]->name,
13377              h->elf.root.root.string);
13378           ret = FALSE;
13379         }
13380
13381       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13382                                     input_bfd,
13383                                     input_section,
13384                                     contents,
13385                                     rel->r_offset,
13386                                     relocation,
13387                                     addend);
13388
13389       if (r != bfd_reloc_ok)
13390         {
13391           if (sym_name == NULL)
13392             sym_name = "(null)";
13393           if (r == bfd_reloc_overflow)
13394             {
13395               if (warned)
13396                 continue;
13397               if (h != NULL
13398                   && h->elf.root.type == bfd_link_hash_undefweak
13399                   && ppc64_elf_howto_table[r_type]->pc_relative)
13400                 {
13401                   /* Assume this is a call protected by other code that
13402                      detects the symbol is undefined.  If this is the case,
13403                      we can safely ignore the overflow.  If not, the
13404                      program is hosed anyway, and a little warning isn't
13405                      going to help.  */
13406
13407                   continue;
13408                 }
13409
13410               if (!((*info->callbacks->reloc_overflow)
13411                     (info, (h ? &h->elf.root : NULL), sym_name,
13412                      ppc64_elf_howto_table[r_type]->name,
13413                      orig_addend, input_bfd, input_section, rel->r_offset)))
13414                 return FALSE;
13415             }
13416           else
13417             {
13418               info->callbacks->einfo
13419                 (_("%P: %H: %s reloc against `%s': error %d\n"),
13420                  input_bfd, input_section, rel->r_offset,
13421                  ppc64_elf_howto_table[r_type]->name,
13422                  sym_name,
13423                  (int) r);
13424               ret = FALSE;
13425             }
13426         }
13427     }
13428
13429   if (ha_opt != NULL)
13430     {
13431       if (!no_ha_opt)
13432         {
13433           unsigned char *opt = ha_opt;
13434           rel = relocs;
13435           relend = relocs + input_section->reloc_count;
13436           for (; rel < relend; opt++, rel++)
13437             if (*opt != 0)
13438               {
13439                 bfd_byte *p = contents + (rel->r_offset & ~3);
13440                 bfd_put_32 (input_bfd, NOP, p);
13441               }
13442         }
13443       free (ha_opt);
13444     }
13445
13446   /* If we're emitting relocations, then shortly after this function
13447      returns, reloc offsets and addends for this section will be
13448      adjusted.  Worse, reloc symbol indices will be for the output
13449      file rather than the input.  Save a copy of the relocs for
13450      opd_entry_value.  */
13451   if (is_opd && (info->emitrelocations || info->relocatable))
13452     {
13453       bfd_size_type amt;
13454       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13455       rel = bfd_alloc (input_bfd, amt);
13456       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13457       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13458       if (rel == NULL)
13459         return FALSE;
13460       memcpy (rel, relocs, amt);
13461     }
13462   return ret;
13463 }
13464
13465 /* Adjust the value of any local symbols in opd sections.  */
13466
13467 static int
13468 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13469                               const char *name ATTRIBUTE_UNUSED,
13470                               Elf_Internal_Sym *elfsym,
13471                               asection *input_sec,
13472                               struct elf_link_hash_entry *h)
13473 {
13474   struct _opd_sec_data *opd;
13475   long adjust;
13476   bfd_vma value;
13477
13478   if (h != NULL)
13479     return 1;
13480
13481   opd = get_opd_info (input_sec);
13482   if (opd == NULL || opd->adjust == NULL)
13483     return 1;
13484
13485   value = elfsym->st_value - input_sec->output_offset;
13486   if (!info->relocatable)
13487     value -= input_sec->output_section->vma;
13488
13489   adjust = opd->adjust[value / 8];
13490   if (adjust == -1)
13491     return 2;
13492
13493   elfsym->st_value += adjust;
13494   return 1;
13495 }
13496
13497 /* Finish up dynamic symbol handling.  We set the contents of various
13498    dynamic sections here.  */
13499
13500 static bfd_boolean
13501 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13502                                  struct bfd_link_info *info,
13503                                  struct elf_link_hash_entry *h,
13504                                  Elf_Internal_Sym *sym)
13505 {
13506   struct ppc_link_hash_table *htab;
13507   struct plt_entry *ent;
13508   Elf_Internal_Rela rela;
13509   bfd_byte *loc;
13510
13511   htab = ppc_hash_table (info);
13512   if (htab == NULL)
13513     return FALSE;
13514
13515   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13516     if (ent->plt.offset != (bfd_vma) -1)
13517       {
13518         /* This symbol has an entry in the procedure linkage
13519            table.  Set it up.  */
13520         if (!htab->elf.dynamic_sections_created
13521             || h->dynindx == -1)
13522           {
13523             BFD_ASSERT (h->type == STT_GNU_IFUNC
13524                         && h->def_regular
13525                         && (h->root.type == bfd_link_hash_defined
13526                             || h->root.type == bfd_link_hash_defweak));
13527             rela.r_offset = (htab->iplt->output_section->vma
13528                              + htab->iplt->output_offset
13529                              + ent->plt.offset);
13530             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13531             rela.r_addend = (h->root.u.def.value
13532                              + h->root.u.def.section->output_offset
13533                              + h->root.u.def.section->output_section->vma
13534                              + ent->addend);
13535             loc = (htab->reliplt->contents
13536                    + (htab->reliplt->reloc_count++
13537                       * sizeof (Elf64_External_Rela)));
13538           }
13539         else
13540           {
13541             rela.r_offset = (htab->plt->output_section->vma
13542                              + htab->plt->output_offset
13543                              + ent->plt.offset);
13544             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13545             rela.r_addend = ent->addend;
13546             loc = (htab->relplt->contents
13547                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13548                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13549           }
13550         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13551       }
13552
13553   if (h->needs_copy)
13554     {
13555       /* This symbol needs a copy reloc.  Set it up.  */
13556
13557       if (h->dynindx == -1
13558           || (h->root.type != bfd_link_hash_defined
13559               && h->root.type != bfd_link_hash_defweak)
13560           || htab->relbss == NULL)
13561         abort ();
13562
13563       rela.r_offset = (h->root.u.def.value
13564                        + h->root.u.def.section->output_section->vma
13565                        + h->root.u.def.section->output_offset);
13566       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13567       rela.r_addend = 0;
13568       loc = htab->relbss->contents;
13569       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13570       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13571     }
13572
13573   /* Mark some specially defined symbols as absolute.  */
13574   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13575     sym->st_shndx = SHN_ABS;
13576
13577   return TRUE;
13578 }
13579
13580 /* Used to decide how to sort relocs in an optimal manner for the
13581    dynamic linker, before writing them out.  */
13582
13583 static enum elf_reloc_type_class
13584 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13585 {
13586   enum elf_ppc64_reloc_type r_type;
13587
13588   r_type = ELF64_R_TYPE (rela->r_info);
13589   switch (r_type)
13590     {
13591     case R_PPC64_RELATIVE:
13592       return reloc_class_relative;
13593     case R_PPC64_JMP_SLOT:
13594       return reloc_class_plt;
13595     case R_PPC64_COPY:
13596       return reloc_class_copy;
13597     default:
13598       return reloc_class_normal;
13599     }
13600 }
13601
13602 /* Finish up the dynamic sections.  */
13603
13604 static bfd_boolean
13605 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13606                                    struct bfd_link_info *info)
13607 {
13608   struct ppc_link_hash_table *htab;
13609   bfd *dynobj;
13610   asection *sdyn;
13611
13612   htab = ppc_hash_table (info);
13613   if (htab == NULL)
13614     return FALSE;
13615
13616   dynobj = htab->elf.dynobj;
13617   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13618
13619   if (htab->elf.dynamic_sections_created)
13620     {
13621       Elf64_External_Dyn *dyncon, *dynconend;
13622
13623       if (sdyn == NULL || htab->got == NULL)
13624         abort ();
13625
13626       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13627       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13628       for (; dyncon < dynconend; dyncon++)
13629         {
13630           Elf_Internal_Dyn dyn;
13631           asection *s;
13632
13633           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13634
13635           switch (dyn.d_tag)
13636             {
13637             default:
13638               continue;
13639
13640             case DT_PPC64_GLINK:
13641               s = htab->glink;
13642               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13643               /* We stupidly defined DT_PPC64_GLINK to be the start
13644                  of glink rather than the first entry point, which is
13645                  what ld.so needs, and now have a bigger stub to
13646                  support automatic multiple TOCs.  */
13647               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13648               break;
13649
13650             case DT_PPC64_OPD:
13651               s = bfd_get_section_by_name (output_bfd, ".opd");
13652               if (s == NULL)
13653                 continue;
13654               dyn.d_un.d_ptr = s->vma;
13655               break;
13656
13657             case DT_PPC64_OPDSZ:
13658               s = bfd_get_section_by_name (output_bfd, ".opd");
13659               if (s == NULL)
13660                 continue;
13661               dyn.d_un.d_val = s->size;
13662               break;
13663
13664             case DT_PLTGOT:
13665               s = htab->plt;
13666               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13667               break;
13668
13669             case DT_JMPREL:
13670               s = htab->relplt;
13671               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13672               break;
13673
13674             case DT_PLTRELSZ:
13675               dyn.d_un.d_val = htab->relplt->size;
13676               break;
13677
13678             case DT_RELASZ:
13679               /* Don't count procedure linkage table relocs in the
13680                  overall reloc count.  */
13681               s = htab->relplt;
13682               if (s == NULL)
13683                 continue;
13684               dyn.d_un.d_val -= s->size;
13685               break;
13686
13687             case DT_RELA:
13688               /* We may not be using the standard ELF linker script.
13689                  If .rela.plt is the first .rela section, we adjust
13690                  DT_RELA to not include it.  */
13691               s = htab->relplt;
13692               if (s == NULL)
13693                 continue;
13694               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13695                 continue;
13696               dyn.d_un.d_ptr += s->size;
13697               break;
13698             }
13699
13700           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13701         }
13702     }
13703
13704   if (htab->got != NULL && htab->got->size != 0)
13705     {
13706       /* Fill in the first entry in the global offset table.
13707          We use it to hold the link-time TOCbase.  */
13708       bfd_put_64 (output_bfd,
13709                   elf_gp (output_bfd) + TOC_BASE_OFF,
13710                   htab->got->contents);
13711
13712       /* Set .got entry size.  */
13713       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13714     }
13715
13716   if (htab->plt != NULL && htab->plt->size != 0)
13717     {
13718       /* Set .plt entry size.  */
13719       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13720         = PLT_ENTRY_SIZE;
13721     }
13722
13723   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13724      brlt ourselves if emitrelocations.  */
13725   if (htab->brlt != NULL
13726       && htab->brlt->reloc_count != 0
13727       && !_bfd_elf_link_output_relocs (output_bfd,
13728                                        htab->brlt,
13729                                        elf_section_data (htab->brlt)->rela.hdr,
13730                                        elf_section_data (htab->brlt)->relocs,
13731                                        NULL))
13732     return FALSE;
13733
13734   if (htab->glink != NULL
13735       && htab->glink->reloc_count != 0
13736       && !_bfd_elf_link_output_relocs (output_bfd,
13737                                        htab->glink,
13738                                        elf_section_data (htab->glink)->rela.hdr,
13739                                        elf_section_data (htab->glink)->relocs,
13740                                        NULL))
13741     return FALSE;
13742
13743
13744   if (htab->glink_eh_frame != NULL
13745       && htab->glink_eh_frame->sec_info_type == ELF_INFO_TYPE_EH_FRAME
13746       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
13747                                            htab->glink_eh_frame,
13748                                            htab->glink_eh_frame->contents))
13749     return FALSE;
13750
13751   /* We need to handle writing out multiple GOT sections ourselves,
13752      since we didn't add them to DYNOBJ.  We know dynobj is the first
13753      bfd.  */
13754   while ((dynobj = dynobj->link_next) != NULL)
13755     {
13756       asection *s;
13757
13758       if (!is_ppc64_elf (dynobj))
13759         continue;
13760
13761       s = ppc64_elf_tdata (dynobj)->got;
13762       if (s != NULL
13763           && s->size != 0
13764           && s->output_section != bfd_abs_section_ptr
13765           && !bfd_set_section_contents (output_bfd, s->output_section,
13766                                         s->contents, s->output_offset,
13767                                         s->size))
13768         return FALSE;
13769       s = ppc64_elf_tdata (dynobj)->relgot;
13770       if (s != NULL
13771           && s->size != 0
13772           && s->output_section != bfd_abs_section_ptr
13773           && !bfd_set_section_contents (output_bfd, s->output_section,
13774                                         s->contents, s->output_offset,
13775                                         s->size))
13776         return FALSE;
13777     }
13778
13779   return TRUE;
13780 }
13781
13782 #include "elf64-target.h"