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 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
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *);
  58
  59 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_MACHINE_CODE        EM_PPC64
  65 #define ELF_MAXPAGESIZE         0x10000
  66 #define ELF_COMMONPAGESIZE      0x1000
  67 #define elf_info_to_howto       ppc64_elf_info_to_howto
  68
  69 #define elf_backend_want_got_sym 0
  70 #define elf_backend_want_plt_sym 0
  71 #define elf_backend_plt_alignment 3
  72 #define elf_backend_plt_not_loaded 1
  73 #define elf_backend_got_header_size 8
  74 #define elf_backend_can_gc_sections 1
  75 #define elf_backend_can_refcount 1
  76 #define elf_backend_rela_normal 1
  77 #define elf_backend_default_execstack 0
  78
  79 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  80 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
  82 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  83 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  84 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  85 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  86 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  87
  88 #define elf_backend_object_p                  ppc64_elf_object_p
  89 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  90 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  91 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  92 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  93 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  94 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  95 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  96 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
  97 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  98 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  99 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 100 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 101 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 102 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 103 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 104 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 105 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 106 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 107 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 108 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 109 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 110 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 111 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 112 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 113 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 114 #define elf_backend_special_sections          ppc64_elf_special_sections
 115 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 116
 117 /* The name of the dynamic interpreter.  This is put in the .interp
 118    section.  */
 119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 120
 121 /* The size in bytes of an entry in the procedure linkage table.  */
 122 #define PLT_ENTRY_SIZE 24
 123
 124 /* The initial size of the plt reserved for the dynamic linker.  */
 125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 126
 127 /* TOC base pointers offset from start of TOC.  */
 128 #define TOC_BASE_OFF    0x8000
 129
 130 /* Offset of tp and dtp pointers from start of TLS block.  */
 131 #define TP_OFFSET       0x7000
 132 #define DTP_OFFSET      0x8000
 133
 134 /* .plt call stub instructions.  The normal stub is like this, but
 135    sometimes the .plt entry crosses a 64k boundary and we need to
 136    insert an addi to adjust r12.  */
 137 #define PLT_CALL_STUB_SIZE (7*4)
 138 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 139 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 140 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 141 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 142 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 143                                         /* ld    %r11,xxx+16@l(%r12) */
 144 #define BCTR            0x4e800420      /* bctr                      */
 145
 146
 147 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 148 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 149 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 150 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 151
 152 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 153 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 154
 155 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 156
 157 /* glink call stub instructions.  We enter with the index in R0.  */
 158 #define GLINK_CALL_STUB_SIZE (16*4)
 159                                         /* 0:                           */
 160                                         /*  .quad plt0-1f               */
 161                                         /* __glink:                     */
 162 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 163 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 164                                         /* 1:                           */
 165 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 166 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 167 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 168 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 169                                         /*  ld %11,0(%12)               */
 170                                         /*  ld %2,8(%12)                */
 171                                         /*  mtctr %11                   */
 172                                         /*  ld %11,16(%12)              */
 173                                         /*  bctr                        */
 174
 175 /* Pad with this.  */
 176 #define NOP             0x60000000
 177
 178 /* Some other nops.  */
 179 #define CROR_151515     0x4def7b82
 180 #define CROR_313131     0x4ffffb82
 181
 182 /* .glink entries for the first 32k functions are two instructions.  */
 183 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 184 #define B_DOT           0x48000000      /* b     .              */
 185
 186 /* After that, we need two instructions to load the index, followed by
 187    a branch.  */
 188 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 189 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 190
 191 /* Instructions used by the save and restore reg functions.  */
 192 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 193 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 194 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 195 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 196 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 197 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 198 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 199 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 200 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 201 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 202 #define BLR             0x4e800020      /* blr                  */
 203
 204 /* Since .opd is an array of descriptors and each entry will end up
 205    with identical R_PPC64_RELATIVE relocs, there is really no need to
 206    propagate .opd relocs;  The dynamic linker should be taught to
 207    relocate .opd without reloc entries.  */
 208 #ifndef NO_OPD_RELOCS
 209 #define NO_OPD_RELOCS 0
 210 #endif
 211 \f
 212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 213
 214 /* Relocation HOWTO's.  */
 215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 216
 217 static reloc_howto_type ppc64_elf_howto_raw[] = {
 218   /* This reloc does nothing.  */
 219   HOWTO (R_PPC64_NONE,          /* type */
 220          0,                     /* rightshift */
 221          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          FALSE,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_dont, /* complain_on_overflow */
 226          bfd_elf_generic_reloc, /* special_function */
 227          "R_PPC64_NONE",        /* name */
 228          FALSE,                 /* partial_inplace */
 229          0,                     /* src_mask */
 230          0,                     /* dst_mask */
 231          FALSE),                /* pcrel_offset */
 232
 233   /* A standard 32 bit relocation.  */
 234   HOWTO (R_PPC64_ADDR32,        /* type */
 235          0,                     /* rightshift */
 236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          32,                    /* bitsize */
 238          FALSE,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_bitfield, /* complain_on_overflow */
 241          bfd_elf_generic_reloc, /* special_function */
 242          "R_PPC64_ADDR32",      /* name */
 243          FALSE,                 /* partial_inplace */
 244          0,                     /* src_mask */
 245          0xffffffff,            /* dst_mask */
 246          FALSE),                /* pcrel_offset */
 247
 248   /* An absolute 26 bit branch; the lower two bits must be zero.
 249      FIXME: we don't check that, we just clear them.  */
 250   HOWTO (R_PPC64_ADDR24,        /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          26,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_bitfield, /* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_PPC64_ADDR24",      /* name */
 259          FALSE,                 /* partial_inplace */
 260          0,                     /* src_mask */
 261          0x03fffffc,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   /* A standard 16 bit relocation.  */
 265   HOWTO (R_PPC64_ADDR16,        /* type */
 266          0,                     /* rightshift */
 267          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          16,                    /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_bitfield, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_ADDR16",      /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0xffff,                /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A 16 bit relocation without overflow.  */
 280   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 281          0,                     /* rightshift */
 282          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          16,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_dont,/* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR16_LO",   /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffff,                /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* Bits 16-31 of an address.  */
 295   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 296          16,                    /* rightshift */
 297          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_dont, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC64_ADDR16_HI",   /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0xffff,                /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 310      bits, treated as a signed number, is negative.  */
 311   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 312          16,                    /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_dont, /* complain_on_overflow */
 318          ppc64_elf_ha_reloc,    /* special_function */
 319          "R_PPC64_ADDR16_HA",   /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* An absolute 16 bit branch; the lower two bits must be zero.
 326      FIXME: we don't check that, we just clear them.  */
 327   HOWTO (R_PPC64_ADDR14,        /* type */
 328          0,                     /* rightshift */
 329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 330          16,                    /* bitsize */
 331          FALSE,                 /* pc_relative */
 332          0,                     /* bitpos */
 333          complain_overflow_bitfield, /* complain_on_overflow */
 334          ppc64_elf_branch_reloc, /* special_function */
 335          "R_PPC64_ADDR14",      /* name */
 336          FALSE,                 /* partial_inplace */
 337          0,                     /* src_mask */
 338          0x0000fffc,            /* dst_mask */
 339          FALSE),                /* pcrel_offset */
 340
 341   /* An absolute 16 bit branch, for which bit 10 should be set to
 342      indicate that the branch is expected to be taken.  The lower two
 343      bits must be zero.  */
 344   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          16,                    /* bitsize */
 348          FALSE,                 /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_bitfield, /* complain_on_overflow */
 351          ppc64_elf_brtaken_reloc, /* special_function */
 352          "R_PPC64_ADDR14_BRTAKEN",/* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x0000fffc,            /* dst_mask */
 356          FALSE),                /* pcrel_offset */
 357
 358   /* An absolute 16 bit branch, for which bit 10 should be set to
 359      indicate that the branch is not expected to be taken.  The lower
 360      two bits must be zero.  */
 361   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 362          0,                     /* rightshift */
 363          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_bitfield, /* complain_on_overflow */
 368          ppc64_elf_brtaken_reloc, /* special_function */
 369          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0x0000fffc,            /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* A relative 26 bit branch; the lower two bits must be zero.  */
 376   HOWTO (R_PPC64_REL24,         /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          26,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          ppc64_elf_branch_reloc, /* special_function */
 384          "R_PPC64_REL24",       /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0x03fffffc,            /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch; the lower two bits must be zero.  */
 391   HOWTO (R_PPC64_REL14,         /* type */
 392          0,                     /* rightshift */
 393          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 394          16,                    /* bitsize */
 395          TRUE,                  /* pc_relative */
 396          0,                     /* bitpos */
 397          complain_overflow_signed, /* complain_on_overflow */
 398          ppc64_elf_branch_reloc, /* special_function */
 399          "R_PPC64_REL14",       /* name */
 400          FALSE,                 /* partial_inplace */
 401          0,                     /* src_mask */
 402          0x0000fffc,            /* dst_mask */
 403          TRUE),                 /* pcrel_offset */
 404
 405   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 406      the branch is expected to be taken.  The lower two bits must be
 407      zero.  */
 408   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          ppc64_elf_brtaken_reloc, /* special_function */
 416          "R_PPC64_REL14_BRTAKEN", /* name */
 417          FALSE,                 /* partial_inplace */
 418          0,                     /* src_mask */
 419          0x0000fffc,            /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 423      the branch is not expected to be taken.  The lower two bits must
 424      be zero.  */
 425   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 426          0,                     /* rightshift */
 427          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          TRUE,                  /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_signed, /* complain_on_overflow */
 432          ppc64_elf_brtaken_reloc, /* special_function */
 433          "R_PPC64_REL14_BRNTAKEN",/* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0x0000fffc,            /* dst_mask */
 437          TRUE),                 /* pcrel_offset */
 438
 439   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 440      symbol.  */
 441   HOWTO (R_PPC64_GOT16,         /* type */
 442          0,                     /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_unhandled_reloc, /* special_function */
 449          "R_PPC64_GOT16",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                /* pcrel_offset */
 454
 455   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC64_GOT16_LO,      /* type */
 458          0,                     /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          ppc64_elf_unhandled_reloc, /* special_function */
 465          "R_PPC64_GOT16_LO",    /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 472      the symbol.  */
 473   HOWTO (R_PPC64_GOT16_HI,      /* type */
 474          16,                    /* rightshift */
 475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          16,                    /* bitsize */
 477          FALSE,                 /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_dont,/* complain_on_overflow */
 480          ppc64_elf_unhandled_reloc, /* special_function */
 481          "R_PPC64_GOT16_HI",    /* name */
 482          FALSE,                 /* partial_inplace */
 483          0,                     /* src_mask */
 484          0xffff,                /* dst_mask */
 485          FALSE),                /* pcrel_offset */
 486
 487   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 488      the symbol.  */
 489   HOWTO (R_PPC64_GOT16_HA,      /* type */
 490          16,                    /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_dont,/* complain_on_overflow */
 496          ppc64_elf_unhandled_reloc, /* special_function */
 497          "R_PPC64_GOT16_HA",    /* name */
 498          FALSE,                 /* partial_inplace */
 499          0,                     /* src_mask */
 500          0xffff,                /* dst_mask */
 501          FALSE),                /* pcrel_offset */
 502
 503   /* This is used only by the dynamic linker.  The symbol should exist
 504      both in the object being run and in some shared library.  The
 505      dynamic linker copies the data addressed by the symbol from the
 506      shared library into the object, because the object being
 507      run has to have the data at some particular address.  */
 508   HOWTO (R_PPC64_COPY,          /* type */
 509          0,                     /* rightshift */
 510          0,                     /* this one is variable size */
 511          0,                     /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_COPY",        /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0,                     /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR64, but used when setting global offset table
 523      entries.  */
 524   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 525          0,                     /* rightshift */
 526          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 527          64,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_dont, /* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc,  /* special_function */
 532          "R_PPC64_GLOB_DAT",    /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          ONES (64),             /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Created by the link editor.  Marks a procedure linkage table
 539      entry for a symbol.  */
 540   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 541          0,                     /* rightshift */
 542          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          0,                     /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_JMP_SLOT",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0,                     /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Used only by the dynamic linker.  When the object is run, this
 555      doubleword64 is set to the load address of the object, plus the
 556      addend.  */
 557   HOWTO (R_PPC64_RELATIVE,      /* type */
 558          0,                     /* rightshift */
 559          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 560          64,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_dont, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC64_RELATIVE",    /* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          ONES (64),             /* dst_mask */
 569          FALSE),                /* pcrel_offset */
 570
 571   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 572   HOWTO (R_PPC64_UADDR32,       /* type */
 573          0,                     /* rightshift */
 574          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          32,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_bitfield, /* complain_on_overflow */
 579          bfd_elf_generic_reloc, /* special_function */
 580          "R_PPC64_UADDR32",     /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffffffff,            /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 587   HOWTO (R_PPC64_UADDR16,       /* type */
 588          0,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          16,                    /* bitsize */
 591          FALSE,                 /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_bitfield, /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_PPC64_UADDR16",     /* name */
 596          FALSE,                 /* partial_inplace */
 597          0,                     /* src_mask */
 598          0xffff,                /* dst_mask */
 599          FALSE),                /* pcrel_offset */
 600
 601   /* 32-bit PC relative.  */
 602   HOWTO (R_PPC64_REL32,         /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 609          complain_overflow_signed, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_REL32",       /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          0xffffffff,            /* dst_mask */
 615          TRUE),                 /* pcrel_offset */
 616
 617   /* 32-bit relocation to the symbol's procedure linkage table.  */
 618   HOWTO (R_PPC64_PLT32,         /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          ppc64_elf_unhandled_reloc, /* special_function */
 626          "R_PPC64_PLT32",       /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 633      FIXME: R_PPC64_PLTREL32 not supported.  */
 634   HOWTO (R_PPC64_PLTREL32,      /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          TRUE,                  /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_signed, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_PPC64_PLTREL32",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          TRUE),                 /* pcrel_offset */
 647
 648   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC64_PLT16_LO,      /* type */
 651          0,                     /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          ppc64_elf_unhandled_reloc, /* special_function */
 658          "R_PPC64_PLT16_LO",    /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 665      the symbol.  */
 666   HOWTO (R_PPC64_PLT16_HI,      /* type */
 667          16,                    /* rightshift */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          16,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_dont, /* complain_on_overflow */
 673          ppc64_elf_unhandled_reloc, /* special_function */
 674          "R_PPC64_PLT16_HI",    /* name */
 675          FALSE,                 /* partial_inplace */
 676          0,                     /* src_mask */
 677          0xffff,                /* dst_mask */
 678          FALSE),                /* pcrel_offset */
 679
 680   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 681      the symbol.  */
 682   HOWTO (R_PPC64_PLT16_HA,      /* type */
 683          16,                    /* rightshift */
 684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          16,                    /* bitsize */
 686          FALSE,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_dont, /* complain_on_overflow */
 689          ppc64_elf_unhandled_reloc, /* special_function */
 690          "R_PPC64_PLT16_HA",    /* name */
 691          FALSE,                 /* partial_inplace */
 692          0,                     /* src_mask */
 693          0xffff,                /* dst_mask */
 694          FALSE),                /* pcrel_offset */
 695
 696   /* 16-bit section relative relocation.  */
 697   HOWTO (R_PPC64_SECTOFF,       /* type */
 698          0,                     /* rightshift */
 699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 700          16,                    /* bitsize */
 701          FALSE,                 /* pc_relative */
 702          0,                     /* bitpos */
 703          complain_overflow_bitfield, /* complain_on_overflow */
 704          ppc64_elf_sectoff_reloc, /* special_function */
 705          "R_PPC64_SECTOFF",     /* name */
 706          FALSE,                 /* partial_inplace */
 707          0,                     /* src_mask */
 708          0xffff,                /* dst_mask */
 709          FALSE),                /* pcrel_offset */
 710
 711   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 712   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 713          0,                     /* rightshift */
 714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 715          16,                    /* bitsize */
 716          FALSE,                 /* pc_relative */
 717          0,                     /* bitpos */
 718          complain_overflow_dont, /* complain_on_overflow */
 719          ppc64_elf_sectoff_reloc, /* special_function */
 720          "R_PPC64_SECTOFF_LO",  /* name */
 721          FALSE,                 /* partial_inplace */
 722          0,                     /* src_mask */
 723          0xffff,                /* dst_mask */
 724          FALSE),                /* pcrel_offset */
 725
 726   /* 16-bit upper half section relative relocation.  */
 727   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          ppc64_elf_sectoff_reloc, /* special_function */
 735          "R_PPC64_SECTOFF_HI",  /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit upper half adjusted section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 743          16,                    /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_dont, /* complain_on_overflow */
 749          ppc64_elf_sectoff_ha_reloc, /* special_function */
 750          "R_PPC64_SECTOFF_HA",  /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 757   HOWTO (R_PPC64_REL30,         /* type */
 758          2,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          30,                    /* bitsize */
 761          TRUE,                  /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_PPC64_REL30",       /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xfffffffc,            /* dst_mask */
 769          TRUE),                 /* pcrel_offset */
 770
 771   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 772
 773   /* A standard 64-bit relocation.  */
 774   HOWTO (R_PPC64_ADDR64,        /* type */
 775          0,                     /* rightshift */
 776          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 777          64,                    /* bitsize */
 778          FALSE,                 /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_dont, /* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_PPC64_ADDR64",      /* name */
 783          FALSE,                 /* partial_inplace */
 784          0,                     /* src_mask */
 785          ONES (64),             /* dst_mask */
 786          FALSE),                /* pcrel_offset */
 787
 788   /* The bits 32-47 of an address.  */
 789   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 790          32,                    /* rightshift */
 791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 792          16,                    /* bitsize */
 793          FALSE,                 /* pc_relative */
 794          0,                     /* bitpos */
 795          complain_overflow_dont, /* complain_on_overflow */
 796          bfd_elf_generic_reloc, /* special_function */
 797          "R_PPC64_ADDR16_HIGHER", /* name */
 798          FALSE,                 /* partial_inplace */
 799          0,                     /* src_mask */
 800          0xffff,                /* dst_mask */
 801          FALSE),                /* pcrel_offset */
 802
 803   /* The bits 32-47 of an address, plus 1 if the contents of the low
 804      16 bits, treated as a signed number, is negative.  */
 805   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 806          32,                    /* rightshift */
 807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 808          16,                    /* bitsize */
 809          FALSE,                 /* pc_relative */
 810          0,                     /* bitpos */
 811          complain_overflow_dont, /* complain_on_overflow */
 812          ppc64_elf_ha_reloc,    /* special_function */
 813          "R_PPC64_ADDR16_HIGHERA", /* name */
 814          FALSE,                 /* partial_inplace */
 815          0,                     /* src_mask */
 816          0xffff,                /* dst_mask */
 817          FALSE),                /* pcrel_offset */
 818
 819   /* The bits 48-63 of an address.  */
 820   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 821          48,                    /* rightshift */
 822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 823          16,                    /* bitsize */
 824          FALSE,                 /* pc_relative */
 825          0,                     /* bitpos */
 826          complain_overflow_dont, /* complain_on_overflow */
 827          bfd_elf_generic_reloc, /* special_function */
 828          "R_PPC64_ADDR16_HIGHEST", /* name */
 829          FALSE,                 /* partial_inplace */
 830          0,                     /* src_mask */
 831          0xffff,                /* dst_mask */
 832          FALSE),                /* pcrel_offset */
 833
 834   /* The bits 48-63 of an address, plus 1 if the contents of the low
 835      16 bits, treated as a signed number, is negative.  */
 836   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 837          48,                    /* rightshift */
 838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 839          16,                    /* bitsize */
 840          FALSE,                 /* pc_relative */
 841          0,                     /* bitpos */
 842          complain_overflow_dont, /* complain_on_overflow */
 843          ppc64_elf_ha_reloc,    /* special_function */
 844          "R_PPC64_ADDR16_HIGHESTA", /* name */
 845          FALSE,                 /* partial_inplace */
 846          0,                     /* src_mask */
 847          0xffff,                /* dst_mask */
 848          FALSE),                /* pcrel_offset */
 849
 850   /* Like ADDR64, but may be unaligned.  */
 851   HOWTO (R_PPC64_UADDR64,       /* type */
 852          0,                     /* rightshift */
 853          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 854          64,                    /* bitsize */
 855          FALSE,                 /* pc_relative */
 856          0,                     /* bitpos */
 857          complain_overflow_dont, /* complain_on_overflow */
 858          bfd_elf_generic_reloc, /* special_function */
 859          "R_PPC64_UADDR64",     /* name */
 860          FALSE,                 /* partial_inplace */
 861          0,                     /* src_mask */
 862          ONES (64),             /* dst_mask */
 863          FALSE),                /* pcrel_offset */
 864
 865   /* 64-bit relative relocation.  */
 866   HOWTO (R_PPC64_REL64,         /* type */
 867          0,                     /* rightshift */
 868          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 869          64,                    /* bitsize */
 870          TRUE,                  /* pc_relative */
 871          0,                     /* bitpos */
 872          complain_overflow_dont, /* complain_on_overflow */
 873          bfd_elf_generic_reloc, /* special_function */
 874          "R_PPC64_REL64",       /* name */
 875          FALSE,                 /* partial_inplace */
 876          0,                     /* src_mask */
 877          ONES (64),             /* dst_mask */
 878          TRUE),                 /* pcrel_offset */
 879
 880   /* 64-bit relocation to the symbol's procedure linkage table.  */
 881   HOWTO (R_PPC64_PLT64,         /* type */
 882          0,                     /* rightshift */
 883          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 884          64,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_unhandled_reloc, /* special_function */
 889          "R_PPC64_PLT64",       /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          ONES (64),             /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* 64-bit PC relative relocation to the symbol's procedure linkage
 896      table.  */
 897   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 898   HOWTO (R_PPC64_PLTREL64,      /* type */
 899          0,                     /* rightshift */
 900          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 901          64,                    /* bitsize */
 902          TRUE,                  /* pc_relative */
 903          0,                     /* bitpos */
 904          complain_overflow_dont, /* complain_on_overflow */
 905          ppc64_elf_unhandled_reloc, /* special_function */
 906          "R_PPC64_PLTREL64",    /* name */
 907          FALSE,                 /* partial_inplace */
 908          0,                     /* src_mask */
 909          ONES (64),             /* dst_mask */
 910          TRUE),                 /* pcrel_offset */
 911
 912   /* 16 bit TOC-relative relocation.  */
 913
 914   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 915   HOWTO (R_PPC64_TOC16,         /* type */
 916          0,                     /* rightshift */
 917          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 918          16,                    /* bitsize */
 919          FALSE,                 /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_signed, /* complain_on_overflow */
 922          ppc64_elf_toc_reloc,   /* special_function */
 923          "R_PPC64_TOC16",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          0xffff,                /* dst_mask */
 927          FALSE),                /* pcrel_offset */
 928
 929   /* 16 bit TOC-relative relocation without overflow.  */
 930
 931   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 932   HOWTO (R_PPC64_TOC16_LO,      /* type */
 933          0,                     /* rightshift */
 934          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 935          16,                    /* bitsize */
 936          FALSE,                 /* pc_relative */
 937          0,                     /* bitpos */
 938          complain_overflow_dont, /* complain_on_overflow */
 939          ppc64_elf_toc_reloc,   /* special_function */
 940          "R_PPC64_TOC16_LO",    /* name */
 941          FALSE,                 /* partial_inplace */
 942          0,                     /* src_mask */
 943          0xffff,                /* dst_mask */
 944          FALSE),                /* pcrel_offset */
 945
 946   /* 16 bit TOC-relative relocation, high 16 bits.  */
 947
 948   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 949   HOWTO (R_PPC64_TOC16_HI,      /* type */
 950          16,                    /* rightshift */
 951          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 952          16,                    /* bitsize */
 953          FALSE,                 /* pc_relative */
 954          0,                     /* bitpos */
 955          complain_overflow_dont, /* complain_on_overflow */
 956          ppc64_elf_toc_reloc,   /* special_function */
 957          "R_PPC64_TOC16_HI",    /* name */
 958          FALSE,                 /* partial_inplace */
 959          0,                     /* src_mask */
 960          0xffff,                /* dst_mask */
 961          FALSE),                /* pcrel_offset */
 962
 963   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 964      contents of the low 16 bits, treated as a signed number, is
 965      negative.  */
 966
 967   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 968   HOWTO (R_PPC64_TOC16_HA,      /* type */
 969          16,                    /* rightshift */
 970          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 971          16,                    /* bitsize */
 972          FALSE,                 /* pc_relative */
 973          0,                     /* bitpos */
 974          complain_overflow_dont, /* complain_on_overflow */
 975          ppc64_elf_toc_ha_reloc, /* special_function */
 976          "R_PPC64_TOC16_HA",    /* name */
 977          FALSE,                 /* partial_inplace */
 978          0,                     /* src_mask */
 979          0xffff,                /* dst_mask */
 980          FALSE),                /* pcrel_offset */
 981
 982   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 983
 984   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 985   HOWTO (R_PPC64_TOC,           /* type */
 986          0,                     /* rightshift */
 987          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 988          64,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_bitfield, /* complain_on_overflow */
 992          ppc64_elf_toc64_reloc, /* special_function */
 993          "R_PPC64_TOC",         /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          ONES (64),             /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* Like R_PPC64_GOT16, but also informs the link editor that the
1000      value to relocate may (!) refer to a PLT entry which the link
1001      editor (a) may replace with the symbol value.  If the link editor
1002      is unable to fully resolve the symbol, it may (b) create a PLT
1003      entry and store the address to the new PLT entry in the GOT.
1004      This permits lazy resolution of function symbols at run time.
1005      The link editor may also skip all of this and just (c) emit a
1006      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1007   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1008     HOWTO (R_PPC64_PLTGOT16,    /* type */
1009          0,                     /* rightshift */
1010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          16,                    /* bitsize */
1012          FALSE,                 /* pc_relative */
1013          0,                     /* bitpos */
1014          complain_overflow_signed, /* complain_on_overflow */
1015          ppc64_elf_unhandled_reloc, /* special_function */
1016          "R_PPC64_PLTGOT16",    /* name */
1017          FALSE,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0xffff,                /* dst_mask */
1020          FALSE),                /* pcrel_offset */
1021
1022   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1023   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1024   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1025          0,                     /* rightshift */
1026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1027          16,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_unhandled_reloc, /* special_function */
1032          "R_PPC64_PLTGOT16_LO", /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          0xffff,                /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1039   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1040   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1041          16,                    /* rightshift */
1042          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1043          16,                    /* bitsize */
1044          FALSE,                 /* pc_relative */
1045          0,                     /* bitpos */
1046          complain_overflow_dont, /* complain_on_overflow */
1047          ppc64_elf_unhandled_reloc, /* special_function */
1048          "R_PPC64_PLTGOT16_HI", /* name */
1049          FALSE,                 /* partial_inplace */
1050          0,                     /* src_mask */
1051          0xffff,                /* dst_mask */
1052          FALSE),                /* pcrel_offset */
1053
1054   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055      1 if the contents of the low 16 bits, treated as a signed number,
1056      is negative.  */
1057   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1058   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1059          16,                    /* rightshift */
1060          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1061          16,                    /* bitsize */
1062          FALSE,                 /* pc_relative */
1063          0,                     /* bitpos */
1064          complain_overflow_dont,/* complain_on_overflow */
1065          ppc64_elf_unhandled_reloc, /* special_function */
1066          "R_PPC64_PLTGOT16_HA", /* name */
1067          FALSE,                 /* partial_inplace */
1068          0,                     /* src_mask */
1069          0xffff,                /* dst_mask */
1070          FALSE),                /* pcrel_offset */
1071
1072   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1073   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_bitfield, /* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_PPC64_ADDR16_DS",   /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xfffc,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1088   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1089          0,                     /* rightshift */
1090          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1091          16,                    /* bitsize */
1092          FALSE,                 /* pc_relative */
1093          0,                     /* bitpos */
1094          complain_overflow_dont,/* complain_on_overflow */
1095          bfd_elf_generic_reloc, /* special_function */
1096          "R_PPC64_ADDR16_LO_DS",/* name */
1097          FALSE,                 /* partial_inplace */
1098          0,                     /* src_mask */
1099          0xfffc,                /* dst_mask */
1100          FALSE),                /* pcrel_offset */
1101
1102   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1103   HOWTO (R_PPC64_GOT16_DS,      /* type */
1104          0,                     /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_GOT16_DS",    /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xfffc,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_dont, /* complain_on_overflow */
1125          ppc64_elf_unhandled_reloc, /* special_function */
1126          "R_PPC64_GOT16_LO_DS", /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont, /* complain_on_overflow */
1140          ppc64_elf_unhandled_reloc, /* special_function */
1141          "R_PPC64_PLT16_LO_DS", /* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_bitfield, /* complain_on_overflow */
1155          ppc64_elf_sectoff_reloc, /* special_function */
1156          "R_PPC64_SECTOFF_DS",  /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_sectoff_reloc, /* special_function */
1171          "R_PPC64_SECTOFF_LO_DS",/* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_TOC16_DS,      /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_signed, /* complain_on_overflow */
1185          ppc64_elf_toc_reloc,   /* special_function */
1186          "R_PPC64_TOC16_DS",    /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont, /* complain_on_overflow */
1200          ppc64_elf_toc_reloc,   /* special_function */
1201          "R_PPC64_TOC16_LO_DS", /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1208   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1209   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1210          0,                     /* rightshift */
1211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1212          16,                    /* bitsize */
1213          FALSE,                 /* pc_relative */
1214          0,                     /* bitpos */
1215          complain_overflow_signed, /* complain_on_overflow */
1216          ppc64_elf_unhandled_reloc, /* special_function */
1217          "R_PPC64_PLTGOT16_DS", /* name */
1218          FALSE,                 /* partial_inplace */
1219          0,                     /* src_mask */
1220          0xfffc,                /* dst_mask */
1221          FALSE),                /* pcrel_offset */
1222
1223   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1224   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1225   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226          0,                     /* rightshift */
1227          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1228          16,                    /* bitsize */
1229          FALSE,                 /* pc_relative */
1230          0,                     /* bitpos */
1231          complain_overflow_dont, /* complain_on_overflow */
1232          ppc64_elf_unhandled_reloc, /* special_function */
1233          "R_PPC64_PLTGOT16_LO_DS",/* name */
1234          FALSE,                 /* partial_inplace */
1235          0,                     /* src_mask */
1236          0xfffc,                /* dst_mask */
1237          FALSE),                /* pcrel_offset */
1238
1239   /* Marker relocs for TLS.  */
1240   HOWTO (R_PPC64_TLS,
1241          0,                     /* rightshift */
1242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1243          32,                    /* bitsize */
1244          FALSE,                 /* pc_relative */
1245          0,                     /* bitpos */
1246          complain_overflow_dont, /* complain_on_overflow */
1247          bfd_elf_generic_reloc, /* special_function */
1248          "R_PPC64_TLS",         /* name */
1249          FALSE,                 /* partial_inplace */
1250          0,                     /* src_mask */
1251          0,                     /* dst_mask */
1252          FALSE),                /* pcrel_offset */
1253
1254   HOWTO (R_PPC64_TLSGD,
1255          0,                     /* rightshift */
1256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          32,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_dont, /* complain_on_overflow */
1261          bfd_elf_generic_reloc, /* special_function */
1262          "R_PPC64_TLSGD",       /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0,                     /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   HOWTO (R_PPC64_TLSLD,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLSLD",       /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   /* Computes the load module index of the load module that contains the
1283      definition of its TLS sym.  */
1284   HOWTO (R_PPC64_DTPMOD64,
1285          0,                     /* rightshift */
1286          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1287          64,                    /* bitsize */
1288          FALSE,                 /* pc_relative */
1289          0,                     /* bitpos */
1290          complain_overflow_dont, /* complain_on_overflow */
1291          ppc64_elf_unhandled_reloc, /* special_function */
1292          "R_PPC64_DTPMOD64",    /* name */
1293          FALSE,                 /* partial_inplace */
1294          0,                     /* src_mask */
1295          ONES (64),             /* dst_mask */
1296          FALSE),                /* pcrel_offset */
1297
1298   /* Computes a dtv-relative displacement, the difference between the value
1299      of sym+add and the base address of the thread-local storage block that
1300      contains the definition of sym, minus 0x8000.  */
1301   HOWTO (R_PPC64_DTPREL64,
1302          0,                     /* rightshift */
1303          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          64,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont, /* complain_on_overflow */
1308          ppc64_elf_unhandled_reloc, /* special_function */
1309          "R_PPC64_DTPREL64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* A 16 bit dtprel reloc.  */
1316   HOWTO (R_PPC64_DTPREL16,
1317          0,                     /* rightshift */
1318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1319          16,                    /* bitsize */
1320          FALSE,                 /* pc_relative */
1321          0,                     /* bitpos */
1322          complain_overflow_signed, /* complain_on_overflow */
1323          ppc64_elf_unhandled_reloc, /* special_function */
1324          "R_PPC64_DTPREL16",    /* name */
1325          FALSE,                 /* partial_inplace */
1326          0,                     /* src_mask */
1327          0xffff,                /* dst_mask */
1328          FALSE),                /* pcrel_offset */
1329
1330   /* Like DTPREL16, but no overflow.  */
1331   HOWTO (R_PPC64_DTPREL16_LO,
1332          0,                     /* rightshift */
1333          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          16,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          ppc64_elf_unhandled_reloc, /* special_function */
1339          "R_PPC64_DTPREL16_LO", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0xffff,                /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1346   HOWTO (R_PPC64_DTPREL16_HI,
1347          16,                    /* rightshift */
1348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1349          16,                    /* bitsize */
1350          FALSE,                 /* pc_relative */
1351          0,                     /* bitpos */
1352          complain_overflow_dont, /* complain_on_overflow */
1353          ppc64_elf_unhandled_reloc, /* special_function */
1354          "R_PPC64_DTPREL16_HI", /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1361   HOWTO (R_PPC64_DTPREL16_HA,
1362          16,                    /* rightshift */
1363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1364          16,                    /* bitsize */
1365          FALSE,                 /* pc_relative */
1366          0,                     /* bitpos */
1367          complain_overflow_dont, /* complain_on_overflow */
1368          ppc64_elf_unhandled_reloc, /* special_function */
1369          "R_PPC64_DTPREL16_HA", /* name */
1370          FALSE,                 /* partial_inplace */
1371          0,                     /* src_mask */
1372          0xffff,                /* dst_mask */
1373          FALSE),                /* pcrel_offset */
1374
1375   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1376   HOWTO (R_PPC64_DTPREL16_HIGHER,
1377          32,                    /* rightshift */
1378          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1379          16,                    /* bitsize */
1380          FALSE,                 /* pc_relative */
1381          0,                     /* bitpos */
1382          complain_overflow_dont, /* complain_on_overflow */
1383          ppc64_elf_unhandled_reloc, /* special_function */
1384          "R_PPC64_DTPREL16_HIGHER", /* name */
1385          FALSE,                 /* partial_inplace */
1386          0,                     /* src_mask */
1387          0xffff,                /* dst_mask */
1388          FALSE),                /* pcrel_offset */
1389
1390   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1391   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392          32,                    /* rightshift */
1393          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1394          16,                    /* bitsize */
1395          FALSE,                 /* pc_relative */
1396          0,                     /* bitpos */
1397          complain_overflow_dont, /* complain_on_overflow */
1398          ppc64_elf_unhandled_reloc, /* special_function */
1399          "R_PPC64_DTPREL16_HIGHERA", /* name */
1400          FALSE,                 /* partial_inplace */
1401          0,                     /* src_mask */
1402          0xffff,                /* dst_mask */
1403          FALSE),                /* pcrel_offset */
1404
1405   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1406   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407          48,                    /* rightshift */
1408          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1409          16,                    /* bitsize */
1410          FALSE,                 /* pc_relative */
1411          0,                     /* bitpos */
1412          complain_overflow_dont, /* complain_on_overflow */
1413          ppc64_elf_unhandled_reloc, /* special_function */
1414          "R_PPC64_DTPREL16_HIGHEST", /* name */
1415          FALSE,                 /* partial_inplace */
1416          0,                     /* src_mask */
1417          0xffff,                /* dst_mask */
1418          FALSE),                /* pcrel_offset */
1419
1420   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1421   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422          48,                    /* rightshift */
1423          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1424          16,                    /* bitsize */
1425          FALSE,                 /* pc_relative */
1426          0,                     /* bitpos */
1427          complain_overflow_dont, /* complain_on_overflow */
1428          ppc64_elf_unhandled_reloc, /* special_function */
1429          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430          FALSE,                 /* partial_inplace */
1431          0,                     /* src_mask */
1432          0xffff,                /* dst_mask */
1433          FALSE),                /* pcrel_offset */
1434
1435   /* Like DTPREL16, but for insns with a DS field.  */
1436   HOWTO (R_PPC64_DTPREL16_DS,
1437          0,                     /* rightshift */
1438          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1439          16,                    /* bitsize */
1440          FALSE,                 /* pc_relative */
1441          0,                     /* bitpos */
1442          complain_overflow_signed, /* complain_on_overflow */
1443          ppc64_elf_unhandled_reloc, /* special_function */
1444          "R_PPC64_DTPREL16_DS", /* name */
1445          FALSE,                 /* partial_inplace */
1446          0,                     /* src_mask */
1447          0xfffc,                /* dst_mask */
1448          FALSE),                /* pcrel_offset */
1449
1450   /* Like DTPREL16_DS, but no overflow.  */
1451   HOWTO (R_PPC64_DTPREL16_LO_DS,
1452          0,                     /* rightshift */
1453          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1454          16,                    /* bitsize */
1455          FALSE,                 /* pc_relative */
1456          0,                     /* bitpos */
1457          complain_overflow_dont, /* complain_on_overflow */
1458          ppc64_elf_unhandled_reloc, /* special_function */
1459          "R_PPC64_DTPREL16_LO_DS", /* name */
1460          FALSE,                 /* partial_inplace */
1461          0,                     /* src_mask */
1462          0xfffc,                /* dst_mask */
1463          FALSE),                /* pcrel_offset */
1464
1465   /* Computes a tp-relative displacement, the difference between the value of
1466      sym+add and the value of the thread pointer (r13).  */
1467   HOWTO (R_PPC64_TPREL64,
1468          0,                     /* rightshift */
1469          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          64,                    /* bitsize */
1471          FALSE,                 /* pc_relative */
1472          0,                     /* bitpos */
1473          complain_overflow_dont, /* complain_on_overflow */
1474          ppc64_elf_unhandled_reloc, /* special_function */
1475          "R_PPC64_TPREL64",     /* name */
1476          FALSE,                 /* partial_inplace */
1477          0,                     /* src_mask */
1478          ONES (64),             /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   /* A 16 bit tprel reloc.  */
1482   HOWTO (R_PPC64_TPREL16,
1483          0,                     /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_signed, /* complain_on_overflow */
1489          ppc64_elf_unhandled_reloc, /* special_function */
1490          "R_PPC64_TPREL16",     /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Like TPREL16, but no overflow.  */
1497   HOWTO (R_PPC64_TPREL16_LO,
1498          0,                     /* rightshift */
1499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1500          16,                    /* bitsize */
1501          FALSE,                 /* pc_relative */
1502          0,                     /* bitpos */
1503          complain_overflow_dont, /* complain_on_overflow */
1504          ppc64_elf_unhandled_reloc, /* special_function */
1505          "R_PPC64_TPREL16_LO",  /* name */
1506          FALSE,                 /* partial_inplace */
1507          0,                     /* src_mask */
1508          0xffff,                /* dst_mask */
1509          FALSE),                /* pcrel_offset */
1510
1511   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1512   HOWTO (R_PPC64_TPREL16_HI,
1513          16,                    /* rightshift */
1514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1515          16,                    /* bitsize */
1516          FALSE,                 /* pc_relative */
1517          0,                     /* bitpos */
1518          complain_overflow_dont, /* complain_on_overflow */
1519          ppc64_elf_unhandled_reloc, /* special_function */
1520          "R_PPC64_TPREL16_HI",  /* name */
1521          FALSE,                 /* partial_inplace */
1522          0,                     /* src_mask */
1523          0xffff,                /* dst_mask */
1524          FALSE),                /* pcrel_offset */
1525
1526   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1527   HOWTO (R_PPC64_TPREL16_HA,
1528          16,                    /* rightshift */
1529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1530          16,                    /* bitsize */
1531          FALSE,                 /* pc_relative */
1532          0,                     /* bitpos */
1533          complain_overflow_dont, /* complain_on_overflow */
1534          ppc64_elf_unhandled_reloc, /* special_function */
1535          "R_PPC64_TPREL16_HA",  /* name */
1536          FALSE,                 /* partial_inplace */
1537          0,                     /* src_mask */
1538          0xffff,                /* dst_mask */
1539          FALSE),                /* pcrel_offset */
1540
1541   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1542   HOWTO (R_PPC64_TPREL16_HIGHER,
1543          32,                    /* rightshift */
1544          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1545          16,                    /* bitsize */
1546          FALSE,                 /* pc_relative */
1547          0,                     /* bitpos */
1548          complain_overflow_dont, /* complain_on_overflow */
1549          ppc64_elf_unhandled_reloc, /* special_function */
1550          "R_PPC64_TPREL16_HIGHER",      /* name */
1551          FALSE,                 /* partial_inplace */
1552          0,                     /* src_mask */
1553          0xffff,                /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1557   HOWTO (R_PPC64_TPREL16_HIGHERA,
1558          32,                    /* rightshift */
1559          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1560          16,                    /* bitsize */
1561          FALSE,                 /* pc_relative */
1562          0,                     /* bitpos */
1563          complain_overflow_dont, /* complain_on_overflow */
1564          ppc64_elf_unhandled_reloc, /* special_function */
1565          "R_PPC64_TPREL16_HIGHERA", /* name */
1566          FALSE,                 /* partial_inplace */
1567          0,                     /* src_mask */
1568          0xffff,                /* dst_mask */
1569          FALSE),                /* pcrel_offset */
1570
1571   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1572   HOWTO (R_PPC64_TPREL16_HIGHEST,
1573          48,                    /* rightshift */
1574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1575          16,                    /* bitsize */
1576          FALSE,                 /* pc_relative */
1577          0,                     /* bitpos */
1578          complain_overflow_dont, /* complain_on_overflow */
1579          ppc64_elf_unhandled_reloc, /* special_function */
1580          "R_PPC64_TPREL16_HIGHEST", /* name */
1581          FALSE,                 /* partial_inplace */
1582          0,                     /* src_mask */
1583          0xffff,                /* dst_mask */
1584          FALSE),                /* pcrel_offset */
1585
1586   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1587   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588          48,                    /* rightshift */
1589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1590          16,                    /* bitsize */
1591          FALSE,                 /* pc_relative */
1592          0,                     /* bitpos */
1593          complain_overflow_dont, /* complain_on_overflow */
1594          ppc64_elf_unhandled_reloc, /* special_function */
1595          "R_PPC64_TPREL16_HIGHESTA", /* name */
1596          FALSE,                 /* partial_inplace */
1597          0,                     /* src_mask */
1598          0xffff,                /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600
1601   /* Like TPREL16, but for insns with a DS field.  */
1602   HOWTO (R_PPC64_TPREL16_DS,
1603          0,                     /* rightshift */
1604          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          16,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_signed, /* complain_on_overflow */
1609          ppc64_elf_unhandled_reloc, /* special_function */
1610          "R_PPC64_TPREL16_DS",  /* name */
1611          FALSE,                 /* partial_inplace */
1612          0,                     /* src_mask */
1613          0xfffc,                /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   /* Like TPREL16_DS, but no overflow.  */
1617   HOWTO (R_PPC64_TPREL16_LO_DS,
1618          0,                     /* rightshift */
1619          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1620          16,                    /* bitsize */
1621          FALSE,                 /* pc_relative */
1622          0,                     /* bitpos */
1623          complain_overflow_dont, /* complain_on_overflow */
1624          ppc64_elf_unhandled_reloc, /* special_function */
1625          "R_PPC64_TPREL16_LO_DS", /* name */
1626          FALSE,                 /* partial_inplace */
1627          0,                     /* src_mask */
1628          0xfffc,                /* dst_mask */
1629          FALSE),                /* pcrel_offset */
1630
1631   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633      to the first entry relative to the TOC base (r2).  */
1634   HOWTO (R_PPC64_GOT_TLSGD16,
1635          0,                     /* rightshift */
1636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1637          16,                    /* bitsize */
1638          FALSE,                 /* pc_relative */
1639          0,                     /* bitpos */
1640          complain_overflow_signed, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_GOT_TLSGD16", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xffff,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Like GOT_TLSGD16, but no overflow.  */
1649   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650          0,                     /* rightshift */
1651          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1652          16,                    /* bitsize */
1653          FALSE,                 /* pc_relative */
1654          0,                     /* bitpos */
1655          complain_overflow_dont, /* complain_on_overflow */
1656          ppc64_elf_unhandled_reloc, /* special_function */
1657          "R_PPC64_GOT_TLSGD16_LO", /* name */
1658          FALSE,                 /* partial_inplace */
1659          0,                     /* src_mask */
1660          0xffff,                /* dst_mask */
1661          FALSE),                /* pcrel_offset */
1662
1663   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1664   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665          16,                    /* rightshift */
1666          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1667          16,                    /* bitsize */
1668          FALSE,                 /* pc_relative */
1669          0,                     /* bitpos */
1670          complain_overflow_dont, /* complain_on_overflow */
1671          ppc64_elf_unhandled_reloc, /* special_function */
1672          "R_PPC64_GOT_TLSGD16_HI", /* name */
1673          FALSE,                 /* partial_inplace */
1674          0,                     /* src_mask */
1675          0xffff,                /* dst_mask */
1676          FALSE),                /* pcrel_offset */
1677
1678   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1679   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680          16,                    /* rightshift */
1681          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1682          16,                    /* bitsize */
1683          FALSE,                 /* pc_relative */
1684          0,                     /* bitpos */
1685          complain_overflow_dont, /* complain_on_overflow */
1686          ppc64_elf_unhandled_reloc, /* special_function */
1687          "R_PPC64_GOT_TLSGD16_HA", /* name */
1688          FALSE,                 /* partial_inplace */
1689          0,                     /* src_mask */
1690          0xffff,                /* dst_mask */
1691          FALSE),                /* pcrel_offset */
1692
1693   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694      with values (sym+add)@dtpmod and zero, and computes the offset to the
1695      first entry relative to the TOC base (r2).  */
1696   HOWTO (R_PPC64_GOT_TLSLD16,
1697          0,                     /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_signed, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSLD16", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Like GOT_TLSLD16, but no overflow.  */
1711   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712          0,                     /* rightshift */
1713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1714          16,                    /* bitsize */
1715          FALSE,                 /* pc_relative */
1716          0,                     /* bitpos */
1717          complain_overflow_dont, /* complain_on_overflow */
1718          ppc64_elf_unhandled_reloc, /* special_function */
1719          "R_PPC64_GOT_TLSLD16_LO", /* name */
1720          FALSE,                 /* partial_inplace */
1721          0,                     /* src_mask */
1722          0xffff,                /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1726   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727          16,                    /* rightshift */
1728          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1729          16,                    /* bitsize */
1730          FALSE,                 /* pc_relative */
1731          0,                     /* bitpos */
1732          complain_overflow_dont, /* complain_on_overflow */
1733          ppc64_elf_unhandled_reloc, /* special_function */
1734          "R_PPC64_GOT_TLSLD16_HI", /* name */
1735          FALSE,                 /* partial_inplace */
1736          0,                     /* src_mask */
1737          0xffff,                /* dst_mask */
1738          FALSE),                /* pcrel_offset */
1739
1740   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1741   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742          16,                    /* rightshift */
1743          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1744          16,                    /* bitsize */
1745          FALSE,                 /* pc_relative */
1746          0,                     /* bitpos */
1747          complain_overflow_dont, /* complain_on_overflow */
1748          ppc64_elf_unhandled_reloc, /* special_function */
1749          "R_PPC64_GOT_TLSLD16_HA", /* name */
1750          FALSE,                 /* partial_inplace */
1751          0,                     /* src_mask */
1752          0xffff,                /* dst_mask */
1753          FALSE),                /* pcrel_offset */
1754
1755   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756      the offset to the entry relative to the TOC base (r2).  */
1757   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758          0,                     /* rightshift */
1759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1760          16,                    /* bitsize */
1761          FALSE,                 /* pc_relative */
1762          0,                     /* bitpos */
1763          complain_overflow_signed, /* complain_on_overflow */
1764          ppc64_elf_unhandled_reloc, /* special_function */
1765          "R_PPC64_GOT_DTPREL16_DS", /* name */
1766          FALSE,                 /* partial_inplace */
1767          0,                     /* src_mask */
1768          0xfffc,                /* dst_mask */
1769          FALSE),                /* pcrel_offset */
1770
1771   /* Like GOT_DTPREL16_DS, but no overflow.  */
1772   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773          0,                     /* rightshift */
1774          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1775          16,                    /* bitsize */
1776          FALSE,                 /* pc_relative */
1777          0,                     /* bitpos */
1778          complain_overflow_dont, /* complain_on_overflow */
1779          ppc64_elf_unhandled_reloc, /* special_function */
1780          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1781          FALSE,                 /* partial_inplace */
1782          0,                     /* src_mask */
1783          0xfffc,                /* dst_mask */
1784          FALSE),                /* pcrel_offset */
1785
1786   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1787   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788          16,                    /* rightshift */
1789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1790          16,                    /* bitsize */
1791          FALSE,                 /* pc_relative */
1792          0,                     /* bitpos */
1793          complain_overflow_dont, /* complain_on_overflow */
1794          ppc64_elf_unhandled_reloc, /* special_function */
1795          "R_PPC64_GOT_DTPREL16_HI", /* name */
1796          FALSE,                 /* partial_inplace */
1797          0,                     /* src_mask */
1798          0xffff,                /* dst_mask */
1799          FALSE),                /* pcrel_offset */
1800
1801   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1802   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803          16,                    /* rightshift */
1804          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1805          16,                    /* bitsize */
1806          FALSE,                 /* pc_relative */
1807          0,                     /* bitpos */
1808          complain_overflow_dont, /* complain_on_overflow */
1809          ppc64_elf_unhandled_reloc, /* special_function */
1810          "R_PPC64_GOT_DTPREL16_HA", /* name */
1811          FALSE,                 /* partial_inplace */
1812          0,                     /* src_mask */
1813          0xffff,                /* dst_mask */
1814          FALSE),                /* pcrel_offset */
1815
1816   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817      offset to the entry relative to the TOC base (r2).  */
1818   HOWTO (R_PPC64_GOT_TPREL16_DS,
1819          0,                     /* rightshift */
1820          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1821          16,                    /* bitsize */
1822          FALSE,                 /* pc_relative */
1823          0,                     /* bitpos */
1824          complain_overflow_signed, /* complain_on_overflow */
1825          ppc64_elf_unhandled_reloc, /* special_function */
1826          "R_PPC64_GOT_TPREL16_DS", /* name */
1827          FALSE,                 /* partial_inplace */
1828          0,                     /* src_mask */
1829          0xfffc,                /* dst_mask */
1830          FALSE),                /* pcrel_offset */
1831
1832   /* Like GOT_TPREL16_DS, but no overflow.  */
1833   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834          0,                     /* rightshift */
1835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1836          16,                    /* bitsize */
1837          FALSE,                 /* pc_relative */
1838          0,                     /* bitpos */
1839          complain_overflow_dont, /* complain_on_overflow */
1840          ppc64_elf_unhandled_reloc, /* special_function */
1841          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1842          FALSE,                 /* partial_inplace */
1843          0,                     /* src_mask */
1844          0xfffc,                /* dst_mask */
1845          FALSE),                /* pcrel_offset */
1846
1847   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1848   HOWTO (R_PPC64_GOT_TPREL16_HI,
1849          16,                    /* rightshift */
1850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1851          16,                    /* bitsize */
1852          FALSE,                 /* pc_relative */
1853          0,                     /* bitpos */
1854          complain_overflow_dont, /* complain_on_overflow */
1855          ppc64_elf_unhandled_reloc, /* special_function */
1856          "R_PPC64_GOT_TPREL16_HI", /* name */
1857          FALSE,                 /* partial_inplace */
1858          0,                     /* src_mask */
1859          0xffff,                /* dst_mask */
1860          FALSE),                /* pcrel_offset */
1861
1862   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1863   HOWTO (R_PPC64_GOT_TPREL16_HA,
1864          16,                    /* rightshift */
1865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1866          16,                    /* bitsize */
1867          FALSE,                 /* pc_relative */
1868          0,                     /* bitpos */
1869          complain_overflow_dont, /* complain_on_overflow */
1870          ppc64_elf_unhandled_reloc, /* special_function */
1871          "R_PPC64_GOT_TPREL16_HA", /* name */
1872          FALSE,                 /* partial_inplace */
1873          0,                     /* src_mask */
1874          0xffff,                /* dst_mask */
1875          FALSE),                /* pcrel_offset */
1876
1877   HOWTO (R_PPC64_JMP_IREL,      /* type */
1878          0,                     /* rightshift */
1879          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880          0,                     /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_dont, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_JMP_IREL",    /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0,                     /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   HOWTO (R_PPC64_IRELATIVE,     /* type */
1892          0,                     /* rightshift */
1893          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1894          64,                    /* bitsize */
1895          FALSE,                 /* pc_relative */
1896          0,                     /* bitpos */
1897          complain_overflow_dont, /* complain_on_overflow */
1898          bfd_elf_generic_reloc, /* special_function */
1899          "R_PPC64_IRELATIVE",   /* name */
1900          FALSE,                 /* partial_inplace */
1901          0,                     /* src_mask */
1902          ONES (64),             /* dst_mask */
1903          FALSE),                /* pcrel_offset */
1904
1905   /* A 16 bit relative relocation.  */
1906   HOWTO (R_PPC64_REL16,         /* type */
1907          0,                     /* rightshift */
1908          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1909          16,                    /* bitsize */
1910          TRUE,                  /* pc_relative */
1911          0,                     /* bitpos */
1912          complain_overflow_bitfield, /* complain_on_overflow */
1913          bfd_elf_generic_reloc, /* special_function */
1914          "R_PPC64_REL16",       /* name */
1915          FALSE,                 /* partial_inplace */
1916          0,                     /* src_mask */
1917          0xffff,                /* dst_mask */
1918          TRUE),                 /* pcrel_offset */
1919
1920   /* A 16 bit relative relocation without overflow.  */
1921   HOWTO (R_PPC64_REL16_LO,      /* type */
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          TRUE,                  /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_dont,/* complain_on_overflow */
1928          bfd_elf_generic_reloc, /* special_function */
1929          "R_PPC64_REL16_LO",    /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xffff,                /* dst_mask */
1933          TRUE),                 /* pcrel_offset */
1934
1935   /* The high order 16 bits of a relative address.  */
1936   HOWTO (R_PPC64_REL16_HI,      /* type */
1937          16,                    /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          TRUE,                  /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          bfd_elf_generic_reloc, /* special_function */
1944          "R_PPC64_REL16_HI",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xffff,                /* dst_mask */
1948          TRUE),                 /* pcrel_offset */
1949
1950   /* The high order 16 bits of a relative address, plus 1 if the contents of
1951      the low 16 bits, treated as a signed number, is negative.  */
1952   HOWTO (R_PPC64_REL16_HA,      /* type */
1953          16,                    /* rightshift */
1954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1955          16,                    /* bitsize */
1956          TRUE,                  /* pc_relative */
1957          0,                     /* bitpos */
1958          complain_overflow_dont, /* complain_on_overflow */
1959          ppc64_elf_ha_reloc,    /* special_function */
1960          "R_PPC64_REL16_HA",    /* name */
1961          FALSE,                 /* partial_inplace */
1962          0,                     /* src_mask */
1963          0xffff,                /* dst_mask */
1964          TRUE),                 /* pcrel_offset */
1965
1966   /* GNU extension to record C++ vtable hierarchy.  */
1967   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1968          0,                     /* rightshift */
1969          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1970          0,                     /* bitsize */
1971          FALSE,                 /* pc_relative */
1972          0,                     /* bitpos */
1973          complain_overflow_dont, /* complain_on_overflow */
1974          NULL,                  /* special_function */
1975          "R_PPC64_GNU_VTINHERIT", /* name */
1976          FALSE,                 /* partial_inplace */
1977          0,                     /* src_mask */
1978          0,                     /* dst_mask */
1979          FALSE),                /* pcrel_offset */
1980
1981   /* GNU extension to record C++ vtable member usage.  */
1982   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1983          0,                     /* rightshift */
1984          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1985          0,                     /* bitsize */
1986          FALSE,                 /* pc_relative */
1987          0,                     /* bitpos */
1988          complain_overflow_dont, /* complain_on_overflow */
1989          NULL,                  /* special_function */
1990          "R_PPC64_GNU_VTENTRY", /* name */
1991          FALSE,                 /* partial_inplace */
1992          0,                     /* src_mask */
1993          0,                     /* dst_mask */
1994          FALSE),                /* pcrel_offset */
1995 };
1996
1997 \f
1998 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1999    be done.  */
2000
2001 static void
2002 ppc_howto_init (void)
2003 {
2004   unsigned int i, type;
2005
2006   for (i = 0;
2007        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2008        i++)
2009     {
2010       type = ppc64_elf_howto_raw[i].type;
2011       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2012                           / sizeof (ppc64_elf_howto_table[0])));
2013       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2014     }
2015 }
2016
2017 static reloc_howto_type *
2018 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2019                              bfd_reloc_code_real_type code)
2020 {
2021   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2022
2023   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2024     /* Initialize howto table if needed.  */
2025     ppc_howto_init ();
2026
2027   switch (code)
2028     {
2029     default:
2030       return NULL;
2031
2032     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2033       break;
2034     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2035       break;
2036     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2037       break;
2038     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2039       break;
2040     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2041       break;
2042     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2043       break;
2044     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2045       break;
2046     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2047       break;
2048     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2049       break;
2050     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2051       break;
2052     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2053       break;
2054     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2055       break;
2056     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2057       break;
2058     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2059       break;
2060     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2061       break;
2062     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2063       break;
2064     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2065       break;
2066     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2067       break;
2068     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2069       break;
2070     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2071       break;
2072     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2073       break;
2074     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2075       break;
2076     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2077       break;
2078     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2079       break;
2080     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2081       break;
2082     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2083       break;
2084     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2085       break;
2086     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2087       break;
2088     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2089       break;
2090     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2091       break;
2092     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2093       break;
2094     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2095       break;
2096     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2097       break;
2098     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2099       break;
2100     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2101       break;
2102     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2103       break;
2104     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2105       break;
2106     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2107       break;
2108     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2109       break;
2110     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2111       break;
2112     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2113       break;
2114     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2115       break;
2116     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2117       break;
2118     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2119       break;
2120     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2121       break;
2122     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2123       break;
2124     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2125       break;
2126     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2127       break;
2128     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2129       break;
2130     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2131       break;
2132     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2133       break;
2134     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2135       break;
2136     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2137       break;
2138     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2139       break;
2140     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2141       break;
2142     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2143       break;
2144     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2145       break;
2146     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2147       break;
2148     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2149       break;
2150     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2151       break;
2152     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2153       break;
2154     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2155       break;
2156     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2157       break;
2158     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2159       break;
2160     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2161       break;
2162     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2163       break;
2164     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2165       break;
2166     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2167       break;
2168     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2169       break;
2170     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2171       break;
2172     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2173       break;
2174     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2175       break;
2176     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2177       break;
2178     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2179       break;
2180     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2181       break;
2182     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2183       break;
2184     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2185       break;
2186     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2187       break;
2188     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2189       break;
2190     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2191       break;
2192     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2193       break;
2194     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2195       break;
2196     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2197       break;
2198     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2199       break;
2200     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2201       break;
2202     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2203       break;
2204     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2205       break;
2206     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2207       break;
2208     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2209       break;
2210     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2211       break;
2212     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2213       break;
2214     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2215       break;
2216     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2217       break;
2218     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2219       break;
2220     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2221       break;
2222     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2223       break;
2224     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2225       break;
2226     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2227       break;
2228     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2229       break;
2230     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2231       break;
2232     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2233       break;
2234     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2235       break;
2236     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2237       break;
2238     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2241       break;
2242     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2243       break;
2244     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2245       break;
2246     }
2247
2248   return ppc64_elf_howto_table[r];
2249 };
2250
2251 static reloc_howto_type *
2252 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2253                              const char *r_name)
2254 {
2255   unsigned int i;
2256
2257   for (i = 0;
2258        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2259        i++)
2260     if (ppc64_elf_howto_raw[i].name != NULL
2261         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2262       return &ppc64_elf_howto_raw[i];
2263
2264   return NULL;
2265 }
2266
2267 /* Set the howto pointer for a PowerPC ELF reloc.  */
2268
2269 static void
2270 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2271                          Elf_Internal_Rela *dst)
2272 {
2273   unsigned int type;
2274
2275   /* Initialize howto table if needed.  */
2276   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2277     ppc_howto_init ();
2278
2279   type = ELF64_R_TYPE (dst->r_info);
2280   if (type >= (sizeof (ppc64_elf_howto_table)
2281                / sizeof (ppc64_elf_howto_table[0])))
2282     {
2283       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2284                              abfd, (int) type);
2285       type = R_PPC64_NONE;
2286     }
2287   cache_ptr->howto = ppc64_elf_howto_table[type];
2288 }
2289
2290 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2291
2292 static bfd_reloc_status_type
2293 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2294                     void *data, asection *input_section,
2295                     bfd *output_bfd, char **error_message)
2296 {
2297   /* If this is a relocatable link (output_bfd test tells us), just
2298      call the generic function.  Any adjustment will be done at final
2299      link time.  */
2300   if (output_bfd != NULL)
2301     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2302                                   input_section, output_bfd, error_message);
2303
2304   /* Adjust the addend for sign extension of the low 16 bits.
2305      We won't actually be using the low 16 bits, so trashing them
2306      doesn't matter.  */
2307   reloc_entry->addend += 0x8000;
2308   return bfd_reloc_continue;
2309 }
2310
2311 static bfd_reloc_status_type
2312 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2313                         void *data, asection *input_section,
2314                         bfd *output_bfd, char **error_message)
2315 {
2316   if (output_bfd != NULL)
2317     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2318                                   input_section, output_bfd, error_message);
2319
2320   if (strcmp (symbol->section->name, ".opd") == 0
2321       && (symbol->section->owner->flags & DYNAMIC) == 0)
2322     {
2323       bfd_vma dest = opd_entry_value (symbol->section,
2324                                       symbol->value + reloc_entry->addend,
2325                                       NULL, NULL);
2326       if (dest != (bfd_vma) -1)
2327         reloc_entry->addend = dest - (symbol->value
2328                                       + symbol->section->output_section->vma
2329                                       + symbol->section->output_offset);
2330     }
2331   return bfd_reloc_continue;
2332 }
2333
2334 static bfd_reloc_status_type
2335 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2336                          void *data, asection *input_section,
2337                          bfd *output_bfd, char **error_message)
2338 {
2339   long insn;
2340   enum elf_ppc64_reloc_type r_type;
2341   bfd_size_type octets;
2342   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2343   bfd_boolean is_power4 = FALSE;
2344
2345   /* If this is a relocatable link (output_bfd test tells us), just
2346      call the generic function.  Any adjustment will be done at final
2347      link time.  */
2348   if (output_bfd != NULL)
2349     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2350                                   input_section, output_bfd, error_message);
2351
2352   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2353   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2354   insn &= ~(0x01 << 21);
2355   r_type = reloc_entry->howto->type;
2356   if (r_type == R_PPC64_ADDR14_BRTAKEN
2357       || r_type == R_PPC64_REL14_BRTAKEN)
2358     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2359
2360   if (is_power4)
2361     {
2362       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2363          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2364          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2365       if ((insn & (0x14 << 21)) == (0x04 << 21))
2366         insn |= 0x02 << 21;
2367       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2368         insn |= 0x08 << 21;
2369       else
2370         goto out;
2371     }
2372   else
2373     {
2374       bfd_vma target = 0;
2375       bfd_vma from;
2376
2377       if (!bfd_is_com_section (symbol->section))
2378         target = symbol->value;
2379       target += symbol->section->output_section->vma;
2380       target += symbol->section->output_offset;
2381       target += reloc_entry->addend;
2382
2383       from = (reloc_entry->address
2384               + input_section->output_offset
2385               + input_section->output_section->vma);
2386
2387       /* Invert 'y' bit if not the default.  */
2388       if ((bfd_signed_vma) (target - from) < 0)
2389         insn ^= 0x01 << 21;
2390     }
2391   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2392  out:
2393   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2394                                  input_section, output_bfd, error_message);
2395 }
2396
2397 static bfd_reloc_status_type
2398 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2399                          void *data, asection *input_section,
2400                          bfd *output_bfd, char **error_message)
2401 {
2402   /* If this is a relocatable link (output_bfd test tells us), just
2403      call the generic function.  Any adjustment will be done at final
2404      link time.  */
2405   if (output_bfd != NULL)
2406     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2407                                   input_section, output_bfd, error_message);
2408
2409   /* Subtract the symbol section base address.  */
2410   reloc_entry->addend -= symbol->section->output_section->vma;
2411   return bfd_reloc_continue;
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416                             void *data, asection *input_section,
2417                             bfd *output_bfd, char **error_message)
2418 {
2419   /* If this is a relocatable link (output_bfd test tells us), just
2420      call the generic function.  Any adjustment will be done at final
2421      link time.  */
2422   if (output_bfd != NULL)
2423     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424                                   input_section, output_bfd, error_message);
2425
2426   /* Subtract the symbol section base address.  */
2427   reloc_entry->addend -= symbol->section->output_section->vma;
2428
2429   /* Adjust the addend for sign extension of the low 16 bits.  */
2430   reloc_entry->addend += 0x8000;
2431   return bfd_reloc_continue;
2432 }
2433
2434 static bfd_reloc_status_type
2435 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2436                      void *data, asection *input_section,
2437                      bfd *output_bfd, char **error_message)
2438 {
2439   bfd_vma TOCstart;
2440
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2449   if (TOCstart == 0)
2450     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2451
2452   /* Subtract the TOC base address.  */
2453   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2454   return bfd_reloc_continue;
2455 }
2456
2457 static bfd_reloc_status_type
2458 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2459                         void *data, asection *input_section,
2460                         bfd *output_bfd, char **error_message)
2461 {
2462   bfd_vma TOCstart;
2463
2464   /* If this is a relocatable link (output_bfd test tells us), just
2465      call the generic function.  Any adjustment will be done at final
2466      link time.  */
2467   if (output_bfd != NULL)
2468     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2469                                   input_section, output_bfd, error_message);
2470
2471   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2472   if (TOCstart == 0)
2473     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2474
2475   /* Subtract the TOC base address.  */
2476   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2477
2478   /* Adjust the addend for sign extension of the low 16 bits.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                        void *data, asection *input_section,
2486                        bfd *output_bfd, char **error_message)
2487 {
2488   bfd_vma TOCstart;
2489   bfd_size_type octets;
2490
2491   /* If this is a relocatable link (output_bfd test tells us), just
2492      call the generic function.  Any adjustment will be done at final
2493      link time.  */
2494   if (output_bfd != NULL)
2495     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496                                   input_section, output_bfd, error_message);
2497
2498   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2499   if (TOCstart == 0)
2500     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2501
2502   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2503   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2504   return bfd_reloc_ok;
2505 }
2506
2507 static bfd_reloc_status_type
2508 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2509                            void *data, asection *input_section,
2510                            bfd *output_bfd, char **error_message)
2511 {
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   if (error_message != NULL)
2520     {
2521       static char buf[60];
2522       sprintf (buf, "generic linker can't handle %s",
2523                reloc_entry->howto->name);
2524       *error_message = buf;
2525     }
2526   return bfd_reloc_dangerous;
2527 }
2528
2529 struct ppc64_elf_obj_tdata
2530 {
2531   struct elf_obj_tdata elf;
2532
2533   /* Shortcuts to dynamic linker sections.  */
2534   asection *got;
2535   asection *relgot;
2536
2537   /* Used during garbage collection.  We attach global symbols defined
2538      on removed .opd entries to this section so that the sym is removed.  */
2539   asection *deleted_section;
2540
2541   /* TLS local dynamic got entry handling.  Suppose for multiple GOT
2542      sections means we potentially need one of these for each input bfd.  */
2543   union {
2544     bfd_signed_vma refcount;
2545     bfd_vma offset;
2546   } tlsld_got;
2547
2548   /* A copy of relocs before they are modified for --emit-relocs.  */
2549   Elf_Internal_Rela *opd_relocs;
2550 };
2551
2552 #define ppc64_elf_tdata(bfd) \
2553   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2554
2555 #define ppc64_tlsld_got(bfd) \
2556   (&ppc64_elf_tdata (bfd)->tlsld_got)
2557
2558 #define is_ppc64_elf(bfd) \
2559   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2560    && elf_object_id (bfd) == PPC64_ELF_TDATA)
2561
2562 /* Override the generic function because we store some extras.  */
2563
2564 static bfd_boolean
2565 ppc64_elf_mkobject (bfd *abfd)
2566 {
2567   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2568                                   PPC64_ELF_TDATA);
2569 }
2570
2571 /* Fix bad default arch selected for a 64 bit input bfd when the
2572    default is 32 bit.  */
2573
2574 static bfd_boolean
2575 ppc64_elf_object_p (bfd *abfd)
2576 {
2577   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2578     {
2579       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2580
2581       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2582         {
2583           /* Relies on arch after 32 bit default being 64 bit default.  */
2584           abfd->arch_info = abfd->arch_info->next;
2585           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2586         }
2587     }
2588   return TRUE;
2589 }
2590
2591 /* Support for core dump NOTE sections.  */
2592
2593 static bfd_boolean
2594 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2595 {
2596   size_t offset, size;
2597
2598   if (note->descsz != 504)
2599     return FALSE;
2600
2601   /* pr_cursig */
2602   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2603
2604   /* pr_pid */
2605   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2606
2607   /* pr_reg */
2608   offset = 112;
2609   size = 384;
2610
2611   /* Make a ".reg/999" section.  */
2612   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2613                                           size, note->descpos + offset);
2614 }
2615
2616 static bfd_boolean
2617 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2618 {
2619   if (note->descsz != 136)
2620     return FALSE;
2621
2622   elf_tdata (abfd)->core_program
2623     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2624   elf_tdata (abfd)->core_command
2625     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2626
2627   return TRUE;
2628 }
2629
2630 static char *
2631 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2632                            ...)
2633 {
2634   switch (note_type)
2635     {
2636     default:
2637       return NULL;
2638
2639     case NT_PRPSINFO:
2640       {
2641         char data[136];
2642         va_list ap;
2643
2644         va_start (ap, note_type);
2645         memset (data, 0, 40);
2646         strncpy (data + 40, va_arg (ap, const char *), 16);
2647         strncpy (data + 56, va_arg (ap, const char *), 80);
2648         va_end (ap);
2649         return elfcore_write_note (abfd, buf, bufsiz,
2650                                    "CORE", note_type, data, sizeof (data));
2651       }
2652
2653     case NT_PRSTATUS:
2654       {
2655         char data[504];
2656         va_list ap;
2657         long pid;
2658         int cursig;
2659         const void *greg;
2660
2661         va_start (ap, note_type);
2662         memset (data, 0, 112);
2663         pid = va_arg (ap, long);
2664         bfd_put_32 (abfd, pid, data + 32);
2665         cursig = va_arg (ap, int);
2666         bfd_put_16 (abfd, cursig, data + 12);
2667         greg = va_arg (ap, const void *);
2668         memcpy (data + 112, greg, 384);
2669         memset (data + 496, 0, 8);
2670         va_end (ap);
2671         return elfcore_write_note (abfd, buf, bufsiz,
2672                                    "CORE", note_type, data, sizeof (data));
2673       }
2674     }
2675 }
2676
2677 /* Merge backend specific data from an object file to the output
2678    object file when linking.  */
2679
2680 static bfd_boolean
2681 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2682 {
2683   /* Check if we have the same endianess.  */
2684   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2685       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2686       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2687     {
2688       const char *msg;
2689
2690       if (bfd_big_endian (ibfd))
2691         msg = _("%B: compiled for a big endian system "
2692                 "and target is little endian");
2693       else
2694         msg = _("%B: compiled for a little endian system "
2695                 "and target is big endian");
2696
2697       (*_bfd_error_handler) (msg, ibfd);
2698
2699       bfd_set_error (bfd_error_wrong_format);
2700       return FALSE;
2701     }
2702
2703   return TRUE;
2704 }
2705
2706 /* Add extra PPC sections.  */
2707
2708 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2709 {
2710   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2711   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2712   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2713   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2714   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2715   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2716   { NULL,                     0,  0, 0,            0 }
2717 };
2718
2719 enum _ppc64_sec_type {
2720   sec_normal = 0,
2721   sec_opd = 1,
2722   sec_toc = 2
2723 };
2724
2725 struct _ppc64_elf_section_data
2726 {
2727   struct bfd_elf_section_data elf;
2728
2729   union
2730   {
2731     /* An array with one entry for each opd function descriptor.  */
2732     struct _opd_sec_data
2733     {
2734       /* Points to the function code section for local opd entries.  */
2735       asection **func_sec;
2736
2737       /* After editing .opd, adjust references to opd local syms.  */
2738       long *adjust;
2739     } opd;
2740
2741     /* An array for toc sections, indexed by offset/8.  */
2742     struct _toc_sec_data
2743     {
2744       /* Specifies the relocation symbol index used at a given toc offset.  */
2745       unsigned *symndx;
2746
2747       /* And the relocation addend.  */
2748       bfd_vma *add;
2749     } toc;
2750   } u;
2751
2752   enum _ppc64_sec_type sec_type:2;
2753
2754   /* Flag set when small branches are detected.  Used to
2755      select suitable defaults for the stub group size.  */
2756   unsigned int has_14bit_branch:1;
2757 };
2758
2759 #define ppc64_elf_section_data(sec) \
2760   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2761
2762 static bfd_boolean
2763 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2764 {
2765   if (!sec->used_by_bfd)
2766     {
2767       struct _ppc64_elf_section_data *sdata;
2768       bfd_size_type amt = sizeof (*sdata);
2769
2770       sdata = bfd_zalloc (abfd, amt);
2771       if (sdata == NULL)
2772         return FALSE;
2773       sec->used_by_bfd = sdata;
2774     }
2775
2776   return _bfd_elf_new_section_hook (abfd, sec);
2777 }
2778
2779 static struct _opd_sec_data *
2780 get_opd_info (asection * sec)
2781 {
2782   if (sec != NULL
2783       && ppc64_elf_section_data (sec) != NULL
2784       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2785     return &ppc64_elf_section_data (sec)->u.opd;
2786   return NULL;
2787 }
2788 \f
2789 /* Parameters for the qsort hook.  */
2790 static bfd_boolean synthetic_relocatable;
2791
2792 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2793
2794 static int
2795 compare_symbols (const void *ap, const void *bp)
2796 {
2797   const asymbol *a = * (const asymbol **) ap;
2798   const asymbol *b = * (const asymbol **) bp;
2799
2800   /* Section symbols first.  */
2801   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2802     return -1;
2803   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2804     return 1;
2805
2806   /* then .opd symbols.  */
2807   if (strcmp (a->section->name, ".opd") == 0
2808       && strcmp (b->section->name, ".opd") != 0)
2809     return -1;
2810   if (strcmp (a->section->name, ".opd") != 0
2811       && strcmp (b->section->name, ".opd") == 0)
2812     return 1;
2813
2814   /* then other code symbols.  */
2815   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2816       == (SEC_CODE | SEC_ALLOC)
2817       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2818          != (SEC_CODE | SEC_ALLOC))
2819     return -1;
2820
2821   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2822       != (SEC_CODE | SEC_ALLOC)
2823       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2824          == (SEC_CODE | SEC_ALLOC))
2825     return 1;
2826
2827   if (synthetic_relocatable)
2828     {
2829       if (a->section->id < b->section->id)
2830         return -1;
2831
2832       if (a->section->id > b->section->id)
2833         return 1;
2834     }
2835
2836   if (a->value + a->section->vma < b->value + b->section->vma)
2837     return -1;
2838
2839   if (a->value + a->section->vma > b->value + b->section->vma)
2840     return 1;
2841
2842   /* For syms with the same value, prefer strong dynamic global function
2843      syms over other syms.  */
2844   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2845     return -1;
2846
2847   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2848     return 1;
2849
2850   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2851     return -1;
2852
2853   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2854     return 1;
2855
2856   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2857     return -1;
2858
2859   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2860     return 1;
2861
2862   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2863     return -1;
2864
2865   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2866     return 1;
2867
2868   return 0;
2869 }
2870
2871 /* Search SYMS for a symbol of the given VALUE.  */
2872
2873 static asymbol *
2874 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2875 {
2876   long mid;
2877
2878   if (id == -1)
2879     {
2880       while (lo < hi)
2881         {
2882           mid = (lo + hi) >> 1;
2883           if (syms[mid]->value + syms[mid]->section->vma < value)
2884             lo = mid + 1;
2885           else if (syms[mid]->value + syms[mid]->section->vma > value)
2886             hi = mid;
2887           else
2888             return syms[mid];
2889         }
2890     }
2891   else
2892     {
2893       while (lo < hi)
2894         {
2895           mid = (lo + hi) >> 1;
2896           if (syms[mid]->section->id < id)
2897             lo = mid + 1;
2898           else if (syms[mid]->section->id > id)
2899             hi = mid;
2900           else if (syms[mid]->value < value)
2901             lo = mid + 1;
2902           else if (syms[mid]->value > value)
2903             hi = mid;
2904           else
2905             return syms[mid];
2906         }
2907     }
2908   return NULL;
2909 }
2910
2911 static bfd_boolean
2912 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2913 {
2914   bfd_vma vma = *(bfd_vma *) ptr;
2915   return ((section->flags & SEC_ALLOC) != 0
2916           && section->vma <= vma
2917           && vma < section->vma + section->size);
2918 }
2919
2920 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2921    entry syms.  Also generate @plt symbols for the glink branch table.  */
2922
2923 static long
2924 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2925                                 long static_count, asymbol **static_syms,
2926                                 long dyn_count, asymbol **dyn_syms,
2927                                 asymbol **ret)
2928 {
2929   asymbol *s;
2930   long i;
2931   long count;
2932   char *names;
2933   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2934   asection *opd;
2935   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2936   asymbol **syms;
2937
2938   *ret = NULL;
2939
2940   opd = bfd_get_section_by_name (abfd, ".opd");
2941   if (opd == NULL)
2942     return 0;
2943
2944   symcount = static_count;
2945   if (!relocatable)
2946     symcount += dyn_count;
2947   if (symcount == 0)
2948     return 0;
2949
2950   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2951   if (syms == NULL)
2952     return -1;
2953
2954   if (!relocatable && static_count != 0 && dyn_count != 0)
2955     {
2956       /* Use both symbol tables.  */
2957       memcpy (syms, static_syms, static_count * sizeof (*syms));
2958       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2959     }
2960   else if (!relocatable && static_count == 0)
2961     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2962   else
2963     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2964
2965   synthetic_relocatable = relocatable;
2966   qsort (syms, symcount, sizeof (*syms), compare_symbols);
2967
2968   if (!relocatable && symcount > 1)
2969     {
2970       long j;
2971       /* Trim duplicate syms, since we may have merged the normal and
2972          dynamic symbols.  Actually, we only care about syms that have
2973          different values, so trim any with the same value.  */
2974       for (i = 1, j = 1; i < symcount; ++i)
2975         if (syms[i - 1]->value + syms[i - 1]->section->vma
2976             != syms[i]->value + syms[i]->section->vma)
2977           syms[j++] = syms[i];
2978       symcount = j;
2979     }
2980
2981   i = 0;
2982   if (strcmp (syms[i]->section->name, ".opd") == 0)
2983     ++i;
2984   codesecsym = i;
2985
2986   for (; i < symcount; ++i)
2987     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2988          != (SEC_CODE | SEC_ALLOC))
2989         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2990       break;
2991   codesecsymend = i;
2992
2993   for (; i < symcount; ++i)
2994     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2995       break;
2996   secsymend = i;
2997
2998   for (; i < symcount; ++i)
2999     if (strcmp (syms[i]->section->name, ".opd") != 0)
3000       break;
3001   opdsymend = i;
3002
3003   for (; i < symcount; ++i)
3004     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3005         != (SEC_CODE | SEC_ALLOC))
3006       break;
3007   symcount = i;
3008
3009   count = 0;
3010
3011   if (relocatable)
3012     {
3013       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3014       arelent *r;
3015       size_t size;
3016       long relcount;
3017
3018       if (opdsymend == secsymend)
3019         goto done;
3020
3021       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3022       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3023       if (relcount == 0)
3024         goto done;
3025
3026       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3027         {
3028           count = -1;
3029           goto done;
3030         }
3031
3032       size = 0;
3033       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3034         {
3035           asymbol *sym;
3036
3037           while (r < opd->relocation + relcount
3038                  && r->address < syms[i]->value + opd->vma)
3039             ++r;
3040
3041           if (r == opd->relocation + relcount)
3042             break;
3043
3044           if (r->address != syms[i]->value + opd->vma)
3045             continue;
3046
3047           if (r->howto->type != R_PPC64_ADDR64)
3048             continue;
3049
3050           sym = *r->sym_ptr_ptr;
3051           if (!sym_exists_at (syms, opdsymend, symcount,
3052                               sym->section->id, sym->value + r->addend))
3053             {
3054               ++count;
3055               size += sizeof (asymbol);
3056               size += strlen (syms[i]->name) + 2;
3057             }
3058         }
3059
3060       s = *ret = bfd_malloc (size);
3061       if (s == NULL)
3062         {
3063           count = -1;
3064           goto done;
3065         }
3066
3067       names = (char *) (s + count);
3068
3069       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3070         {
3071           asymbol *sym;
3072
3073           while (r < opd->relocation + relcount
3074                  && r->address < syms[i]->value + opd->vma)
3075             ++r;
3076
3077           if (r == opd->relocation + relcount)
3078             break;
3079
3080           if (r->address != syms[i]->value + opd->vma)
3081             continue;
3082
3083           if (r->howto->type != R_PPC64_ADDR64)
3084             continue;
3085
3086           sym = *r->sym_ptr_ptr;
3087           if (!sym_exists_at (syms, opdsymend, symcount,
3088                               sym->section->id, sym->value + r->addend))
3089             {
3090               size_t len;
3091
3092               *s = *syms[i];
3093               s->flags |= BSF_SYNTHETIC;
3094               s->section = sym->section;
3095               s->value = sym->value + r->addend;
3096               s->name = names;
3097               *names++ = '.';
3098               len = strlen (syms[i]->name);
3099               memcpy (names, syms[i]->name, len + 1);
3100               names += len + 1;
3101               /* Have udata.p point back to the original symbol this
3102                  synthetic symbol was derived from.  */
3103               s->udata.p = syms[i];
3104               s++;
3105             }
3106         }
3107     }
3108   else
3109     {
3110       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3111       bfd_byte *contents;
3112       size_t size;
3113       long plt_count = 0;
3114       bfd_vma glink_vma = 0, resolv_vma = 0;
3115       asection *dynamic, *glink = NULL, *relplt = NULL;
3116       arelent *p;
3117
3118       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3119         {
3120           if (contents)
3121             {
3122             free_contents_and_exit:
3123               free (contents);
3124             }
3125           count = -1;
3126           goto done;
3127         }
3128
3129       size = 0;
3130       for (i = secsymend; i < opdsymend; ++i)
3131         {
3132           bfd_vma ent;
3133
3134           /* Ignore bogus symbols.  */
3135           if (syms[i]->value > opd->size - 8)
3136             continue;
3137
3138           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3139           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3140             {
3141               ++count;
3142               size += sizeof (asymbol);
3143               size += strlen (syms[i]->name) + 2;
3144             }
3145         }
3146
3147       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3148       if (dyn_count != 0
3149           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3150         {
3151           bfd_byte *dynbuf, *extdyn, *extdynend;
3152           size_t extdynsize;
3153           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3154
3155           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3156             goto free_contents_and_exit;
3157
3158           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3159           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3160
3161           extdyn = dynbuf;
3162           extdynend = extdyn + dynamic->size;
3163           for (; extdyn < extdynend; extdyn += extdynsize)
3164             {
3165               Elf_Internal_Dyn dyn;
3166               (*swap_dyn_in) (abfd, extdyn, &dyn);
3167
3168               if (dyn.d_tag == DT_NULL)
3169                 break;
3170
3171               if (dyn.d_tag == DT_PPC64_GLINK)
3172                 {
3173                   /* The first glink stub starts at offset 32; see comment in
3174                      ppc64_elf_finish_dynamic_sections. */
3175                   glink_vma = dyn.d_un.d_val + 32;
3176                   /* The .glink section usually does not survive the final
3177                      link; search for the section (usually .text) where the
3178                      glink stubs now reside.  */
3179                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3180                                                 &glink_vma);
3181                   break;
3182                 }
3183             }
3184
3185           free (dynbuf);
3186         }
3187
3188       if (glink != NULL)
3189         {
3190           /* Determine __glink trampoline by reading the relative branch
3191              from the first glink stub.  */
3192           bfd_byte buf[4];
3193           if (bfd_get_section_contents (abfd, glink, buf,
3194                                         glink_vma + 4 - glink->vma, 4))
3195             {
3196               unsigned int insn = bfd_get_32 (abfd, buf);
3197               insn ^= B_DOT;
3198               if ((insn & ~0x3fffffc) == 0)
3199                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3200             }
3201
3202           if (resolv_vma)
3203             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3204
3205           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3206           if (relplt != NULL)
3207             {
3208               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3209               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3210                 goto free_contents_and_exit;
3211
3212               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3213               size += plt_count * sizeof (asymbol);
3214
3215               p = relplt->relocation;
3216               for (i = 0; i < plt_count; i++, p++)
3217                 {
3218                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3219                   if (p->addend != 0)
3220                     size += sizeof ("+0x") - 1 + 16;
3221                 }
3222             }
3223         }
3224
3225       s = *ret = bfd_malloc (size);
3226       if (s == NULL)
3227         goto free_contents_and_exit;
3228
3229       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3230
3231       for (i = secsymend; i < opdsymend; ++i)
3232         {
3233           bfd_vma ent;
3234
3235           if (syms[i]->value > opd->size - 8)
3236             continue;
3237
3238           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3239           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3240             {
3241               long lo, hi;
3242               size_t len;
3243               asection *sec = abfd->sections;
3244
3245               *s = *syms[i];
3246               lo = codesecsym;
3247               hi = codesecsymend;
3248               while (lo < hi)
3249                 {
3250                   long mid = (lo + hi) >> 1;
3251                   if (syms[mid]->section->vma < ent)
3252                     lo = mid + 1;
3253                   else if (syms[mid]->section->vma > ent)
3254                     hi = mid;
3255                   else
3256                     {
3257                       sec = syms[mid]->section;
3258                       break;
3259                     }
3260                 }
3261
3262               if (lo >= hi && lo > codesecsym)
3263                 sec = syms[lo - 1]->section;
3264
3265               for (; sec != NULL; sec = sec->next)
3266                 {
3267                   if (sec->vma > ent)
3268                     break;
3269                   if ((sec->flags & SEC_ALLOC) == 0
3270                       || (sec->flags & SEC_LOAD) == 0)
3271                     break;
3272                   if ((sec->flags & SEC_CODE) != 0)
3273                     s->section = sec;
3274                 }
3275               s->flags |= BSF_SYNTHETIC;
3276               s->value = ent - s->section->vma;
3277               s->name = names;
3278               *names++ = '.';
3279               len = strlen (syms[i]->name);
3280               memcpy (names, syms[i]->name, len + 1);
3281               names += len + 1;
3282               /* Have udata.p point back to the original symbol this
3283                  synthetic symbol was derived from.  */
3284               s->udata.p = syms[i];
3285               s++;
3286             }
3287         }
3288       free (contents);
3289
3290       if (glink != NULL && relplt != NULL)
3291         {
3292           if (resolv_vma)
3293             {
3294               /* Add a symbol for the main glink trampoline.  */
3295               memset (s, 0, sizeof *s);
3296               s->the_bfd = abfd;
3297               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3298               s->section = glink;
3299               s->value = resolv_vma - glink->vma;
3300               s->name = names;
3301               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3302               names += sizeof ("__glink_PLTresolve");
3303               s++;
3304               count++;
3305             }
3306
3307           /* FIXME: It would be very much nicer to put sym@plt on the
3308              stub rather than on the glink branch table entry.  The
3309              objdump disassembler would then use a sensible symbol
3310              name on plt calls.  The difficulty in doing so is
3311              a) finding the stubs, and,
3312              b) matching stubs against plt entries, and,
3313              c) there can be multiple stubs for a given plt entry.
3314
3315              Solving (a) could be done by code scanning, but older
3316              ppc64 binaries used different stubs to current code.
3317              (b) is the tricky one since you need to known the toc
3318              pointer for at least one function that uses a pic stub to
3319              be able to calculate the plt address referenced.
3320              (c) means gdb would need to set multiple breakpoints (or
3321              find the glink branch itself) when setting breakpoints
3322              for pending shared library loads.  */
3323           p = relplt->relocation;
3324           for (i = 0; i < plt_count; i++, p++)
3325             {
3326               size_t len;
3327
3328               *s = **p->sym_ptr_ptr;
3329               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3330                  we are defining a symbol, ensure one of them is set.  */
3331               if ((s->flags & BSF_LOCAL) == 0)
3332                 s->flags |= BSF_GLOBAL;
3333               s->flags |= BSF_SYNTHETIC;
3334               s->section = glink;
3335               s->value = glink_vma - glink->vma;
3336               s->name = names;
3337               s->udata.p = NULL;
3338               len = strlen ((*p->sym_ptr_ptr)->name);
3339               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3340               names += len;
3341               if (p->addend != 0)
3342                 {
3343                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3344                   names += sizeof ("+0x") - 1;
3345                   bfd_sprintf_vma (abfd, names, p->addend);
3346                   names += strlen (names);
3347                 }
3348               memcpy (names, "@plt", sizeof ("@plt"));
3349               names += sizeof ("@plt");
3350               s++;
3351               glink_vma += 8;
3352               if (i >= 0x8000)
3353                 glink_vma += 4;
3354             }
3355           count += plt_count;
3356         }
3357     }
3358
3359  done:
3360   free (syms);
3361   return count;
3362 }
3363 \f
3364 /* The following functions are specific to the ELF linker, while
3365    functions above are used generally.  Those named ppc64_elf_* are
3366    called by the main ELF linker code.  They appear in this file more
3367    or less in the order in which they are called.  eg.
3368    ppc64_elf_check_relocs is called early in the link process,
3369    ppc64_elf_finish_dynamic_sections is one of the last functions
3370    called.
3371
3372    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3373    functions have both a function code symbol and a function descriptor
3374    symbol.  A call to foo in a relocatable object file looks like:
3375
3376    .            .text
3377    .    x:
3378    .            bl      .foo
3379    .            nop
3380
3381    The function definition in another object file might be:
3382
3383    .            .section .opd
3384    .    foo:    .quad   .foo
3385    .            .quad   .TOC.@tocbase
3386    .            .quad   0
3387    .
3388    .            .text
3389    .    .foo:   blr
3390
3391    When the linker resolves the call during a static link, the branch
3392    unsurprisingly just goes to .foo and the .opd information is unused.
3393    If the function definition is in a shared library, things are a little
3394    different:  The call goes via a plt call stub, the opd information gets
3395    copied to the plt, and the linker patches the nop.
3396
3397    .    x:
3398    .            bl      .foo_stub
3399    .            ld      2,40(1)
3400    .
3401    .
3402    .    .foo_stub:
3403    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3404    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3405    .            std     2,40(1)                 # this is the general idea
3406    .            ld      11,0(12)
3407    .            ld      2,8(12)
3408    .            mtctr   11
3409    .            ld      11,16(12)
3410    .            bctr
3411    .
3412    .            .section .plt
3413    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3414
3415    The "reloc ()" notation is supposed to indicate that the linker emits
3416    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3417    copying.
3418
3419    What are the difficulties here?  Well, firstly, the relocations
3420    examined by the linker in check_relocs are against the function code
3421    sym .foo, while the dynamic relocation in the plt is emitted against
3422    the function descriptor symbol, foo.  Somewhere along the line, we need
3423    to carefully copy dynamic link information from one symbol to the other.
3424    Secondly, the generic part of the elf linker will make .foo a dynamic
3425    symbol as is normal for most other backends.  We need foo dynamic
3426    instead, at least for an application final link.  However, when
3427    creating a shared library containing foo, we need to have both symbols
3428    dynamic so that references to .foo are satisfied during the early
3429    stages of linking.  Otherwise the linker might decide to pull in a
3430    definition from some other object, eg. a static library.
3431
3432    Update: As of August 2004, we support a new convention.  Function
3433    calls may use the function descriptor symbol, ie. "bl foo".  This
3434    behaves exactly as "bl .foo".  */
3435
3436 /* The linker needs to keep track of the number of relocs that it
3437    decides to copy as dynamic relocs in check_relocs for each symbol.
3438    This is so that it can later discard them if they are found to be
3439    unnecessary.  We store the information in a field extending the
3440    regular ELF linker hash table.  */
3441
3442 struct ppc_dyn_relocs
3443 {
3444   struct ppc_dyn_relocs *next;
3445
3446   /* The input section of the reloc.  */
3447   asection *sec;
3448
3449   /* Total number of relocs copied for the input section.  */
3450   bfd_size_type count;
3451
3452   /* Number of pc-relative relocs copied for the input section.  */
3453   bfd_size_type pc_count;
3454 };
3455
3456 /* Track GOT entries needed for a given symbol.  We might need more
3457    than one got entry per symbol.  */
3458 struct got_entry
3459 {
3460   struct got_entry *next;
3461
3462   /* The symbol addend that we'll be placing in the GOT.  */
3463   bfd_vma addend;
3464
3465   /* Unlike other ELF targets, we use separate GOT entries for the same
3466      symbol referenced from different input files.  This is to support
3467      automatic multiple TOC/GOT sections, where the TOC base can vary
3468      from one input file to another.  FIXME: After group_sections we
3469      ought to merge entries within the group.
3470
3471      Point to the BFD owning this GOT entry.  */
3472   bfd *owner;
3473
3474   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3475      TLS_TPREL or TLS_DTPREL for tls entries.  */
3476   char tls_type;
3477
3478   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
3479   union
3480     {
3481       bfd_signed_vma refcount;
3482       bfd_vma offset;
3483     } got;
3484 };
3485
3486 /* The same for PLT.  */
3487 struct plt_entry
3488 {
3489   struct plt_entry *next;
3490
3491   bfd_vma addend;
3492
3493   union
3494     {
3495       bfd_signed_vma refcount;
3496       bfd_vma offset;
3497     } plt;
3498 };
3499
3500 /* Of those relocs that might be copied as dynamic relocs, this function
3501    selects those that must be copied when linking a shared library,
3502    even when the symbol is local.  */
3503
3504 static int
3505 must_be_dyn_reloc (struct bfd_link_info *info,
3506                    enum elf_ppc64_reloc_type r_type)
3507 {
3508   switch (r_type)
3509     {
3510     default:
3511       return 1;
3512
3513     case R_PPC64_REL32:
3514     case R_PPC64_REL64:
3515     case R_PPC64_REL30:
3516       return 0;
3517
3518     case R_PPC64_TPREL16:
3519     case R_PPC64_TPREL16_LO:
3520     case R_PPC64_TPREL16_HI:
3521     case R_PPC64_TPREL16_HA:
3522     case R_PPC64_TPREL16_DS:
3523     case R_PPC64_TPREL16_LO_DS:
3524     case R_PPC64_TPREL16_HIGHER:
3525     case R_PPC64_TPREL16_HIGHERA:
3526     case R_PPC64_TPREL16_HIGHEST:
3527     case R_PPC64_TPREL16_HIGHESTA:
3528     case R_PPC64_TPREL64:
3529       return !info->executable;
3530     }
3531 }
3532
3533 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3534    copying dynamic variables from a shared lib into an app's dynbss
3535    section, and instead use a dynamic relocation to point into the
3536    shared lib.  With code that gcc generates, it's vital that this be
3537    enabled;  In the PowerPC64 ABI, the address of a function is actually
3538    the address of a function descriptor, which resides in the .opd
3539    section.  gcc uses the descriptor directly rather than going via the
3540    GOT as some other ABI's do, which means that initialized function
3541    pointers must reference the descriptor.  Thus, a function pointer
3542    initialized to the address of a function in a shared library will
3543    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3544    redefines the function descriptor symbol to point to the copy.  This
3545    presents a problem as a plt entry for that function is also
3546    initialized from the function descriptor symbol and the copy reloc
3547    may not be initialized first.  */
3548 #define ELIMINATE_COPY_RELOCS 1
3549
3550 /* Section name for stubs is the associated section name plus this
3551    string.  */
3552 #define STUB_SUFFIX ".stub"
3553
3554 /* Linker stubs.
3555    ppc_stub_long_branch:
3556    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3557    destination, but a 24 bit branch in a stub section will reach.
3558    .    b       dest
3559
3560    ppc_stub_plt_branch:
3561    Similar to the above, but a 24 bit branch in the stub section won't
3562    reach its destination.
3563    .    addis   %r12,%r2,xxx@toc@ha
3564    .    ld      %r11,xxx@toc@l(%r12)
3565    .    mtctr   %r11
3566    .    bctr
3567
3568    ppc_stub_plt_call:
3569    Used to call a function in a shared library.  If it so happens that
3570    the plt entry referenced crosses a 64k boundary, then an extra
3571    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3572    .    addis   %r12,%r2,xxx@toc@ha
3573    .    std     %r2,40(%r1)
3574    .    ld      %r11,xxx+0@toc@l(%r12)
3575    .    mtctr   %r11
3576    .    ld      %r2,xxx+8@toc@l(%r12)
3577    .    ld      %r11,xxx+16@toc@l(%r12)
3578    .    bctr
3579
3580    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3581    code to adjust the value and save r2 to support multiple toc sections.
3582    A ppc_stub_long_branch with an r2 offset looks like:
3583    .    std     %r2,40(%r1)
3584    .    addis   %r2,%r2,off@ha
3585    .    addi    %r2,%r2,off@l
3586    .    b       dest
3587
3588    A ppc_stub_plt_branch with an r2 offset looks like:
3589    .    std     %r2,40(%r1)
3590    .    addis   %r12,%r2,xxx@toc@ha
3591    .    ld      %r11,xxx@toc@l(%r12)
3592    .    addis   %r2,%r2,off@ha
3593    .    addi    %r2,%r2,off@l
3594    .    mtctr   %r11
3595    .    bctr
3596
3597    In cases where the "addis" instruction would add zero, the "addis" is
3598    omitted and following instructions modified slightly in some cases.
3599 */
3600
3601 enum ppc_stub_type {
3602   ppc_stub_none,
3603   ppc_stub_long_branch,
3604   ppc_stub_long_branch_r2off,
3605   ppc_stub_plt_branch,
3606   ppc_stub_plt_branch_r2off,
3607   ppc_stub_plt_call
3608 };
3609
3610 struct ppc_stub_hash_entry {
3611
3612   /* Base hash table entry structure.  */
3613   struct bfd_hash_entry root;
3614
3615   enum ppc_stub_type stub_type;
3616
3617   /* The stub section.  */
3618   asection *stub_sec;
3619
3620   /* Offset within stub_sec of the beginning of this stub.  */
3621   bfd_vma stub_offset;
3622
3623   /* Given the symbol's value and its section we can determine its final
3624      value when building the stubs (so the stub knows where to jump.  */
3625   bfd_vma target_value;
3626   asection *target_section;
3627
3628   /* The symbol table entry, if any, that this was derived from.  */
3629   struct ppc_link_hash_entry *h;
3630   struct plt_entry *plt_ent;
3631
3632   /* And the reloc addend that this was derived from.  */
3633   bfd_vma addend;
3634
3635   /* Where this stub is being called from, or, in the case of combined
3636      stub sections, the first input section in the group.  */
3637   asection *id_sec;
3638 };
3639
3640 struct ppc_branch_hash_entry {
3641
3642   /* Base hash table entry structure.  */
3643   struct bfd_hash_entry root;
3644
3645   /* Offset within branch lookup table.  */
3646   unsigned int offset;
3647
3648   /* Generation marker.  */
3649   unsigned int iter;
3650 };
3651
3652 struct ppc_link_hash_entry
3653 {
3654   struct elf_link_hash_entry elf;
3655
3656   union {
3657     /* A pointer to the most recently used stub hash entry against this
3658        symbol.  */
3659     struct ppc_stub_hash_entry *stub_cache;
3660
3661     /* A pointer to the next symbol starting with a '.'  */
3662     struct ppc_link_hash_entry *next_dot_sym;
3663   } u;
3664
3665   /* Track dynamic relocs copied for this symbol.  */
3666   struct ppc_dyn_relocs *dyn_relocs;
3667
3668   /* Link between function code and descriptor symbols.  */
3669   struct ppc_link_hash_entry *oh;
3670
3671   /* Flag function code and descriptor symbols.  */
3672   unsigned int is_func:1;
3673   unsigned int is_func_descriptor:1;
3674   unsigned int fake:1;
3675
3676   /* Whether global opd/toc sym has been adjusted or not.
3677      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3678      should be set for all globals defined in any opd/toc section.  */
3679   unsigned int adjust_done:1;
3680
3681   /* Set if we twiddled this symbol to weak at some stage.  */
3682   unsigned int was_undefined:1;
3683
3684   /* Contexts in which symbol is used in the GOT (or TOC).
3685      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3686      corresponding relocs are encountered during check_relocs.
3687      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3688      indicate the corresponding GOT entry type is not needed.
3689      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3690      a TPREL one.  We use a separate flag rather than setting TPREL
3691      just for convenience in distinguishing the two cases.  */
3692 #define TLS_GD           1      /* GD reloc. */
3693 #define TLS_LD           2      /* LD reloc. */
3694 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3695 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3696 #define TLS_TLS         16      /* Any TLS reloc.  */
3697 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3698 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3699 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3700   char tls_mask;
3701 };
3702
3703 /* ppc64 ELF linker hash table.  */
3704
3705 struct ppc_link_hash_table
3706 {
3707   struct elf_link_hash_table elf;
3708
3709   /* The stub hash table.  */
3710   struct bfd_hash_table stub_hash_table;
3711
3712   /* Another hash table for plt_branch stubs.  */
3713   struct bfd_hash_table branch_hash_table;
3714
3715   /* Linker stub bfd.  */
3716   bfd *stub_bfd;
3717
3718   /* Linker call-backs.  */
3719   asection * (*add_stub_section) (const char *, asection *);
3720   void (*layout_sections_again) (void);
3721
3722   /* Array to keep track of which stub sections have been created, and
3723      information on stub grouping.  */
3724   struct map_stub {
3725     /* This is the section to which stubs in the group will be attached.  */
3726     asection *link_sec;
3727     /* The stub section.  */
3728     asection *stub_sec;
3729     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3730     bfd_vma toc_off;
3731   } *stub_group;
3732
3733   /* Temp used when calculating TOC pointers.  */
3734   bfd_vma toc_curr;
3735   bfd *toc_bfd;
3736   asection *toc_first_sec;
3737
3738   /* Highest input section id.  */
3739   int top_id;
3740
3741   /* Highest output section index.  */
3742   int top_index;
3743
3744   /* Used when adding symbols.  */
3745   struct ppc_link_hash_entry *dot_syms;
3746
3747   /* List of input sections for each output section.  */
3748   asection **input_list;
3749
3750   /* Short-cuts to get to dynamic linker sections.  */
3751   asection *got;
3752   asection *plt;
3753   asection *relplt;
3754   asection *iplt;
3755   asection *reliplt;
3756   asection *dynbss;
3757   asection *relbss;
3758   asection *glink;
3759   asection *sfpr;
3760   asection *brlt;
3761   asection *relbrlt;
3762
3763   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3764   struct ppc_link_hash_entry *tls_get_addr;
3765   struct ppc_link_hash_entry *tls_get_addr_fd;
3766
3767   /* Statistics.  */
3768   unsigned long stub_count[ppc_stub_plt_call];
3769
3770   /* Number of stubs against global syms.  */
3771   unsigned long stub_globals;
3772
3773   /* Set if we should emit symbols for stubs.  */
3774   unsigned int emit_stub_syms:1;
3775
3776   /* Set if __tls_get_addr optimization should not be done.  */
3777   unsigned int no_tls_get_addr_opt:1;
3778
3779   /* Support for multiple toc sections.  */
3780   unsigned int no_multi_toc:1;
3781   unsigned int multi_toc_needed:1;
3782
3783   /* Set on error.  */
3784   unsigned int stub_error:1;
3785
3786   /* Temp used by ppc64_elf_process_dot_syms.  */
3787   unsigned int twiddled_syms:1;
3788
3789   /* Incremented every time we size stubs.  */
3790   unsigned int stub_iteration;
3791
3792   /* Small local sym cache.  */
3793   struct sym_cache sym_cache;
3794 };
3795
3796 /* Rename some of the generic section flags to better document how they
3797    are used here.  */
3798 #define has_toc_reloc has_gp_reloc
3799 #define makes_toc_func_call need_finalize_relax
3800 #define call_check_in_progress reloc_done
3801
3802 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3803
3804 #define ppc_hash_table(p) \
3805   ((struct ppc_link_hash_table *) ((p)->hash))
3806
3807 #define ppc_stub_hash_lookup(table, string, create, copy) \
3808   ((struct ppc_stub_hash_entry *) \
3809    bfd_hash_lookup ((table), (string), (create), (copy)))
3810
3811 #define ppc_branch_hash_lookup(table, string, create, copy) \
3812   ((struct ppc_branch_hash_entry *) \
3813    bfd_hash_lookup ((table), (string), (create), (copy)))
3814
3815 /* Create an entry in the stub hash table.  */
3816
3817 static struct bfd_hash_entry *
3818 stub_hash_newfunc (struct bfd_hash_entry *entry,
3819                    struct bfd_hash_table *table,
3820                    const char *string)
3821 {
3822   /* Allocate the structure if it has not already been allocated by a
3823      subclass.  */
3824   if (entry == NULL)
3825     {
3826       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3827       if (entry == NULL)
3828         return entry;
3829     }
3830
3831   /* Call the allocation method of the superclass.  */
3832   entry = bfd_hash_newfunc (entry, table, string);
3833   if (entry != NULL)
3834     {
3835       struct ppc_stub_hash_entry *eh;
3836
3837       /* Initialize the local fields.  */
3838       eh = (struct ppc_stub_hash_entry *) entry;
3839       eh->stub_type = ppc_stub_none;
3840       eh->stub_sec = NULL;
3841       eh->stub_offset = 0;
3842       eh->target_value = 0;
3843       eh->target_section = NULL;
3844       eh->h = NULL;
3845       eh->id_sec = NULL;
3846     }
3847
3848   return entry;
3849 }
3850
3851 /* Create an entry in the branch hash table.  */
3852
3853 static struct bfd_hash_entry *
3854 branch_hash_newfunc (struct bfd_hash_entry *entry,
3855                      struct bfd_hash_table *table,
3856                      const char *string)
3857 {
3858   /* Allocate the structure if it has not already been allocated by a
3859      subclass.  */
3860   if (entry == NULL)
3861     {
3862       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3863       if (entry == NULL)
3864         return entry;
3865     }
3866
3867   /* Call the allocation method of the superclass.  */
3868   entry = bfd_hash_newfunc (entry, table, string);
3869   if (entry != NULL)
3870     {
3871       struct ppc_branch_hash_entry *eh;
3872
3873       /* Initialize the local fields.  */
3874       eh = (struct ppc_branch_hash_entry *) entry;
3875       eh->offset = 0;
3876       eh->iter = 0;
3877     }
3878
3879   return entry;
3880 }
3881
3882 /* Create an entry in a ppc64 ELF linker hash table.  */
3883
3884 static struct bfd_hash_entry *
3885 link_hash_newfunc (struct bfd_hash_entry *entry,
3886                    struct bfd_hash_table *table,
3887                    const char *string)
3888 {
3889   /* Allocate the structure if it has not already been allocated by a
3890      subclass.  */
3891   if (entry == NULL)
3892     {
3893       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3894       if (entry == NULL)
3895         return entry;
3896     }
3897
3898   /* Call the allocation method of the superclass.  */
3899   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3900   if (entry != NULL)
3901     {
3902       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3903
3904       memset (&eh->u.stub_cache, 0,
3905               (sizeof (struct ppc_link_hash_entry)
3906                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3907
3908       /* When making function calls, old ABI code references function entry
3909          points (dot symbols), while new ABI code references the function
3910          descriptor symbol.  We need to make any combination of reference and
3911          definition work together, without breaking archive linking.
3912
3913          For a defined function "foo" and an undefined call to "bar":
3914          An old object defines "foo" and ".foo", references ".bar" (possibly
3915          "bar" too).
3916          A new object defines "foo" and references "bar".
3917
3918          A new object thus has no problem with its undefined symbols being
3919          satisfied by definitions in an old object.  On the other hand, the
3920          old object won't have ".bar" satisfied by a new object.
3921
3922          Keep a list of newly added dot-symbols.  */
3923
3924       if (string[0] == '.')
3925         {
3926           struct ppc_link_hash_table *htab;
3927
3928           htab = (struct ppc_link_hash_table *) table;
3929           eh->u.next_dot_sym = htab->dot_syms;
3930           htab->dot_syms = eh;
3931         }
3932     }
3933
3934   return entry;
3935 }
3936
3937 /* Create a ppc64 ELF linker hash table.  */
3938
3939 static struct bfd_link_hash_table *
3940 ppc64_elf_link_hash_table_create (bfd *abfd)
3941 {
3942   struct ppc_link_hash_table *htab;
3943   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3944
3945   htab = bfd_zmalloc (amt);
3946   if (htab == NULL)
3947     return NULL;
3948
3949   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3950                                       sizeof (struct ppc_link_hash_entry)))
3951     {
3952       free (htab);
3953       return NULL;
3954     }
3955
3956   /* Init the stub hash table too.  */
3957   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3958                             sizeof (struct ppc_stub_hash_entry)))
3959     return NULL;
3960
3961   /* And the branch hash table.  */
3962   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3963                             sizeof (struct ppc_branch_hash_entry)))
3964     return NULL;
3965
3966   /* Initializing two fields of the union is just cosmetic.  We really
3967      only care about glist, but when compiled on a 32-bit host the
3968      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3969      debugger inspection of these fields look nicer.  */
3970   htab->elf.init_got_refcount.refcount = 0;
3971   htab->elf.init_got_refcount.glist = NULL;
3972   htab->elf.init_plt_refcount.refcount = 0;
3973   htab->elf.init_plt_refcount.glist = NULL;
3974   htab->elf.init_got_offset.offset = 0;
3975   htab->elf.init_got_offset.glist = NULL;
3976   htab->elf.init_plt_offset.offset = 0;
3977   htab->elf.init_plt_offset.glist = NULL;
3978
3979   return &htab->elf.root;
3980 }
3981
3982 /* Free the derived linker hash table.  */
3983
3984 static void
3985 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3986 {
3987   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3988
3989   bfd_hash_table_free (&ret->stub_hash_table);
3990   bfd_hash_table_free (&ret->branch_hash_table);
3991   _bfd_generic_link_hash_table_free (hash);
3992 }
3993
3994 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3995
3996 void
3997 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3998 {
3999   struct ppc_link_hash_table *htab;
4000
4001   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4002
4003 /* Always hook our dynamic sections into the first bfd, which is the
4004    linker created stub bfd.  This ensures that the GOT header is at
4005    the start of the output TOC section.  */
4006   htab = ppc_hash_table (info);
4007   htab->stub_bfd = abfd;
4008   htab->elf.dynobj = abfd;
4009 }
4010
4011 /* Build a name for an entry in the stub hash table.  */
4012
4013 static char *
4014 ppc_stub_name (const asection *input_section,
4015                const asection *sym_sec,
4016                const struct ppc_link_hash_entry *h,
4017                const Elf_Internal_Rela *rel)
4018 {
4019   char *stub_name;
4020   bfd_size_type len;
4021
4022   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4023      offsets from a sym as a branch target?  In fact, we could
4024      probably assume the addend is always zero.  */
4025   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4026
4027   if (h)
4028     {
4029       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4030       stub_name = bfd_malloc (len);
4031       if (stub_name == NULL)
4032         return stub_name;
4033
4034       sprintf (stub_name, "%08x.%s+%x",
4035                input_section->id & 0xffffffff,
4036                h->elf.root.root.string,
4037                (int) rel->r_addend & 0xffffffff);
4038     }
4039   else
4040     {
4041       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4042       stub_name = bfd_malloc (len);
4043       if (stub_name == NULL)
4044         return stub_name;
4045
4046       sprintf (stub_name, "%08x.%x:%x+%x",
4047                input_section->id & 0xffffffff,
4048                sym_sec->id & 0xffffffff,
4049                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4050                (int) rel->r_addend & 0xffffffff);
4051     }
4052   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4053     stub_name[len - 2] = 0;
4054   return stub_name;
4055 }
4056
4057 /* Look up an entry in the stub hash.  Stub entries are cached because
4058    creating the stub name takes a bit of time.  */
4059
4060 static struct ppc_stub_hash_entry *
4061 ppc_get_stub_entry (const asection *input_section,
4062                     const asection *sym_sec,
4063                     struct ppc_link_hash_entry *h,
4064                     const Elf_Internal_Rela *rel,
4065                     struct ppc_link_hash_table *htab)
4066 {
4067   struct ppc_stub_hash_entry *stub_entry;
4068   const asection *id_sec;
4069
4070   /* If this input section is part of a group of sections sharing one
4071      stub section, then use the id of the first section in the group.
4072      Stub names need to include a section id, as there may well be
4073      more than one stub used to reach say, printf, and we need to
4074      distinguish between them.  */
4075   id_sec = htab->stub_group[input_section->id].link_sec;
4076
4077   if (h != NULL && h->u.stub_cache != NULL
4078       && h->u.stub_cache->h == h
4079       && h->u.stub_cache->id_sec == id_sec)
4080     {
4081       stub_entry = h->u.stub_cache;
4082     }
4083   else
4084     {
4085       char *stub_name;
4086
4087       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4088       if (stub_name == NULL)
4089         return NULL;
4090
4091       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4092                                          stub_name, FALSE, FALSE);
4093       if (h != NULL)
4094         h->u.stub_cache = stub_entry;
4095
4096       free (stub_name);
4097     }
4098
4099   return stub_entry;
4100 }
4101
4102 /* Add a new stub entry to the stub hash.  Not all fields of the new
4103    stub entry are initialised.  */
4104
4105 static struct ppc_stub_hash_entry *
4106 ppc_add_stub (const char *stub_name,
4107               asection *section,
4108               struct ppc_link_hash_table *htab)
4109 {
4110   asection *link_sec;
4111   asection *stub_sec;
4112   struct ppc_stub_hash_entry *stub_entry;
4113
4114   link_sec = htab->stub_group[section->id].link_sec;
4115   stub_sec = htab->stub_group[section->id].stub_sec;
4116   if (stub_sec == NULL)
4117     {
4118       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4119       if (stub_sec == NULL)
4120         {
4121           size_t namelen;
4122           bfd_size_type len;
4123           char *s_name;
4124
4125           namelen = strlen (link_sec->name);
4126           len = namelen + sizeof (STUB_SUFFIX);
4127           s_name = bfd_alloc (htab->stub_bfd, len);
4128           if (s_name == NULL)
4129             return NULL;
4130
4131           memcpy (s_name, link_sec->name, namelen);
4132           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4133           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4134           if (stub_sec == NULL)
4135             return NULL;
4136           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4137         }
4138       htab->stub_group[section->id].stub_sec = stub_sec;
4139     }
4140
4141   /* Enter this entry into the linker stub hash table.  */
4142   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4143                                      TRUE, FALSE);
4144   if (stub_entry == NULL)
4145     {
4146       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4147                              section->owner, stub_name);
4148       return NULL;
4149     }
4150
4151   stub_entry->stub_sec = stub_sec;
4152   stub_entry->stub_offset = 0;
4153   stub_entry->id_sec = link_sec;
4154   return stub_entry;
4155 }
4156
4157 /* Create sections for linker generated code.  */
4158
4159 static bfd_boolean
4160 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4161 {
4162   struct ppc_link_hash_table *htab;
4163   flagword flags;
4164
4165   htab = ppc_hash_table (info);
4166
4167   /* Create .sfpr for code to save and restore fp regs.  */
4168   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4169            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4170   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4171                                                    flags);
4172   if (htab->sfpr == NULL
4173       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4174     return FALSE;
4175
4176   /* Create .glink for lazy dynamic linking support.  */
4177   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4178                                                     flags);
4179   if (htab->glink == NULL
4180       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4181     return FALSE;
4182
4183   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4184   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4185   if (htab->iplt == NULL
4186       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4187     return FALSE;
4188
4189   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4190            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4191   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4192                                                       ".rela.iplt",
4193                                                       flags);
4194   if (htab->reliplt == NULL
4195       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4196     return FALSE;
4197
4198   /* Create branch lookup table for plt_branch stubs.  */
4199   flags = (SEC_ALLOC | SEC_LOAD
4200            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4201   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4202                                                    flags);
4203   if (htab->brlt == NULL
4204       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4205     return FALSE;
4206
4207   if (!info->shared)
4208     return TRUE;
4209
4210   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4211            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4212   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4213                                                       ".rela.branch_lt",
4214                                                       flags);
4215   if (htab->relbrlt == NULL
4216       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4217     return FALSE;
4218
4219   return TRUE;
4220 }
4221
4222 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4223    not already done.  */
4224
4225 static bfd_boolean
4226 create_got_section (bfd *abfd, struct bfd_link_info *info)
4227 {
4228   asection *got, *relgot;
4229   flagword flags;
4230   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4231
4232   if (!is_ppc64_elf (abfd))
4233     return FALSE;
4234
4235   if (!htab->got)
4236     {
4237       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4238         return FALSE;
4239
4240       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4241       if (!htab->got)
4242         abort ();
4243     }
4244
4245   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4246            | SEC_LINKER_CREATED);
4247
4248   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4249   if (!got
4250       || !bfd_set_section_alignment (abfd, got, 3))
4251     return FALSE;
4252
4253   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4254                                                flags | SEC_READONLY);
4255   if (!relgot
4256       || ! bfd_set_section_alignment (abfd, relgot, 3))
4257     return FALSE;
4258
4259   ppc64_elf_tdata (abfd)->got = got;
4260   ppc64_elf_tdata (abfd)->relgot = relgot;
4261   return TRUE;
4262 }
4263
4264 /* Create the dynamic sections, and set up shortcuts.  */
4265
4266 static bfd_boolean
4267 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4268 {
4269   struct ppc_link_hash_table *htab;
4270
4271   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4272     return FALSE;
4273
4274   htab = ppc_hash_table (info);
4275   if (!htab->got)
4276     htab->got = bfd_get_section_by_name (dynobj, ".got");
4277   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4278   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4279   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4280   if (!info->shared)
4281     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4282
4283   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4284       || (!info->shared && !htab->relbss))
4285     abort ();
4286
4287   return TRUE;
4288 }
4289
4290 /* Follow indirect and warning symbol links.  */
4291
4292 static inline struct bfd_link_hash_entry *
4293 follow_link (struct bfd_link_hash_entry *h)
4294 {
4295   while (h->type == bfd_link_hash_indirect
4296          || h->type == bfd_link_hash_warning)
4297     h = h->u.i.link;
4298   return h;
4299 }
4300
4301 static inline struct elf_link_hash_entry *
4302 elf_follow_link (struct elf_link_hash_entry *h)
4303 {
4304   return (struct elf_link_hash_entry *) follow_link (&h->root);
4305 }
4306
4307 static inline struct ppc_link_hash_entry *
4308 ppc_follow_link (struct ppc_link_hash_entry *h)
4309 {
4310   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4311 }
4312
4313 /* Merge PLT info on FROM with that on TO.  */
4314
4315 static void
4316 move_plt_plist (struct ppc_link_hash_entry *from,
4317                 struct ppc_link_hash_entry *to)
4318 {
4319   if (from->elf.plt.plist != NULL)
4320     {
4321       if (to->elf.plt.plist != NULL)
4322         {
4323           struct plt_entry **entp;
4324           struct plt_entry *ent;
4325
4326           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4327             {
4328               struct plt_entry *dent;
4329
4330               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4331                 if (dent->addend == ent->addend)
4332                   {
4333                     dent->plt.refcount += ent->plt.refcount;
4334                     *entp = ent->next;
4335                     break;
4336                   }
4337               if (dent == NULL)
4338                 entp = &ent->next;
4339             }
4340           *entp = to->elf.plt.plist;
4341         }
4342
4343       to->elf.plt.plist = from->elf.plt.plist;
4344       from->elf.plt.plist = NULL;
4345     }
4346 }
4347
4348 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4349
4350 static void
4351 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4352                                 struct elf_link_hash_entry *dir,
4353                                 struct elf_link_hash_entry *ind)
4354 {
4355   struct ppc_link_hash_entry *edir, *eind;
4356
4357   edir = (struct ppc_link_hash_entry *) dir;
4358   eind = (struct ppc_link_hash_entry *) ind;
4359
4360   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4361   if (eind->dyn_relocs != NULL)
4362     {
4363       if (edir->dyn_relocs != NULL)
4364         {
4365           struct ppc_dyn_relocs **pp;
4366           struct ppc_dyn_relocs *p;
4367
4368           /* Add reloc counts against the indirect sym to the direct sym
4369              list.  Merge any entries against the same section.  */
4370           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4371             {
4372               struct ppc_dyn_relocs *q;
4373
4374               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4375                 if (q->sec == p->sec)
4376                   {
4377                     q->pc_count += p->pc_count;
4378                     q->count += p->count;
4379                     *pp = p->next;
4380                     break;
4381                   }
4382               if (q == NULL)
4383                 pp = &p->next;
4384             }
4385           *pp = edir->dyn_relocs;
4386         }
4387
4388       edir->dyn_relocs = eind->dyn_relocs;
4389       eind->dyn_relocs = NULL;
4390     }
4391
4392   edir->is_func |= eind->is_func;
4393   edir->is_func_descriptor |= eind->is_func_descriptor;
4394   edir->tls_mask |= eind->tls_mask;
4395   if (eind->oh != NULL)
4396     edir->oh = ppc_follow_link (eind->oh);
4397
4398   /* If called to transfer flags for a weakdef during processing
4399      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4400      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4401   if (!(ELIMINATE_COPY_RELOCS
4402         && eind->elf.root.type != bfd_link_hash_indirect
4403         && edir->elf.dynamic_adjusted))
4404     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4405
4406   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4407   edir->elf.ref_regular |= eind->elf.ref_regular;
4408   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4409   edir->elf.needs_plt |= eind->elf.needs_plt;
4410
4411   /* If we were called to copy over info for a weak sym, that's all.  */
4412   if (eind->elf.root.type != bfd_link_hash_indirect)
4413     return;
4414
4415   /* Copy over got entries that we may have already seen to the
4416      symbol which just became indirect.  */
4417   if (eind->elf.got.glist != NULL)
4418     {
4419       if (edir->elf.got.glist != NULL)
4420         {
4421           struct got_entry **entp;
4422           struct got_entry *ent;
4423
4424           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4425             {
4426               struct got_entry *dent;
4427
4428               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4429                 if (dent->addend == ent->addend
4430                     && dent->owner == ent->owner
4431                     && dent->tls_type == ent->tls_type)
4432                   {
4433                     dent->got.refcount += ent->got.refcount;
4434                     *entp = ent->next;
4435                     break;
4436                   }
4437               if (dent == NULL)
4438                 entp = &ent->next;
4439             }
4440           *entp = edir->elf.got.glist;
4441         }
4442
4443       edir->elf.got.glist = eind->elf.got.glist;
4444       eind->elf.got.glist = NULL;
4445     }
4446
4447   /* And plt entries.  */
4448   move_plt_plist (eind, edir);
4449
4450   if (eind->elf.dynindx != -1)
4451     {
4452       if (edir->elf.dynindx != -1)
4453         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4454                                 edir->elf.dynstr_index);
4455       edir->elf.dynindx = eind->elf.dynindx;
4456       edir->elf.dynstr_index = eind->elf.dynstr_index;
4457       eind->elf.dynindx = -1;
4458       eind->elf.dynstr_index = 0;
4459     }
4460 }
4461
4462 /* Find the function descriptor hash entry from the given function code
4463    hash entry FH.  Link the entries via their OH fields.  */
4464
4465 static struct ppc_link_hash_entry *
4466 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4467 {
4468   struct ppc_link_hash_entry *fdh = fh->oh;
4469
4470   if (fdh == NULL)
4471     {
4472       const char *fd_name = fh->elf.root.root.string + 1;
4473
4474       fdh = (struct ppc_link_hash_entry *)
4475         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4476       if (fdh == NULL)
4477         return fdh;
4478
4479       fdh->is_func_descriptor = 1;
4480       fdh->oh = fh;
4481       fh->is_func = 1;
4482       fh->oh = fdh;
4483     }
4484
4485   return ppc_follow_link (fdh);
4486 }
4487
4488 /* Make a fake function descriptor sym for the code sym FH.  */
4489
4490 static struct ppc_link_hash_entry *
4491 make_fdh (struct bfd_link_info *info,
4492           struct ppc_link_hash_entry *fh)
4493 {
4494   bfd *abfd;
4495   asymbol *newsym;
4496   struct bfd_link_hash_entry *bh;
4497   struct ppc_link_hash_entry *fdh;
4498
4499   abfd = fh->elf.root.u.undef.abfd;
4500   newsym = bfd_make_empty_symbol (abfd);
4501   newsym->name = fh->elf.root.root.string + 1;
4502   newsym->section = bfd_und_section_ptr;
4503   newsym->value = 0;
4504   newsym->flags = BSF_WEAK;
4505
4506   bh = NULL;
4507   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4508                                          newsym->flags, newsym->section,
4509                                          newsym->value, NULL, FALSE, FALSE,
4510                                          &bh))
4511     return NULL;
4512
4513   fdh = (struct ppc_link_hash_entry *) bh;
4514   fdh->elf.non_elf = 0;
4515   fdh->fake = 1;
4516   fdh->is_func_descriptor = 1;
4517   fdh->oh = fh;
4518   fh->is_func = 1;
4519   fh->oh = fdh;
4520   return fdh;
4521 }
4522
4523 /* Fix function descriptor symbols defined in .opd sections to be
4524    function type.  */
4525
4526 static bfd_boolean
4527 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4528                            struct bfd_link_info *info,
4529                            Elf_Internal_Sym *isym,
4530                            const char **name ATTRIBUTE_UNUSED,
4531                            flagword *flags ATTRIBUTE_UNUSED,
4532                            asection **sec,
4533                            bfd_vma *value ATTRIBUTE_UNUSED)
4534 {
4535   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4536     elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4537   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4538     ;
4539   else if (*sec != NULL
4540            && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4541     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4542
4543   return TRUE;
4544 }
4545
4546 /* This function makes an old ABI object reference to ".bar" cause the
4547    inclusion of a new ABI object archive that defines "bar".
4548    NAME is a symbol defined in an archive.  Return a symbol in the hash
4549    table that might be satisfied by the archive symbols.  */
4550
4551 static struct elf_link_hash_entry *
4552 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4553                                  struct bfd_link_info *info,
4554                                  const char *name)
4555 {
4556   struct elf_link_hash_entry *h;
4557   char *dot_name;
4558   size_t len;
4559
4560   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4561   if (h != NULL
4562       /* Don't return this sym if it is a fake function descriptor
4563          created by add_symbol_adjust.  */
4564       && !(h->root.type == bfd_link_hash_undefweak
4565            && ((struct ppc_link_hash_entry *) h)->fake))
4566     return h;
4567
4568   if (name[0] == '.')
4569     return h;
4570
4571   len = strlen (name);
4572   dot_name = bfd_alloc (abfd, len + 2);
4573   if (dot_name == NULL)
4574     return (struct elf_link_hash_entry *) 0 - 1;
4575   dot_name[0] = '.';
4576   memcpy (dot_name + 1, name, len + 1);
4577   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4578   bfd_release (abfd, dot_name);
4579   return h;
4580 }
4581
4582 /* This function satisfies all old ABI object references to ".bar" if a
4583    new ABI object defines "bar".  Well, at least, undefined dot symbols
4584    are made weak.  This stops later archive searches from including an
4585    object if we already have a function descriptor definition.  It also
4586    prevents the linker complaining about undefined symbols.
4587    We also check and correct mismatched symbol visibility here.  The
4588    most restrictive visibility of the function descriptor and the
4589    function entry symbol is used.  */
4590
4591 static bfd_boolean
4592 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4593 {
4594   struct ppc_link_hash_table *htab;
4595   struct ppc_link_hash_entry *fdh;
4596
4597   if (eh->elf.root.type == bfd_link_hash_indirect)
4598     return TRUE;
4599
4600   if (eh->elf.root.type == bfd_link_hash_warning)
4601     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4602
4603   if (eh->elf.root.root.string[0] != '.')
4604     abort ();
4605
4606   htab = ppc_hash_table (info);
4607   fdh = lookup_fdh (eh, htab);
4608   if (fdh == NULL)
4609     {
4610       if (!info->relocatable
4611           && (eh->elf.root.type == bfd_link_hash_undefined
4612               || eh->elf.root.type == bfd_link_hash_undefweak)
4613           && eh->elf.ref_regular)
4614         {
4615           /* Make an undefweak function descriptor sym, which is enough to
4616              pull in an --as-needed shared lib, but won't cause link
4617              errors.  Archives are handled elsewhere.  */
4618           fdh = make_fdh (info, eh);
4619           if (fdh == NULL)
4620             return FALSE;
4621           fdh->elf.ref_regular = 1;
4622         }
4623     }
4624   else
4625     {
4626       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4627       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4628       if (entry_vis < descr_vis)
4629         fdh->elf.other += entry_vis - descr_vis;
4630       else if (entry_vis > descr_vis)
4631         eh->elf.other += descr_vis - entry_vis;
4632
4633       if ((fdh->elf.root.type == bfd_link_hash_defined
4634            || fdh->elf.root.type == bfd_link_hash_defweak)
4635           && eh->elf.root.type == bfd_link_hash_undefined)
4636         {
4637           eh->elf.root.type = bfd_link_hash_undefweak;
4638           eh->was_undefined = 1;
4639           htab->twiddled_syms = 1;
4640         }
4641     }
4642
4643   return TRUE;
4644 }
4645
4646 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4647
4648 static bfd_boolean
4649 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4650 {
4651   struct ppc_link_hash_table *htab;
4652   struct ppc_link_hash_entry **p, *eh;
4653
4654   htab = ppc_hash_table (info);
4655   if (!is_ppc64_elf (info->output_bfd))
4656     return TRUE;
4657
4658   if (is_ppc64_elf (ibfd))
4659     {
4660       p = &htab->dot_syms;
4661       while ((eh = *p) != NULL)
4662         {
4663           *p = NULL;
4664           if (!add_symbol_adjust (eh, info))
4665             return FALSE;
4666           p = &eh->u.next_dot_sym;
4667         }
4668     }
4669
4670   /* Clear the list for non-ppc64 input files.  */
4671   p = &htab->dot_syms;
4672   while ((eh = *p) != NULL)
4673     {
4674       *p = NULL;
4675       p = &eh->u.next_dot_sym;
4676     }
4677
4678   /* We need to fix the undefs list for any syms we have twiddled to
4679      undef_weak.  */
4680   if (htab->twiddled_syms)
4681     {
4682       bfd_link_repair_undef_list (&htab->elf.root);
4683       htab->twiddled_syms = 0;
4684     }
4685   return TRUE;
4686 }
4687
4688 /* Undo hash table changes when an --as-needed input file is determined
4689    not to be needed.  */
4690
4691 static bfd_boolean
4692 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4693                              struct bfd_link_info *info)
4694 {
4695   ppc_hash_table (info)->dot_syms = NULL;
4696   return TRUE;
4697 }
4698
4699 static struct plt_entry **
4700 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4701                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4702 {
4703   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4704   struct plt_entry **local_plt;
4705   char *local_got_tls_masks;
4706
4707   if (local_got_ents == NULL)
4708     {
4709       bfd_size_type size = symtab_hdr->sh_info;
4710
4711       size *= (sizeof (*local_got_ents)
4712                + sizeof (*local_plt)
4713                + sizeof (*local_got_tls_masks));
4714       local_got_ents = bfd_zalloc (abfd, size);
4715       if (local_got_ents == NULL)
4716         return NULL;
4717       elf_local_got_ents (abfd) = local_got_ents;
4718     }
4719
4720   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4721     {
4722       struct got_entry *ent;
4723
4724       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4725         if (ent->addend == r_addend
4726             && ent->owner == abfd
4727             && ent->tls_type == tls_type)
4728           break;
4729       if (ent == NULL)
4730         {
4731           bfd_size_type amt = sizeof (*ent);
4732           ent = bfd_alloc (abfd, amt);
4733           if (ent == NULL)
4734             return FALSE;
4735           ent->next = local_got_ents[r_symndx];
4736           ent->addend = r_addend;
4737           ent->owner = abfd;
4738           ent->tls_type = tls_type;
4739           ent->got.refcount = 0;
4740           local_got_ents[r_symndx] = ent;
4741         }
4742       ent->got.refcount += 1;
4743     }
4744
4745   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4746   local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
4747   local_got_tls_masks[r_symndx] |= tls_type;
4748
4749   return local_plt + r_symndx;
4750 }
4751
4752 static bfd_boolean
4753 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4754 {
4755   struct plt_entry *ent;
4756
4757   for (ent = *plist; ent != NULL; ent = ent->next)
4758     if (ent->addend == addend)
4759       break;
4760   if (ent == NULL)
4761     {
4762       bfd_size_type amt = sizeof (*ent);
4763       ent = bfd_alloc (abfd, amt);
4764       if (ent == NULL)
4765         return FALSE;
4766       ent->next = *plist;
4767       ent->addend = addend;
4768       ent->plt.refcount = 0;
4769       *plist = ent;
4770     }
4771   ent->plt.refcount += 1;
4772   return TRUE;
4773 }
4774
4775 static bfd_boolean
4776 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4777 {
4778   return (r_type == R_PPC64_REL24
4779           || r_type == R_PPC64_REL14
4780           || r_type == R_PPC64_REL14_BRTAKEN
4781           || r_type == R_PPC64_REL14_BRNTAKEN
4782           || r_type == R_PPC64_ADDR24
4783           || r_type == R_PPC64_ADDR14
4784           || r_type == R_PPC64_ADDR14_BRTAKEN
4785           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4786 }
4787
4788 /* Look through the relocs for a section during the first phase, and
4789    calculate needed space in the global offset table, procedure
4790    linkage table, and dynamic reloc sections.  */
4791
4792 static bfd_boolean
4793 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4794                         asection *sec, const Elf_Internal_Rela *relocs)
4795 {
4796   struct ppc_link_hash_table *htab;
4797   Elf_Internal_Shdr *symtab_hdr;
4798   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4799   const Elf_Internal_Rela *rel;
4800   const Elf_Internal_Rela *rel_end;
4801   asection *sreloc;
4802   asection **opd_sym_map;
4803   struct elf_link_hash_entry *tga, *dottga;
4804
4805   if (info->relocatable)
4806     return TRUE;
4807
4808   /* Don't do anything special with non-loaded, non-alloced sections.
4809      In particular, any relocs in such sections should not affect GOT
4810      and PLT reference counting (ie. we don't allow them to create GOT
4811      or PLT entries), there's no possibility or desire to optimize TLS
4812      relocs, and there's not much point in propagating relocs to shared
4813      libs that the dynamic linker won't relocate.  */
4814   if ((sec->flags & SEC_ALLOC) == 0)
4815     return TRUE;
4816
4817   BFD_ASSERT (is_ppc64_elf (abfd));
4818
4819   htab = ppc_hash_table (info);
4820   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4821                               FALSE, FALSE, TRUE);
4822   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4823                                  FALSE, FALSE, TRUE);
4824   symtab_hdr = &elf_symtab_hdr (abfd);
4825
4826   sym_hashes = elf_sym_hashes (abfd);
4827   sym_hashes_end = (sym_hashes
4828                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4829                     - symtab_hdr->sh_info);
4830
4831   sreloc = NULL;
4832   opd_sym_map = NULL;
4833   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4834     {
4835       /* Garbage collection needs some extra help with .opd sections.
4836          We don't want to necessarily keep everything referenced by
4837          relocs in .opd, as that would keep all functions.  Instead,
4838          if we reference an .opd symbol (a function descriptor), we
4839          want to keep the function code symbol's section.  This is
4840          easy for global symbols, but for local syms we need to keep
4841          information about the associated function section.  */
4842       bfd_size_type amt;
4843
4844       amt = sec->size * sizeof (*opd_sym_map) / 8;
4845       opd_sym_map = bfd_zalloc (abfd, amt);
4846       if (opd_sym_map == NULL)
4847         return FALSE;
4848       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4849       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4850       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4851     }
4852
4853   if (htab->sfpr == NULL
4854       && !create_linkage_sections (htab->elf.dynobj, info))
4855     return FALSE;
4856
4857   rel_end = relocs + sec->reloc_count;
4858   for (rel = relocs; rel < rel_end; rel++)
4859     {
4860       unsigned long r_symndx;
4861       struct elf_link_hash_entry *h;
4862       enum elf_ppc64_reloc_type r_type;
4863       int tls_type;
4864       struct _ppc64_elf_section_data *ppc64_sec;
4865       struct plt_entry **ifunc;
4866
4867       r_symndx = ELF64_R_SYM (rel->r_info);
4868       if (r_symndx < symtab_hdr->sh_info)
4869         h = NULL;
4870       else
4871         {
4872           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4873           h = elf_follow_link (h);
4874         }
4875
4876       tls_type = 0;
4877       ifunc = NULL;
4878       if (h != NULL)
4879         {
4880           if (h->type == STT_GNU_IFUNC)
4881             {
4882               h->needs_plt = 1;
4883               ifunc = &h->plt.plist;
4884             }
4885         }
4886       else
4887         {
4888           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4889                                                           abfd, r_symndx);
4890           if (isym == NULL)
4891             return FALSE;
4892
4893           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4894             {
4895               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4896                                              rel->r_addend, PLT_IFUNC);
4897               if (ifunc == NULL)
4898                 return FALSE;
4899             }
4900         }
4901       r_type = ELF64_R_TYPE (rel->r_info);
4902       if (is_branch_reloc (r_type))
4903         {
4904           if (h != NULL && (h == tga || h == dottga))
4905             {
4906               if (rel != relocs
4907                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4908                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4909                 /* We have a new-style __tls_get_addr call with a marker
4910                    reloc.  */
4911                 ;
4912               else
4913                 /* Mark this section as having an old-style call.  */
4914                 sec->has_tls_get_addr_call = 1;
4915             }
4916
4917           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4918           if (ifunc != NULL
4919               && !update_plt_info (abfd, ifunc, rel->r_addend))
4920             return FALSE;
4921         }
4922
4923       switch (r_type)
4924         {
4925         case R_PPC64_TLSGD:
4926         case R_PPC64_TLSLD:
4927           /* These special tls relocs tie a call to __tls_get_addr with
4928              its parameter symbol.  */
4929           break;
4930
4931         case R_PPC64_GOT_TLSLD16:
4932         case R_PPC64_GOT_TLSLD16_LO:
4933         case R_PPC64_GOT_TLSLD16_HI:
4934         case R_PPC64_GOT_TLSLD16_HA:
4935           tls_type = TLS_TLS | TLS_LD;
4936           goto dogottls;
4937
4938         case R_PPC64_GOT_TLSGD16:
4939         case R_PPC64_GOT_TLSGD16_LO:
4940         case R_PPC64_GOT_TLSGD16_HI:
4941         case R_PPC64_GOT_TLSGD16_HA:
4942           tls_type = TLS_TLS | TLS_GD;
4943           goto dogottls;
4944
4945         case R_PPC64_GOT_TPREL16_DS:
4946         case R_PPC64_GOT_TPREL16_LO_DS:
4947         case R_PPC64_GOT_TPREL16_HI:
4948         case R_PPC64_GOT_TPREL16_HA:
4949           if (!info->executable)
4950             info->flags |= DF_STATIC_TLS;
4951           tls_type = TLS_TLS | TLS_TPREL;
4952           goto dogottls;
4953
4954         case R_PPC64_GOT_DTPREL16_DS:
4955         case R_PPC64_GOT_DTPREL16_LO_DS:
4956         case R_PPC64_GOT_DTPREL16_HI:
4957         case R_PPC64_GOT_DTPREL16_HA:
4958           tls_type = TLS_TLS | TLS_DTPREL;
4959         dogottls:
4960           sec->has_tls_reloc = 1;
4961           /* Fall thru */
4962
4963         case R_PPC64_GOT16:
4964         case R_PPC64_GOT16_DS:
4965         case R_PPC64_GOT16_HA:
4966         case R_PPC64_GOT16_HI:
4967         case R_PPC64_GOT16_LO:
4968         case R_PPC64_GOT16_LO_DS:
4969           /* This symbol requires a global offset table entry.  */
4970           sec->has_toc_reloc = 1;
4971           if (ppc64_elf_tdata (abfd)->got == NULL
4972               && !create_got_section (abfd, info))
4973             return FALSE;
4974
4975           if (h != NULL)
4976             {
4977               struct ppc_link_hash_entry *eh;
4978               struct got_entry *ent;
4979
4980               eh = (struct ppc_link_hash_entry *) h;
4981               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4982                 if (ent->addend == rel->r_addend
4983                     && ent->owner == abfd
4984                     && ent->tls_type == tls_type)
4985                   break;
4986               if (ent == NULL)
4987                 {
4988                   bfd_size_type amt = sizeof (*ent);
4989                   ent = bfd_alloc (abfd, amt);
4990                   if (ent == NULL)
4991                     return FALSE;
4992                   ent->next = eh->elf.got.glist;
4993                   ent->addend = rel->r_addend;
4994                   ent->owner = abfd;
4995                   ent->tls_type = tls_type;
4996                   ent->got.refcount = 0;
4997                   eh->elf.got.glist = ent;
4998                 }
4999               ent->got.refcount += 1;
5000               eh->tls_mask |= tls_type;
5001             }
5002           else
5003             /* This is a global offset table entry for a local symbol.  */
5004             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5005                                         rel->r_addend, tls_type))
5006               return FALSE;
5007           break;
5008
5009         case R_PPC64_PLT16_HA:
5010         case R_PPC64_PLT16_HI:
5011         case R_PPC64_PLT16_LO:
5012         case R_PPC64_PLT32:
5013         case R_PPC64_PLT64:
5014           /* This symbol requires a procedure linkage table entry.  We
5015              actually build the entry in adjust_dynamic_symbol,
5016              because this might be a case of linking PIC code without
5017              linking in any dynamic objects, in which case we don't
5018              need to generate a procedure linkage table after all.  */
5019           if (h == NULL)
5020             {
5021               /* It does not make sense to have a procedure linkage
5022                  table entry for a local symbol.  */
5023               bfd_set_error (bfd_error_bad_value);
5024               return FALSE;
5025             }
5026           else
5027             {
5028               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5029                 return FALSE;
5030               h->needs_plt = 1;
5031               if (h->root.root.string[0] == '.'
5032                   && h->root.root.string[1] != '\0')
5033                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5034             }
5035           break;
5036
5037           /* The following relocations don't need to propagate the
5038              relocation if linking a shared object since they are
5039              section relative.  */
5040         case R_PPC64_SECTOFF:
5041         case R_PPC64_SECTOFF_LO:
5042         case R_PPC64_SECTOFF_HI:
5043         case R_PPC64_SECTOFF_HA:
5044         case R_PPC64_SECTOFF_DS:
5045         case R_PPC64_SECTOFF_LO_DS:
5046         case R_PPC64_DTPREL16:
5047         case R_PPC64_DTPREL16_LO:
5048         case R_PPC64_DTPREL16_HI:
5049         case R_PPC64_DTPREL16_HA:
5050         case R_PPC64_DTPREL16_DS:
5051         case R_PPC64_DTPREL16_LO_DS:
5052         case R_PPC64_DTPREL16_HIGHER:
5053         case R_PPC64_DTPREL16_HIGHERA:
5054         case R_PPC64_DTPREL16_HIGHEST:
5055         case R_PPC64_DTPREL16_HIGHESTA:
5056           break;
5057
5058           /* Nor do these.  */
5059         case R_PPC64_REL16:
5060         case R_PPC64_REL16_LO:
5061         case R_PPC64_REL16_HI:
5062         case R_PPC64_REL16_HA:
5063           break;
5064
5065         case R_PPC64_TOC16:
5066         case R_PPC64_TOC16_LO:
5067         case R_PPC64_TOC16_HI:
5068         case R_PPC64_TOC16_HA:
5069         case R_PPC64_TOC16_DS:
5070         case R_PPC64_TOC16_LO_DS:
5071           sec->has_toc_reloc = 1;
5072           break;
5073
5074           /* This relocation describes the C++ object vtable hierarchy.
5075              Reconstruct it for later use during GC.  */
5076         case R_PPC64_GNU_VTINHERIT:
5077           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5078             return FALSE;
5079           break;
5080
5081           /* This relocation describes which C++ vtable entries are actually
5082              used.  Record for later use during GC.  */
5083         case R_PPC64_GNU_VTENTRY:
5084           BFD_ASSERT (h != NULL);
5085           if (h != NULL
5086               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5087             return FALSE;
5088           break;
5089
5090         case R_PPC64_REL14:
5091         case R_PPC64_REL14_BRTAKEN:
5092         case R_PPC64_REL14_BRNTAKEN:
5093           {
5094             asection *dest = NULL;
5095
5096             /* Heuristic: If jumping outside our section, chances are
5097                we are going to need a stub.  */
5098             if (h != NULL)
5099               {
5100                 /* If the sym is weak it may be overridden later, so
5101                    don't assume we know where a weak sym lives.  */
5102                 if (h->root.type == bfd_link_hash_defined)
5103                   dest = h->root.u.def.section;
5104               }
5105             else
5106               {
5107                 Elf_Internal_Sym *isym;
5108
5109                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5110                                               abfd, r_symndx);
5111                 if (isym == NULL)
5112                   return FALSE;
5113
5114                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5115               }
5116
5117             if (dest != sec)
5118               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5119           }
5120           /* Fall through.  */
5121
5122         case R_PPC64_REL24:
5123           if (h != NULL && ifunc == NULL)
5124             {
5125               /* We may need a .plt entry if the function this reloc
5126                  refers to is in a shared lib.  */
5127               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5128                 return FALSE;
5129               h->needs_plt = 1;
5130               if (h->root.root.string[0] == '.'
5131                   && h->root.root.string[1] != '\0')
5132                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5133               if (h == tga || h == dottga)
5134                 sec->has_tls_reloc = 1;
5135             }
5136           break;
5137
5138         case R_PPC64_TPREL64:
5139           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5140           if (!info->executable)
5141             info->flags |= DF_STATIC_TLS;
5142           goto dotlstoc;
5143
5144         case R_PPC64_DTPMOD64:
5145           if (rel + 1 < rel_end
5146               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5147               && rel[1].r_offset == rel->r_offset + 8)
5148             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5149           else
5150             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5151           goto dotlstoc;
5152
5153         case R_PPC64_DTPREL64:
5154           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5155           if (rel != relocs
5156               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5157               && rel[-1].r_offset == rel->r_offset - 8)
5158             /* This is the second reloc of a dtpmod, dtprel pair.
5159                Don't mark with TLS_DTPREL.  */
5160             goto dodyn;
5161
5162         dotlstoc:
5163           sec->has_tls_reloc = 1;
5164           if (h != NULL)
5165             {
5166               struct ppc_link_hash_entry *eh;
5167               eh = (struct ppc_link_hash_entry *) h;
5168               eh->tls_mask |= tls_type;
5169             }
5170           else
5171             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5172                                         rel->r_addend, tls_type))
5173               return FALSE;
5174
5175           ppc64_sec = ppc64_elf_section_data (sec);
5176           if (ppc64_sec->sec_type != sec_toc)
5177             {
5178               bfd_size_type amt;
5179
5180               /* One extra to simplify get_tls_mask.  */
5181               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5182               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5183               if (ppc64_sec->u.toc.symndx == NULL)
5184                 return FALSE;
5185               amt = sec->size * sizeof (bfd_vma) / 8;
5186               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5187               if (ppc64_sec->u.toc.add == NULL)
5188                 return FALSE;
5189               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5190               ppc64_sec->sec_type = sec_toc;
5191             }
5192           BFD_ASSERT (rel->r_offset % 8 == 0);
5193           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5194           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5195
5196           /* Mark the second slot of a GD or LD entry.
5197              -1 to indicate GD and -2 to indicate LD.  */
5198           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5199             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5200           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5201             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5202           goto dodyn;
5203
5204         case R_PPC64_TPREL16:
5205         case R_PPC64_TPREL16_LO:
5206         case R_PPC64_TPREL16_HI:
5207         case R_PPC64_TPREL16_HA:
5208         case R_PPC64_TPREL16_DS:
5209         case R_PPC64_TPREL16_LO_DS:
5210         case R_PPC64_TPREL16_HIGHER:
5211         case R_PPC64_TPREL16_HIGHERA:
5212         case R_PPC64_TPREL16_HIGHEST:
5213         case R_PPC64_TPREL16_HIGHESTA:
5214           if (info->shared)
5215             {
5216               if (!info->executable)
5217                 info->flags |= DF_STATIC_TLS;
5218               goto dodyn;
5219             }
5220           break;
5221
5222         case R_PPC64_ADDR64:
5223           if (opd_sym_map != NULL
5224               && rel + 1 < rel_end
5225               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5226             {
5227               if (h != NULL)
5228                 {
5229                   if (h->root.root.string[0] == '.'
5230                       && h->root.root.string[1] != 0
5231                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5232                     ;
5233                   else
5234                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5235                 }
5236               else
5237                 {
5238                   asection *s;
5239                   Elf_Internal_Sym *isym;
5240
5241                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5242                                                 abfd, r_symndx);
5243                   if (isym == NULL)
5244                     return FALSE;
5245
5246                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5247                   if (s != NULL && s != sec)
5248                     opd_sym_map[rel->r_offset / 8] = s;
5249                 }
5250             }
5251           /* Fall through.  */
5252
5253         case R_PPC64_REL30:
5254         case R_PPC64_REL32:
5255         case R_PPC64_REL64:
5256         case R_PPC64_ADDR14:
5257         case R_PPC64_ADDR14_BRNTAKEN:
5258         case R_PPC64_ADDR14_BRTAKEN:
5259         case R_PPC64_ADDR16:
5260         case R_PPC64_ADDR16_DS:
5261         case R_PPC64_ADDR16_HA:
5262         case R_PPC64_ADDR16_HI:
5263         case R_PPC64_ADDR16_HIGHER:
5264         case R_PPC64_ADDR16_HIGHERA:
5265         case R_PPC64_ADDR16_HIGHEST:
5266         case R_PPC64_ADDR16_HIGHESTA:
5267         case R_PPC64_ADDR16_LO:
5268         case R_PPC64_ADDR16_LO_DS:
5269         case R_PPC64_ADDR24:
5270         case R_PPC64_ADDR32:
5271         case R_PPC64_UADDR16:
5272         case R_PPC64_UADDR32:
5273         case R_PPC64_UADDR64:
5274         case R_PPC64_TOC:
5275           if (h != NULL && !info->shared)
5276             /* We may need a copy reloc.  */
5277             h->non_got_ref = 1;
5278
5279           /* Don't propagate .opd relocs.  */
5280           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5281             break;
5282
5283           /* If we are creating a shared library, and this is a reloc
5284              against a global symbol, or a non PC relative reloc
5285              against a local symbol, then we need to copy the reloc
5286              into the shared library.  However, if we are linking with
5287              -Bsymbolic, we do not need to copy a reloc against a
5288              global symbol which is defined in an object we are
5289              including in the link (i.e., DEF_REGULAR is set).  At
5290              this point we have not seen all the input files, so it is
5291              possible that DEF_REGULAR is not set now but will be set
5292              later (it is never cleared).  In case of a weak definition,
5293              DEF_REGULAR may be cleared later by a strong definition in
5294              a shared library.  We account for that possibility below by
5295              storing information in the dyn_relocs field of the hash
5296              table entry.  A similar situation occurs when creating
5297              shared libraries and symbol visibility changes render the
5298              symbol local.
5299
5300              If on the other hand, we are creating an executable, we
5301              may need to keep relocations for symbols satisfied by a
5302              dynamic library if we manage to avoid copy relocs for the
5303              symbol.  */
5304         dodyn:
5305           if ((info->shared
5306                && (must_be_dyn_reloc (info, r_type)
5307                    || (h != NULL
5308                        && (! info->symbolic
5309                            || h->root.type == bfd_link_hash_defweak
5310                            || !h->def_regular))))
5311               || (ELIMINATE_COPY_RELOCS
5312                   && !info->shared
5313                   && h != NULL
5314                   && (h->root.type == bfd_link_hash_defweak
5315                       || !h->def_regular))
5316               || (!info->shared
5317                   && ifunc != NULL))
5318             {
5319               struct ppc_dyn_relocs *p;
5320               struct ppc_dyn_relocs **head;
5321
5322               /* We must copy these reloc types into the output file.
5323                  Create a reloc section in dynobj and make room for
5324                  this reloc.  */
5325               if (sreloc == NULL)
5326                 {
5327                   sreloc = _bfd_elf_make_dynamic_reloc_section
5328                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5329
5330                   if (sreloc == NULL)
5331                     return FALSE;
5332                 }
5333
5334               /* If this is a global symbol, we count the number of
5335                  relocations we need for this symbol.  */
5336               if (h != NULL)
5337                 {
5338                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5339                 }
5340               else
5341                 {
5342                   /* Track dynamic relocs needed for local syms too.
5343                      We really need local syms available to do this
5344                      easily.  Oh well.  */
5345                   asection *s;
5346                   void *vpp;
5347                   Elf_Internal_Sym *isym;
5348
5349                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5350                                                 abfd, r_symndx);
5351                   if (isym == NULL)
5352                     return FALSE;
5353
5354                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5355                   if (s == NULL)
5356                     s = sec;
5357
5358                   vpp = &elf_section_data (s)->local_dynrel;
5359                   head = (struct ppc_dyn_relocs **) vpp;
5360                 }
5361
5362               p = *head;
5363               if (p == NULL || p->sec != sec)
5364                 {
5365                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5366                   if (p == NULL)
5367                     return FALSE;
5368                   p->next = *head;
5369                   *head = p;
5370                   p->sec = sec;
5371                   p->count = 0;
5372                   p->pc_count = 0;
5373                 }
5374
5375               p->count += 1;
5376               if (!must_be_dyn_reloc (info, r_type))
5377                 p->pc_count += 1;
5378             }
5379           break;
5380
5381         default:
5382           break;
5383         }
5384     }
5385
5386   return TRUE;
5387 }
5388
5389 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5390    of the code entry point, and its section.  */
5391
5392 static bfd_vma
5393 opd_entry_value (asection *opd_sec,
5394                  bfd_vma offset,
5395                  asection **code_sec,
5396                  bfd_vma *code_off)
5397 {
5398   bfd *opd_bfd = opd_sec->owner;
5399   Elf_Internal_Rela *relocs;
5400   Elf_Internal_Rela *lo, *hi, *look;
5401   bfd_vma val;
5402
5403   /* No relocs implies we are linking a --just-symbols object.  */
5404   if (opd_sec->reloc_count == 0)
5405     {
5406       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5407         return (bfd_vma) -1;
5408
5409       if (code_sec != NULL)
5410         {
5411           asection *sec, *likely = NULL;
5412           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5413             if (sec->vma <= val
5414                 && (sec->flags & SEC_LOAD) != 0
5415                 && (sec->flags & SEC_ALLOC) != 0)
5416               likely = sec;
5417           if (likely != NULL)
5418             {
5419               *code_sec = likely;
5420               if (code_off != NULL)
5421                 *code_off = val - likely->vma;
5422             }
5423         }
5424       return val;
5425     }
5426
5427   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5428
5429   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5430   if (relocs == NULL)
5431     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5432
5433   /* Go find the opd reloc at the sym address.  */
5434   lo = relocs;
5435   BFD_ASSERT (lo != NULL);
5436   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5437   val = (bfd_vma) -1;
5438   while (lo < hi)
5439     {
5440       look = lo + (hi - lo) / 2;
5441       if (look->r_offset < offset)
5442         lo = look + 1;
5443       else if (look->r_offset > offset)
5444         hi = look;
5445       else
5446         {
5447           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5448
5449           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5450               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5451             {
5452               unsigned long symndx = ELF64_R_SYM (look->r_info);
5453               asection *sec;
5454
5455               if (symndx < symtab_hdr->sh_info)
5456                 {
5457                   Elf_Internal_Sym *sym;
5458
5459                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5460                   if (sym == NULL)
5461                     {
5462                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5463                                                   symtab_hdr->sh_info,
5464                                                   0, NULL, NULL, NULL);
5465                       if (sym == NULL)
5466                         break;
5467                       symtab_hdr->contents = (bfd_byte *) sym;
5468                     }
5469
5470                   sym += symndx;
5471                   val = sym->st_value;
5472                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5473                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5474                 }
5475               else
5476                 {
5477                   struct elf_link_hash_entry **sym_hashes;
5478                   struct elf_link_hash_entry *rh;
5479
5480                   sym_hashes = elf_sym_hashes (opd_bfd);
5481                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5482                   rh = elf_follow_link (rh);
5483                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5484                               || rh->root.type == bfd_link_hash_defweak);
5485                   val = rh->root.u.def.value;
5486                   sec = rh->root.u.def.section;
5487                 }
5488               val += look->r_addend;
5489               if (code_off != NULL)
5490                 *code_off = val;
5491               if (code_sec != NULL)
5492                 *code_sec = sec;
5493               if (sec != NULL && sec->output_section != NULL)
5494                 val += sec->output_section->vma + sec->output_offset;
5495             }
5496           break;
5497         }
5498     }
5499
5500   return val;
5501 }
5502
5503 /* If FDH is a function descriptor symbol, return the associated code
5504    entry symbol if it is defined.  Return NULL otherwise.  */
5505
5506 static struct ppc_link_hash_entry *
5507 defined_code_entry (struct ppc_link_hash_entry *fdh)
5508 {
5509   if (fdh->is_func_descriptor)
5510     {
5511       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5512       if (fh->elf.root.type == bfd_link_hash_defined
5513           || fh->elf.root.type == bfd_link_hash_defweak)
5514         return fh;
5515     }
5516   return NULL;
5517 }
5518
5519 /* If FH is a function code entry symbol, return the associated
5520    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5521
5522 static struct ppc_link_hash_entry *
5523 defined_func_desc (struct ppc_link_hash_entry *fh)
5524 {
5525   if (fh->oh != NULL
5526       && fh->oh->is_func_descriptor)
5527     {
5528       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5529       if (fdh->elf.root.type == bfd_link_hash_defined
5530           || fdh->elf.root.type == bfd_link_hash_defweak)
5531         return fdh;
5532     }
5533   return NULL;
5534 }
5535
5536 /* Mark all our entry sym sections, both opd and code section.  */
5537
5538 static void
5539 ppc64_elf_gc_keep (struct bfd_link_info *info)
5540 {
5541   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5542   struct bfd_sym_chain *sym;
5543
5544   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5545     {
5546       struct ppc_link_hash_entry *eh, *fh;
5547       asection *sec;
5548
5549       eh = (struct ppc_link_hash_entry *)
5550         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5551       if (eh == NULL)
5552         continue;
5553       if (eh->elf.root.type != bfd_link_hash_defined
5554           && eh->elf.root.type != bfd_link_hash_defweak)
5555         continue;
5556
5557       fh = defined_code_entry (eh);
5558       if (fh != NULL)
5559         {
5560           sec = fh->elf.root.u.def.section;
5561           sec->flags |= SEC_KEEP;
5562         }
5563       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5564                && opd_entry_value (eh->elf.root.u.def.section,
5565                                    eh->elf.root.u.def.value,
5566                                    &sec, NULL) != (bfd_vma) -1)
5567         sec->flags |= SEC_KEEP;
5568
5569       sec = eh->elf.root.u.def.section;
5570       sec->flags |= SEC_KEEP;
5571     }
5572 }
5573
5574 /* Mark sections containing dynamically referenced symbols.  When
5575    building shared libraries, we must assume that any visible symbol is
5576    referenced.  */
5577
5578 static bfd_boolean
5579 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5580 {
5581   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5582   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5583   struct ppc_link_hash_entry *fdh;
5584
5585   if (eh->elf.root.type == bfd_link_hash_warning)
5586     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5587
5588   /* Dynamic linking info is on the func descriptor sym.  */
5589   fdh = defined_func_desc (eh);
5590   if (fdh != NULL)
5591     eh = fdh;
5592
5593   if ((eh->elf.root.type == bfd_link_hash_defined
5594        || eh->elf.root.type == bfd_link_hash_defweak)
5595       && (eh->elf.ref_dynamic
5596           || (!info->executable
5597               && eh->elf.def_regular
5598               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5599               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5600     {
5601       asection *code_sec;
5602       struct ppc_link_hash_entry *fh;
5603
5604       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5605
5606       /* Function descriptor syms cause the associated
5607          function code sym section to be marked.  */
5608       fh = defined_code_entry (eh);
5609       if (fh != NULL)
5610         {
5611           code_sec = fh->elf.root.u.def.section;
5612           code_sec->flags |= SEC_KEEP;
5613         }
5614       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5615                && opd_entry_value (eh->elf.root.u.def.section,
5616                                    eh->elf.root.u.def.value,
5617                                    &code_sec, NULL) != (bfd_vma) -1)
5618         code_sec->flags |= SEC_KEEP;
5619     }
5620
5621   return TRUE;
5622 }
5623
5624 /* Return the section that should be marked against GC for a given
5625    relocation.  */
5626
5627 static asection *
5628 ppc64_elf_gc_mark_hook (asection *sec,
5629                         struct bfd_link_info *info,
5630                         Elf_Internal_Rela *rel,
5631                         struct elf_link_hash_entry *h,
5632                         Elf_Internal_Sym *sym)
5633 {
5634   asection *rsec;
5635
5636   /* Syms return NULL if we're marking .opd, so we avoid marking all
5637      function sections, as all functions are referenced in .opd.  */
5638   rsec = NULL;
5639   if (get_opd_info (sec) != NULL)
5640     return rsec;
5641
5642   if (h != NULL)
5643     {
5644       enum elf_ppc64_reloc_type r_type;
5645       struct ppc_link_hash_entry *eh, *fh, *fdh;
5646
5647       r_type = ELF64_R_TYPE (rel->r_info);
5648       switch (r_type)
5649         {
5650         case R_PPC64_GNU_VTINHERIT:
5651         case R_PPC64_GNU_VTENTRY:
5652           break;
5653
5654         default:
5655           switch (h->root.type)
5656             {
5657             case bfd_link_hash_defined:
5658             case bfd_link_hash_defweak:
5659               eh = (struct ppc_link_hash_entry *) h;
5660               fdh = defined_func_desc (eh);
5661               if (fdh != NULL)
5662                 eh = fdh;
5663
5664               /* Function descriptor syms cause the associated
5665                  function code sym section to be marked.  */
5666               fh = defined_code_entry (eh);
5667               if (fh != NULL)
5668                 {
5669                   /* They also mark their opd section.  */
5670                   eh->elf.root.u.def.section->gc_mark = 1;
5671
5672                   rsec = fh->elf.root.u.def.section;
5673                 }
5674               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5675                        && opd_entry_value (eh->elf.root.u.def.section,
5676                                            eh->elf.root.u.def.value,
5677                                            &rsec, NULL) != (bfd_vma) -1)
5678                 eh->elf.root.u.def.section->gc_mark = 1;
5679               else
5680                 rsec = h->root.u.def.section;
5681               break;
5682
5683             case bfd_link_hash_common:
5684               rsec = h->root.u.c.p->section;
5685               break;
5686
5687             default:
5688               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5689             }
5690         }
5691     }
5692   else
5693     {
5694       struct _opd_sec_data *opd;
5695
5696       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5697       opd = get_opd_info (rsec);
5698       if (opd != NULL && opd->func_sec != NULL)
5699         {
5700           rsec->gc_mark = 1;
5701
5702           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5703         }
5704     }
5705
5706   return rsec;
5707 }
5708
5709 /* Update the .got, .plt. and dynamic reloc reference counts for the
5710    section being removed.  */
5711
5712 static bfd_boolean
5713 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5714                          asection *sec, const Elf_Internal_Rela *relocs)
5715 {
5716   struct ppc_link_hash_table *htab;
5717   Elf_Internal_Shdr *symtab_hdr;
5718   struct elf_link_hash_entry **sym_hashes;
5719   struct got_entry **local_got_ents;
5720   const Elf_Internal_Rela *rel, *relend;
5721
5722   if (info->relocatable)
5723     return TRUE;
5724
5725   if ((sec->flags & SEC_ALLOC) == 0)
5726     return TRUE;
5727
5728   elf_section_data (sec)->local_dynrel = NULL;
5729
5730   htab = ppc_hash_table (info);
5731   symtab_hdr = &elf_symtab_hdr (abfd);
5732   sym_hashes = elf_sym_hashes (abfd);
5733   local_got_ents = elf_local_got_ents (abfd);
5734
5735   relend = relocs + sec->reloc_count;
5736   for (rel = relocs; rel < relend; rel++)
5737     {
5738       unsigned long r_symndx;
5739       enum elf_ppc64_reloc_type r_type;
5740       struct elf_link_hash_entry *h = NULL;
5741       char tls_type = 0;
5742
5743       r_symndx = ELF64_R_SYM (rel->r_info);
5744       r_type = ELF64_R_TYPE (rel->r_info);
5745       if (r_symndx >= symtab_hdr->sh_info)
5746         {
5747           struct ppc_link_hash_entry *eh;
5748           struct ppc_dyn_relocs **pp;
5749           struct ppc_dyn_relocs *p;
5750
5751           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5752           h = elf_follow_link (h);
5753           eh = (struct ppc_link_hash_entry *) h;
5754
5755           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5756             if (p->sec == sec)
5757               {
5758                 /* Everything must go for SEC.  */
5759                 *pp = p->next;
5760                 break;
5761               }
5762         }
5763
5764       if (is_branch_reloc (r_type))
5765         {
5766           struct plt_entry **ifunc = NULL;
5767           if (h != NULL)
5768             {
5769               if (h->type == STT_GNU_IFUNC)
5770                 ifunc = &h->plt.plist;
5771             }
5772           else if (local_got_ents != NULL)
5773             {
5774               struct plt_entry **local_plt = (struct plt_entry **)
5775                 (local_got_ents + symtab_hdr->sh_info);
5776               char *local_got_tls_masks = (char *)
5777                 (local_plt + symtab_hdr->sh_info);
5778               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5779                 ifunc = local_plt + r_symndx;
5780             }
5781           if (ifunc != NULL)
5782             {
5783               struct plt_entry *ent;
5784
5785               for (ent = *ifunc; ent != NULL; ent = ent->next)
5786                 if (ent->addend == rel->r_addend)
5787                   break;
5788               if (ent == NULL)
5789                 abort ();
5790               if (ent->plt.refcount > 0)
5791                 ent->plt.refcount -= 1;
5792               continue;
5793             }
5794         }
5795
5796       switch (r_type)
5797         {
5798         case R_PPC64_GOT_TLSLD16:
5799         case R_PPC64_GOT_TLSLD16_LO:
5800         case R_PPC64_GOT_TLSLD16_HI:
5801         case R_PPC64_GOT_TLSLD16_HA:
5802           tls_type = TLS_TLS | TLS_LD;
5803           goto dogot;
5804
5805         case R_PPC64_GOT_TLSGD16:
5806         case R_PPC64_GOT_TLSGD16_LO:
5807         case R_PPC64_GOT_TLSGD16_HI:
5808         case R_PPC64_GOT_TLSGD16_HA:
5809           tls_type = TLS_TLS | TLS_GD;
5810           goto dogot;
5811
5812         case R_PPC64_GOT_TPREL16_DS:
5813         case R_PPC64_GOT_TPREL16_LO_DS:
5814         case R_PPC64_GOT_TPREL16_HI:
5815         case R_PPC64_GOT_TPREL16_HA:
5816           tls_type = TLS_TLS | TLS_TPREL;
5817           goto dogot;
5818
5819         case R_PPC64_GOT_DTPREL16_DS:
5820         case R_PPC64_GOT_DTPREL16_LO_DS:
5821         case R_PPC64_GOT_DTPREL16_HI:
5822         case R_PPC64_GOT_DTPREL16_HA:
5823           tls_type = TLS_TLS | TLS_DTPREL;
5824           goto dogot;
5825
5826         case R_PPC64_GOT16:
5827         case R_PPC64_GOT16_DS:
5828         case R_PPC64_GOT16_HA:
5829         case R_PPC64_GOT16_HI:
5830         case R_PPC64_GOT16_LO:
5831         case R_PPC64_GOT16_LO_DS:
5832         dogot:
5833           {
5834             struct got_entry *ent;
5835
5836             if (h != NULL)
5837               ent = h->got.glist;
5838             else
5839               ent = local_got_ents[r_symndx];
5840
5841             for (; ent != NULL; ent = ent->next)
5842               if (ent->addend == rel->r_addend
5843                   && ent->owner == abfd
5844                   && ent->tls_type == tls_type)
5845                 break;
5846             if (ent == NULL)
5847               abort ();
5848             if (ent->got.refcount > 0)
5849               ent->got.refcount -= 1;
5850           }
5851           break;
5852
5853         case R_PPC64_PLT16_HA:
5854         case R_PPC64_PLT16_HI:
5855         case R_PPC64_PLT16_LO:
5856         case R_PPC64_PLT32:
5857         case R_PPC64_PLT64:
5858         case R_PPC64_REL14:
5859         case R_PPC64_REL14_BRNTAKEN:
5860         case R_PPC64_REL14_BRTAKEN:
5861         case R_PPC64_REL24:
5862           if (h != NULL)
5863             {
5864               struct plt_entry *ent;
5865
5866               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5867                 if (ent->addend == rel->r_addend)
5868                   break;
5869               if (ent != NULL && ent->plt.refcount > 0)
5870                 ent->plt.refcount -= 1;
5871             }
5872           break;
5873
5874         default:
5875           break;
5876         }
5877     }
5878   return TRUE;
5879 }
5880
5881 /* The maximum size of .sfpr.  */
5882 #define SFPR_MAX (218*4)
5883
5884 struct sfpr_def_parms
5885 {
5886   const char name[12];
5887   unsigned char lo, hi;
5888   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5889   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5890 };
5891
5892 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5893
5894 static unsigned int
5895 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5896 {
5897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5898   unsigned int i;
5899   size_t len = strlen (parm->name);
5900   bfd_boolean writing = FALSE;
5901   char sym[16];
5902
5903   memcpy (sym, parm->name, len);
5904   sym[len + 2] = 0;
5905
5906   for (i = parm->lo; i <= parm->hi; i++)
5907     {
5908       struct elf_link_hash_entry *h;
5909
5910       sym[len + 0] = i / 10 + '0';
5911       sym[len + 1] = i % 10 + '0';
5912       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5913       if (h != NULL
5914           && !h->def_regular)
5915         {
5916           h->root.type = bfd_link_hash_defined;
5917           h->root.u.def.section = htab->sfpr;
5918           h->root.u.def.value = htab->sfpr->size;
5919           h->type = STT_FUNC;
5920           h->def_regular = 1;
5921           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5922           writing = TRUE;
5923           if (htab->sfpr->contents == NULL)
5924             {
5925               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5926               if (htab->sfpr->contents == NULL)
5927                 return FALSE;
5928             }
5929         }
5930       if (writing)
5931         {
5932           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5933           if (i != parm->hi)
5934             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5935           else
5936             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5937           htab->sfpr->size = p - htab->sfpr->contents;
5938         }
5939     }
5940
5941   return TRUE;
5942 }
5943
5944 static bfd_byte *
5945 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5946 {
5947   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5948   return p + 4;
5949 }
5950
5951 static bfd_byte *
5952 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5953 {
5954   p = savegpr0 (abfd, p, r);
5955   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5956   p = p + 4;
5957   bfd_put_32 (abfd, BLR, p);
5958   return p + 4;
5959 }
5960
5961 static bfd_byte *
5962 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5963 {
5964   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5965   return p + 4;
5966 }
5967
5968 static bfd_byte *
5969 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5970 {
5971   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5972   p = p + 4;
5973   p = restgpr0 (abfd, p, r);
5974   bfd_put_32 (abfd, MTLR_R0, p);
5975   p = p + 4;
5976   if (r == 29)
5977     {
5978       p = restgpr0 (abfd, p, 30);
5979       p = restgpr0 (abfd, p, 31);
5980     }
5981   bfd_put_32 (abfd, BLR, p);
5982   return p + 4;
5983 }
5984
5985 static bfd_byte *
5986 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5987 {
5988   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5989   return p + 4;
5990 }
5991
5992 static bfd_byte *
5993 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5994 {
5995   p = savegpr1 (abfd, p, r);
5996   bfd_put_32 (abfd, BLR, p);
5997   return p + 4;
5998 }
5999
6000 static bfd_byte *
6001 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6002 {
6003   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6004   return p + 4;
6005 }
6006
6007 static bfd_byte *
6008 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6009 {
6010   p = restgpr1 (abfd, p, r);
6011   bfd_put_32 (abfd, BLR, p);
6012   return p + 4;
6013 }
6014
6015 static bfd_byte *
6016 savefpr (bfd *abfd, bfd_byte *p, int r)
6017 {
6018   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6019   return p + 4;
6020 }
6021
6022 static bfd_byte *
6023 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6024 {
6025   p = savefpr (abfd, p, r);
6026   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6027   p = p + 4;
6028   bfd_put_32 (abfd, BLR, p);
6029   return p + 4;
6030 }
6031
6032 static bfd_byte *
6033 restfpr (bfd *abfd, bfd_byte *p, int r)
6034 {
6035   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6036   return p + 4;
6037 }
6038
6039 static bfd_byte *
6040 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6041 {
6042   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6043   p = p + 4;
6044   p = restfpr (abfd, p, r);
6045   bfd_put_32 (abfd, MTLR_R0, p);
6046   p = p + 4;
6047   if (r == 29)
6048     {
6049       p = restfpr (abfd, p, 30);
6050       p = restfpr (abfd, p, 31);
6051     }
6052   bfd_put_32 (abfd, BLR, p);
6053   return p + 4;
6054 }
6055
6056 static bfd_byte *
6057 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6058 {
6059   p = savefpr (abfd, p, r);
6060   bfd_put_32 (abfd, BLR, p);
6061   return p + 4;
6062 }
6063
6064 static bfd_byte *
6065 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6066 {
6067   p = restfpr (abfd, p, r);
6068   bfd_put_32 (abfd, BLR, p);
6069   return p + 4;
6070 }
6071
6072 static bfd_byte *
6073 savevr (bfd *abfd, bfd_byte *p, int r)
6074 {
6075   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6076   p = p + 4;
6077   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6078   return p + 4;
6079 }
6080
6081 static bfd_byte *
6082 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6083 {
6084   p = savevr (abfd, p, r);
6085   bfd_put_32 (abfd, BLR, p);
6086   return p + 4;
6087 }
6088
6089 static bfd_byte *
6090 restvr (bfd *abfd, bfd_byte *p, int r)
6091 {
6092   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6093   p = p + 4;
6094   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6095   return p + 4;
6096 }
6097
6098 static bfd_byte *
6099 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6100 {
6101   p = restvr (abfd, p, r);
6102   bfd_put_32 (abfd, BLR, p);
6103   return p + 4;
6104 }
6105
6106 /* Called via elf_link_hash_traverse to transfer dynamic linking
6107    information on function code symbol entries to their corresponding
6108    function descriptor symbol entries.  */
6109
6110 static bfd_boolean
6111 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6112 {
6113   struct bfd_link_info *info;
6114   struct ppc_link_hash_table *htab;
6115   struct plt_entry *ent;
6116   struct ppc_link_hash_entry *fh;
6117   struct ppc_link_hash_entry *fdh;
6118   bfd_boolean force_local;
6119
6120   fh = (struct ppc_link_hash_entry *) h;
6121   if (fh->elf.root.type == bfd_link_hash_indirect)
6122     return TRUE;
6123
6124   if (fh->elf.root.type == bfd_link_hash_warning)
6125     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6126
6127   info = inf;
6128   htab = ppc_hash_table (info);
6129
6130   /* Resolve undefined references to dot-symbols as the value
6131      in the function descriptor, if we have one in a regular object.
6132      This is to satisfy cases like ".quad .foo".  Calls to functions
6133      in dynamic objects are handled elsewhere.  */
6134   if (fh->elf.root.type == bfd_link_hash_undefweak
6135       && fh->was_undefined
6136       && (fdh = defined_func_desc (fh)) != NULL
6137       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6138       && opd_entry_value (fdh->elf.root.u.def.section,
6139                           fdh->elf.root.u.def.value,
6140                           &fh->elf.root.u.def.section,
6141                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6142     {
6143       fh->elf.root.type = fdh->elf.root.type;
6144       fh->elf.forced_local = 1;
6145       fh->elf.def_regular = fdh->elf.def_regular;
6146       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6147     }
6148
6149   /* If this is a function code symbol, transfer dynamic linking
6150      information to the function descriptor symbol.  */
6151   if (!fh->is_func)
6152     return TRUE;
6153
6154   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6155     if (ent->plt.refcount > 0)
6156       break;
6157   if (ent == NULL
6158       || fh->elf.root.root.string[0] != '.'
6159       || fh->elf.root.root.string[1] == '\0')
6160     return TRUE;
6161
6162   /* Find the corresponding function descriptor symbol.  Create it
6163      as undefined if necessary.  */
6164
6165   fdh = lookup_fdh (fh, htab);
6166   if (fdh == NULL
6167       && !info->executable
6168       && (fh->elf.root.type == bfd_link_hash_undefined
6169           || fh->elf.root.type == bfd_link_hash_undefweak))
6170     {
6171       fdh = make_fdh (info, fh);
6172       if (fdh == NULL)
6173         return FALSE;
6174     }
6175
6176   /* Fake function descriptors are made undefweak.  If the function
6177      code symbol is strong undefined, make the fake sym the same.
6178      If the function code symbol is defined, then force the fake
6179      descriptor local;  We can't support overriding of symbols in a
6180      shared library on a fake descriptor.  */
6181
6182   if (fdh != NULL
6183       && fdh->fake
6184       && fdh->elf.root.type == bfd_link_hash_undefweak)
6185     {
6186       if (fh->elf.root.type == bfd_link_hash_undefined)
6187         {
6188           fdh->elf.root.type = bfd_link_hash_undefined;
6189           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6190         }
6191       else if (fh->elf.root.type == bfd_link_hash_defined
6192                || fh->elf.root.type == bfd_link_hash_defweak)
6193         {
6194           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6195         }
6196     }
6197
6198   if (fdh != NULL
6199       && !fdh->elf.forced_local
6200       && (!info->executable
6201           || fdh->elf.def_dynamic
6202           || fdh->elf.ref_dynamic
6203           || (fdh->elf.root.type == bfd_link_hash_undefweak
6204               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6205     {
6206       if (fdh->elf.dynindx == -1)
6207         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6208           return FALSE;
6209       fdh->elf.ref_regular |= fh->elf.ref_regular;
6210       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6211       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6212       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6213       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6214         {
6215           move_plt_plist (fh, fdh);
6216           fdh->elf.needs_plt = 1;
6217         }
6218       fdh->is_func_descriptor = 1;
6219       fdh->oh = fh;
6220       fh->oh = fdh;
6221     }
6222
6223   /* Now that the info is on the function descriptor, clear the
6224      function code sym info.  Any function code syms for which we
6225      don't have a definition in a regular file, we force local.
6226      This prevents a shared library from exporting syms that have
6227      been imported from another library.  Function code syms that
6228      are really in the library we must leave global to prevent the
6229      linker dragging in a definition from a static library.  */
6230   force_local = (!fh->elf.def_regular
6231                  || fdh == NULL
6232                  || !fdh->elf.def_regular
6233                  || fdh->elf.forced_local);
6234   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6235
6236   return TRUE;
6237 }
6238
6239 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6240    this hook to a) provide some gcc support functions, and b) transfer
6241    dynamic linking information gathered so far on function code symbol
6242    entries, to their corresponding function descriptor symbol entries.  */
6243
6244 static bfd_boolean
6245 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6246                             struct bfd_link_info *info)
6247 {
6248   struct ppc_link_hash_table *htab;
6249   unsigned int i;
6250   const struct sfpr_def_parms funcs[] =
6251     {
6252       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6253       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6254       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6255       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6256       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6257       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6258       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6259       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6260       { "._savef", 14, 31, savefpr, savefpr1_tail },
6261       { "._restf", 14, 31, restfpr, restfpr1_tail },
6262       { "_savevr_", 20, 31, savevr, savevr_tail },
6263       { "_restvr_", 20, 31, restvr, restvr_tail }
6264     };
6265
6266   htab = ppc_hash_table (info);
6267   if (htab->sfpr == NULL)
6268     /* We don't have any relocs.  */
6269     return TRUE;
6270
6271   /* Provide any missing _save* and _rest* functions.  */
6272   htab->sfpr->size = 0;
6273   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6274     if (!sfpr_define (info, &funcs[i]))
6275       return FALSE;
6276
6277   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6278
6279   if (htab->sfpr->size == 0)
6280     htab->sfpr->flags |= SEC_EXCLUDE;
6281
6282   return TRUE;
6283 }
6284
6285 /* Adjust a symbol defined by a dynamic object and referenced by a
6286    regular object.  The current definition is in some section of the
6287    dynamic object, but we're not including those sections.  We have to
6288    change the definition to something the rest of the link can
6289    understand.  */
6290
6291 static bfd_boolean
6292 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6293                                  struct elf_link_hash_entry *h)
6294 {
6295   struct ppc_link_hash_table *htab;
6296   asection *s;
6297
6298   htab = ppc_hash_table (info);
6299
6300   /* Deal with function syms.  */
6301   if (h->type == STT_FUNC
6302       || h->type == STT_GNU_IFUNC
6303       || h->needs_plt)
6304     {
6305       /* Clear procedure linkage table information for any symbol that
6306          won't need a .plt entry.  */
6307       struct plt_entry *ent;
6308       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6309         if (ent->plt.refcount > 0)
6310           break;
6311       if (ent == NULL
6312           || (h->type != STT_GNU_IFUNC
6313               && (SYMBOL_CALLS_LOCAL (info, h)
6314                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6315                       && h->root.type == bfd_link_hash_undefweak))))
6316         {
6317           h->plt.plist = NULL;
6318           h->needs_plt = 0;
6319         }
6320     }
6321   else
6322     h->plt.plist = NULL;
6323
6324   /* If this is a weak symbol, and there is a real definition, the
6325      processor independent code will have arranged for us to see the
6326      real definition first, and we can just use the same value.  */
6327   if (h->u.weakdef != NULL)
6328     {
6329       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6330                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6331       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6332       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6333       if (ELIMINATE_COPY_RELOCS)
6334         h->non_got_ref = h->u.weakdef->non_got_ref;
6335       return TRUE;
6336     }
6337
6338   /* If we are creating a shared library, we must presume that the
6339      only references to the symbol are via the global offset table.
6340      For such cases we need not do anything here; the relocations will
6341      be handled correctly by relocate_section.  */
6342   if (info->shared)
6343     return TRUE;
6344
6345   /* If there are no references to this symbol that do not use the
6346      GOT, we don't need to generate a copy reloc.  */
6347   if (!h->non_got_ref)
6348     return TRUE;
6349
6350   /* Don't generate a copy reloc for symbols defined in the executable.  */
6351   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6352     return TRUE;
6353
6354   if (ELIMINATE_COPY_RELOCS)
6355     {
6356       struct ppc_link_hash_entry * eh;
6357       struct ppc_dyn_relocs *p;
6358
6359       eh = (struct ppc_link_hash_entry *) h;
6360       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6361         {
6362           s = p->sec->output_section;
6363           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6364             break;
6365         }
6366
6367       /* If we didn't find any dynamic relocs in read-only sections, then
6368          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6369       if (p == NULL)
6370         {
6371           h->non_got_ref = 0;
6372           return TRUE;
6373         }
6374     }
6375
6376   if (h->plt.plist != NULL)
6377     {
6378       /* We should never get here, but unfortunately there are versions
6379          of gcc out there that improperly (for this ABI) put initialized
6380          function pointers, vtable refs and suchlike in read-only
6381          sections.  Allow them to proceed, but warn that this might
6382          break at runtime.  */
6383       (*_bfd_error_handler)
6384         (_("copy reloc against `%s' requires lazy plt linking; "
6385            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6386          h->root.root.string);
6387     }
6388
6389   /* This is a reference to a symbol defined by a dynamic object which
6390      is not a function.  */
6391
6392   if (h->size == 0)
6393     {
6394       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6395                              h->root.root.string);
6396       return TRUE;
6397     }
6398
6399   /* We must allocate the symbol in our .dynbss section, which will
6400      become part of the .bss section of the executable.  There will be
6401      an entry for this symbol in the .dynsym section.  The dynamic
6402      object will contain position independent code, so all references
6403      from the dynamic object to this symbol will go through the global
6404      offset table.  The dynamic linker will use the .dynsym entry to
6405      determine the address it must put in the global offset table, so
6406      both the dynamic object and the regular object will refer to the
6407      same memory location for the variable.  */
6408
6409   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6410      to copy the initial value out of the dynamic object and into the
6411      runtime process image.  We need to remember the offset into the
6412      .rela.bss section we are going to use.  */
6413   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6414     {
6415       htab->relbss->size += sizeof (Elf64_External_Rela);
6416       h->needs_copy = 1;
6417     }
6418
6419   s = htab->dynbss;
6420
6421   return _bfd_elf_adjust_dynamic_copy (h, s);
6422 }
6423
6424 /* If given a function descriptor symbol, hide both the function code
6425    sym and the descriptor.  */
6426 static void
6427 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6428                        struct elf_link_hash_entry *h,
6429                        bfd_boolean force_local)
6430 {
6431   struct ppc_link_hash_entry *eh;
6432   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6433
6434   eh = (struct ppc_link_hash_entry *) h;
6435   if (eh->is_func_descriptor)
6436     {
6437       struct ppc_link_hash_entry *fh = eh->oh;
6438
6439       if (fh == NULL)
6440         {
6441           const char *p, *q;
6442           struct ppc_link_hash_table *htab;
6443           char save;
6444
6445           /* We aren't supposed to use alloca in BFD because on
6446              systems which do not have alloca the version in libiberty
6447              calls xmalloc, which might cause the program to crash
6448              when it runs out of memory.  This function doesn't have a
6449              return status, so there's no way to gracefully return an
6450              error.  So cheat.  We know that string[-1] can be safely
6451              accessed;  It's either a string in an ELF string table,
6452              or allocated in an objalloc structure.  */
6453
6454           p = eh->elf.root.root.string - 1;
6455           save = *p;
6456           *(char *) p = '.';
6457           htab = ppc_hash_table (info);
6458           fh = (struct ppc_link_hash_entry *)
6459             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6460           *(char *) p = save;
6461
6462           /* Unfortunately, if it so happens that the string we were
6463              looking for was allocated immediately before this string,
6464              then we overwrote the string terminator.  That's the only
6465              reason the lookup should fail.  */
6466           if (fh == NULL)
6467             {
6468               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6469               while (q >= eh->elf.root.root.string && *q == *p)
6470                 --q, --p;
6471               if (q < eh->elf.root.root.string && *p == '.')
6472                 fh = (struct ppc_link_hash_entry *)
6473                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6474             }
6475           if (fh != NULL)
6476             {
6477               eh->oh = fh;
6478               fh->oh = eh;
6479             }
6480         }
6481       if (fh != NULL)
6482         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6483     }
6484 }
6485
6486 static bfd_boolean
6487 get_sym_h (struct elf_link_hash_entry **hp,
6488            Elf_Internal_Sym **symp,
6489            asection **symsecp,
6490            char **tls_maskp,
6491            Elf_Internal_Sym **locsymsp,
6492            unsigned long r_symndx,
6493            bfd *ibfd)
6494 {
6495   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6496
6497   if (r_symndx >= symtab_hdr->sh_info)
6498     {
6499       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6500       struct elf_link_hash_entry *h;
6501
6502       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6503       h = elf_follow_link (h);
6504
6505       if (hp != NULL)
6506         *hp = h;
6507
6508       if (symp != NULL)
6509         *symp = NULL;
6510
6511       if (symsecp != NULL)
6512         {
6513           asection *symsec = NULL;
6514           if (h->root.type == bfd_link_hash_defined
6515               || h->root.type == bfd_link_hash_defweak)
6516             symsec = h->root.u.def.section;
6517           *symsecp = symsec;
6518         }
6519
6520       if (tls_maskp != NULL)
6521         {
6522           struct ppc_link_hash_entry *eh;
6523
6524           eh = (struct ppc_link_hash_entry *) h;
6525           *tls_maskp = &eh->tls_mask;
6526         }
6527     }
6528   else
6529     {
6530       Elf_Internal_Sym *sym;
6531       Elf_Internal_Sym *locsyms = *locsymsp;
6532
6533       if (locsyms == NULL)
6534         {
6535           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6536           if (locsyms == NULL)
6537             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6538                                             symtab_hdr->sh_info,
6539                                             0, NULL, NULL, NULL);
6540           if (locsyms == NULL)
6541             return FALSE;
6542           *locsymsp = locsyms;
6543         }
6544       sym = locsyms + r_symndx;
6545
6546       if (hp != NULL)
6547         *hp = NULL;
6548
6549       if (symp != NULL)
6550         *symp = sym;
6551
6552       if (symsecp != NULL)
6553         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6554
6555       if (tls_maskp != NULL)
6556         {
6557           struct got_entry **lgot_ents;
6558           char *tls_mask;
6559
6560           tls_mask = NULL;
6561           lgot_ents = elf_local_got_ents (ibfd);
6562           if (lgot_ents != NULL)
6563             {
6564               struct plt_entry **local_plt = (struct plt_entry **)
6565                 (lgot_ents + symtab_hdr->sh_info);
6566               char *lgot_masks = (char *)
6567                 (local_plt + symtab_hdr->sh_info);
6568               tls_mask = &lgot_masks[r_symndx];
6569             }
6570           *tls_maskp = tls_mask;
6571         }
6572     }
6573   return TRUE;
6574 }
6575
6576 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6577    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6578    type suitable for optimization, and 1 otherwise.  */
6579
6580 static int
6581 get_tls_mask (char **tls_maskp,
6582               unsigned long *toc_symndx,
6583               bfd_vma *toc_addend,
6584               Elf_Internal_Sym **locsymsp,
6585               const Elf_Internal_Rela *rel,
6586               bfd *ibfd)
6587 {
6588   unsigned long r_symndx;
6589   int next_r;
6590   struct elf_link_hash_entry *h;
6591   Elf_Internal_Sym *sym;
6592   asection *sec;
6593   bfd_vma off;
6594
6595   r_symndx = ELF64_R_SYM (rel->r_info);
6596   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6597     return 0;
6598
6599   if ((*tls_maskp != NULL && **tls_maskp != 0)
6600       || sec == NULL
6601       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6602     return 1;
6603
6604   /* Look inside a TOC section too.  */
6605   if (h != NULL)
6606     {
6607       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6608       off = h->root.u.def.value;
6609     }
6610   else
6611     off = sym->st_value;
6612   off += rel->r_addend;
6613   BFD_ASSERT (off % 8 == 0);
6614   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6615   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6616   if (toc_symndx != NULL)
6617     *toc_symndx = r_symndx;
6618   if (toc_addend != NULL)
6619     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6620   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6621     return 0;
6622   if ((h == NULL
6623        || ((h->root.type == bfd_link_hash_defined
6624             || h->root.type == bfd_link_hash_defweak)
6625            && !h->def_dynamic))
6626       && (next_r == -1 || next_r == -2))
6627     return 1 - next_r;
6628   return 1;
6629 }
6630
6631 /* Adjust all global syms defined in opd sections.  In gcc generated
6632    code for the old ABI, these will already have been done.  */
6633
6634 static bfd_boolean
6635 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6636 {
6637   struct ppc_link_hash_entry *eh;
6638   asection *sym_sec;
6639   struct _opd_sec_data *opd;
6640
6641   if (h->root.type == bfd_link_hash_indirect)
6642     return TRUE;
6643
6644   if (h->root.type == bfd_link_hash_warning)
6645     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6646
6647   if (h->root.type != bfd_link_hash_defined
6648       && h->root.type != bfd_link_hash_defweak)
6649     return TRUE;
6650
6651   eh = (struct ppc_link_hash_entry *) h;
6652   if (eh->adjust_done)
6653     return TRUE;
6654
6655   sym_sec = eh->elf.root.u.def.section;
6656   opd = get_opd_info (sym_sec);
6657   if (opd != NULL && opd->adjust != NULL)
6658     {
6659       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6660       if (adjust == -1)
6661         {
6662           /* This entry has been deleted.  */
6663           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6664           if (dsec == NULL)
6665             {
6666               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6667                 if (elf_discarded_section (dsec))
6668                   {
6669                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6670                     break;
6671                   }
6672             }
6673           eh->elf.root.u.def.value = 0;
6674           eh->elf.root.u.def.section = dsec;
6675         }
6676       else
6677         eh->elf.root.u.def.value += adjust;
6678       eh->adjust_done = 1;
6679     }
6680   return TRUE;
6681 }
6682
6683 /* Handles decrementing dynamic reloc counts for the reloc specified by
6684    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6685    have already been determined.  */
6686
6687 static bfd_boolean
6688 dec_dynrel_count (bfd_vma r_info,
6689                   asection *sec,
6690                   struct bfd_link_info *info,
6691                   Elf_Internal_Sym **local_syms,
6692                   struct elf_link_hash_entry *h,
6693                   asection *sym_sec)
6694 {
6695   enum elf_ppc64_reloc_type r_type;
6696   struct ppc_dyn_relocs *p;
6697   struct ppc_dyn_relocs **pp;
6698
6699   /* Can this reloc be dynamic?  This switch, and later tests here
6700      should be kept in sync with the code in check_relocs.  */
6701   r_type = ELF64_R_TYPE (r_info);
6702   switch (r_type)
6703     {
6704     default:
6705       return TRUE;
6706
6707     case R_PPC64_TPREL16:
6708     case R_PPC64_TPREL16_LO:
6709     case R_PPC64_TPREL16_HI:
6710     case R_PPC64_TPREL16_HA:
6711     case R_PPC64_TPREL16_DS:
6712     case R_PPC64_TPREL16_LO_DS:
6713     case R_PPC64_TPREL16_HIGHER:
6714     case R_PPC64_TPREL16_HIGHERA:
6715     case R_PPC64_TPREL16_HIGHEST:
6716     case R_PPC64_TPREL16_HIGHESTA:
6717       if (!info->shared)
6718         return TRUE;
6719
6720     case R_PPC64_TPREL64:
6721     case R_PPC64_DTPMOD64:
6722     case R_PPC64_DTPREL64:
6723     case R_PPC64_ADDR64:
6724     case R_PPC64_REL30:
6725     case R_PPC64_REL32:
6726     case R_PPC64_REL64:
6727     case R_PPC64_ADDR14:
6728     case R_PPC64_ADDR14_BRNTAKEN:
6729     case R_PPC64_ADDR14_BRTAKEN:
6730     case R_PPC64_ADDR16:
6731     case R_PPC64_ADDR16_DS:
6732     case R_PPC64_ADDR16_HA:
6733     case R_PPC64_ADDR16_HI:
6734     case R_PPC64_ADDR16_HIGHER:
6735     case R_PPC64_ADDR16_HIGHERA:
6736     case R_PPC64_ADDR16_HIGHEST:
6737     case R_PPC64_ADDR16_HIGHESTA:
6738     case R_PPC64_ADDR16_LO:
6739     case R_PPC64_ADDR16_LO_DS:
6740     case R_PPC64_ADDR24:
6741     case R_PPC64_ADDR32:
6742     case R_PPC64_UADDR16:
6743     case R_PPC64_UADDR32:
6744     case R_PPC64_UADDR64:
6745     case R_PPC64_TOC:
6746       break;
6747     }
6748
6749   if (local_syms != NULL)
6750     {
6751       unsigned long r_symndx;
6752       Elf_Internal_Sym *sym;
6753       bfd *ibfd = sec->owner;
6754
6755       r_symndx = ELF64_R_SYM (r_info);
6756       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6757         return FALSE;
6758     }
6759
6760   if ((info->shared
6761        && (must_be_dyn_reloc (info, r_type)
6762            || (h != NULL
6763                && (!info->symbolic
6764                    || h->root.type == bfd_link_hash_defweak
6765                    || !h->def_regular))))
6766       || (ELIMINATE_COPY_RELOCS
6767           && !info->shared
6768           && h != NULL
6769           && (h->root.type == bfd_link_hash_defweak
6770               || !h->def_regular)))
6771     ;
6772   else
6773     return TRUE;
6774
6775   if (h != NULL)
6776     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6777   else
6778     {
6779       if (sym_sec != NULL)
6780         {
6781           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6782           pp = (struct ppc_dyn_relocs **) vpp;
6783         }
6784       else
6785         {
6786           void *vpp = &elf_section_data (sec)->local_dynrel;
6787           pp = (struct ppc_dyn_relocs **) vpp;
6788         }
6789
6790       /* elf_gc_sweep may have already removed all dyn relocs associated
6791          with local syms for a given section.  Don't report a dynreloc
6792          miscount.  */
6793       if (*pp == NULL)
6794         return TRUE;
6795     }
6796
6797   while ((p = *pp) != NULL)
6798     {
6799       if (p->sec == sec)
6800         {
6801           if (!must_be_dyn_reloc (info, r_type))
6802             p->pc_count -= 1;
6803           p->count -= 1;
6804           if (p->count == 0)
6805             *pp = p->next;
6806           return TRUE;
6807         }
6808       pp = &p->next;
6809     }
6810
6811   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6812                            sec->owner, sec);
6813   bfd_set_error (bfd_error_bad_value);
6814   return FALSE;
6815 }
6816
6817 /* Remove unused Official Procedure Descriptor entries.  Currently we
6818    only remove those associated with functions in discarded link-once
6819    sections, or weakly defined functions that have been overridden.  It
6820    would be possible to remove many more entries for statically linked
6821    applications.  */
6822
6823 bfd_boolean
6824 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6825                     bfd_boolean non_overlapping)
6826 {
6827   bfd *ibfd;
6828   bfd_boolean some_edited = FALSE;
6829   asection *need_pad = NULL;
6830
6831   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6832     {
6833       asection *sec;
6834       Elf_Internal_Rela *relstart, *rel, *relend;
6835       Elf_Internal_Shdr *symtab_hdr;
6836       Elf_Internal_Sym *local_syms;
6837       struct elf_link_hash_entry **sym_hashes;
6838       bfd_vma offset;
6839       struct _opd_sec_data *opd;
6840       bfd_boolean need_edit, add_aux_fields;
6841       bfd_size_type cnt_16b = 0;
6842
6843       sec = bfd_get_section_by_name (ibfd, ".opd");
6844       if (sec == NULL || sec->size == 0)
6845         continue;
6846
6847       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6848         continue;
6849
6850       if (sec->output_section == bfd_abs_section_ptr)
6851         continue;
6852
6853       /* Look through the section relocs.  */
6854       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6855         continue;
6856
6857       local_syms = NULL;
6858       symtab_hdr = &elf_symtab_hdr (ibfd);
6859       sym_hashes = elf_sym_hashes (ibfd);
6860
6861       /* Read the relocations.  */
6862       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6863                                             info->keep_memory);
6864       if (relstart == NULL)
6865         return FALSE;
6866
6867       /* First run through the relocs to check they are sane, and to
6868          determine whether we need to edit this opd section.  */
6869       need_edit = FALSE;
6870       need_pad = sec;
6871       offset = 0;
6872       relend = relstart + sec->reloc_count;
6873       for (rel = relstart; rel < relend; )
6874         {
6875           enum elf_ppc64_reloc_type r_type;
6876           unsigned long r_symndx;
6877           asection *sym_sec;
6878           struct elf_link_hash_entry *h;
6879           Elf_Internal_Sym *sym;
6880
6881           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6882              only interested in the reloc pointing to a function entry
6883              point.  */
6884           if (rel->r_offset != offset
6885               || rel + 1 >= relend
6886               || (rel + 1)->r_offset != offset + 8)
6887             {
6888               /* If someone messes with .opd alignment then after a
6889                  "ld -r" we might have padding in the middle of .opd.
6890                  Also, there's nothing to prevent someone putting
6891                  something silly in .opd with the assembler.  No .opd
6892                  optimization for them!  */
6893             broken_opd:
6894               (*_bfd_error_handler)
6895                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6896               need_edit = FALSE;
6897               break;
6898             }
6899
6900           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6901               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6902             {
6903               (*_bfd_error_handler)
6904                 (_("%B: unexpected reloc type %u in .opd section"),
6905                  ibfd, r_type);
6906               need_edit = FALSE;
6907               break;
6908             }
6909
6910           r_symndx = ELF64_R_SYM (rel->r_info);
6911           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6912                           r_symndx, ibfd))
6913             goto error_ret;
6914
6915           if (sym_sec == NULL || sym_sec->owner == NULL)
6916             {
6917               const char *sym_name;
6918               if (h != NULL)
6919                 sym_name = h->root.root.string;
6920               else
6921                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6922                                              sym_sec);
6923
6924               (*_bfd_error_handler)
6925                 (_("%B: undefined sym `%s' in .opd section"),
6926                  ibfd, sym_name);
6927               need_edit = FALSE;
6928               break;
6929             }
6930
6931           /* opd entries are always for functions defined in the
6932              current input bfd.  If the symbol isn't defined in the
6933              input bfd, then we won't be using the function in this
6934              bfd;  It must be defined in a linkonce section in another
6935              bfd, or is weak.  It's also possible that we are
6936              discarding the function due to a linker script /DISCARD/,
6937              which we test for via the output_section.  */
6938           if (sym_sec->owner != ibfd
6939               || sym_sec->output_section == bfd_abs_section_ptr)
6940             need_edit = TRUE;
6941
6942           rel += 2;
6943           if (rel == relend
6944               || (rel + 1 == relend && rel->r_offset == offset + 16))
6945             {
6946               if (sec->size == offset + 24)
6947                 {
6948                   need_pad = NULL;
6949                   break;
6950                 }
6951               if (rel == relend && sec->size == offset + 16)
6952                 {
6953                   cnt_16b++;
6954                   break;
6955                 }
6956               goto broken_opd;
6957             }
6958
6959           if (rel->r_offset == offset + 24)
6960             offset += 24;
6961           else if (rel->r_offset != offset + 16)
6962             goto broken_opd;
6963           else if (rel + 1 < relend
6964                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6965                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6966             {
6967               offset += 16;
6968               cnt_16b++;
6969             }
6970           else if (rel + 2 < relend
6971                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6972                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6973             {
6974               offset += 24;
6975               rel += 1;
6976             }
6977           else
6978             goto broken_opd;
6979         }
6980
6981       add_aux_fields = non_overlapping && cnt_16b > 0;
6982
6983       if (need_edit || add_aux_fields)
6984         {
6985           Elf_Internal_Rela *write_rel;
6986           bfd_byte *rptr, *wptr;
6987           bfd_byte *new_contents;
6988           bfd_boolean skip;
6989           long opd_ent_size;
6990           bfd_size_type amt;
6991
6992           new_contents = NULL;
6993           amt = sec->size * sizeof (long) / 8;
6994           opd = &ppc64_elf_section_data (sec)->u.opd;
6995           opd->adjust = bfd_zalloc (obfd, amt);
6996           if (opd->adjust == NULL)
6997             return FALSE;
6998           ppc64_elf_section_data (sec)->sec_type = sec_opd;
6999
7000           /* This seems a waste of time as input .opd sections are all
7001              zeros as generated by gcc, but I suppose there's no reason
7002              this will always be so.  We might start putting something in
7003              the third word of .opd entries.  */
7004           if ((sec->flags & SEC_IN_MEMORY) == 0)
7005             {
7006               bfd_byte *loc;
7007               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7008                 {
7009                   if (loc != NULL)
7010                     free (loc);
7011                 error_ret:
7012                   if (local_syms != NULL
7013                       && symtab_hdr->contents != (unsigned char *) local_syms)
7014                     free (local_syms);
7015                   if (elf_section_data (sec)->relocs != relstart)
7016                     free (relstart);
7017                   return FALSE;
7018                 }
7019               sec->contents = loc;
7020               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7021             }
7022
7023           elf_section_data (sec)->relocs = relstart;
7024
7025           new_contents = sec->contents;
7026           if (add_aux_fields)
7027             {
7028               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7029               if (new_contents == NULL)
7030                 return FALSE;
7031               need_pad = FALSE;
7032             }
7033           wptr = new_contents;
7034           rptr = sec->contents;
7035
7036           write_rel = relstart;
7037           skip = FALSE;
7038           offset = 0;
7039           opd_ent_size = 0;
7040           for (rel = relstart; rel < relend; rel++)
7041             {
7042               unsigned long r_symndx;
7043               asection *sym_sec;
7044               struct elf_link_hash_entry *h;
7045               Elf_Internal_Sym *sym;
7046
7047               r_symndx = ELF64_R_SYM (rel->r_info);
7048               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7049                               r_symndx, ibfd))
7050                 goto error_ret;
7051
7052               if (rel->r_offset == offset)
7053                 {
7054                   struct ppc_link_hash_entry *fdh = NULL;
7055
7056                   /* See if the .opd entry is full 24 byte or
7057                      16 byte (with fd_aux entry overlapped with next
7058                      fd_func).  */
7059                   opd_ent_size = 24;
7060                   if ((rel + 2 == relend && sec->size == offset + 16)
7061                       || (rel + 3 < relend
7062                           && rel[2].r_offset == offset + 16
7063                           && rel[3].r_offset == offset + 24
7064                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7065                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7066                     opd_ent_size = 16;
7067
7068                   if (h != NULL
7069                       && h->root.root.string[0] == '.')
7070                     {
7071                       fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7072                                         ppc_hash_table (info));
7073                       if (fdh != NULL
7074                           && fdh->elf.root.type != bfd_link_hash_defined
7075                           && fdh->elf.root.type != bfd_link_hash_defweak)
7076                         fdh = NULL;
7077                     }
7078
7079                   skip = (sym_sec->owner != ibfd
7080                           || sym_sec->output_section == bfd_abs_section_ptr);
7081                   if (skip)
7082                     {
7083                       if (fdh != NULL && sym_sec->owner == ibfd)
7084                         {
7085                           /* Arrange for the function descriptor sym
7086                              to be dropped.  */
7087                           fdh->elf.root.u.def.value = 0;
7088                           fdh->elf.root.u.def.section = sym_sec;
7089                         }
7090                       opd->adjust[rel->r_offset / 8] = -1;
7091                     }
7092                   else
7093                     {
7094                       /* We'll be keeping this opd entry.  */
7095
7096                       if (fdh != NULL)
7097                         {
7098                           /* Redefine the function descriptor symbol to
7099                              this location in the opd section.  It is
7100                              necessary to update the value here rather
7101                              than using an array of adjustments as we do
7102                              for local symbols, because various places
7103                              in the generic ELF code use the value
7104                              stored in u.def.value.  */
7105                           fdh->elf.root.u.def.value = wptr - new_contents;
7106                           fdh->adjust_done = 1;
7107                         }
7108
7109                       /* Local syms are a bit tricky.  We could
7110                          tweak them as they can be cached, but
7111                          we'd need to look through the local syms
7112                          for the function descriptor sym which we
7113                          don't have at the moment.  So keep an
7114                          array of adjustments.  */
7115                       opd->adjust[rel->r_offset / 8]
7116                         = (wptr - new_contents) - (rptr - sec->contents);
7117
7118                       if (wptr != rptr)
7119                         memcpy (wptr, rptr, opd_ent_size);
7120                       wptr += opd_ent_size;
7121                       if (add_aux_fields && opd_ent_size == 16)
7122                         {
7123                           memset (wptr, '\0', 8);
7124                           wptr += 8;
7125                         }
7126                     }
7127                   rptr += opd_ent_size;
7128                   offset += opd_ent_size;
7129                 }
7130
7131               if (skip)
7132                 {
7133                   if (!NO_OPD_RELOCS
7134                       && !info->relocatable
7135                       && !dec_dynrel_count (rel->r_info, sec, info,
7136                                             NULL, h, sym_sec))
7137                     goto error_ret;
7138                 }
7139               else
7140                 {
7141                   /* We need to adjust any reloc offsets to point to the
7142                      new opd entries.  While we're at it, we may as well
7143                      remove redundant relocs.  */
7144                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7145                   if (write_rel != rel)
7146                     memcpy (write_rel, rel, sizeof (*rel));
7147                   ++write_rel;
7148                 }
7149             }
7150
7151           sec->size = wptr - new_contents;
7152           sec->reloc_count = write_rel - relstart;
7153           if (add_aux_fields)
7154             {
7155               free (sec->contents);
7156               sec->contents = new_contents;
7157             }
7158
7159           /* Fudge the header size too, as this is used later in
7160              elf_bfd_final_link if we are emitting relocs.  */
7161           elf_section_data (sec)->rel_hdr.sh_size
7162             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7163           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7164           some_edited = TRUE;
7165         }
7166       else if (elf_section_data (sec)->relocs != relstart)
7167         free (relstart);
7168
7169       if (local_syms != NULL
7170           && symtab_hdr->contents != (unsigned char *) local_syms)
7171         {
7172           if (!info->keep_memory)
7173             free (local_syms);
7174           else
7175             symtab_hdr->contents = (unsigned char *) local_syms;
7176         }
7177     }
7178
7179   if (some_edited)
7180     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7181
7182   /* If we are doing a final link and the last .opd entry is just 16 byte
7183      long, add a 8 byte padding after it.  */
7184   if (need_pad != NULL && !info->relocatable)
7185     {
7186       bfd_byte *p;
7187
7188       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7189         {
7190           BFD_ASSERT (need_pad->size > 0);
7191
7192           p = bfd_malloc (need_pad->size + 8);
7193           if (p == NULL)
7194             return FALSE;
7195
7196           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7197                                           p, 0, need_pad->size))
7198             return FALSE;
7199
7200           need_pad->contents = p;
7201           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7202         }
7203       else
7204         {
7205           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7206           if (p == NULL)
7207             return FALSE;
7208
7209           need_pad->contents = p;
7210         }
7211
7212       memset (need_pad->contents + need_pad->size, 0, 8);
7213       need_pad->size += 8;
7214     }
7215
7216   return TRUE;
7217 }
7218
7219 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7220
7221 asection *
7222 ppc64_elf_tls_setup (bfd *obfd,
7223                      struct bfd_link_info *info,
7224                      int no_tls_get_addr_opt)
7225 {
7226   struct ppc_link_hash_table *htab;
7227
7228   htab = ppc_hash_table (info);
7229   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7230                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7231                                               FALSE, FALSE, TRUE));
7232   /* Move dynamic linking info to the function descriptor sym.  */
7233   if (htab->tls_get_addr != NULL)
7234     func_desc_adjust (&htab->tls_get_addr->elf, info);
7235   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7236                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7237                                                  FALSE, FALSE, TRUE));
7238   if (!no_tls_get_addr_opt)
7239     {
7240       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7241
7242       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7243                                   FALSE, FALSE, TRUE);
7244       if (opt != NULL)
7245         func_desc_adjust (opt, info);
7246       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7247                                      FALSE, FALSE, TRUE);
7248       if (opt_fd != NULL
7249           && (opt_fd->root.type == bfd_link_hash_defined
7250               || opt_fd->root.type == bfd_link_hash_defweak))
7251         {
7252           /* If glibc supports an optimized __tls_get_addr call stub,
7253              signalled by the presence of __tls_get_addr_opt, and we'll
7254              be calling __tls_get_addr via a plt call stub, then
7255              make __tls_get_addr point to __tls_get_addr_opt.  */
7256           tga_fd = &htab->tls_get_addr_fd->elf;
7257           if (htab->elf.dynamic_sections_created
7258               && tga_fd != NULL
7259               && (tga_fd->type == STT_FUNC
7260                   || tga_fd->needs_plt)
7261               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7262                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7263                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7264             {
7265               struct plt_entry *ent;
7266
7267               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7268                 if (ent->plt.refcount > 0)
7269                   break;
7270               if (ent != NULL)
7271                 {
7272                   tga_fd->root.type = bfd_link_hash_indirect;
7273                   tga_fd->root.u.i.link = &opt_fd->root;
7274                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7275                   if (opt_fd->dynindx != -1)
7276                     {
7277                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7278                       opt_fd->dynindx = -1;
7279                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7280                                               opt_fd->dynstr_index);
7281                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7282                         return FALSE;
7283                     }
7284                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7285                   tga = &htab->tls_get_addr->elf;
7286                   if (opt != NULL && tga != NULL)
7287                     {
7288                       tga->root.type = bfd_link_hash_indirect;
7289                       tga->root.u.i.link = &opt->root;
7290                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7291                       _bfd_elf_link_hash_hide_symbol (info, opt,
7292                                                       tga->forced_local);
7293                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7294                     }
7295                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7296                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7297                   if (htab->tls_get_addr != NULL)
7298                     {
7299                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7300                       htab->tls_get_addr->is_func = 1;
7301                     }
7302                 }
7303             }
7304         }
7305       else
7306         no_tls_get_addr_opt = TRUE;
7307     }
7308   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7309   return _bfd_elf_tls_setup (obfd, info);
7310 }
7311
7312 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7313    HASH1 or HASH2.  */
7314
7315 static bfd_boolean
7316 branch_reloc_hash_match (const bfd *ibfd,
7317                          const Elf_Internal_Rela *rel,
7318                          const struct ppc_link_hash_entry *hash1,
7319                          const struct ppc_link_hash_entry *hash2)
7320 {
7321   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7322   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7323   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7324
7325   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7326     {
7327       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7328       struct elf_link_hash_entry *h;
7329
7330       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7331       h = elf_follow_link (h);
7332       if (h == &hash1->elf || h == &hash2->elf)
7333         return TRUE;
7334     }
7335   return FALSE;
7336 }
7337
7338 /* Run through all the TLS relocs looking for optimization
7339    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7340    a preliminary section layout so that we know the TLS segment
7341    offsets.  We can't optimize earlier because some optimizations need
7342    to know the tp offset, and we need to optimize before allocating
7343    dynamic relocations.  */
7344
7345 bfd_boolean
7346 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7347 {
7348   bfd *ibfd;
7349   asection *sec;
7350   struct ppc_link_hash_table *htab;
7351   int pass;
7352
7353   if (info->relocatable || !info->executable)
7354     return TRUE;
7355
7356   htab = ppc_hash_table (info);
7357   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7358     {
7359       Elf_Internal_Sym *locsyms = NULL;
7360       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7361       unsigned char *toc_ref = NULL;
7362
7363       /* Look at all the sections for this file.  Make two passes over
7364          the relocs.  On the first pass, mark toc entries involved
7365          with tls relocs, and check that tls relocs involved in
7366          setting up a tls_get_addr call are indeed followed by such a
7367          call.  If they are not, exclude them from the optimizations
7368          done on the second pass.  */
7369       for (pass = 0; pass < 2; ++pass)
7370         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7371           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7372             {
7373               Elf_Internal_Rela *relstart, *rel, *relend;
7374
7375               /* Read the relocations.  */
7376               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7377                                                     info->keep_memory);
7378               if (relstart == NULL)
7379                 return FALSE;
7380
7381               relend = relstart + sec->reloc_count;
7382               for (rel = relstart; rel < relend; rel++)
7383                 {
7384                   enum elf_ppc64_reloc_type r_type;
7385                   unsigned long r_symndx;
7386                   struct elf_link_hash_entry *h;
7387                   Elf_Internal_Sym *sym;
7388                   asection *sym_sec;
7389                   char *tls_mask;
7390                   char tls_set, tls_clear, tls_type = 0;
7391                   bfd_vma value;
7392                   bfd_boolean ok_tprel, is_local;
7393                   long toc_ref_index = 0;
7394                   int expecting_tls_get_addr = 0;
7395
7396                   r_symndx = ELF64_R_SYM (rel->r_info);
7397                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7398                                   r_symndx, ibfd))
7399                     {
7400                     err_free_rel:
7401                       if (elf_section_data (sec)->relocs != relstart)
7402                         free (relstart);
7403                       if (toc_ref != NULL)
7404                         free (toc_ref);
7405                       if (locsyms != NULL
7406                           && (elf_symtab_hdr (ibfd).contents
7407                               != (unsigned char *) locsyms))
7408                         free (locsyms);
7409                       return FALSE;
7410                     }
7411
7412                   if (h != NULL)
7413                     {
7414                       if (h->root.type == bfd_link_hash_defined
7415                           || h->root.type == bfd_link_hash_defweak)
7416                         value = h->root.u.def.value;
7417                       else if (h->root.type == bfd_link_hash_undefweak)
7418                         value = 0;
7419                       else
7420                         continue;
7421                     }
7422                   else
7423                     /* Symbols referenced by TLS relocs must be of type
7424                        STT_TLS.  So no need for .opd local sym adjust.  */
7425                     value = sym->st_value;
7426
7427                   ok_tprel = FALSE;
7428                   is_local = FALSE;
7429                   if (h == NULL
7430                       || !h->def_dynamic)
7431                     {
7432                       is_local = TRUE;
7433                       if (h != NULL
7434                           && h->root.type == bfd_link_hash_undefweak)
7435                         ok_tprel = TRUE;
7436                       else
7437                         {
7438                           value += sym_sec->output_offset;
7439                           value += sym_sec->output_section->vma;
7440                           value -= htab->elf.tls_sec->vma;
7441                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7442                                       < (bfd_vma) 1 << 32);
7443                         }
7444                     }
7445
7446                   r_type = ELF64_R_TYPE (rel->r_info);
7447                   switch (r_type)
7448                     {
7449                     case R_PPC64_GOT_TLSLD16:
7450                     case R_PPC64_GOT_TLSLD16_LO:
7451                       expecting_tls_get_addr = 1;
7452                       /* Fall thru */
7453
7454                     case R_PPC64_GOT_TLSLD16_HI:
7455                     case R_PPC64_GOT_TLSLD16_HA:
7456                       /* These relocs should never be against a symbol
7457                          defined in a shared lib.  Leave them alone if
7458                          that turns out to be the case.  */
7459                       if (!is_local)
7460                         continue;
7461
7462                       /* LD -> LE */
7463                       tls_set = 0;
7464                       tls_clear = TLS_LD;
7465                       tls_type = TLS_TLS | TLS_LD;
7466                       break;
7467
7468                     case R_PPC64_GOT_TLSGD16:
7469                     case R_PPC64_GOT_TLSGD16_LO:
7470                       expecting_tls_get_addr = 1;
7471                       /* Fall thru */
7472
7473                     case R_PPC64_GOT_TLSGD16_HI:
7474                     case R_PPC64_GOT_TLSGD16_HA:
7475                       if (ok_tprel)
7476                         /* GD -> LE */
7477                         tls_set = 0;
7478                       else
7479                         /* GD -> IE */
7480                         tls_set = TLS_TLS | TLS_TPRELGD;
7481                       tls_clear = TLS_GD;
7482                       tls_type = TLS_TLS | TLS_GD;
7483                       break;
7484
7485                     case R_PPC64_GOT_TPREL16_DS:
7486                     case R_PPC64_GOT_TPREL16_LO_DS:
7487                     case R_PPC64_GOT_TPREL16_HI:
7488                     case R_PPC64_GOT_TPREL16_HA:
7489                       if (ok_tprel)
7490                         {
7491                           /* IE -> LE */
7492                           tls_set = 0;
7493                           tls_clear = TLS_TPREL;
7494                           tls_type = TLS_TLS | TLS_TPREL;
7495                           break;
7496                         }
7497                       continue;
7498
7499                     case R_PPC64_TOC16:
7500                     case R_PPC64_TOC16_LO:
7501                     case R_PPC64_TLS:
7502                     case R_PPC64_TLSGD:
7503                     case R_PPC64_TLSLD:
7504                       if (sym_sec == NULL || sym_sec != toc)
7505                         continue;
7506
7507                       /* Mark this toc entry as referenced by a TLS
7508                          code sequence.  We can do that now in the
7509                          case of R_PPC64_TLS, and after checking for
7510                          tls_get_addr for the TOC16 relocs.  */
7511                       if (toc_ref == NULL)
7512                         {
7513                           toc_ref = bfd_zmalloc (toc->size / 8);
7514                           if (toc_ref == NULL)
7515                             goto err_free_rel;
7516                         }
7517                       if (h != NULL)
7518                         value = h->root.u.def.value;
7519                       else
7520                         value = sym->st_value;
7521                       value += rel->r_addend;
7522                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7523                       toc_ref_index = value / 8;
7524                       if (r_type == R_PPC64_TLS
7525                           || r_type == R_PPC64_TLSGD
7526                           || r_type == R_PPC64_TLSLD)
7527                         {
7528                           toc_ref[toc_ref_index] = 1;
7529                           continue;
7530                         }
7531
7532                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7533                         continue;
7534
7535                       tls_set = 0;
7536                       tls_clear = 0;
7537                       expecting_tls_get_addr = 2;
7538                       break;
7539
7540                     case R_PPC64_TPREL64:
7541                       if (pass == 0
7542                           || sec != toc
7543                           || toc_ref == NULL
7544                           || !toc_ref[rel->r_offset / 8])
7545                         continue;
7546                       if (ok_tprel)
7547                         {
7548                           /* IE -> LE */
7549                           tls_set = TLS_EXPLICIT;
7550                           tls_clear = TLS_TPREL;
7551                           break;
7552                         }
7553                       continue;
7554
7555                     case R_PPC64_DTPMOD64:
7556                       if (pass == 0
7557                           || sec != toc
7558                           || toc_ref == NULL
7559                           || !toc_ref[rel->r_offset / 8])
7560                         continue;
7561                       if (rel + 1 < relend
7562                           && (rel[1].r_info
7563                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7564                           && rel[1].r_offset == rel->r_offset + 8)
7565                         {
7566                           if (ok_tprel)
7567                             /* GD -> LE */
7568                             tls_set = TLS_EXPLICIT | TLS_GD;
7569                           else
7570                             /* GD -> IE */
7571                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7572                           tls_clear = TLS_GD;
7573                         }
7574                       else
7575                         {
7576                           if (!is_local)
7577                             continue;
7578
7579                           /* LD -> LE */
7580                           tls_set = TLS_EXPLICIT;
7581                           tls_clear = TLS_LD;
7582                         }
7583                       break;
7584
7585                     default:
7586                       continue;
7587                     }
7588
7589                   if (pass == 0)
7590                     {
7591                       if (!expecting_tls_get_addr
7592                           || !sec->has_tls_get_addr_call)
7593                         continue;
7594
7595                       if (rel + 1 < relend
7596                           && branch_reloc_hash_match (ibfd, rel + 1,
7597                                                       htab->tls_get_addr,
7598                                                       htab->tls_get_addr_fd))
7599                         {
7600                           if (expecting_tls_get_addr == 2)
7601                             {
7602                               /* Check for toc tls entries.  */
7603                               char *toc_tls;
7604                               int retval;
7605
7606                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7607                                                      &locsyms,
7608                                                      rel, ibfd);
7609                               if (retval == 0)
7610                                 goto err_free_rel;
7611                               if (retval > 1 && toc_tls != NULL)
7612                                 toc_ref[toc_ref_index] = 1;
7613                             }
7614                           continue;
7615                         }
7616
7617                       if (expecting_tls_get_addr != 1)
7618                         continue;
7619
7620                       /* Uh oh, we didn't find the expected call.  We
7621                          could just mark this symbol to exclude it
7622                          from tls optimization but it's safer to skip
7623                          the entire section.  */
7624                       sec->has_tls_reloc = 0;
7625                       break;
7626                     }
7627
7628                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7629                     {
7630                       struct plt_entry *ent;
7631                       for (ent = htab->tls_get_addr->elf.plt.plist;
7632                            ent != NULL;
7633                            ent = ent->next)
7634                         if (ent->addend == 0)
7635                           {
7636                             if (ent->plt.refcount > 0)
7637                               {
7638                                 ent->plt.refcount -= 1;
7639                                 expecting_tls_get_addr = 0;
7640                               }
7641                             break;
7642                           }
7643                     }
7644
7645                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7646                     {
7647                       struct plt_entry *ent;
7648                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7649                            ent != NULL;
7650                            ent = ent->next)
7651                         if (ent->addend == 0)
7652                           {
7653                             if (ent->plt.refcount > 0)
7654                               ent->plt.refcount -= 1;
7655                             break;
7656                           }
7657                     }
7658
7659                   if (tls_clear == 0)
7660                     continue;
7661
7662                   if ((tls_set & TLS_EXPLICIT) == 0)
7663                     {
7664                       struct got_entry *ent;
7665
7666                       /* Adjust got entry for this reloc.  */
7667                       if (h != NULL)
7668                         ent = h->got.glist;
7669                       else
7670                         ent = elf_local_got_ents (ibfd)[r_symndx];
7671
7672                       for (; ent != NULL; ent = ent->next)
7673                         if (ent->addend == rel->r_addend
7674                             && ent->owner == ibfd
7675                             && ent->tls_type == tls_type)
7676                           break;
7677                       if (ent == NULL)
7678                         abort ();
7679
7680                       if (tls_set == 0)
7681                         {
7682                           /* We managed to get rid of a got entry.  */
7683                           if (ent->got.refcount > 0)
7684                             ent->got.refcount -= 1;
7685                         }
7686                     }
7687                   else
7688                     {
7689                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7690                          we'll lose one or two dyn relocs.  */
7691                       if (!dec_dynrel_count (rel->r_info, sec, info,
7692                                              NULL, h, sym_sec))
7693                         return FALSE;
7694
7695                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7696                         {
7697                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7698                                                  NULL, h, sym_sec))
7699                             return FALSE;
7700                         }
7701                     }
7702
7703                   *tls_mask |= tls_set;
7704                   *tls_mask &= ~tls_clear;
7705                 }
7706
7707               if (elf_section_data (sec)->relocs != relstart)
7708                 free (relstart);
7709             }
7710
7711       if (toc_ref != NULL)
7712         free (toc_ref);
7713
7714       if (locsyms != NULL
7715           && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7716         {
7717           if (!info->keep_memory)
7718             free (locsyms);
7719           else
7720             elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7721         }
7722     }
7723   return TRUE;
7724 }
7725
7726 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7727    the values of any global symbols in a toc section that has been
7728    edited.  Globals in toc sections should be a rarity, so this function
7729    sets a flag if any are found in toc sections other than the one just
7730    edited, so that futher hash table traversals can be avoided.  */
7731
7732 struct adjust_toc_info
7733 {
7734   asection *toc;
7735   unsigned long *skip;
7736   bfd_boolean global_toc_syms;
7737 };
7738
7739 static bfd_boolean
7740 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7741 {
7742   struct ppc_link_hash_entry *eh;
7743   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7744
7745   if (h->root.type == bfd_link_hash_indirect)
7746     return TRUE;
7747
7748   if (h->root.type == bfd_link_hash_warning)
7749     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7750
7751   if (h->root.type != bfd_link_hash_defined
7752       && h->root.type != bfd_link_hash_defweak)
7753     return TRUE;
7754
7755   eh = (struct ppc_link_hash_entry *) h;
7756   if (eh->adjust_done)
7757     return TRUE;
7758
7759   if (eh->elf.root.u.def.section == toc_inf->toc)
7760     {
7761       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7762       if (skip != (unsigned long) -1)
7763         eh->elf.root.u.def.value -= skip;
7764       else
7765         {
7766           (*_bfd_error_handler)
7767             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7768           eh->elf.root.u.def.section = &bfd_abs_section;
7769           eh->elf.root.u.def.value = 0;
7770         }
7771       eh->adjust_done = 1;
7772     }
7773   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7774     toc_inf->global_toc_syms = TRUE;
7775
7776   return TRUE;
7777 }
7778
7779 /* Examine all relocs referencing .toc sections in order to remove
7780    unused .toc entries.  */
7781
7782 bfd_boolean
7783 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7784 {
7785   bfd *ibfd;
7786   struct adjust_toc_info toc_inf;
7787
7788   toc_inf.global_toc_syms = TRUE;
7789   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7790     {
7791       asection *toc, *sec;
7792       Elf_Internal_Shdr *symtab_hdr;
7793       Elf_Internal_Sym *local_syms;
7794       struct elf_link_hash_entry **sym_hashes;
7795       Elf_Internal_Rela *relstart, *rel;
7796       unsigned long *skip, *drop;
7797       unsigned char *used;
7798       unsigned char *keep, last, some_unused;
7799
7800       toc = bfd_get_section_by_name (ibfd, ".toc");
7801       if (toc == NULL
7802           || toc->size == 0
7803           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7804           || elf_discarded_section (toc))
7805         continue;
7806
7807       local_syms = NULL;
7808       symtab_hdr = &elf_symtab_hdr (ibfd);
7809       sym_hashes = elf_sym_hashes (ibfd);
7810
7811       /* Look at sections dropped from the final link.  */
7812       skip = NULL;
7813       relstart = NULL;
7814       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7815         {
7816           if (sec->reloc_count == 0
7817               || !elf_discarded_section (sec)
7818               || get_opd_info (sec)
7819               || (sec->flags & SEC_ALLOC) == 0
7820               || (sec->flags & SEC_DEBUGGING) != 0)
7821             continue;
7822
7823           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7824           if (relstart == NULL)
7825             goto error_ret;
7826
7827           /* Run through the relocs to see which toc entries might be
7828              unused.  */
7829           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7830             {
7831               enum elf_ppc64_reloc_type r_type;
7832               unsigned long r_symndx;
7833               asection *sym_sec;
7834               struct elf_link_hash_entry *h;
7835               Elf_Internal_Sym *sym;
7836               bfd_vma val;
7837
7838               r_type = ELF64_R_TYPE (rel->r_info);
7839               switch (r_type)
7840                 {
7841                 default:
7842                   continue;
7843
7844                 case R_PPC64_TOC16:
7845                 case R_PPC64_TOC16_LO:
7846                 case R_PPC64_TOC16_HI:
7847                 case R_PPC64_TOC16_HA:
7848                 case R_PPC64_TOC16_DS:
7849                 case R_PPC64_TOC16_LO_DS:
7850                   break;
7851                 }
7852
7853               r_symndx = ELF64_R_SYM (rel->r_info);
7854               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7855                               r_symndx, ibfd))
7856                 goto error_ret;
7857
7858               if (sym_sec != toc)
7859                 continue;
7860
7861               if (h != NULL)
7862                 val = h->root.u.def.value;
7863               else
7864                 val = sym->st_value;
7865               val += rel->r_addend;
7866
7867               if (val >= toc->size)
7868                 continue;
7869
7870               /* Anything in the toc ought to be aligned to 8 bytes.
7871                  If not, don't mark as unused.  */
7872               if (val & 7)
7873                 continue;
7874
7875               if (skip == NULL)
7876                 {
7877                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7878                   if (skip == NULL)
7879                     goto error_ret;
7880                 }
7881
7882               skip[val >> 3] = 1;
7883             }
7884
7885           if (elf_section_data (sec)->relocs != relstart)
7886             free (relstart);
7887         }
7888
7889       if (skip == NULL)
7890         continue;
7891
7892       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7893       if (used == NULL)
7894         {
7895         error_ret:
7896           if (local_syms != NULL
7897               && symtab_hdr->contents != (unsigned char *) local_syms)
7898             free (local_syms);
7899           if (sec != NULL
7900               && relstart != NULL
7901               && elf_section_data (sec)->relocs != relstart)
7902             free (relstart);
7903           if (skip != NULL)
7904             free (skip);
7905           return FALSE;
7906         }
7907
7908       /* Now check all kept sections that might reference the toc.
7909          Check the toc itself last.  */
7910       for (sec = (ibfd->sections == toc && toc->next ? toc->next
7911                   : ibfd->sections);
7912            sec != NULL;
7913            sec = (sec == toc ? NULL
7914                   : sec->next == NULL ? toc
7915                   : sec->next == toc && toc->next ? toc->next
7916                   : sec->next))
7917         {
7918           int repeat;
7919
7920           if (sec->reloc_count == 0
7921               || elf_discarded_section (sec)
7922               || get_opd_info (sec)
7923               || (sec->flags & SEC_ALLOC) == 0
7924               || (sec->flags & SEC_DEBUGGING) != 0)
7925             continue;
7926
7927           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7928           if (relstart == NULL)
7929             goto error_ret;
7930
7931           /* Mark toc entries referenced as used.  */
7932           repeat = 0;
7933           do
7934             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7935               {
7936                 enum elf_ppc64_reloc_type r_type;
7937                 unsigned long r_symndx;
7938                 asection *sym_sec;
7939                 struct elf_link_hash_entry *h;
7940                 Elf_Internal_Sym *sym;
7941                 bfd_vma val;
7942
7943                 r_type = ELF64_R_TYPE (rel->r_info);
7944                 switch (r_type)
7945                   {
7946                   case R_PPC64_TOC16:
7947                   case R_PPC64_TOC16_LO:
7948                   case R_PPC64_TOC16_HI:
7949                   case R_PPC64_TOC16_HA:
7950                   case R_PPC64_TOC16_DS:
7951                   case R_PPC64_TOC16_LO_DS:
7952                     /* In case we're taking addresses of toc entries.  */
7953                   case R_PPC64_ADDR64:
7954                     break;
7955
7956                   default:
7957                     continue;
7958                   }
7959
7960                 r_symndx = ELF64_R_SYM (rel->r_info);
7961                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7962                                 r_symndx, ibfd))
7963                   {
7964                     free (used);
7965                     goto error_ret;
7966                   }
7967
7968                 if (sym_sec != toc)
7969                   continue;
7970
7971                 if (h != NULL)
7972                   val = h->root.u.def.value;
7973                 else
7974                   val = sym->st_value;
7975                 val += rel->r_addend;
7976
7977                 if (val >= toc->size)
7978                   continue;
7979
7980                 /* For the toc section, we only mark as used if
7981                    this entry itself isn't unused.  */
7982                 if (sec == toc
7983                     && !used[val >> 3]
7984                     && (used[rel->r_offset >> 3]
7985                         || !skip[rel->r_offset >> 3]))
7986                   /* Do all the relocs again, to catch reference
7987                      chains.  */
7988                   repeat = 1;
7989
7990                 used[val >> 3] = 1;
7991               }
7992           while (repeat);
7993         }
7994
7995       /* Merge the used and skip arrays.  Assume that TOC
7996          doublewords not appearing as either used or unused belong
7997          to to an entry more than one doubleword in size.  */
7998       for (drop = skip, keep = used, last = 0, some_unused = 0;
7999            drop < skip + (toc->size + 7) / 8;
8000            ++drop, ++keep)
8001         {
8002           if (*keep)
8003             {
8004               *drop = 0;
8005               last = 0;
8006             }
8007           else if (*drop)
8008             {
8009               some_unused = 1;
8010               last = 1;
8011             }
8012           else
8013             *drop = last;
8014         }
8015
8016       free (used);
8017
8018       if (some_unused)
8019         {
8020           bfd_byte *contents, *src;
8021           unsigned long off;
8022
8023           /* Shuffle the toc contents, and at the same time convert the
8024              skip array from booleans into offsets.  */
8025           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8026             goto error_ret;
8027
8028           elf_section_data (toc)->this_hdr.contents = contents;
8029
8030           for (src = contents, off = 0, drop = skip;
8031                src < contents + toc->size;
8032                src += 8, ++drop)
8033             {
8034               if (*drop)
8035                 {
8036                   *drop = (unsigned long) -1;
8037                   off += 8;
8038                 }
8039               else if (off != 0)
8040                 {
8041                   *drop = off;
8042                   memcpy (src - off, src, 8);
8043                 }
8044             }
8045           toc->rawsize = toc->size;
8046           toc->size = src - contents - off;
8047
8048           if (toc->reloc_count != 0)
8049             {
8050               Elf_Internal_Rela *wrel;
8051               bfd_size_type sz;
8052
8053               /* Read toc relocs.  */
8054               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8055                                                     TRUE);
8056               if (relstart == NULL)
8057                 goto error_ret;
8058
8059               /* Remove unused toc relocs, and adjust those we keep.  */
8060               wrel = relstart;
8061               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8062                 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
8063                   {
8064                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8065                     wrel->r_info = rel->r_info;
8066                     wrel->r_addend = rel->r_addend;
8067                     ++wrel;
8068                   }
8069                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8070                                             &local_syms, NULL, NULL))
8071                   goto error_ret;
8072
8073               toc->reloc_count = wrel - relstart;
8074               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
8075               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
8076               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
8077             }
8078
8079           /* Adjust addends for relocs against the toc section sym.  */
8080           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8081             {
8082               if (sec->reloc_count == 0
8083                   || elf_discarded_section (sec))
8084                 continue;
8085
8086               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8087                                                     TRUE);
8088               if (relstart == NULL)
8089                 goto error_ret;
8090
8091               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8092                 {
8093                   enum elf_ppc64_reloc_type r_type;
8094                   unsigned long r_symndx;
8095                   asection *sym_sec;
8096                   struct elf_link_hash_entry *h;
8097                   Elf_Internal_Sym *sym;
8098
8099                   r_type = ELF64_R_TYPE (rel->r_info);
8100                   switch (r_type)
8101                     {
8102                     default:
8103                       continue;
8104
8105                     case R_PPC64_TOC16:
8106                     case R_PPC64_TOC16_LO:
8107                     case R_PPC64_TOC16_HI:
8108                     case R_PPC64_TOC16_HA:
8109                     case R_PPC64_TOC16_DS:
8110                     case R_PPC64_TOC16_LO_DS:
8111                     case R_PPC64_ADDR64:
8112                       break;
8113                     }
8114
8115                   r_symndx = ELF64_R_SYM (rel->r_info);
8116                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8117                                   r_symndx, ibfd))
8118                     goto error_ret;
8119
8120                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
8121                     continue;
8122
8123                   rel->r_addend -= skip[rel->r_addend >> 3];
8124                 }
8125             }
8126
8127           /* We shouldn't have local or global symbols defined in the TOC,
8128              but handle them anyway.  */
8129           if (local_syms != NULL)
8130             {
8131               Elf_Internal_Sym *sym;
8132
8133               for (sym = local_syms;
8134                    sym < local_syms + symtab_hdr->sh_info;
8135                    ++sym)
8136                 if (sym->st_value != 0
8137                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8138                   {
8139                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
8140                       sym->st_value -= skip[sym->st_value >> 3];
8141                     else
8142                       {
8143                         (*_bfd_error_handler)
8144                           (_("%s defined in removed toc entry"),
8145                            bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8146                                              NULL));
8147                         sym->st_value = 0;
8148                         sym->st_shndx = SHN_ABS;
8149                       }
8150                     symtab_hdr->contents = (unsigned char *) local_syms;
8151                   }
8152             }
8153
8154           /* Finally, adjust any global syms defined in the toc.  */
8155           if (toc_inf.global_toc_syms)
8156             {
8157               toc_inf.toc = toc;
8158               toc_inf.skip = skip;
8159               toc_inf.global_toc_syms = FALSE;
8160               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8161                                       &toc_inf);
8162             }
8163         }
8164
8165       if (local_syms != NULL
8166           && symtab_hdr->contents != (unsigned char *) local_syms)
8167         {
8168           if (!info->keep_memory)
8169             free (local_syms);
8170           else
8171             symtab_hdr->contents = (unsigned char *) local_syms;
8172         }
8173       free (skip);
8174     }
8175
8176   return TRUE;
8177 }
8178
8179 /* Allocate space in .plt, .got and associated reloc sections for
8180    dynamic relocs.  */
8181
8182 static bfd_boolean
8183 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8184 {
8185   struct bfd_link_info *info;
8186   struct ppc_link_hash_table *htab;
8187   asection *s;
8188   struct ppc_link_hash_entry *eh;
8189   struct ppc_dyn_relocs *p;
8190   struct got_entry *gent;
8191
8192   if (h->root.type == bfd_link_hash_indirect)
8193     return TRUE;
8194
8195   if (h->root.type == bfd_link_hash_warning)
8196     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8197
8198   info = (struct bfd_link_info *) inf;
8199   htab = ppc_hash_table (info);
8200
8201   if ((htab->elf.dynamic_sections_created
8202        && h->dynindx != -1
8203        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8204       || h->type == STT_GNU_IFUNC)
8205     {
8206       struct plt_entry *pent;
8207       bfd_boolean doneone = FALSE;
8208       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8209         if (pent->plt.refcount > 0)
8210           {
8211             if (!htab->elf.dynamic_sections_created
8212                 || h->dynindx == -1)
8213               {
8214                 s = htab->iplt;
8215                 pent->plt.offset = s->size;
8216                 s->size += PLT_ENTRY_SIZE;
8217                 s = htab->reliplt;
8218               }
8219             else
8220               {
8221                 /* If this is the first .plt entry, make room for the special
8222                    first entry.  */
8223                 s = htab->plt;
8224                 if (s->size == 0)
8225                   s->size += PLT_INITIAL_ENTRY_SIZE;
8226
8227                 pent->plt.offset = s->size;
8228
8229                 /* Make room for this entry.  */
8230                 s->size += PLT_ENTRY_SIZE;
8231
8232                 /* Make room for the .glink code.  */
8233                 s = htab->glink;
8234                 if (s->size == 0)
8235                   s->size += GLINK_CALL_STUB_SIZE;
8236                 /* We need bigger stubs past index 32767.  */
8237                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8238                   s->size += 4;
8239                 s->size += 2*4;
8240
8241                 /* We also need to make an entry in the .rela.plt section.  */
8242                 s = htab->relplt;
8243               }
8244             s->size += sizeof (Elf64_External_Rela);
8245             doneone = TRUE;
8246           }
8247         else
8248           pent->plt.offset = (bfd_vma) -1;
8249       if (!doneone)
8250         {
8251           h->plt.plist = NULL;
8252           h->needs_plt = 0;
8253         }
8254     }
8255   else
8256     {
8257       h->plt.plist = NULL;
8258       h->needs_plt = 0;
8259     }
8260
8261   eh = (struct ppc_link_hash_entry *) h;
8262   /* Run through the TLS GD got entries first if we're changing them
8263      to TPREL.  */
8264   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8265     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8266       if (gent->got.refcount > 0
8267           && (gent->tls_type & TLS_GD) != 0)
8268         {
8269           /* This was a GD entry that has been converted to TPREL.  If
8270              there happens to be a TPREL entry we can use that one.  */
8271           struct got_entry *ent;
8272           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8273             if (ent->got.refcount > 0
8274                 && (ent->tls_type & TLS_TPREL) != 0
8275                 && ent->addend == gent->addend
8276                 && ent->owner == gent->owner)
8277               {
8278                 gent->got.refcount = 0;
8279                 break;
8280               }
8281
8282           /* If not, then we'll be using our own TPREL entry.  */
8283           if (gent->got.refcount != 0)
8284             gent->tls_type = TLS_TLS | TLS_TPREL;
8285         }
8286
8287   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8288     if (gent->got.refcount > 0)
8289       {
8290         bfd_boolean dyn;
8291         asection *rsec;
8292
8293         /* Make sure this symbol is output as a dynamic symbol.
8294            Undefined weak syms won't yet be marked as dynamic,
8295            nor will all TLS symbols.  */
8296         if (h->dynindx == -1
8297             && !h->forced_local
8298             && h->type != STT_GNU_IFUNC
8299             && htab->elf.dynamic_sections_created)
8300           {
8301             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8302               return FALSE;
8303           }
8304
8305         if ((gent->tls_type & TLS_LD) != 0
8306             && !h->def_dynamic)
8307           {
8308             ppc64_tlsld_got (gent->owner)->refcount += 1;
8309             gent->got.offset = (bfd_vma) -1;
8310             continue;
8311           }
8312
8313         if (!is_ppc64_elf (gent->owner))
8314           continue;
8315
8316         s = ppc64_elf_tdata (gent->owner)->got;
8317         gent->got.offset = s->size;
8318         s->size
8319           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
8320         dyn = htab->elf.dynamic_sections_created;
8321         rsec = NULL;
8322         if ((info->shared
8323              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8324             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8325                 || h->root.type != bfd_link_hash_undefweak))
8326           rsec = ppc64_elf_tdata (gent->owner)->relgot;
8327         else if (h->type == STT_GNU_IFUNC)
8328           rsec = htab->reliplt;
8329         if (rsec != NULL)
8330           rsec->size += (gent->tls_type & eh->tls_mask & TLS_GD
8331                          ? 2 * sizeof (Elf64_External_Rela)
8332                          : sizeof (Elf64_External_Rela));
8333       }
8334     else
8335       gent->got.offset = (bfd_vma) -1;
8336
8337   if (eh->dyn_relocs == NULL
8338       || (!htab->elf.dynamic_sections_created
8339           && h->type != STT_GNU_IFUNC))
8340     return TRUE;
8341
8342   /* In the shared -Bsymbolic case, discard space allocated for
8343      dynamic pc-relative relocs against symbols which turn out to be
8344      defined in regular objects.  For the normal shared case, discard
8345      space for relocs that have become local due to symbol visibility
8346      changes.  */
8347
8348   if (info->shared)
8349     {
8350       /* Relocs that use pc_count are those that appear on a call insn,
8351          or certain REL relocs (see must_be_dyn_reloc) that can be
8352          generated via assembly.  We want calls to protected symbols to
8353          resolve directly to the function rather than going via the plt.
8354          If people want function pointer comparisons to work as expected
8355          then they should avoid writing weird assembly.  */
8356       if (SYMBOL_CALLS_LOCAL (info, h))
8357         {
8358           struct ppc_dyn_relocs **pp;
8359
8360           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8361             {
8362               p->count -= p->pc_count;
8363               p->pc_count = 0;
8364               if (p->count == 0)
8365                 *pp = p->next;
8366               else
8367                 pp = &p->next;
8368             }
8369         }
8370
8371       /* Also discard relocs on undefined weak syms with non-default
8372          visibility.  */
8373       if (eh->dyn_relocs != NULL
8374           && h->root.type == bfd_link_hash_undefweak)
8375         {
8376           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8377             eh->dyn_relocs = NULL;
8378
8379           /* Make sure this symbol is output as a dynamic symbol.
8380              Undefined weak syms won't yet be marked as dynamic.  */
8381           else if (h->dynindx == -1
8382                    && !h->forced_local)
8383             {
8384               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8385                 return FALSE;
8386             }
8387         }
8388     }
8389   else if (h->type == STT_GNU_IFUNC)
8390     {
8391       if (!h->non_got_ref)
8392         eh->dyn_relocs = NULL;
8393     }
8394   else if (ELIMINATE_COPY_RELOCS)
8395     {
8396       /* For the non-shared case, discard space for relocs against
8397          symbols which turn out to need copy relocs or are not
8398          dynamic.  */
8399
8400       if (!h->non_got_ref
8401           && !h->def_regular)
8402         {
8403           /* Make sure this symbol is output as a dynamic symbol.
8404              Undefined weak syms won't yet be marked as dynamic.  */
8405           if (h->dynindx == -1
8406               && !h->forced_local)
8407             {
8408               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8409                 return FALSE;
8410             }
8411
8412           /* If that succeeded, we know we'll be keeping all the
8413              relocs.  */
8414           if (h->dynindx != -1)
8415             goto keep;
8416         }
8417
8418       eh->dyn_relocs = NULL;
8419
8420     keep: ;
8421     }
8422
8423   /* Finally, allocate space.  */
8424   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8425     {
8426       asection *sreloc = elf_section_data (p->sec)->sreloc;
8427       if (!htab->elf.dynamic_sections_created)
8428         sreloc = htab->reliplt;
8429       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8430     }
8431
8432   return TRUE;
8433 }
8434
8435 /* Find any dynamic relocs that apply to read-only sections.  */
8436
8437 static bfd_boolean
8438 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8439 {
8440   struct ppc_link_hash_entry *eh;
8441   struct ppc_dyn_relocs *p;
8442
8443   if (h->root.type == bfd_link_hash_warning)
8444     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8445
8446   eh = (struct ppc_link_hash_entry *) h;
8447   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8448     {
8449       asection *s = p->sec->output_section;
8450
8451       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8452         {
8453           struct bfd_link_info *info = inf;
8454
8455           info->flags |= DF_TEXTREL;
8456
8457           /* Not an error, just cut short the traversal.  */
8458           return FALSE;
8459         }
8460     }
8461   return TRUE;
8462 }
8463
8464 /* Set the sizes of the dynamic sections.  */
8465
8466 static bfd_boolean
8467 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8468                                  struct bfd_link_info *info)
8469 {
8470   struct ppc_link_hash_table *htab;
8471   bfd *dynobj;
8472   asection *s;
8473   bfd_boolean relocs;
8474   bfd *ibfd;
8475
8476   htab = ppc_hash_table (info);
8477   dynobj = htab->elf.dynobj;
8478   if (dynobj == NULL)
8479     abort ();
8480
8481   if (htab->elf.dynamic_sections_created)
8482     {
8483       /* Set the contents of the .interp section to the interpreter.  */
8484       if (info->executable)
8485         {
8486           s = bfd_get_section_by_name (dynobj, ".interp");
8487           if (s == NULL)
8488             abort ();
8489           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8490           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8491         }
8492     }
8493
8494   /* Set up .got offsets for local syms, and space for local dynamic
8495      relocs.  */
8496   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8497     {
8498       struct got_entry **lgot_ents;
8499       struct got_entry **end_lgot_ents;
8500       struct plt_entry **local_plt;
8501       struct plt_entry **end_local_plt;
8502       char *lgot_masks;
8503       bfd_size_type locsymcount;
8504       Elf_Internal_Shdr *symtab_hdr;
8505       asection *srel;
8506
8507       if (!is_ppc64_elf (ibfd))
8508         continue;
8509
8510       for (s = ibfd->sections; s != NULL; s = s->next)
8511         {
8512           struct ppc_dyn_relocs *p;
8513
8514           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8515             {
8516               if (!bfd_is_abs_section (p->sec)
8517                   && bfd_is_abs_section (p->sec->output_section))
8518                 {
8519                   /* Input section has been discarded, either because
8520                      it is a copy of a linkonce section or due to
8521                      linker script /DISCARD/, so we'll be discarding
8522                      the relocs too.  */
8523                 }
8524               else if (p->count != 0)
8525                 {
8526                   srel = elf_section_data (p->sec)->sreloc;
8527                   if (!htab->elf.dynamic_sections_created)
8528                     srel = htab->reliplt;
8529                   srel->size += p->count * sizeof (Elf64_External_Rela);
8530                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8531                     info->flags |= DF_TEXTREL;
8532                 }
8533             }
8534         }
8535
8536       lgot_ents = elf_local_got_ents (ibfd);
8537       if (!lgot_ents)
8538         continue;
8539
8540       symtab_hdr = &elf_symtab_hdr (ibfd);
8541       locsymcount = symtab_hdr->sh_info;
8542       end_lgot_ents = lgot_ents + locsymcount;
8543       local_plt = (struct plt_entry **) end_lgot_ents;
8544       end_local_plt = local_plt + locsymcount;
8545       lgot_masks = (char *) end_local_plt;
8546       s = ppc64_elf_tdata (ibfd)->got;
8547       srel = ppc64_elf_tdata (ibfd)->relgot;
8548       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8549         {
8550           struct got_entry *ent;
8551
8552           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8553             if (ent->got.refcount > 0)
8554               {
8555                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8556                   {
8557                     ppc64_tlsld_got (ibfd)->refcount += 1;
8558                     ent->got.offset = (bfd_vma) -1;
8559                   }
8560                 else
8561                   {
8562                     unsigned int num = 1;
8563                     ent->got.offset = s->size;
8564                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8565                       num = 2;
8566                     s->size += num * 8;
8567                     if (info->shared)
8568                       srel->size += num * sizeof (Elf64_External_Rela);
8569                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8570                       htab->reliplt->size += num * sizeof (Elf64_External_Rela);
8571                   }
8572               }
8573             else
8574               ent->got.offset = (bfd_vma) -1;
8575         }
8576
8577       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8578       for (; local_plt < end_local_plt; ++local_plt)
8579         {
8580           struct plt_entry *ent;
8581
8582           for (ent = *local_plt; ent != NULL; ent = ent->next)
8583             if (ent->plt.refcount > 0)
8584               {
8585                 s = htab->iplt;
8586                 ent->plt.offset = s->size;
8587                 s->size += PLT_ENTRY_SIZE;
8588
8589                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8590               }
8591             else
8592               ent->plt.offset = (bfd_vma) -1;
8593         }
8594     }
8595
8596   /* Allocate global sym .plt and .got entries, and space for global
8597      sym dynamic relocs.  */
8598   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8599
8600   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8601     {
8602       if (!is_ppc64_elf (ibfd))
8603         continue;
8604
8605       if (ppc64_tlsld_got (ibfd)->refcount > 0)
8606         {
8607           s = ppc64_elf_tdata (ibfd)->got;
8608           ppc64_tlsld_got (ibfd)->offset = s->size;
8609           s->size += 16;
8610           if (info->shared)
8611             {
8612               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8613               srel->size += sizeof (Elf64_External_Rela);
8614             }
8615         }
8616       else
8617         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8618     }
8619
8620   /* We now have determined the sizes of the various dynamic sections.
8621      Allocate memory for them.  */
8622   relocs = FALSE;
8623   for (s = dynobj->sections; s != NULL; s = s->next)
8624     {
8625       if ((s->flags & SEC_LINKER_CREATED) == 0)
8626         continue;
8627
8628       if (s == htab->brlt || s == htab->relbrlt)
8629         /* These haven't been allocated yet;  don't strip.  */
8630         continue;
8631       else if (s == htab->got
8632                || s == htab->plt
8633                || s == htab->iplt
8634                || s == htab->glink
8635                || s == htab->dynbss)
8636         {
8637           /* Strip this section if we don't need it; see the
8638              comment below.  */
8639         }
8640       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8641         {
8642           if (s->size != 0)
8643             {
8644               if (s != htab->relplt)
8645                 relocs = TRUE;
8646
8647               /* We use the reloc_count field as a counter if we need
8648                  to copy relocs into the output file.  */
8649               s->reloc_count = 0;
8650             }
8651         }
8652       else
8653         {
8654           /* It's not one of our sections, so don't allocate space.  */
8655           continue;
8656         }
8657
8658       if (s->size == 0)
8659         {
8660           /* If we don't need this section, strip it from the
8661              output file.  This is mostly to handle .rela.bss and
8662              .rela.plt.  We must create both sections in
8663              create_dynamic_sections, because they must be created
8664              before the linker maps input sections to output
8665              sections.  The linker does that before
8666              adjust_dynamic_symbol is called, and it is that
8667              function which decides whether anything needs to go
8668              into these sections.  */
8669           s->flags |= SEC_EXCLUDE;
8670           continue;
8671         }
8672
8673       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8674         continue;
8675
8676       /* Allocate memory for the section contents.  We use bfd_zalloc
8677          here in case unused entries are not reclaimed before the
8678          section's contents are written out.  This should not happen,
8679          but this way if it does we get a R_PPC64_NONE reloc in .rela
8680          sections instead of garbage.
8681          We also rely on the section contents being zero when writing
8682          the GOT.  */
8683       s->contents = bfd_zalloc (dynobj, s->size);
8684       if (s->contents == NULL)
8685         return FALSE;
8686     }
8687
8688   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8689     {
8690       if (!is_ppc64_elf (ibfd))
8691         continue;
8692
8693       s = ppc64_elf_tdata (ibfd)->got;
8694       if (s != NULL && s != htab->got)
8695         {
8696           if (s->size == 0)
8697             s->flags |= SEC_EXCLUDE;
8698           else
8699             {
8700               s->contents = bfd_zalloc (ibfd, s->size);
8701               if (s->contents == NULL)
8702                 return FALSE;
8703             }
8704         }
8705       s = ppc64_elf_tdata (ibfd)->relgot;
8706       if (s != NULL)
8707         {
8708           if (s->size == 0)
8709             s->flags |= SEC_EXCLUDE;
8710           else
8711             {
8712               s->contents = bfd_zalloc (ibfd, s->size);
8713               if (s->contents == NULL)
8714                 return FALSE;
8715               relocs = TRUE;
8716               s->reloc_count = 0;
8717             }
8718         }
8719     }
8720
8721   if (htab->elf.dynamic_sections_created)
8722     {
8723       /* Add some entries to the .dynamic section.  We fill in the
8724          values later, in ppc64_elf_finish_dynamic_sections, but we
8725          must add the entries now so that we get the correct size for
8726          the .dynamic section.  The DT_DEBUG entry is filled in by the
8727          dynamic linker and used by the debugger.  */
8728 #define add_dynamic_entry(TAG, VAL) \
8729   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8730
8731       if (info->executable)
8732         {
8733           if (!add_dynamic_entry (DT_DEBUG, 0))
8734             return FALSE;
8735         }
8736
8737       if (htab->plt != NULL && htab->plt->size != 0)
8738         {
8739           if (!add_dynamic_entry (DT_PLTGOT, 0)
8740               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8741               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8742               || !add_dynamic_entry (DT_JMPREL, 0)
8743               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8744             return FALSE;
8745         }
8746
8747       if (NO_OPD_RELOCS)
8748         {
8749           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8750               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8751             return FALSE;
8752         }
8753
8754       if (!htab->no_tls_get_addr_opt
8755           && htab->tls_get_addr_fd != NULL
8756           && htab->tls_get_addr_fd->elf.plt.plist != NULL
8757           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
8758         return FALSE;
8759
8760       if (relocs)
8761         {
8762           if (!add_dynamic_entry (DT_RELA, 0)
8763               || !add_dynamic_entry (DT_RELASZ, 0)
8764               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8765             return FALSE;
8766
8767           /* If any dynamic relocs apply to a read-only section,
8768              then we need a DT_TEXTREL entry.  */
8769           if ((info->flags & DF_TEXTREL) == 0)
8770             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8771
8772           if ((info->flags & DF_TEXTREL) != 0)
8773             {
8774               if (!add_dynamic_entry (DT_TEXTREL, 0))
8775                 return FALSE;
8776             }
8777         }
8778     }
8779 #undef add_dynamic_entry
8780
8781   return TRUE;
8782 }
8783
8784 /* Determine the type of stub needed, if any, for a call.  */
8785
8786 static inline enum ppc_stub_type
8787 ppc_type_of_stub (asection *input_sec,
8788                   const Elf_Internal_Rela *rel,
8789                   struct ppc_link_hash_entry **hash,
8790                   struct plt_entry **plt_ent,
8791                   bfd_vma destination)
8792 {
8793   struct ppc_link_hash_entry *h = *hash;
8794   bfd_vma location;
8795   bfd_vma branch_offset;
8796   bfd_vma max_branch_offset;
8797   enum elf_ppc64_reloc_type r_type;
8798
8799   if (h != NULL)
8800     {
8801       struct plt_entry *ent;
8802       struct ppc_link_hash_entry *fdh = h;
8803       if (h->oh != NULL
8804           && h->oh->is_func_descriptor)
8805         fdh = ppc_follow_link (h->oh);
8806
8807       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8808         if (ent->addend == rel->r_addend
8809             && ent->plt.offset != (bfd_vma) -1)
8810           {
8811             *hash = fdh;
8812             *plt_ent = ent;
8813             return ppc_stub_plt_call;
8814           }
8815
8816       /* Here, we know we don't have a plt entry.  If we don't have a
8817          either a defined function descriptor or a defined entry symbol
8818          in a regular object file, then it is pointless trying to make
8819          any other type of stub.  */
8820       if (!((fdh->elf.root.type == bfd_link_hash_defined
8821             || fdh->elf.root.type == bfd_link_hash_defweak)
8822             && fdh->elf.root.u.def.section->output_section != NULL)
8823           && !((h->elf.root.type == bfd_link_hash_defined
8824                 || h->elf.root.type == bfd_link_hash_defweak)
8825                && h->elf.root.u.def.section->output_section != NULL))
8826         return ppc_stub_none;
8827     }
8828   else if (elf_local_got_ents (input_sec->owner) != NULL)
8829     {
8830       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
8831       struct plt_entry **local_plt = (struct plt_entry **)
8832         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
8833       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
8834
8835       if (local_plt[r_symndx] != NULL)
8836         {
8837           struct plt_entry *ent;
8838
8839           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
8840             if (ent->addend == rel->r_addend
8841                 && ent->plt.offset != (bfd_vma) -1)
8842               {
8843                 *plt_ent = ent;
8844                 return ppc_stub_plt_call;
8845               }
8846         }
8847     }
8848
8849   /* Determine where the call point is.  */
8850   location = (input_sec->output_offset
8851               + input_sec->output_section->vma
8852               + rel->r_offset);
8853
8854   branch_offset = destination - location;
8855   r_type = ELF64_R_TYPE (rel->r_info);
8856
8857   /* Determine if a long branch stub is needed.  */
8858   max_branch_offset = 1 << 25;
8859   if (r_type != R_PPC64_REL24)
8860     max_branch_offset = 1 << 15;
8861
8862   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8863     /* We need a stub.  Figure out whether a long_branch or plt_branch
8864        is needed later.  */
8865     return ppc_stub_long_branch;
8866
8867   return ppc_stub_none;
8868 }
8869
8870 /* Build a .plt call stub.  */
8871
8872 static inline bfd_byte *
8873 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8874 {
8875 #define PPC_LO(v) ((v) & 0xffff)
8876 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8877 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8878
8879   if (PPC_HA (offset) != 0)
8880     {
8881       if (r != NULL)
8882         {
8883           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8884           r[1].r_offset = r[0].r_offset + 8;
8885           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8886           r[1].r_addend = r[0].r_addend;
8887           if (PPC_HA (offset + 16) != PPC_HA (offset))
8888             {
8889               r[2].r_offset = r[1].r_offset + 4;
8890               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8891               r[2].r_addend = r[0].r_addend;
8892             }
8893           else
8894             {
8895               r[2].r_offset = r[1].r_offset + 8;
8896               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8897               r[2].r_addend = r[0].r_addend + 8;
8898               r[3].r_offset = r[2].r_offset + 4;
8899               r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8900               r[3].r_addend = r[0].r_addend + 16;
8901             }
8902         }
8903       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
8904       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8905       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
8906       if (PPC_HA (offset + 16) != PPC_HA (offset))
8907         {
8908           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8909           offset = 0;
8910         }
8911       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8912       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
8913       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8914       bfd_put_32 (obfd, BCTR, p),                               p += 4;
8915     }
8916   else
8917     {
8918       if (r != NULL)
8919         {
8920           r[0].r_offset += 4;
8921           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8922           if (PPC_HA (offset + 16) != PPC_HA (offset))
8923             {
8924               r[1].r_offset = r[0].r_offset + 4;
8925               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8926               r[1].r_addend = r[0].r_addend;
8927             }
8928           else
8929             {
8930               r[1].r_offset = r[0].r_offset + 8;
8931               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8932               r[1].r_addend = r[0].r_addend + 16;
8933               r[2].r_offset = r[1].r_offset + 4;
8934               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8935               r[2].r_addend = r[0].r_addend + 8;
8936             }
8937         }
8938       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8939       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
8940       if (PPC_HA (offset + 16) != PPC_HA (offset))
8941         {
8942           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
8943           offset = 0;
8944         }
8945       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8946       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
8947       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
8948       bfd_put_32 (obfd, BCTR, p),                               p += 4;
8949     }
8950   return p;
8951 }
8952
8953 /* Build a special .plt call stub for __tls_get_addr.  */
8954
8955 #define LD_R11_0R3      0xe9630000
8956 #define LD_R12_0R3      0xe9830000
8957 #define MR_R0_R3        0x7c601b78
8958 #define CMPDI_R11_0     0x2c2b0000
8959 #define ADD_R3_R12_R13  0x7c6c6a14
8960 #define BEQLR           0x4d820020
8961 #define MR_R3_R0        0x7c030378
8962 #define MFLR_R11        0x7d6802a6
8963 #define STD_R11_0R1     0xf9610000
8964 #define BCTRL           0x4e800421
8965 #define LD_R11_0R1      0xe9610000
8966 #define LD_R2_0R1       0xe8410000
8967 #define MTLR_R11        0x7d6803a6
8968
8969 static inline bfd_byte *
8970 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
8971                          Elf_Internal_Rela *r)
8972 {
8973   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
8974   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
8975   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
8976   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
8977   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
8978   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
8979   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
8980   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
8981   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
8982
8983   if (r != NULL)
8984     r[0].r_offset += 9 * 4;
8985   p = build_plt_stub (obfd, p, offset, r);
8986   bfd_put_32 (obfd, BCTRL, p - 4);
8987
8988   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
8989   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
8990   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
8991   bfd_put_32 (obfd, BLR, p),                    p += 4;
8992
8993   return p;
8994 }
8995
8996 static Elf_Internal_Rela *
8997 get_relocs (asection *sec, int count)
8998 {
8999   Elf_Internal_Rela *relocs;
9000   struct bfd_elf_section_data *elfsec_data;
9001
9002   elfsec_data = elf_section_data (sec);
9003   relocs = elfsec_data->relocs;
9004   if (relocs == NULL)
9005     {
9006       bfd_size_type relsize;
9007       relsize = sec->reloc_count * sizeof (*relocs);
9008       relocs = bfd_alloc (sec->owner, relsize);
9009       if (relocs == NULL)
9010         return NULL;
9011       elfsec_data->relocs = relocs;
9012       elfsec_data->rel_hdr.sh_size = (sec->reloc_count
9013                                       * sizeof (Elf64_External_Rela));
9014       elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
9015       sec->reloc_count = 0;
9016     }
9017   relocs += sec->reloc_count;
9018   sec->reloc_count += count;
9019   return relocs;
9020 }
9021
9022 static bfd_boolean
9023 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9024 {
9025   struct ppc_stub_hash_entry *stub_entry;
9026   struct ppc_branch_hash_entry *br_entry;
9027   struct bfd_link_info *info;
9028   struct ppc_link_hash_table *htab;
9029   bfd_byte *loc;
9030   bfd_byte *p;
9031   bfd_vma dest, off;
9032   int size;
9033   Elf_Internal_Rela *r;
9034   asection *plt;
9035
9036   /* Massage our args to the form they really have.  */
9037   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9038   info = in_arg;
9039
9040   htab = ppc_hash_table (info);
9041
9042   /* Make a note of the offset within the stubs for this entry.  */
9043   stub_entry->stub_offset = stub_entry->stub_sec->size;
9044   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9045
9046   htab->stub_count[stub_entry->stub_type - 1] += 1;
9047   switch (stub_entry->stub_type)
9048     {
9049     case ppc_stub_long_branch:
9050     case ppc_stub_long_branch_r2off:
9051       /* Branches are relative.  This is where we are going to.  */
9052       off = dest = (stub_entry->target_value
9053                     + stub_entry->target_section->output_offset
9054                     + stub_entry->target_section->output_section->vma);
9055
9056       /* And this is where we are coming from.  */
9057       off -= (stub_entry->stub_offset
9058               + stub_entry->stub_sec->output_offset
9059               + stub_entry->stub_sec->output_section->vma);
9060
9061       size = 4;
9062       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9063         {
9064           bfd_vma r2off;
9065
9066           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9067                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9068           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9069           loc += 4;
9070           size = 12;
9071           if (PPC_HA (r2off) != 0)
9072             {
9073               size = 16;
9074               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9075               loc += 4;
9076             }
9077           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9078           loc += 4;
9079           off -= size - 4;
9080         }
9081       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9082
9083       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9084         {
9085           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9086                                  stub_entry->root.string);
9087           htab->stub_error = TRUE;
9088           return FALSE;
9089         }
9090
9091       if (info->emitrelocations)
9092         {
9093           r = get_relocs (stub_entry->stub_sec, 1);
9094           if (r == NULL)
9095             return FALSE;
9096           r->r_offset = loc - stub_entry->stub_sec->contents;
9097           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9098           r->r_addend = dest;
9099           if (stub_entry->h != NULL)
9100             {
9101               struct elf_link_hash_entry **hashes;
9102               unsigned long symndx;
9103               struct ppc_link_hash_entry *h;
9104
9105               hashes = elf_sym_hashes (htab->stub_bfd);
9106               if (hashes == NULL)
9107                 {
9108                   bfd_size_type hsize;
9109
9110                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9111                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9112                   if (hashes == NULL)
9113                     return FALSE;
9114                   elf_sym_hashes (htab->stub_bfd) = hashes;
9115                   htab->stub_globals = 1;
9116                 }
9117               symndx = htab->stub_globals++;
9118               h = stub_entry->h;
9119               hashes[symndx] = &h->elf;
9120               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9121               if (h->oh != NULL && h->oh->is_func)
9122                 h = ppc_follow_link (h->oh);
9123               if (h->elf.root.u.def.section != stub_entry->target_section)
9124                 /* H is an opd symbol.  The addend must be zero.  */
9125                 r->r_addend = 0;
9126               else
9127                 {
9128                   off = (h->elf.root.u.def.value
9129                          + h->elf.root.u.def.section->output_offset
9130                          + h->elf.root.u.def.section->output_section->vma);
9131                   r->r_addend -= off;
9132                 }
9133             }
9134         }
9135       break;
9136
9137     case ppc_stub_plt_branch:
9138     case ppc_stub_plt_branch_r2off:
9139       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9140                                          stub_entry->root.string + 9,
9141                                          FALSE, FALSE);
9142       if (br_entry == NULL)
9143         {
9144           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9145                                  stub_entry->root.string);
9146           htab->stub_error = TRUE;
9147           return FALSE;
9148         }
9149
9150       dest = (stub_entry->target_value
9151               + stub_entry->target_section->output_offset
9152               + stub_entry->target_section->output_section->vma);
9153
9154       bfd_put_64 (htab->brlt->owner, dest,
9155                   htab->brlt->contents + br_entry->offset);
9156
9157       if (br_entry->iter == htab->stub_iteration)
9158         {
9159           br_entry->iter = 0;
9160
9161           if (htab->relbrlt != NULL)
9162             {
9163               /* Create a reloc for the branch lookup table entry.  */
9164               Elf_Internal_Rela rela;
9165               bfd_byte *rl;
9166
9167               rela.r_offset = (br_entry->offset
9168                                + htab->brlt->output_offset
9169                                + htab->brlt->output_section->vma);
9170               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9171               rela.r_addend = dest;
9172
9173               rl = htab->relbrlt->contents;
9174               rl += (htab->relbrlt->reloc_count++
9175                      * sizeof (Elf64_External_Rela));
9176               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9177             }
9178           else if (info->emitrelocations)
9179             {
9180               r = get_relocs (htab->brlt, 1);
9181               if (r == NULL)
9182                 return FALSE;
9183               /* brlt, being SEC_LINKER_CREATED does not go through the
9184                  normal reloc processing.  Symbols and offsets are not
9185                  translated from input file to output file form, so
9186                  set up the offset per the output file.  */
9187               r->r_offset = (br_entry->offset
9188                              + htab->brlt->output_offset
9189                              + htab->brlt->output_section->vma);
9190               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9191               r->r_addend = dest;
9192             }
9193         }
9194
9195       dest = (br_entry->offset
9196               + htab->brlt->output_offset
9197               + htab->brlt->output_section->vma);
9198
9199       off = (dest
9200              - elf_gp (htab->brlt->output_section->owner)
9201              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9202
9203       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9204         {
9205           (*_bfd_error_handler)
9206             (_("linkage table error against `%s'"),
9207              stub_entry->root.string);
9208           bfd_set_error (bfd_error_bad_value);
9209           htab->stub_error = TRUE;
9210           return FALSE;
9211         }
9212
9213       if (info->emitrelocations)
9214         {
9215           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9216           if (r == NULL)
9217             return FALSE;
9218           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9219           if (bfd_big_endian (info->output_bfd))
9220             r[0].r_offset += 2;
9221           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9222             r[0].r_offset += 4;
9223           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9224           r[0].r_addend = dest;
9225           if (PPC_HA (off) != 0)
9226             {
9227               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9228               r[1].r_offset = r[0].r_offset + 4;
9229               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9230               r[1].r_addend = r[0].r_addend;
9231             }
9232         }
9233
9234       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9235         {
9236           if (PPC_HA (off) != 0)
9237             {
9238               size = 16;
9239               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9240               loc += 4;
9241               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9242             }
9243           else
9244             {
9245               size = 12;
9246               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9247             }
9248         }
9249       else
9250         {
9251           bfd_vma r2off;
9252
9253           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9254                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9255           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9256           loc += 4;
9257           size = 20;
9258           if (PPC_HA (off) != 0)
9259             {
9260               size += 4;
9261               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9262               loc += 4;
9263               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9264               loc += 4;
9265             }
9266           else
9267             {
9268               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9269               loc += 4;
9270             }
9271
9272           if (PPC_HA (r2off) != 0)
9273             {
9274               size += 4;
9275               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9276               loc += 4;
9277             }
9278           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9279         }
9280       loc += 4;
9281       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9282       loc += 4;
9283       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9284       break;
9285
9286     case ppc_stub_plt_call:
9287       if (stub_entry->h != NULL
9288           && stub_entry->h->is_func_descriptor
9289           && stub_entry->h->oh != NULL)
9290         {
9291           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9292
9293           /* If the old-ABI "dot-symbol" is undefined make it weak so
9294              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9295              FIXME: We used to define the symbol on one of the call
9296              stubs instead, which is why we test symbol section id
9297              against htab->top_id in various places.  Likely all
9298              these checks could now disappear.  */
9299           if (fh->elf.root.type == bfd_link_hash_undefined)
9300             fh->elf.root.type = bfd_link_hash_undefweak;
9301         }
9302
9303       /* Now build the stub.  */
9304       dest = stub_entry->plt_ent->plt.offset & ~1;
9305       if (dest >= (bfd_vma) -2)
9306         abort ();
9307
9308       plt = htab->plt;
9309       if (!htab->elf.dynamic_sections_created
9310           || stub_entry->h == NULL
9311           || stub_entry->h->elf.dynindx == -1)
9312         plt = htab->iplt;
9313
9314       dest += plt->output_offset + plt->output_section->vma;
9315
9316       if (stub_entry->h == NULL
9317           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9318         {
9319           Elf_Internal_Rela rela;
9320           bfd_byte *rl;
9321
9322           rela.r_offset = dest;
9323           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9324           rela.r_addend = (stub_entry->target_value
9325                            + stub_entry->target_section->output_offset
9326                            + stub_entry->target_section->output_section->vma);
9327
9328           rl = (htab->reliplt->contents
9329                 + (htab->reliplt->reloc_count++
9330                    * sizeof (Elf64_External_Rela)));
9331           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9332           stub_entry->plt_ent->plt.offset |= 1;
9333         }
9334
9335       off = (dest
9336              - elf_gp (plt->output_section->owner)
9337              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9338
9339       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9340         {
9341           (*_bfd_error_handler)
9342             (_("linkage table error against `%s'"),
9343              stub_entry->h != NULL
9344              ? stub_entry->h->elf.root.root.string
9345              : "<local sym>");
9346           bfd_set_error (bfd_error_bad_value);
9347           htab->stub_error = TRUE;
9348           return FALSE;
9349         }
9350
9351       r = NULL;
9352       if (info->emitrelocations)
9353         {
9354           r = get_relocs (stub_entry->stub_sec,
9355                           (2 + (PPC_HA (off) != 0)
9356                            + (PPC_HA (off + 16) == PPC_HA (off))));
9357           if (r == NULL)
9358             return FALSE;
9359           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9360           if (bfd_big_endian (info->output_bfd))
9361             r[0].r_offset += 2;
9362           r[0].r_addend = dest;
9363         }
9364       if (stub_entry->h != NULL
9365           && (stub_entry->h == htab->tls_get_addr_fd
9366               || stub_entry->h == htab->tls_get_addr)
9367           && !htab->no_tls_get_addr_opt)
9368         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9369       else
9370         p = build_plt_stub (htab->stub_bfd, loc, off, r);
9371       size = p - loc;
9372       break;
9373
9374     default:
9375       BFD_FAIL ();
9376       return FALSE;
9377     }
9378
9379   stub_entry->stub_sec->size += size;
9380
9381   if (htab->emit_stub_syms)
9382     {
9383       struct elf_link_hash_entry *h;
9384       size_t len1, len2;
9385       char *name;
9386       const char *const stub_str[] = { "long_branch",
9387                                        "long_branch_r2off",
9388                                        "plt_branch",
9389                                        "plt_branch_r2off",
9390                                        "plt_call" };
9391
9392       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9393       len2 = strlen (stub_entry->root.string);
9394       name = bfd_malloc (len1 + len2 + 2);
9395       if (name == NULL)
9396         return FALSE;
9397       memcpy (name, stub_entry->root.string, 9);
9398       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9399       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9400       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9401       if (h == NULL)
9402         return FALSE;
9403       if (h->root.type == bfd_link_hash_new)
9404         {
9405           h->root.type = bfd_link_hash_defined;
9406           h->root.u.def.section = stub_entry->stub_sec;
9407           h->root.u.def.value = stub_entry->stub_offset;
9408           h->ref_regular = 1;
9409           h->def_regular = 1;
9410           h->ref_regular_nonweak = 1;
9411           h->forced_local = 1;
9412           h->non_elf = 0;
9413         }
9414     }
9415
9416   return TRUE;
9417 }
9418
9419 /* As above, but don't actually build the stub.  Just bump offset so
9420    we know stub section sizes, and select plt_branch stubs where
9421    long_branch stubs won't do.  */
9422
9423 static bfd_boolean
9424 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9425 {
9426   struct ppc_stub_hash_entry *stub_entry;
9427   struct bfd_link_info *info;
9428   struct ppc_link_hash_table *htab;
9429   bfd_vma off;
9430   int size;
9431
9432   /* Massage our args to the form they really have.  */
9433   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9434   info = in_arg;
9435
9436   htab = ppc_hash_table (info);
9437
9438   if (stub_entry->stub_type == ppc_stub_plt_call)
9439     {
9440       asection *plt;
9441       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9442       if (off >= (bfd_vma) -2)
9443         abort ();
9444       plt = htab->plt;
9445       if (!htab->elf.dynamic_sections_created
9446           || stub_entry->h == NULL
9447           || stub_entry->h->elf.dynindx == -1)
9448         plt = htab->iplt;
9449       off += (plt->output_offset
9450               + plt->output_section->vma
9451               - elf_gp (plt->output_section->owner)
9452               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9453
9454       size = PLT_CALL_STUB_SIZE;
9455       if (PPC_HA (off) == 0)
9456         size -= 4;
9457       if (PPC_HA (off + 16) != PPC_HA (off))
9458         size += 4;
9459       if (stub_entry->h != NULL
9460           && (stub_entry->h == htab->tls_get_addr_fd
9461               || stub_entry->h == htab->tls_get_addr)
9462           && !htab->no_tls_get_addr_opt)
9463         size += 13 * 4;
9464       if (info->emitrelocations)
9465         {
9466           stub_entry->stub_sec->reloc_count
9467             += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9468           stub_entry->stub_sec->flags |= SEC_RELOC;
9469         }
9470     }
9471   else
9472     {
9473       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9474          variants.  */
9475       bfd_vma r2off = 0;
9476
9477       off = (stub_entry->target_value
9478              + stub_entry->target_section->output_offset
9479              + stub_entry->target_section->output_section->vma);
9480       off -= (stub_entry->stub_sec->size
9481               + stub_entry->stub_sec->output_offset
9482               + stub_entry->stub_sec->output_section->vma);
9483
9484       /* Reset the stub type from the plt variant in case we now
9485          can reach with a shorter stub.  */
9486       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9487         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9488
9489       size = 4;
9490       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9491         {
9492           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9493                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9494           size = 12;
9495           if (PPC_HA (r2off) != 0)
9496             size = 16;
9497           off -= size - 4;
9498         }
9499
9500       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9501       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9502         {
9503           struct ppc_branch_hash_entry *br_entry;
9504
9505           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9506                                              stub_entry->root.string + 9,
9507                                              TRUE, FALSE);
9508           if (br_entry == NULL)
9509             {
9510               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9511                                      stub_entry->root.string);
9512               htab->stub_error = TRUE;
9513               return FALSE;
9514             }
9515
9516           if (br_entry->iter != htab->stub_iteration)
9517             {
9518               br_entry->iter = htab->stub_iteration;
9519               br_entry->offset = htab->brlt->size;
9520               htab->brlt->size += 8;
9521
9522               if (htab->relbrlt != NULL)
9523                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9524               else if (info->emitrelocations)
9525                 {
9526                   htab->brlt->reloc_count += 1;
9527                   htab->brlt->flags |= SEC_RELOC;
9528                 }
9529             }
9530
9531           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9532           off = (br_entry->offset
9533                  + htab->brlt->output_offset
9534                  + htab->brlt->output_section->vma
9535                  - elf_gp (htab->brlt->output_section->owner)
9536                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
9537
9538           if (info->emitrelocations)
9539             {
9540               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9541               stub_entry->stub_sec->flags |= SEC_RELOC;
9542             }
9543
9544           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9545             {
9546               size = 12;
9547               if (PPC_HA (off) != 0)
9548                 size = 16;
9549             }
9550           else
9551             {
9552               size = 20;
9553               if (PPC_HA (off) != 0)
9554                 size += 4;
9555
9556               if (PPC_HA (r2off) != 0)
9557                 size += 4;
9558             }
9559         }
9560       else if (info->emitrelocations)
9561         {
9562           stub_entry->stub_sec->reloc_count += 1;
9563           stub_entry->stub_sec->flags |= SEC_RELOC;
9564         }
9565     }
9566
9567   stub_entry->stub_sec->size += size;
9568   return TRUE;
9569 }
9570
9571 /* Set up various things so that we can make a list of input sections
9572    for each output section included in the link.  Returns -1 on error,
9573    0 when no stubs will be needed, and 1 on success.  */
9574
9575 int
9576 ppc64_elf_setup_section_lists (bfd *output_bfd,
9577                                struct bfd_link_info *info,
9578                                int no_multi_toc)
9579 {
9580   bfd *input_bfd;
9581   int top_id, top_index, id;
9582   asection *section;
9583   asection **input_list;
9584   bfd_size_type amt;
9585   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9586
9587   htab->no_multi_toc = no_multi_toc;
9588
9589   if (htab->brlt == NULL)
9590     return 0;
9591
9592   /* Find the top input section id.  */
9593   for (input_bfd = info->input_bfds, top_id = 3;
9594        input_bfd != NULL;
9595        input_bfd = input_bfd->link_next)
9596     {
9597       for (section = input_bfd->sections;
9598            section != NULL;
9599            section = section->next)
9600         {
9601           if (top_id < section->id)
9602             top_id = section->id;
9603         }
9604     }
9605
9606   htab->top_id = top_id;
9607   amt = sizeof (struct map_stub) * (top_id + 1);
9608   htab->stub_group = bfd_zmalloc (amt);
9609   if (htab->stub_group == NULL)
9610     return -1;
9611
9612   /* Set toc_off for com, und, abs and ind sections.  */
9613   for (id = 0; id < 3; id++)
9614     htab->stub_group[id].toc_off = TOC_BASE_OFF;
9615
9616   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
9617   htab->toc_bfd = NULL;
9618   htab->toc_first_sec = NULL;
9619
9620   /* We can't use output_bfd->section_count here to find the top output
9621      section index as some sections may have been removed, and
9622      strip_excluded_output_sections doesn't renumber the indices.  */
9623   for (section = output_bfd->sections, top_index = 0;
9624        section != NULL;
9625        section = section->next)
9626     {
9627       if (top_index < section->index)
9628         top_index = section->index;
9629     }
9630
9631   htab->top_index = top_index;
9632   amt = sizeof (asection *) * (top_index + 1);
9633   input_list = bfd_zmalloc (amt);
9634   htab->input_list = input_list;
9635   if (input_list == NULL)
9636     return -1;
9637
9638   return 1;
9639 }
9640
9641 /* The linker repeatedly calls this function for each TOC input section
9642    and linker generated GOT section.  Group input bfds such that the toc
9643    within a group is less than 64k in size.  Will break with cute linker
9644    scripts that play games with dot in the output toc section.  */
9645
9646 void
9647 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9648 {
9649   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9650
9651   if (!htab->no_multi_toc)
9652     {
9653       bfd_vma addr, off;
9654
9655       if (htab->toc_bfd != isec->owner)
9656         {
9657           htab->toc_bfd = isec->owner;
9658           htab->toc_first_sec = isec;
9659         }
9660       addr = isec->output_offset + isec->output_section->vma;
9661       off = addr - htab->toc_curr;
9662       if (off + isec->size > 0x10000)
9663         {
9664           addr = (htab->toc_first_sec->output_offset
9665                   + htab->toc_first_sec->output_section->vma);
9666           htab->toc_curr = addr;
9667         }
9668
9669       elf_gp (isec->owner) = (htab->toc_curr
9670                               - elf_gp (isec->output_section->owner)
9671                               + TOC_BASE_OFF);
9672     }
9673 }
9674
9675 /* Called after the last call to the above function.  */
9676
9677 void
9678 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
9679 {
9680   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9681
9682   htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
9683
9684   /* toc_curr tracks the TOC offset used for code sections below in
9685      ppc64_elf_next_input_section.  Start off at 0x8000.  */
9686   htab->toc_curr = TOC_BASE_OFF;
9687 }
9688
9689 /* No toc references were found in ISEC.  If the code in ISEC makes no
9690    calls, then there's no need to use toc adjusting stubs when branching
9691    into ISEC.  Actually, indirect calls from ISEC are OK as they will
9692    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
9693    needed, and 2 if a cyclical call-graph was found but no other reason
9694    for a stub was detected.  If called from the top level, a return of
9695    2 means the same as a return of 0.  */
9696
9697 static int
9698 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9699 {
9700   Elf_Internal_Rela *relstart, *rel;
9701   Elf_Internal_Sym *local_syms;
9702   int ret;
9703   struct ppc_link_hash_table *htab;
9704
9705   /* We know none of our code bearing sections will need toc stubs.  */
9706   if ((isec->flags & SEC_LINKER_CREATED) != 0)
9707     return 0;
9708
9709   if (isec->size == 0)
9710     return 0;
9711
9712   if (isec->output_section == NULL)
9713     return 0;
9714
9715   if (isec->reloc_count == 0)
9716     return 0;
9717
9718   relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
9719                                         info->keep_memory);
9720   if (relstart == NULL)
9721     return -1;
9722
9723   /* Look for branches to outside of this section.  */
9724   local_syms = NULL;
9725   ret = 0;
9726   htab = ppc_hash_table (info);
9727   for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9728     {
9729       enum elf_ppc64_reloc_type r_type;
9730       unsigned long r_symndx;
9731       struct elf_link_hash_entry *h;
9732       struct ppc_link_hash_entry *eh;
9733       Elf_Internal_Sym *sym;
9734       asection *sym_sec;
9735       struct _opd_sec_data *opd;
9736       bfd_vma sym_value;
9737       bfd_vma dest;
9738
9739       r_type = ELF64_R_TYPE (rel->r_info);
9740       if (r_type != R_PPC64_REL24
9741           && r_type != R_PPC64_REL14
9742           && r_type != R_PPC64_REL14_BRTAKEN
9743           && r_type != R_PPC64_REL14_BRNTAKEN)
9744         continue;
9745
9746       r_symndx = ELF64_R_SYM (rel->r_info);
9747       if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9748                       isec->owner))
9749         {
9750           ret = -1;
9751           break;
9752         }
9753
9754       /* Calls to dynamic lib functions go through a plt call stub
9755          that uses r2.  */
9756       eh = (struct ppc_link_hash_entry *) h;
9757       if (eh != NULL
9758           && (eh->elf.plt.plist != NULL
9759               || (eh->oh != NULL
9760                   && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
9761         {
9762           ret = 1;
9763           break;
9764         }
9765
9766       if (sym_sec == NULL)
9767         /* Ignore other undefined symbols.  */
9768         continue;
9769
9770       /* Assume branches to other sections not included in the link need
9771          stubs too, to cover -R and absolute syms.  */
9772       if (sym_sec->output_section == NULL)
9773         {
9774           ret = 1;
9775           break;
9776         }
9777
9778       if (h == NULL)
9779         sym_value = sym->st_value;
9780       else
9781         {
9782           if (h->root.type != bfd_link_hash_defined
9783               && h->root.type != bfd_link_hash_defweak)
9784             abort ();
9785           sym_value = h->root.u.def.value;
9786         }
9787       sym_value += rel->r_addend;
9788
9789       /* If this branch reloc uses an opd sym, find the code section.  */
9790       opd = get_opd_info (sym_sec);
9791       if (opd != NULL)
9792         {
9793           if (h == NULL && opd->adjust != NULL)
9794             {
9795               long adjust;
9796
9797               adjust = opd->adjust[sym->st_value / 8];
9798               if (adjust == -1)
9799                 /* Assume deleted functions won't ever be called.  */
9800                 continue;
9801               sym_value += adjust;
9802             }
9803
9804           dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9805           if (dest == (bfd_vma) -1)
9806             continue;
9807         }
9808       else
9809         dest = (sym_value
9810                 + sym_sec->output_offset
9811                 + sym_sec->output_section->vma);
9812
9813       /* Ignore branch to self.  */
9814       if (sym_sec == isec)
9815         continue;
9816
9817       /* If the called function uses the toc, we need a stub.  */
9818       if (sym_sec->has_toc_reloc
9819           || sym_sec->makes_toc_func_call)
9820         {
9821           ret = 1;
9822           break;
9823         }
9824
9825       /* Assume any branch that needs a long branch stub might in fact
9826          need a plt_branch stub.  A plt_branch stub uses r2.  */
9827       else if (dest - (isec->output_offset
9828                        + isec->output_section->vma
9829                        + rel->r_offset) + (1 << 25) >= (2 << 25))
9830         {
9831           ret = 1;
9832           break;
9833         }
9834
9835       /* If calling back to a section in the process of being tested, we
9836          can't say for sure that no toc adjusting stubs are needed, so
9837          don't return zero.  */
9838       else if (sym_sec->call_check_in_progress)
9839         ret = 2;
9840
9841       /* Branches to another section that itself doesn't have any TOC
9842          references are OK.  Recursively call ourselves to check.  */
9843       else if (sym_sec->id <= htab->top_id
9844                && htab->stub_group[sym_sec->id].toc_off == 0)
9845         {
9846           int recur;
9847
9848           /* Mark current section as indeterminate, so that other
9849              sections that call back to current won't be marked as
9850              known.  */
9851           isec->call_check_in_progress = 1;
9852           recur = toc_adjusting_stub_needed (info, sym_sec);
9853           isec->call_check_in_progress = 0;
9854
9855           if (recur < 0)
9856             {
9857               /* An error.  Exit.  */
9858               ret = -1;
9859               break;
9860             }
9861           else if (recur <= 1)
9862             {
9863               /* Known result.  Mark as checked and set section flag.  */
9864               htab->stub_group[sym_sec->id].toc_off = 1;
9865               if (recur != 0)
9866                 {
9867                   sym_sec->makes_toc_func_call = 1;
9868                   ret = 1;
9869                   break;
9870                 }
9871             }
9872           else
9873             {
9874               /* Unknown result.  Continue checking.  */
9875               ret = 2;
9876             }
9877         }
9878     }
9879
9880   if (local_syms != NULL
9881       && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
9882     free (local_syms);
9883   if (elf_section_data (isec)->relocs != relstart)
9884     free (relstart);
9885
9886   return ret;
9887 }
9888
9889 /* The linker repeatedly calls this function for each input section,
9890    in the order that input sections are linked into output sections.
9891    Build lists of input sections to determine groupings between which
9892    we may insert linker stubs.  */
9893
9894 bfd_boolean
9895 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
9896 {
9897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9898
9899   if ((isec->output_section->flags & SEC_CODE) != 0
9900       && isec->output_section->index <= htab->top_index)
9901     {
9902       asection **list = htab->input_list + isec->output_section->index;
9903       /* Steal the link_sec pointer for our list.  */
9904 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
9905       /* This happens to make the list in reverse order,
9906          which is what we want.  */
9907       PREV_SEC (isec) = *list;
9908       *list = isec;
9909     }
9910
9911   if (htab->multi_toc_needed)
9912     {
9913       /* If a code section has a function that uses the TOC then we need
9914          to use the right TOC (obviously).  Also, make sure that .opd gets
9915          the correct TOC value for R_PPC64_TOC relocs that don't have or
9916          can't find their function symbol (shouldn't ever happen now).
9917          Also specially treat .fixup for the linux kernel.  .fixup
9918          contains branches, but only back to the function that hit an
9919          exception.  */
9920       if (isec->has_toc_reloc
9921           || (isec->flags & SEC_CODE) == 0
9922           || strcmp (isec->name, ".fixup") == 0)
9923         {
9924           if (elf_gp (isec->owner) != 0)
9925             htab->toc_curr = elf_gp (isec->owner);
9926         }
9927       else if (htab->stub_group[isec->id].toc_off == 0)
9928         {
9929           int ret = toc_adjusting_stub_needed (info, isec);
9930           if (ret < 0)
9931             return FALSE;
9932           else
9933             isec->makes_toc_func_call = ret & 1;
9934         }
9935     }
9936
9937   /* Functions that don't use the TOC can belong in any TOC group.
9938      Use the last TOC base.  This happens to make _init and _fini
9939      pasting work.  */
9940   htab->stub_group[isec->id].toc_off = htab->toc_curr;
9941   return TRUE;
9942 }
9943
9944 /* See whether we can group stub sections together.  Grouping stub
9945    sections may result in fewer stubs.  More importantly, we need to
9946    put all .init* and .fini* stubs at the beginning of the .init or
9947    .fini output sections respectively, because glibc splits the
9948    _init and _fini functions into multiple parts.  Putting a stub in
9949    the middle of a function is not a good idea.  */
9950
9951 static void
9952 group_sections (struct ppc_link_hash_table *htab,
9953                 bfd_size_type stub_group_size,
9954                 bfd_boolean stubs_always_before_branch)
9955 {
9956   asection **list;
9957   bfd_size_type stub14_group_size;
9958   bfd_boolean suppress_size_errors;
9959
9960   suppress_size_errors = FALSE;
9961   stub14_group_size = stub_group_size;
9962   if (stub_group_size == 1)
9963     {
9964       /* Default values.  */
9965       if (stubs_always_before_branch)
9966         {
9967           stub_group_size = 0x1e00000;
9968           stub14_group_size = 0x7800;
9969         }
9970       else
9971         {
9972           stub_group_size = 0x1c00000;
9973           stub14_group_size = 0x7000;
9974         }
9975       suppress_size_errors = TRUE;
9976     }
9977
9978   list = htab->input_list + htab->top_index;
9979   do
9980     {
9981       asection *tail = *list;
9982       while (tail != NULL)
9983         {
9984           asection *curr;
9985           asection *prev;
9986           bfd_size_type total;
9987           bfd_boolean big_sec;
9988           bfd_vma curr_toc;
9989
9990           curr = tail;
9991           total = tail->size;
9992           big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9993                              ? stub14_group_size : stub_group_size);
9994           if (big_sec && !suppress_size_errors)
9995             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9996                                      tail->owner, tail);
9997           curr_toc = htab->stub_group[tail->id].toc_off;
9998
9999           while ((prev = PREV_SEC (curr)) != NULL
10000                  && ((total += curr->output_offset - prev->output_offset)
10001                      < (ppc64_elf_section_data (prev)->has_14bit_branch
10002                         ? stub14_group_size : stub_group_size))
10003                  && htab->stub_group[prev->id].toc_off == curr_toc)
10004             curr = prev;
10005
10006           /* OK, the size from the start of CURR to the end is less
10007              than stub_group_size and thus can be handled by one stub
10008              section.  (or the tail section is itself larger than
10009              stub_group_size, in which case we may be toast.)  We
10010              should really be keeping track of the total size of stubs
10011              added here, as stubs contribute to the final output
10012              section size.  That's a little tricky, and this way will
10013              only break if stubs added make the total size more than
10014              2^25, ie. for the default stub_group_size, if stubs total
10015              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10016           do
10017             {
10018               prev = PREV_SEC (tail);
10019               /* Set up this stub group.  */
10020               htab->stub_group[tail->id].link_sec = curr;
10021             }
10022           while (tail != curr && (tail = prev) != NULL);
10023
10024           /* But wait, there's more!  Input sections up to stub_group_size
10025              bytes before the stub section can be handled by it too.
10026              Don't do this if we have a really large section after the
10027              stubs, as adding more stubs increases the chance that
10028              branches may not reach into the stub section.  */
10029           if (!stubs_always_before_branch && !big_sec)
10030             {
10031               total = 0;
10032               while (prev != NULL
10033                      && ((total += tail->output_offset - prev->output_offset)
10034                          < (ppc64_elf_section_data (prev)->has_14bit_branch
10035                             ? stub14_group_size : stub_group_size))
10036                      && htab->stub_group[prev->id].toc_off == curr_toc)
10037                 {
10038                   tail = prev;
10039                   prev = PREV_SEC (tail);
10040                   htab->stub_group[tail->id].link_sec = curr;
10041                 }
10042             }
10043           tail = prev;
10044         }
10045     }
10046   while (list-- != htab->input_list);
10047   free (htab->input_list);
10048 #undef PREV_SEC
10049 }
10050
10051 /* Determine and set the size of the stub section for a final link.
10052
10053    The basic idea here is to examine all the relocations looking for
10054    PC-relative calls to a target that is unreachable with a "bl"
10055    instruction.  */
10056
10057 bfd_boolean
10058 ppc64_elf_size_stubs (bfd *output_bfd,
10059                       struct bfd_link_info *info,
10060                       bfd_signed_vma group_size,
10061                       asection *(*add_stub_section) (const char *, asection *),
10062                       void (*layout_sections_again) (void))
10063 {
10064   bfd_size_type stub_group_size;
10065   bfd_boolean stubs_always_before_branch;
10066   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10067
10068   /* Stash our params away.  */
10069   htab->add_stub_section = add_stub_section;
10070   htab->layout_sections_again = layout_sections_again;
10071   stubs_always_before_branch = group_size < 0;
10072   if (group_size < 0)
10073     stub_group_size = -group_size;
10074   else
10075     stub_group_size = group_size;
10076
10077   group_sections (htab, stub_group_size, stubs_always_before_branch);
10078
10079   while (1)
10080     {
10081       bfd *input_bfd;
10082       unsigned int bfd_indx;
10083       asection *stub_sec;
10084
10085       htab->stub_iteration += 1;
10086
10087       for (input_bfd = info->input_bfds, bfd_indx = 0;
10088            input_bfd != NULL;
10089            input_bfd = input_bfd->link_next, bfd_indx++)
10090         {
10091           Elf_Internal_Shdr *symtab_hdr;
10092           asection *section;
10093           Elf_Internal_Sym *local_syms = NULL;
10094
10095           if (!is_ppc64_elf (input_bfd))
10096             continue;
10097
10098           /* We'll need the symbol table in a second.  */
10099           symtab_hdr = &elf_symtab_hdr (input_bfd);
10100           if (symtab_hdr->sh_info == 0)
10101             continue;
10102
10103           /* Walk over each section attached to the input bfd.  */
10104           for (section = input_bfd->sections;
10105                section != NULL;
10106                section = section->next)
10107             {
10108               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10109
10110               /* If there aren't any relocs, then there's nothing more
10111                  to do.  */
10112               if ((section->flags & SEC_RELOC) == 0
10113                   || (section->flags & SEC_ALLOC) == 0
10114                   || (section->flags & SEC_LOAD) == 0
10115                   || (section->flags & SEC_CODE) == 0
10116                   || section->reloc_count == 0)
10117                 continue;
10118
10119               /* If this section is a link-once section that will be
10120                  discarded, then don't create any stubs.  */
10121               if (section->output_section == NULL
10122                   || section->output_section->owner != output_bfd)
10123                 continue;
10124
10125               /* Get the relocs.  */
10126               internal_relocs
10127                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10128                                              info->keep_memory);
10129               if (internal_relocs == NULL)
10130                 goto error_ret_free_local;
10131
10132               /* Now examine each relocation.  */
10133               irela = internal_relocs;
10134               irelaend = irela + section->reloc_count;
10135               for (; irela < irelaend; irela++)
10136                 {
10137                   enum elf_ppc64_reloc_type r_type;
10138                   unsigned int r_indx;
10139                   enum ppc_stub_type stub_type;
10140                   struct ppc_stub_hash_entry *stub_entry;
10141                   asection *sym_sec, *code_sec;
10142                   bfd_vma sym_value, code_value;
10143                   bfd_vma destination;
10144                   bfd_boolean ok_dest;
10145                   struct ppc_link_hash_entry *hash;
10146                   struct ppc_link_hash_entry *fdh;
10147                   struct elf_link_hash_entry *h;
10148                   Elf_Internal_Sym *sym;
10149                   char *stub_name;
10150                   const asection *id_sec;
10151                   struct _opd_sec_data *opd;
10152                   struct plt_entry *plt_ent;
10153
10154                   r_type = ELF64_R_TYPE (irela->r_info);
10155                   r_indx = ELF64_R_SYM (irela->r_info);
10156
10157                   if (r_type >= R_PPC64_max)
10158                     {
10159                       bfd_set_error (bfd_error_bad_value);
10160                       goto error_ret_free_internal;
10161                     }
10162
10163                   /* Only look for stubs on branch instructions.  */
10164                   if (r_type != R_PPC64_REL24
10165                       && r_type != R_PPC64_REL14
10166                       && r_type != R_PPC64_REL14_BRTAKEN
10167                       && r_type != R_PPC64_REL14_BRNTAKEN)
10168                     continue;
10169
10170                   /* Now determine the call target, its name, value,
10171                      section.  */
10172                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
10173                                   r_indx, input_bfd))
10174                     goto error_ret_free_internal;
10175                   hash = (struct ppc_link_hash_entry *) h;
10176
10177                   ok_dest = FALSE;
10178                   fdh = NULL;
10179                   sym_value = 0;
10180                   if (hash == NULL)
10181                     {
10182                       sym_value = sym->st_value;
10183                       ok_dest = TRUE;
10184                     }
10185                   else if (hash->elf.root.type == bfd_link_hash_defined
10186                            || hash->elf.root.type == bfd_link_hash_defweak)
10187                     {
10188                       sym_value = hash->elf.root.u.def.value;
10189                       if (sym_sec->output_section != NULL)
10190                         ok_dest = TRUE;
10191                     }
10192                   else if (hash->elf.root.type == bfd_link_hash_undefweak
10193                            || hash->elf.root.type == bfd_link_hash_undefined)
10194                     {
10195                       /* Recognise an old ABI func code entry sym, and
10196                          use the func descriptor sym instead if it is
10197                          defined.  */
10198                       if (hash->elf.root.root.string[0] == '.'
10199                           && (fdh = lookup_fdh (hash, htab)) != NULL)
10200                         {
10201                           if (fdh->elf.root.type == bfd_link_hash_defined
10202                               || fdh->elf.root.type == bfd_link_hash_defweak)
10203                             {
10204                               sym_sec = fdh->elf.root.u.def.section;
10205                               sym_value = fdh->elf.root.u.def.value;
10206                               if (sym_sec->output_section != NULL)
10207                                 ok_dest = TRUE;
10208                             }
10209                           else
10210                             fdh = NULL;
10211                         }
10212                     }
10213                   else
10214                     {
10215                       bfd_set_error (bfd_error_bad_value);
10216                       goto error_ret_free_internal;
10217                     }
10218
10219                   destination = 0;
10220                   if (ok_dest)
10221                     {
10222                       sym_value += irela->r_addend;
10223                       destination = (sym_value
10224                                      + sym_sec->output_offset
10225                                      + sym_sec->output_section->vma);
10226                     }
10227
10228                   code_sec = sym_sec;
10229                   code_value = sym_value;
10230                   opd = get_opd_info (sym_sec);
10231                   if (opd != NULL)
10232                     {
10233                       bfd_vma dest;
10234
10235                       if (hash == NULL && opd->adjust != NULL)
10236                         {
10237                           long adjust = opd->adjust[sym_value / 8];
10238                           if (adjust == -1)
10239                             continue;
10240                           code_value += adjust;
10241                           sym_value += adjust;
10242                         }
10243                       dest = opd_entry_value (sym_sec, sym_value,
10244                                               &code_sec, &code_value);
10245                       if (dest != (bfd_vma) -1)
10246                         {
10247                           destination = dest;
10248                           if (fdh != NULL)
10249                             {
10250                               /* Fixup old ABI sym to point at code
10251                                  entry.  */
10252                               hash->elf.root.type = bfd_link_hash_defweak;
10253                               hash->elf.root.u.def.section = code_sec;
10254                               hash->elf.root.u.def.value = code_value;
10255                             }
10256                         }
10257                     }
10258
10259                   /* Determine what (if any) linker stub is needed.  */
10260                   plt_ent = NULL;
10261                   stub_type = ppc_type_of_stub (section, irela, &hash,
10262                                                 &plt_ent, destination);
10263
10264                   if (stub_type != ppc_stub_plt_call)
10265                     {
10266                       /* Check whether we need a TOC adjusting stub.
10267                          Since the linker pastes together pieces from
10268                          different object files when creating the
10269                          _init and _fini functions, it may be that a
10270                          call to what looks like a local sym is in
10271                          fact a call needing a TOC adjustment.  */
10272                       if (code_sec != NULL
10273                           && code_sec->output_section != NULL
10274                           && (htab->stub_group[code_sec->id].toc_off
10275                               != htab->stub_group[section->id].toc_off)
10276                           && (code_sec->has_toc_reloc
10277                               || code_sec->makes_toc_func_call))
10278                         stub_type = ppc_stub_long_branch_r2off;
10279                     }
10280
10281                   if (stub_type == ppc_stub_none)
10282                     continue;
10283
10284                   /* __tls_get_addr calls might be eliminated.  */
10285                   if (stub_type != ppc_stub_plt_call
10286                       && hash != NULL
10287                       && (hash == htab->tls_get_addr
10288                           || hash == htab->tls_get_addr_fd)
10289                       && section->has_tls_reloc
10290                       && irela != internal_relocs)
10291                     {
10292                       /* Get tls info.  */
10293                       char *tls_mask;
10294
10295                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
10296                                          irela - 1, input_bfd))
10297                         goto error_ret_free_internal;
10298                       if (*tls_mask != 0)
10299                         continue;
10300                     }
10301
10302                   /* Support for grouping stub sections.  */
10303                   id_sec = htab->stub_group[section->id].link_sec;
10304
10305                   /* Get the name of this stub.  */
10306                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10307                   if (!stub_name)
10308                     goto error_ret_free_internal;
10309
10310                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10311                                                      stub_name, FALSE, FALSE);
10312                   if (stub_entry != NULL)
10313                     {
10314                       /* The proper stub has already been created.  */
10315                       free (stub_name);
10316                       continue;
10317                     }
10318
10319                   stub_entry = ppc_add_stub (stub_name, section, htab);
10320                   if (stub_entry == NULL)
10321                     {
10322                       free (stub_name);
10323                     error_ret_free_internal:
10324                       if (elf_section_data (section)->relocs == NULL)
10325                         free (internal_relocs);
10326                     error_ret_free_local:
10327                       if (local_syms != NULL
10328                           && (symtab_hdr->contents
10329                               != (unsigned char *) local_syms))
10330                         free (local_syms);
10331                       return FALSE;
10332                     }
10333
10334                   stub_entry->stub_type = stub_type;
10335                   if (stub_type != ppc_stub_plt_call)
10336                     {
10337                       stub_entry->target_value = code_value;
10338                       stub_entry->target_section = code_sec;
10339                     }
10340                   else
10341                     {
10342                       stub_entry->target_value = sym_value;
10343                       stub_entry->target_section = sym_sec;
10344                     }
10345                   stub_entry->h = hash;
10346                   stub_entry->plt_ent = plt_ent;
10347                   stub_entry->addend = irela->r_addend;
10348
10349                   if (stub_entry->h != NULL)
10350                     htab->stub_globals += 1;
10351                 }
10352
10353               /* We're done with the internal relocs, free them.  */
10354               if (elf_section_data (section)->relocs != internal_relocs)
10355                 free (internal_relocs);
10356             }
10357
10358           if (local_syms != NULL
10359               && symtab_hdr->contents != (unsigned char *) local_syms)
10360             {
10361               if (!info->keep_memory)
10362                 free (local_syms);
10363               else
10364                 symtab_hdr->contents = (unsigned char *) local_syms;
10365             }
10366         }
10367
10368       /* We may have added some stubs.  Find out the new size of the
10369          stub sections.  */
10370       for (stub_sec = htab->stub_bfd->sections;
10371            stub_sec != NULL;
10372            stub_sec = stub_sec->next)
10373         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10374           {
10375             stub_sec->rawsize = stub_sec->size;
10376             stub_sec->size = 0;
10377             stub_sec->reloc_count = 0;
10378             stub_sec->flags &= ~SEC_RELOC;
10379           }
10380
10381       htab->brlt->size = 0;
10382       htab->brlt->reloc_count = 0;
10383       htab->brlt->flags &= ~SEC_RELOC;
10384       if (htab->relbrlt != NULL)
10385         htab->relbrlt->size = 0;
10386
10387       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
10388
10389       if (info->emitrelocations
10390           && htab->glink != NULL && htab->glink->size != 0)
10391         {
10392           htab->glink->reloc_count = 1;
10393           htab->glink->flags |= SEC_RELOC;
10394         }
10395
10396       for (stub_sec = htab->stub_bfd->sections;
10397            stub_sec != NULL;
10398            stub_sec = stub_sec->next)
10399         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10400             && stub_sec->rawsize != stub_sec->size)
10401           break;
10402
10403       /* Exit from this loop when no stubs have been added, and no stubs
10404          have changed size.  */
10405       if (stub_sec == NULL)
10406         break;
10407
10408       /* Ask the linker to do its stuff.  */
10409       (*htab->layout_sections_again) ();
10410     }
10411
10412   /* It would be nice to strip htab->brlt from the output if the
10413      section is empty, but it's too late.  If we strip sections here,
10414      the dynamic symbol table is corrupted since the section symbol
10415      for the stripped section isn't written.  */
10416
10417   return TRUE;
10418 }
10419
10420 /* Called after we have determined section placement.  If sections
10421    move, we'll be called again.  Provide a value for TOCstart.  */
10422
10423 bfd_vma
10424 ppc64_elf_toc (bfd *obfd)
10425 {
10426   asection *s;
10427   bfd_vma TOCstart;
10428
10429   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10430      order.  The TOC starts where the first of these sections starts.  */
10431   s = bfd_get_section_by_name (obfd, ".got");
10432   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10433     s = bfd_get_section_by_name (obfd, ".toc");
10434   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10435     s = bfd_get_section_by_name (obfd, ".tocbss");
10436   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10437     s = bfd_get_section_by_name (obfd, ".plt");
10438   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10439     {
10440       /* This may happen for
10441          o  references to TOC base (SYM@toc / TOC[tc0]) without a
10442          .toc directive
10443          o  bad linker script
10444          o --gc-sections and empty TOC sections
10445
10446          FIXME: Warn user?  */
10447
10448       /* Look for a likely section.  We probably won't even be
10449          using TOCstart.  */
10450       for (s = obfd->sections; s != NULL; s = s->next)
10451         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10452                          | SEC_EXCLUDE))
10453             == (SEC_ALLOC | SEC_SMALL_DATA))
10454           break;
10455       if (s == NULL)
10456         for (s = obfd->sections; s != NULL; s = s->next)
10457           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
10458               == (SEC_ALLOC | SEC_SMALL_DATA))
10459             break;
10460       if (s == NULL)
10461         for (s = obfd->sections; s != NULL; s = s->next)
10462           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10463               == SEC_ALLOC)
10464             break;
10465       if (s == NULL)
10466         for (s = obfd->sections; s != NULL; s = s->next)
10467           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
10468             break;
10469     }
10470
10471   TOCstart = 0;
10472   if (s != NULL)
10473     TOCstart = s->output_section->vma + s->output_offset;
10474
10475   return TOCstart;
10476 }
10477
10478 /* Build all the stubs associated with the current output file.
10479    The stubs are kept in a hash table attached to the main linker
10480    hash table.  This function is called via gldelf64ppc_finish.  */
10481
10482 bfd_boolean
10483 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10484                        struct bfd_link_info *info,
10485                        char **stats)
10486 {
10487   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10488   asection *stub_sec;
10489   bfd_byte *p;
10490   int stub_sec_count = 0;
10491
10492   htab->emit_stub_syms = emit_stub_syms;
10493
10494   /* Allocate memory to hold the linker stubs.  */
10495   for (stub_sec = htab->stub_bfd->sections;
10496        stub_sec != NULL;
10497        stub_sec = stub_sec->next)
10498     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10499         && stub_sec->size != 0)
10500       {
10501         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
10502         if (stub_sec->contents == NULL)
10503           return FALSE;
10504         /* We want to check that built size is the same as calculated
10505            size.  rawsize is a convenient location to use.  */
10506         stub_sec->rawsize = stub_sec->size;
10507         stub_sec->size = 0;
10508       }
10509
10510   if (htab->glink != NULL && htab->glink->size != 0)
10511     {
10512       unsigned int indx;
10513       bfd_vma plt0;
10514
10515       /* Build the .glink plt call stub.  */
10516       if (htab->emit_stub_syms)
10517         {
10518           struct elf_link_hash_entry *h;
10519           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
10520                                     TRUE, FALSE, FALSE);
10521           if (h == NULL)
10522             return FALSE;
10523           if (h->root.type == bfd_link_hash_new)
10524             {
10525               h->root.type = bfd_link_hash_defined;
10526               h->root.u.def.section = htab->glink;
10527               h->root.u.def.value = 8;
10528               h->ref_regular = 1;
10529               h->def_regular = 1;
10530               h->ref_regular_nonweak = 1;
10531               h->forced_local = 1;
10532               h->non_elf = 0;
10533             }
10534         }
10535       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10536       if (info->emitrelocations)
10537         {
10538           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10539           if (r == NULL)
10540             return FALSE;
10541           r->r_offset = (htab->glink->output_offset
10542                          + htab->glink->output_section->vma);
10543           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10544           r->r_addend = plt0;
10545         }
10546       p = htab->glink->contents;
10547       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
10548       bfd_put_64 (htab->glink->owner, plt0, p);
10549       p += 8;
10550       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
10551       p += 4;
10552       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
10553       p += 4;
10554       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
10555       p += 4;
10556       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
10557       p += 4;
10558       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
10559       p += 4;
10560       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
10561       p += 4;
10562       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
10563       p += 4;
10564       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
10565       p += 4;
10566       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
10567       p += 4;
10568       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
10569       p += 4;
10570       bfd_put_32 (htab->glink->owner, BCTR, p);
10571       p += 4;
10572       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10573         {
10574           bfd_put_32 (htab->glink->owner, NOP, p);
10575           p += 4;
10576         }
10577
10578       /* Build the .glink lazy link call stubs.  */
10579       indx = 0;
10580       while (p < htab->glink->contents + htab->glink->size)
10581         {
10582           if (indx < 0x8000)
10583             {
10584               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
10585               p += 4;
10586             }
10587           else
10588             {
10589               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
10590               p += 4;
10591               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
10592               p += 4;
10593             }
10594           bfd_put_32 (htab->glink->owner,
10595                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
10596           indx++;
10597           p += 4;
10598         }
10599       htab->glink->rawsize = p - htab->glink->contents;
10600     }
10601
10602   if (htab->brlt->size != 0)
10603     {
10604       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
10605                                          htab->brlt->size);
10606       if (htab->brlt->contents == NULL)
10607         return FALSE;
10608     }
10609   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
10610     {
10611       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
10612                                             htab->relbrlt->size);
10613       if (htab->relbrlt->contents == NULL)
10614         return FALSE;
10615     }
10616
10617   /* Build the stubs as directed by the stub hash table.  */
10618   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
10619
10620   if (htab->relbrlt != NULL)
10621     htab->relbrlt->reloc_count = 0;
10622
10623   for (stub_sec = htab->stub_bfd->sections;
10624        stub_sec != NULL;
10625        stub_sec = stub_sec->next)
10626     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10627       {
10628         stub_sec_count += 1;
10629         if (stub_sec->rawsize != stub_sec->size)
10630           break;
10631       }
10632
10633   if (stub_sec != NULL
10634       || htab->glink->rawsize != htab->glink->size)
10635     {
10636       htab->stub_error = TRUE;
10637       (*_bfd_error_handler) (_("stubs don't match calculated size"));
10638     }
10639
10640   if (htab->stub_error)
10641     return FALSE;
10642
10643   if (stats != NULL)
10644     {
10645       *stats = bfd_malloc (500);
10646       if (*stats == NULL)
10647         return FALSE;
10648
10649       sprintf (*stats, _("linker stubs in %u group%s\n"
10650                          "  branch       %lu\n"
10651                          "  toc adjust   %lu\n"
10652                          "  long branch  %lu\n"
10653                          "  long toc adj %lu\n"
10654                          "  plt call     %lu"),
10655                stub_sec_count,
10656                stub_sec_count == 1 ? "" : "s",
10657                htab->stub_count[ppc_stub_long_branch - 1],
10658                htab->stub_count[ppc_stub_long_branch_r2off - 1],
10659                htab->stub_count[ppc_stub_plt_branch - 1],
10660                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
10661                htab->stub_count[ppc_stub_plt_call - 1]);
10662     }
10663   return TRUE;
10664 }
10665
10666 /* This function undoes the changes made by add_symbol_adjust.  */
10667
10668 static bfd_boolean
10669 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10670 {
10671   struct ppc_link_hash_entry *eh;
10672
10673   if (h->root.type == bfd_link_hash_indirect)
10674     return TRUE;
10675
10676   if (h->root.type == bfd_link_hash_warning)
10677     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10678
10679   eh = (struct ppc_link_hash_entry *) h;
10680   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
10681     return TRUE;
10682
10683   eh->elf.root.type = bfd_link_hash_undefined;
10684   return TRUE;
10685 }
10686
10687 void
10688 ppc64_elf_restore_symbols (struct bfd_link_info *info)
10689 {
10690   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10691   elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
10692 }
10693
10694 /* What to do when ld finds relocations against symbols defined in
10695    discarded sections.  */
10696
10697 static unsigned int
10698 ppc64_elf_action_discarded (asection *sec)
10699 {
10700   if (strcmp (".opd", sec->name) == 0)
10701     return 0;
10702
10703   if (strcmp (".toc", sec->name) == 0)
10704     return 0;
10705
10706   if (strcmp (".toc1", sec->name) == 0)
10707     return 0;
10708
10709   return _bfd_elf_default_action_discarded (sec);
10710 }
10711
10712 /* The RELOCATE_SECTION function is called by the ELF backend linker
10713    to handle the relocations for a section.
10714
10715    The relocs are always passed as Rela structures; if the section
10716    actually uses Rel structures, the r_addend field will always be
10717    zero.
10718
10719    This function is responsible for adjust the section contents as
10720    necessary, and (if using Rela relocs and generating a
10721    relocatable output file) adjusting the reloc addend as
10722    necessary.
10723
10724    This function does not have to worry about setting the reloc
10725    address or the reloc symbol index.
10726
10727    LOCAL_SYMS is a pointer to the swapped in local symbols.
10728
10729    LOCAL_SECTIONS is an array giving the section in the input file
10730    corresponding to the st_shndx field of each local symbol.
10731
10732    The global hash table entry for the global symbols can be found
10733    via elf_sym_hashes (input_bfd).
10734
10735    When generating relocatable output, this function must handle
10736    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
10737    going to be the section symbol corresponding to the output
10738    section, which means that the addend must be adjusted
10739    accordingly.  */
10740
10741 static bfd_boolean
10742 ppc64_elf_relocate_section (bfd *output_bfd,
10743                             struct bfd_link_info *info,
10744                             bfd *input_bfd,
10745                             asection *input_section,
10746                             bfd_byte *contents,
10747                             Elf_Internal_Rela *relocs,
10748                             Elf_Internal_Sym *local_syms,
10749                             asection **local_sections)
10750 {
10751   struct ppc_link_hash_table *htab;
10752   Elf_Internal_Shdr *symtab_hdr;
10753   struct elf_link_hash_entry **sym_hashes;
10754   Elf_Internal_Rela *rel;
10755   Elf_Internal_Rela *relend;
10756   Elf_Internal_Rela outrel;
10757   bfd_byte *loc;
10758   struct got_entry **local_got_ents;
10759   bfd_vma TOCstart;
10760   bfd_boolean ret = TRUE;
10761   bfd_boolean is_opd;
10762   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
10763   bfd_boolean is_power4 = FALSE;
10764   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
10765
10766   /* Initialize howto table if needed.  */
10767   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
10768     ppc_howto_init ();
10769
10770   htab = ppc_hash_table (info);
10771
10772   /* Don't relocate stub sections.  */
10773   if (input_section->owner == htab->stub_bfd)
10774     return TRUE;
10775
10776   BFD_ASSERT (is_ppc64_elf (input_bfd));
10777
10778   local_got_ents = elf_local_got_ents (input_bfd);
10779   TOCstart = elf_gp (output_bfd);
10780   symtab_hdr = &elf_symtab_hdr (input_bfd);
10781   sym_hashes = elf_sym_hashes (input_bfd);
10782   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
10783
10784   rel = relocs;
10785   relend = relocs + input_section->reloc_count;
10786   for (; rel < relend; rel++)
10787     {
10788       enum elf_ppc64_reloc_type r_type;
10789       bfd_vma addend, orig_addend;
10790       bfd_reloc_status_type r;
10791       Elf_Internal_Sym *sym;
10792       asection *sec;
10793       struct elf_link_hash_entry *h_elf;
10794       struct ppc_link_hash_entry *h;
10795       struct ppc_link_hash_entry *fdh;
10796       const char *sym_name;
10797       unsigned long r_symndx, toc_symndx;
10798       bfd_vma toc_addend;
10799       char tls_mask, tls_gd, tls_type;
10800       char sym_type;
10801       bfd_vma relocation;
10802       bfd_boolean unresolved_reloc;
10803       bfd_boolean warned;
10804       unsigned long insn, mask;
10805       struct ppc_stub_hash_entry *stub_entry;
10806       bfd_vma max_br_offset;
10807       bfd_vma from;
10808
10809       r_type = ELF64_R_TYPE (rel->r_info);
10810       r_symndx = ELF64_R_SYM (rel->r_info);
10811
10812       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10813          symbol of the previous ADDR64 reloc.  The symbol gives us the
10814          proper TOC base to use.  */
10815       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10816           && rel != relocs
10817           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10818           && is_opd)
10819         r_symndx = ELF64_R_SYM (rel[-1].r_info);
10820
10821       sym = NULL;
10822       sec = NULL;
10823       h_elf = NULL;
10824       sym_name = NULL;
10825       unresolved_reloc = FALSE;
10826       warned = FALSE;
10827       orig_addend = rel->r_addend;
10828
10829       if (r_symndx < symtab_hdr->sh_info)
10830         {
10831           /* It's a local symbol.  */
10832           struct _opd_sec_data *opd;
10833
10834           sym = local_syms + r_symndx;
10835           sec = local_sections[r_symndx];
10836           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
10837           sym_type = ELF64_ST_TYPE (sym->st_info);
10838           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10839           opd = get_opd_info (sec);
10840           if (opd != NULL && opd->adjust != NULL)
10841             {
10842               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
10843               if (adjust == -1)
10844                 relocation = 0;
10845               else
10846                 {
10847                   /* If this is a relocation against the opd section sym
10848                      and we have edited .opd, adjust the reloc addend so
10849                      that ld -r and ld --emit-relocs output is correct.
10850                      If it is a reloc against some other .opd symbol,
10851                      then the symbol value will be adjusted later.  */
10852                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10853                     rel->r_addend += adjust;
10854                   else
10855                     relocation += adjust;
10856                 }
10857             }
10858         }
10859       else
10860         {
10861           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10862                                    r_symndx, symtab_hdr, sym_hashes,
10863                                    h_elf, sec, relocation,
10864                                    unresolved_reloc, warned);
10865           sym_name = h_elf->root.root.string;
10866           sym_type = h_elf->type;
10867         }
10868       h = (struct ppc_link_hash_entry *) h_elf;
10869
10870       if (sec != NULL && elf_discarded_section (sec))
10871         {
10872           /* For relocs against symbols from removed linkonce sections,
10873              or sections discarded by a linker script, we just want the
10874              section contents zeroed.  Avoid any special processing.  */
10875           _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10876                                contents + rel->r_offset);
10877           rel->r_info = 0;
10878           rel->r_addend = 0;
10879           continue;
10880         }
10881
10882       if (info->relocatable)
10883         continue;
10884
10885       /* TLS optimizations.  Replace instruction sequences and relocs
10886          based on information we collected in tls_optimize.  We edit
10887          RELOCS so that --emit-relocs will output something sensible
10888          for the final instruction stream.  */
10889       tls_mask = 0;
10890       tls_gd = 0;
10891       toc_symndx = 0;
10892       if (h != NULL)
10893         tls_mask = h->tls_mask;
10894       else if (local_got_ents != NULL)
10895         {
10896           struct plt_entry **local_plt = (struct plt_entry **)
10897             (local_got_ents + symtab_hdr->sh_info);
10898           char *lgot_masks = (char *)
10899             (local_plt + symtab_hdr->sh_info);
10900           tls_mask = lgot_masks[r_symndx];
10901         }
10902       if (tls_mask == 0
10903           && (r_type == R_PPC64_TLS
10904               || r_type == R_PPC64_TLSGD
10905               || r_type == R_PPC64_TLSLD))
10906         {
10907           /* Check for toc tls entries.  */
10908           char *toc_tls;
10909
10910           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10911                              &local_syms, rel, input_bfd))
10912             return FALSE;
10913
10914           if (toc_tls)
10915             tls_mask = *toc_tls;
10916         }
10917
10918       /* Check that tls relocs are used with tls syms, and non-tls
10919          relocs are used with non-tls syms.  */
10920       if (r_symndx != 0
10921           && r_type != R_PPC64_NONE
10922           && (h == NULL
10923               || h->elf.root.type == bfd_link_hash_defined
10924               || h->elf.root.type == bfd_link_hash_defweak)
10925           && (IS_PPC64_TLS_RELOC (r_type)
10926               != (sym_type == STT_TLS
10927                   || (sym_type == STT_SECTION
10928                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
10929         {
10930           if (tls_mask != 0
10931               && (r_type == R_PPC64_TLS
10932                   || r_type == R_PPC64_TLSGD
10933                   || r_type == R_PPC64_TLSLD))
10934             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
10935             ;
10936           else
10937             (*_bfd_error_handler)
10938               (!IS_PPC64_TLS_RELOC (r_type)
10939                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10940                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10941                input_bfd,
10942                input_section,
10943                (long) rel->r_offset,
10944                ppc64_elf_howto_table[r_type]->name,
10945                sym_name);
10946         }
10947
10948       /* Ensure reloc mapping code below stays sane.  */
10949       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10950           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10951           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
10952           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10953           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10954           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10955           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
10956           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10957           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10958           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10959         abort ();
10960
10961       switch (r_type)
10962         {
10963         default:
10964           break;
10965
10966         case R_PPC64_TOC16:
10967         case R_PPC64_TOC16_LO:
10968         case R_PPC64_TOC16_DS:
10969         case R_PPC64_TOC16_LO_DS:
10970           {
10971             /* Check for toc tls entries.  */
10972             char *toc_tls;
10973             int retval;
10974
10975             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10976                                    &local_syms, rel, input_bfd);
10977             if (retval == 0)
10978               return FALSE;
10979
10980             if (toc_tls)
10981               {
10982                 tls_mask = *toc_tls;
10983                 if (r_type == R_PPC64_TOC16_DS
10984                     || r_type == R_PPC64_TOC16_LO_DS)
10985                   {
10986                     if (tls_mask != 0
10987                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10988                       goto toctprel;
10989                   }
10990                 else
10991                   {
10992                     /* If we found a GD reloc pair, then we might be
10993                        doing a GD->IE transition.  */
10994                     if (retval == 2)
10995                       {
10996                         tls_gd = TLS_TPRELGD;
10997                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10998                           goto tls_ldgd_opt;
10999                       }
11000                     else if (retval == 3)
11001                       {
11002                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11003                           goto tls_ldgd_opt;
11004                       }
11005                   }
11006               }
11007           }
11008           break;
11009
11010         case R_PPC64_GOT_TPREL16_DS:
11011         case R_PPC64_GOT_TPREL16_LO_DS:
11012           if (tls_mask != 0
11013               && (tls_mask & TLS_TPREL) == 0)
11014             {
11015             toctprel:
11016               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11017               insn &= 31 << 21;
11018               insn |= 0x3c0d0000;       /* addis 0,13,0 */
11019               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11020               r_type = R_PPC64_TPREL16_HA;
11021               if (toc_symndx != 0)
11022                 {
11023                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11024                   rel->r_addend = toc_addend;
11025                   /* We changed the symbol.  Start over in order to
11026                      get h, sym, sec etc. right.  */
11027                   rel--;
11028                   continue;
11029                 }
11030               else
11031                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11032             }
11033           break;
11034
11035         case R_PPC64_TLS:
11036           if (tls_mask != 0
11037               && (tls_mask & TLS_TPREL) == 0)
11038             {
11039               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11040               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11041               if (insn == 0)
11042                 abort ();
11043               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11044               /* Was PPC64_TLS which sits on insn boundary, now
11045                  PPC64_TPREL16_LO which is at low-order half-word.  */
11046               rel->r_offset += d_offset;
11047               r_type = R_PPC64_TPREL16_LO;
11048               if (toc_symndx != 0)
11049                 {
11050                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11051                   rel->r_addend = toc_addend;
11052                   /* We changed the symbol.  Start over in order to
11053                      get h, sym, sec etc. right.  */
11054                   rel--;
11055                   continue;
11056                 }
11057               else
11058                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11059             }
11060           break;
11061
11062         case R_PPC64_GOT_TLSGD16_HI:
11063         case R_PPC64_GOT_TLSGD16_HA:
11064           tls_gd = TLS_TPRELGD;
11065           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11066             goto tls_gdld_hi;
11067           break;
11068
11069         case R_PPC64_GOT_TLSLD16_HI:
11070         case R_PPC64_GOT_TLSLD16_HA:
11071           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11072             {
11073             tls_gdld_hi:
11074               if ((tls_mask & tls_gd) != 0)
11075                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11076                           + R_PPC64_GOT_TPREL16_DS);
11077               else
11078                 {
11079                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11080                   rel->r_offset -= d_offset;
11081                   r_type = R_PPC64_NONE;
11082                 }
11083               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11084             }
11085           break;
11086
11087         case R_PPC64_GOT_TLSGD16:
11088         case R_PPC64_GOT_TLSGD16_LO:
11089           tls_gd = TLS_TPRELGD;
11090           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11091             goto tls_ldgd_opt;
11092           break;
11093
11094         case R_PPC64_GOT_TLSLD16:
11095         case R_PPC64_GOT_TLSLD16_LO:
11096           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11097             {
11098               unsigned int insn1, insn2, insn3;
11099               bfd_vma offset;
11100
11101             tls_ldgd_opt:
11102               offset = (bfd_vma) -1;
11103               /* If not using the newer R_PPC64_TLSGD/LD to mark
11104                  __tls_get_addr calls, we must trust that the call
11105                  stays with its arg setup insns, ie. that the next
11106                  reloc is the __tls_get_addr call associated with
11107                  the current reloc.  Edit both insns.  */
11108               if (input_section->has_tls_get_addr_call
11109                   && rel + 1 < relend
11110                   && branch_reloc_hash_match (input_bfd, rel + 1,
11111                                               htab->tls_get_addr,
11112                                               htab->tls_get_addr_fd))
11113                 offset = rel[1].r_offset;
11114               if ((tls_mask & tls_gd) != 0)
11115                 {
11116                   /* IE */
11117                   insn1 = bfd_get_32 (output_bfd,
11118                                       contents + rel->r_offset - d_offset);
11119                   insn1 &= (1 << 26) - (1 << 2);
11120                   insn1 |= 58 << 26;    /* ld */
11121                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11122                   if (offset != (bfd_vma) -1)
11123                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11124                   if ((tls_mask & TLS_EXPLICIT) == 0)
11125                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11126                               + R_PPC64_GOT_TPREL16_DS);
11127                   else
11128                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
11129                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11130                 }
11131               else
11132                 {
11133                   /* LE */
11134                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
11135                   insn2 = 0x38630000;   /* addi 3,3,0 */
11136                   if (tls_gd == 0)
11137                     {
11138                       /* Was an LD reloc.  */
11139                       if (toc_symndx)
11140                         sec = local_sections[toc_symndx];
11141                       for (r_symndx = 0;
11142                            r_symndx < symtab_hdr->sh_info;
11143                            r_symndx++)
11144                         if (local_sections[r_symndx] == sec)
11145                           break;
11146                       if (r_symndx >= symtab_hdr->sh_info)
11147                         r_symndx = 0;
11148                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11149                       if (r_symndx != 0)
11150                         rel->r_addend -= (local_syms[r_symndx].st_value
11151                                           + sec->output_offset
11152                                           + sec->output_section->vma);
11153                     }
11154                   else if (toc_symndx != 0)
11155                     {
11156                       r_symndx = toc_symndx;
11157                       rel->r_addend = toc_addend;
11158                     }
11159                   r_type = R_PPC64_TPREL16_HA;
11160                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11161                   if (offset != (bfd_vma) -1)
11162                     {
11163                       rel[1].r_info = ELF64_R_INFO (r_symndx,
11164                                                     R_PPC64_TPREL16_LO);
11165                       rel[1].r_offset = offset + d_offset;
11166                       rel[1].r_addend = rel->r_addend;
11167                     }
11168                 }
11169               bfd_put_32 (output_bfd, insn1,
11170                           contents + rel->r_offset - d_offset);
11171               if (offset != (bfd_vma) -1)
11172                 {
11173                   insn3 = bfd_get_32 (output_bfd,
11174                                       contents + offset + 4);
11175                   if (insn3 == NOP
11176                       || insn3 == CROR_151515 || insn3 == CROR_313131)
11177                     {
11178                       rel[1].r_offset += 4;
11179                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11180                       insn2 = NOP;
11181                     }
11182                   bfd_put_32 (output_bfd, insn2, contents + offset);
11183                 }
11184               if ((tls_mask & tls_gd) == 0
11185                   && (tls_gd == 0 || toc_symndx != 0))
11186                 {
11187                   /* We changed the symbol.  Start over in order
11188                      to get h, sym, sec etc. right.  */
11189                   rel--;
11190                   continue;
11191                 }
11192             }
11193           break;
11194
11195         case R_PPC64_TLSGD:
11196           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11197             {
11198               unsigned int insn2, insn3;
11199               bfd_vma offset = rel->r_offset;
11200
11201               if ((tls_mask & TLS_TPRELGD) != 0)
11202                 {
11203                   /* IE */
11204                   r_type = R_PPC64_NONE;
11205                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11206                 }
11207               else
11208                 {
11209                   /* LE */
11210                   if (toc_symndx != 0)
11211                     {
11212                       r_symndx = toc_symndx;
11213                       rel->r_addend = toc_addend;
11214                     }
11215                   r_type = R_PPC64_TPREL16_LO;
11216                   rel->r_offset = offset + d_offset;
11217                   insn2 = 0x38630000;   /* addi 3,3,0 */
11218                 }
11219               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11220               /* Zap the reloc on the _tls_get_addr call too.  */
11221               BFD_ASSERT (offset == rel[1].r_offset);
11222               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11223               insn3 = bfd_get_32 (output_bfd,
11224                                   contents + offset + 4);
11225               if (insn3 == NOP
11226                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11227                 {
11228                   rel->r_offset += 4;
11229                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11230                   insn2 = NOP;
11231                 }
11232               bfd_put_32 (output_bfd, insn2, contents + offset);
11233               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
11234                 {
11235                   rel--;
11236                   continue;
11237                 }
11238             }
11239           break;
11240
11241         case R_PPC64_TLSLD:
11242           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11243             {
11244               unsigned int insn2, insn3;
11245               bfd_vma offset = rel->r_offset;
11246
11247               if (toc_symndx)
11248                 sec = local_sections[toc_symndx];
11249               for (r_symndx = 0;
11250                    r_symndx < symtab_hdr->sh_info;
11251                    r_symndx++)
11252                 if (local_sections[r_symndx] == sec)
11253                   break;
11254               if (r_symndx >= symtab_hdr->sh_info)
11255                 r_symndx = 0;
11256               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11257               if (r_symndx != 0)
11258                 rel->r_addend -= (local_syms[r_symndx].st_value
11259                                   + sec->output_offset
11260                                   + sec->output_section->vma);
11261
11262               r_type = R_PPC64_TPREL16_LO;
11263               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11264               rel->r_offset = offset + d_offset;
11265               /* Zap the reloc on the _tls_get_addr call too.  */
11266               BFD_ASSERT (offset == rel[1].r_offset);
11267               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11268               insn2 = 0x38630000;       /* addi 3,3,0 */
11269               insn3 = bfd_get_32 (output_bfd,
11270                                   contents + offset + 4);
11271               if (insn3 == NOP
11272                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11273                 {
11274                   rel->r_offset += 4;
11275                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11276                   insn2 = NOP;
11277                 }
11278               bfd_put_32 (output_bfd, insn2, contents + offset);
11279               rel--;
11280               continue;
11281             }
11282           break;
11283
11284         case R_PPC64_DTPMOD64:
11285           if (rel + 1 < relend
11286               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11287               && rel[1].r_offset == rel->r_offset + 8)
11288             {
11289               if ((tls_mask & TLS_GD) == 0)
11290                 {
11291                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11292                   if ((tls_mask & TLS_TPRELGD) != 0)
11293                     r_type = R_PPC64_TPREL64;
11294                   else
11295                     {
11296                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11297                       r_type = R_PPC64_NONE;
11298                     }
11299                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11300                 }
11301             }
11302           else
11303             {
11304               if ((tls_mask & TLS_LD) == 0)
11305                 {
11306                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11307                   r_type = R_PPC64_NONE;
11308                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11309                 }
11310             }
11311           break;
11312
11313         case R_PPC64_TPREL64:
11314           if ((tls_mask & TLS_TPREL) == 0)
11315             {
11316               r_type = R_PPC64_NONE;
11317               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11318             }
11319           break;
11320         }
11321
11322       /* Handle other relocations that tweak non-addend part of insn.  */
11323       insn = 0;
11324       max_br_offset = 1 << 25;
11325       addend = rel->r_addend;
11326       switch (r_type)
11327         {
11328         default:
11329           break;
11330
11331           /* Branch taken prediction relocations.  */
11332         case R_PPC64_ADDR14_BRTAKEN:
11333         case R_PPC64_REL14_BRTAKEN:
11334           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
11335           /* Fall thru.  */
11336
11337           /* Branch not taken prediction relocations.  */
11338         case R_PPC64_ADDR14_BRNTAKEN:
11339         case R_PPC64_REL14_BRNTAKEN:
11340           insn |= bfd_get_32 (output_bfd,
11341                               contents + rel->r_offset) & ~(0x01 << 21);
11342           /* Fall thru.  */
11343
11344         case R_PPC64_REL14:
11345           max_br_offset = 1 << 15;
11346           /* Fall thru.  */
11347
11348         case R_PPC64_REL24:
11349           /* Calls to functions with a different TOC, such as calls to
11350              shared objects, need to alter the TOC pointer.  This is
11351              done using a linkage stub.  A REL24 branching to these
11352              linkage stubs needs to be followed by a nop, as the nop
11353              will be replaced with an instruction to restore the TOC
11354              base pointer.  */
11355           stub_entry = NULL;
11356           fdh = h;
11357           if (h != NULL
11358               && h->oh != NULL
11359               && h->oh->is_func_descriptor)
11360             fdh = ppc_follow_link (h->oh);
11361           if (((fdh != NULL
11362                 && fdh->elf.plt.plist != NULL)
11363                || (sec != NULL
11364                    && sec->output_section != NULL
11365                    && sec->id <= htab->top_id
11366                    && (htab->stub_group[sec->id].toc_off
11367                        != htab->stub_group[input_section->id].toc_off))
11368                || (h == NULL
11369                    && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
11370               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
11371                                                    rel, htab)) != NULL
11372               && (stub_entry->stub_type == ppc_stub_plt_call
11373                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11374                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
11375             {
11376               bfd_boolean can_plt_call = FALSE;
11377
11378               if (rel->r_offset + 8 <= input_section->size)
11379                 {
11380                   unsigned long nop;
11381                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11382                   if (nop == NOP
11383                       || nop == CROR_151515 || nop == CROR_313131)
11384                     {
11385                       if (h != NULL
11386                           && (h == htab->tls_get_addr_fd
11387                               || h == htab->tls_get_addr)
11388                           && !htab->no_tls_get_addr_opt)
11389                         {
11390                           /* Special stub used, leave nop alone.  */
11391                         }
11392                       else
11393                         bfd_put_32 (input_bfd, LD_R2_40R1,
11394                                     contents + rel->r_offset + 4);
11395                       can_plt_call = TRUE;
11396                     }
11397                 }
11398
11399               if (!can_plt_call)
11400                 {
11401                   if (stub_entry->stub_type == ppc_stub_plt_call)
11402                     {
11403                       /* If this is a plain branch rather than a branch
11404                          and link, don't require a nop.  However, don't
11405                          allow tail calls in a shared library as they
11406                          will result in r2 being corrupted.  */
11407                       unsigned long br;
11408                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
11409                       if (info->executable && (br & 1) == 0)
11410                         can_plt_call = TRUE;
11411                       else
11412                         stub_entry = NULL;
11413                     }
11414                   else if (h != NULL
11415                            && strcmp (h->elf.root.root.string,
11416                                       ".__libc_start_main") == 0)
11417                     {
11418                       /* Allow crt1 branch to go via a toc adjusting stub.  */
11419                       can_plt_call = TRUE;
11420                     }
11421                   else
11422                     {
11423                       if (strcmp (input_section->output_section->name,
11424                                   ".init") == 0
11425                           || strcmp (input_section->output_section->name,
11426                                      ".fini") == 0)
11427                         (*_bfd_error_handler)
11428                           (_("%B(%A+0x%lx): automatic multiple TOCs "
11429                              "not supported using your crt files; "
11430                              "recompile with -mminimal-toc or upgrade gcc"),
11431                            input_bfd,
11432                            input_section,
11433                            (long) rel->r_offset);
11434                       else
11435                         (*_bfd_error_handler)
11436                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
11437                              "does not allow automatic multiple TOCs; "
11438                              "recompile with -mminimal-toc or "
11439                              "-fno-optimize-sibling-calls, "
11440                              "or make `%s' extern"),
11441                            input_bfd,
11442                            input_section,
11443                            (long) rel->r_offset,
11444                            sym_name,
11445                            sym_name);
11446                       bfd_set_error (bfd_error_bad_value);
11447                       ret = FALSE;
11448                     }
11449                 }
11450
11451               if (can_plt_call
11452                   && stub_entry->stub_type == ppc_stub_plt_call)
11453                 unresolved_reloc = FALSE;
11454             }
11455
11456           if (stub_entry == NULL
11457               && get_opd_info (sec) != NULL)
11458             {
11459               /* The branch destination is the value of the opd entry. */
11460               bfd_vma off = (relocation + addend
11461                              - sec->output_section->vma
11462                              - sec->output_offset);
11463               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11464               if (dest != (bfd_vma) -1)
11465                 {
11466                   relocation = dest;
11467                   addend = 0;
11468                 }
11469             }
11470
11471           /* If the branch is out of reach we ought to have a long
11472              branch stub.  */
11473           from = (rel->r_offset
11474                   + input_section->output_offset
11475                   + input_section->output_section->vma);
11476
11477           if (stub_entry == NULL
11478               && (relocation + addend - from + max_br_offset
11479                   >= 2 * max_br_offset)
11480               && r_type != R_PPC64_ADDR14_BRTAKEN
11481               && r_type != R_PPC64_ADDR14_BRNTAKEN)
11482             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
11483                                              htab);
11484
11485           if (stub_entry != NULL)
11486             {
11487               /* Munge up the value and addend so that we call the stub
11488                  rather than the procedure directly.  */
11489               relocation = (stub_entry->stub_offset
11490                             + stub_entry->stub_sec->output_offset
11491                             + stub_entry->stub_sec->output_section->vma);
11492               addend = 0;
11493             }
11494
11495           if (insn != 0)
11496             {
11497               if (is_power4)
11498                 {
11499                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
11500                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
11501                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
11502                   if ((insn & (0x14 << 21)) == (0x04 << 21))
11503                     insn |= 0x02 << 21;
11504                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
11505                     insn |= 0x08 << 21;
11506                   else
11507                     break;
11508                 }
11509               else
11510                 {
11511                   /* Invert 'y' bit if not the default.  */
11512                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
11513                     insn ^= 0x01 << 21;
11514                 }
11515
11516               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11517             }
11518
11519           /* NOP out calls to undefined weak functions.
11520              We can thus call a weak function without first
11521              checking whether the function is defined.  */
11522           else if (h != NULL
11523                    && h->elf.root.type == bfd_link_hash_undefweak
11524                    && h->elf.dynindx == -1
11525                    && r_type == R_PPC64_REL24
11526                    && relocation == 0
11527                    && addend == 0)
11528             {
11529               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11530               continue;
11531             }
11532           break;
11533         }
11534
11535       /* Set `addend'.  */
11536       tls_type = 0;
11537       switch (r_type)
11538         {
11539         default:
11540           (*_bfd_error_handler)
11541             (_("%B: unknown relocation type %d for symbol %s"),
11542              input_bfd, (int) r_type, sym_name);
11543
11544           bfd_set_error (bfd_error_bad_value);
11545           ret = FALSE;
11546           continue;
11547
11548         case R_PPC64_NONE:
11549         case R_PPC64_TLS:
11550         case R_PPC64_TLSGD:
11551         case R_PPC64_TLSLD:
11552         case R_PPC64_GNU_VTINHERIT:
11553         case R_PPC64_GNU_VTENTRY:
11554           continue;
11555
11556           /* GOT16 relocations.  Like an ADDR16 using the symbol's
11557              address in the GOT as relocation value instead of the
11558              symbol's value itself.  Also, create a GOT entry for the
11559              symbol and put the symbol value there.  */
11560         case R_PPC64_GOT_TLSGD16:
11561         case R_PPC64_GOT_TLSGD16_LO:
11562         case R_PPC64_GOT_TLSGD16_HI:
11563         case R_PPC64_GOT_TLSGD16_HA:
11564           tls_type = TLS_TLS | TLS_GD;
11565           goto dogot;
11566
11567         case R_PPC64_GOT_TLSLD16:
11568         case R_PPC64_GOT_TLSLD16_LO:
11569         case R_PPC64_GOT_TLSLD16_HI:
11570         case R_PPC64_GOT_TLSLD16_HA:
11571           tls_type = TLS_TLS | TLS_LD;
11572           goto dogot;
11573
11574         case R_PPC64_GOT_TPREL16_DS:
11575         case R_PPC64_GOT_TPREL16_LO_DS:
11576         case R_PPC64_GOT_TPREL16_HI:
11577         case R_PPC64_GOT_TPREL16_HA:
11578           tls_type = TLS_TLS | TLS_TPREL;
11579           goto dogot;
11580
11581         case R_PPC64_GOT_DTPREL16_DS:
11582         case R_PPC64_GOT_DTPREL16_LO_DS:
11583         case R_PPC64_GOT_DTPREL16_HI:
11584         case R_PPC64_GOT_DTPREL16_HA:
11585           tls_type = TLS_TLS | TLS_DTPREL;
11586           goto dogot;
11587
11588         case R_PPC64_GOT16:
11589         case R_PPC64_GOT16_LO:
11590         case R_PPC64_GOT16_HI:
11591         case R_PPC64_GOT16_HA:
11592         case R_PPC64_GOT16_DS:
11593         case R_PPC64_GOT16_LO_DS:
11594         dogot:
11595           {
11596             /* Relocation is to the entry for this symbol in the global
11597                offset table.  */
11598             asection *got;
11599             bfd_vma *offp;
11600             bfd_vma off;
11601             unsigned long indx = 0;
11602
11603             if (tls_type == (TLS_TLS | TLS_LD)
11604                 && (h == NULL
11605                     || !h->elf.def_dynamic))
11606               offp = &ppc64_tlsld_got (input_bfd)->offset;
11607             else
11608               {
11609                 struct got_entry *ent;
11610
11611                 if (h != NULL)
11612                   {
11613                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
11614                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
11615                                                           &h->elf)
11616                         || (info->shared
11617                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
11618                       /* This is actually a static link, or it is a
11619                          -Bsymbolic link and the symbol is defined
11620                          locally, or the symbol was forced to be local
11621                          because of a version file.  */
11622                       ;
11623                     else
11624                       {
11625                         indx = h->elf.dynindx;
11626                         unresolved_reloc = FALSE;
11627                       }
11628                     ent = h->elf.got.glist;
11629                   }
11630                 else
11631                   {
11632                     if (local_got_ents == NULL)
11633                       abort ();
11634                     ent = local_got_ents[r_symndx];
11635                   }
11636
11637                 for (; ent != NULL; ent = ent->next)
11638                   if (ent->addend == orig_addend
11639                       && ent->owner == input_bfd
11640                       && ent->tls_type == tls_type)
11641                     break;
11642                 if (ent == NULL)
11643                   abort ();
11644                 offp = &ent->got.offset;
11645               }
11646
11647             got = ppc64_elf_tdata (input_bfd)->got;
11648             if (got == NULL)
11649               abort ();
11650
11651             /* The offset must always be a multiple of 8.  We use the
11652                least significant bit to record whether we have already
11653                processed this entry.  */
11654             off = *offp;
11655             if ((off & 1) != 0)
11656               off &= ~1;
11657             else
11658               {
11659                 /* Generate relocs for the dynamic linker, except in
11660                    the case of TLSLD where we'll use one entry per
11661                    module.  */
11662                 asection *relgot;
11663                 bfd_boolean ifunc;
11664
11665                 *offp = off | 1;
11666                 relgot = NULL;
11667                 ifunc = (h != NULL
11668                          ? h->elf.type == STT_GNU_IFUNC
11669                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
11670                 if ((info->shared || indx != 0)
11671                     && (offp == &ppc64_tlsld_got (input_bfd)->offset
11672                         || h == NULL
11673                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11674                         || h->elf.root.type != bfd_link_hash_undefweak))
11675                   relgot = ppc64_elf_tdata (input_bfd)->relgot;
11676                 else if (ifunc)
11677                   relgot = htab->reliplt;
11678                 if (relgot != NULL)
11679                   {
11680                     outrel.r_offset = (got->output_section->vma
11681                                        + got->output_offset
11682                                        + off);
11683                     outrel.r_addend = addend;
11684                     if (tls_type & (TLS_LD | TLS_GD))
11685                       {
11686                         outrel.r_addend = 0;
11687                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
11688                         if (tls_type == (TLS_TLS | TLS_GD))
11689                           {
11690                             loc = relgot->contents;
11691                             loc += (relgot->reloc_count++
11692                                     * sizeof (Elf64_External_Rela));
11693                             bfd_elf64_swap_reloca_out (output_bfd,
11694                                                        &outrel, loc);
11695                             outrel.r_offset += 8;
11696                             outrel.r_addend = addend;
11697                             outrel.r_info
11698                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11699                           }
11700                       }
11701                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
11702                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11703                     else if (tls_type == (TLS_TLS | TLS_TPREL))
11704                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
11705                     else if (indx != 0)
11706                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
11707                     else
11708                       {
11709                         if (ifunc)
11710                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11711                         else
11712                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11713
11714                         /* Write the .got section contents for the sake
11715                            of prelink.  */
11716                         loc = got->contents + off;
11717                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
11718                                     loc);
11719                       }
11720
11721                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
11722                       {
11723                         outrel.r_addend += relocation;
11724                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
11725                           outrel.r_addend -= htab->elf.tls_sec->vma;
11726                       }
11727                     loc = relgot->contents;
11728                     loc += (relgot->reloc_count++
11729                             * sizeof (Elf64_External_Rela));
11730                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11731                   }
11732
11733                 /* Init the .got section contents here if we're not
11734                    emitting a reloc.  */
11735                 else
11736                   {
11737                     relocation += addend;
11738                     if (tls_type == (TLS_TLS | TLS_LD))
11739                       relocation = 1;
11740                     else if (tls_type != 0)
11741                       {
11742                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
11743                         if (tls_type == (TLS_TLS | TLS_TPREL))
11744                           relocation += DTP_OFFSET - TP_OFFSET;
11745
11746                         if (tls_type == (TLS_TLS | TLS_GD))
11747                           {
11748                             bfd_put_64 (output_bfd, relocation,
11749                                         got->contents + off + 8);
11750                             relocation = 1;
11751                           }
11752                       }
11753
11754                     bfd_put_64 (output_bfd, relocation,
11755                                 got->contents + off);
11756                   }
11757               }
11758
11759             if (off >= (bfd_vma) -2)
11760               abort ();
11761
11762             relocation = got->output_section->vma + got->output_offset + off;
11763             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
11764           }
11765           break;
11766
11767         case R_PPC64_PLT16_HA:
11768         case R_PPC64_PLT16_HI:
11769         case R_PPC64_PLT16_LO:
11770         case R_PPC64_PLT32:
11771         case R_PPC64_PLT64:
11772           /* Relocation is to the entry for this symbol in the
11773              procedure linkage table.  */
11774
11775           /* Resolve a PLT reloc against a local symbol directly,
11776              without using the procedure linkage table.  */
11777           if (h == NULL)
11778             break;
11779
11780           /* It's possible that we didn't make a PLT entry for this
11781              symbol.  This happens when statically linking PIC code,
11782              or when using -Bsymbolic.  Go find a match if there is a
11783              PLT entry.  */
11784           if (htab->plt != NULL)
11785             {
11786               struct plt_entry *ent;
11787               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
11788                 if (ent->addend == orig_addend
11789                     && ent->plt.offset != (bfd_vma) -1)
11790                   {
11791                     relocation = (htab->plt->output_section->vma
11792                                   + htab->plt->output_offset
11793                                   + ent->plt.offset);
11794                     unresolved_reloc = FALSE;
11795                   }
11796             }
11797           break;
11798
11799         case R_PPC64_TOC:
11800           /* Relocation value is TOC base.  */
11801           relocation = TOCstart;
11802           if (r_symndx == 0)
11803             relocation += htab->stub_group[input_section->id].toc_off;
11804           else if (unresolved_reloc)
11805             ;
11806           else if (sec != NULL && sec->id <= htab->top_id)
11807             relocation += htab->stub_group[sec->id].toc_off;
11808           else
11809             unresolved_reloc = TRUE;
11810           goto dodyn;
11811
11812           /* TOC16 relocs.  We want the offset relative to the TOC base,
11813              which is the address of the start of the TOC plus 0x8000.
11814              The TOC consists of sections .got, .toc, .tocbss, and .plt,
11815              in this order.  */
11816         case R_PPC64_TOC16:
11817         case R_PPC64_TOC16_LO:
11818         case R_PPC64_TOC16_HI:
11819         case R_PPC64_TOC16_DS:
11820         case R_PPC64_TOC16_LO_DS:
11821         case R_PPC64_TOC16_HA:
11822           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
11823           break;
11824
11825           /* Relocate against the beginning of the section.  */
11826         case R_PPC64_SECTOFF:
11827         case R_PPC64_SECTOFF_LO:
11828         case R_PPC64_SECTOFF_HI:
11829         case R_PPC64_SECTOFF_DS:
11830         case R_PPC64_SECTOFF_LO_DS:
11831         case R_PPC64_SECTOFF_HA:
11832           if (sec != NULL)
11833             addend -= sec->output_section->vma;
11834           break;
11835
11836         case R_PPC64_REL16:
11837         case R_PPC64_REL16_LO:
11838         case R_PPC64_REL16_HI:
11839         case R_PPC64_REL16_HA:
11840           break;
11841
11842         case R_PPC64_REL14:
11843         case R_PPC64_REL14_BRNTAKEN:
11844         case R_PPC64_REL14_BRTAKEN:
11845         case R_PPC64_REL24:
11846           break;
11847
11848         case R_PPC64_TPREL16:
11849         case R_PPC64_TPREL16_LO:
11850         case R_PPC64_TPREL16_HI:
11851         case R_PPC64_TPREL16_HA:
11852         case R_PPC64_TPREL16_DS:
11853         case R_PPC64_TPREL16_LO_DS:
11854         case R_PPC64_TPREL16_HIGHER:
11855         case R_PPC64_TPREL16_HIGHERA:
11856         case R_PPC64_TPREL16_HIGHEST:
11857         case R_PPC64_TPREL16_HIGHESTA:
11858           if (h != NULL
11859               && h->elf.root.type == bfd_link_hash_undefweak
11860               && h->elf.dynindx == -1)
11861             {
11862               /* Make this relocation against an undefined weak symbol
11863                  resolve to zero.  This is really just a tweak, since
11864                  code using weak externs ought to check that they are
11865                  defined before using them.  */
11866               bfd_byte *p = contents + rel->r_offset - d_offset;
11867
11868               insn = bfd_get_32 (output_bfd, p);
11869               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
11870               if (insn != 0)
11871                 bfd_put_32 (output_bfd, insn, p);
11872               break;
11873             }
11874           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11875           if (info->shared)
11876             /* The TPREL16 relocs shouldn't really be used in shared
11877                libs as they will result in DT_TEXTREL being set, but
11878                support them anyway.  */
11879             goto dodyn;
11880           break;
11881
11882         case R_PPC64_DTPREL16:
11883         case R_PPC64_DTPREL16_LO:
11884         case R_PPC64_DTPREL16_HI:
11885         case R_PPC64_DTPREL16_HA:
11886         case R_PPC64_DTPREL16_DS:
11887         case R_PPC64_DTPREL16_LO_DS:
11888         case R_PPC64_DTPREL16_HIGHER:
11889         case R_PPC64_DTPREL16_HIGHERA:
11890         case R_PPC64_DTPREL16_HIGHEST:
11891         case R_PPC64_DTPREL16_HIGHESTA:
11892           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11893           break;
11894
11895         case R_PPC64_DTPMOD64:
11896           relocation = 1;
11897           addend = 0;
11898           goto dodyn;
11899
11900         case R_PPC64_TPREL64:
11901           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11902           goto dodyn;
11903
11904         case R_PPC64_DTPREL64:
11905           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11906           /* Fall thru */
11907
11908           /* Relocations that may need to be propagated if this is a
11909              dynamic object.  */
11910         case R_PPC64_REL30:
11911         case R_PPC64_REL32:
11912         case R_PPC64_REL64:
11913         case R_PPC64_ADDR14:
11914         case R_PPC64_ADDR14_BRNTAKEN:
11915         case R_PPC64_ADDR14_BRTAKEN:
11916         case R_PPC64_ADDR16:
11917         case R_PPC64_ADDR16_DS:
11918         case R_PPC64_ADDR16_HA:
11919         case R_PPC64_ADDR16_HI:
11920         case R_PPC64_ADDR16_HIGHER:
11921         case R_PPC64_ADDR16_HIGHERA:
11922         case R_PPC64_ADDR16_HIGHEST:
11923         case R_PPC64_ADDR16_HIGHESTA:
11924         case R_PPC64_ADDR16_LO:
11925         case R_PPC64_ADDR16_LO_DS:
11926         case R_PPC64_ADDR24:
11927         case R_PPC64_ADDR32:
11928         case R_PPC64_ADDR64:
11929         case R_PPC64_UADDR16:
11930         case R_PPC64_UADDR32:
11931         case R_PPC64_UADDR64:
11932         dodyn:
11933           if ((input_section->flags & SEC_ALLOC) == 0)
11934             break;
11935
11936           if (NO_OPD_RELOCS && is_opd)
11937             break;
11938
11939           if ((info->shared
11940                && (h == NULL
11941                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11942                    || h->elf.root.type != bfd_link_hash_undefweak)
11943                && (must_be_dyn_reloc (info, r_type)
11944                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
11945               || (ELIMINATE_COPY_RELOCS
11946                   && !info->shared
11947                   && h != NULL
11948                   && h->elf.dynindx != -1
11949                   && !h->elf.non_got_ref
11950                   && !h->elf.def_regular)
11951               || (!info->shared
11952                   && (h != NULL
11953                       ? h->elf.type == STT_GNU_IFUNC
11954                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
11955             {
11956               bfd_boolean skip, relocate;
11957               asection *sreloc;
11958               bfd_vma out_off;
11959
11960               /* When generating a dynamic object, these relocations
11961                  are copied into the output file to be resolved at run
11962                  time.  */
11963
11964               skip = FALSE;
11965               relocate = FALSE;
11966
11967               out_off = _bfd_elf_section_offset (output_bfd, info,
11968                                                  input_section, rel->r_offset);
11969               if (out_off == (bfd_vma) -1)
11970                 skip = TRUE;
11971               else if (out_off == (bfd_vma) -2)
11972                 skip = TRUE, relocate = TRUE;
11973               out_off += (input_section->output_section->vma
11974                           + input_section->output_offset);
11975               outrel.r_offset = out_off;
11976               outrel.r_addend = rel->r_addend;
11977
11978               /* Optimize unaligned reloc use.  */
11979               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11980                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11981                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11982               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11983                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11984                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11985               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11986                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11987                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11988
11989               if (skip)
11990                 memset (&outrel, 0, sizeof outrel);
11991               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
11992                        && !is_opd
11993                        && r_type != R_PPC64_TOC)
11994                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
11995               else
11996                 {
11997                   /* This symbol is local, or marked to become local,
11998                      or this is an opd section reloc which must point
11999                      at a local function.  */
12000                   outrel.r_addend += relocation;
12001                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12002                     {
12003                       if (is_opd && h != NULL)
12004                         {
12005                           /* Lie about opd entries.  This case occurs
12006                              when building shared libraries and we
12007                              reference a function in another shared
12008                              lib.  The same thing happens for a weak
12009                              definition in an application that's
12010                              overridden by a strong definition in a
12011                              shared lib.  (I believe this is a generic
12012                              bug in binutils handling of weak syms.)
12013                              In these cases we won't use the opd
12014                              entry in this lib.  */
12015                           unresolved_reloc = FALSE;
12016                         }
12017                       if (!is_opd
12018                           && r_type == R_PPC64_ADDR64
12019                           && (h != NULL
12020                               ? h->elf.type == STT_GNU_IFUNC
12021                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12022                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12023                       else
12024                         {
12025                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12026
12027                           /* We need to relocate .opd contents for ld.so.
12028                              Prelink also wants simple and consistent rules
12029                              for relocs.  This make all RELATIVE relocs have
12030                              *r_offset equal to r_addend.  */
12031                           relocate = TRUE;
12032                         }
12033                     }
12034                   else
12035                     {
12036                       long indx = 0;
12037
12038                       if (h != NULL
12039                           ? h->elf.type == STT_GNU_IFUNC
12040                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12041                         {
12042                           (*_bfd_error_handler)
12043                             (_("%B(%A+0x%lx): relocation %s for indirect "
12044                                "function %s unsupported"),
12045                              input_bfd,
12046                              input_section,
12047                              (long) rel->r_offset,
12048                              ppc64_elf_howto_table[r_type]->name,
12049                              sym_name);
12050                           ret = FALSE;
12051                         }
12052                       else if (r_symndx == 0 || bfd_is_abs_section (sec))
12053                         ;
12054                       else if (sec == NULL || sec->owner == NULL)
12055                         {
12056                           bfd_set_error (bfd_error_bad_value);
12057                           return FALSE;
12058                         }
12059                       else
12060                         {
12061                           asection *osec;
12062
12063                           osec = sec->output_section;
12064                           indx = elf_section_data (osec)->dynindx;
12065
12066                           if (indx == 0)
12067                             {
12068                               if ((osec->flags & SEC_READONLY) == 0
12069                                   && htab->elf.data_index_section != NULL)
12070                                 osec = htab->elf.data_index_section;
12071                               else
12072                                 osec = htab->elf.text_index_section;
12073                               indx = elf_section_data (osec)->dynindx;
12074                             }
12075                           BFD_ASSERT (indx != 0);
12076
12077                           /* We are turning this relocation into one
12078                              against a section symbol, so subtract out
12079                              the output section's address but not the
12080                              offset of the input section in the output
12081                              section.  */
12082                           outrel.r_addend -= osec->vma;
12083                         }
12084
12085                       outrel.r_info = ELF64_R_INFO (indx, r_type);
12086                     }
12087                 }
12088
12089               sreloc = elf_section_data (input_section)->sreloc;
12090               if (!htab->elf.dynamic_sections_created)
12091                 sreloc = htab->reliplt;
12092               if (sreloc == NULL)
12093                 abort ();
12094
12095               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
12096                   >= sreloc->size)
12097                 abort ();
12098               loc = sreloc->contents;
12099               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
12100               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12101
12102               /* If this reloc is against an external symbol, it will
12103                  be computed at runtime, so there's no need to do
12104                  anything now.  However, for the sake of prelink ensure
12105                  that the section contents are a known value.  */
12106               if (! relocate)
12107                 {
12108                   unresolved_reloc = FALSE;
12109                   /* The value chosen here is quite arbitrary as ld.so
12110                      ignores section contents except for the special
12111                      case of .opd where the contents might be accessed
12112                      before relocation.  Choose zero, as that won't
12113                      cause reloc overflow.  */
12114                   relocation = 0;
12115                   addend = 0;
12116                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
12117                      to improve backward compatibility with older
12118                      versions of ld.  */
12119                   if (r_type == R_PPC64_ADDR64)
12120                     addend = outrel.r_addend;
12121                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
12122                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
12123                     addend = (input_section->output_section->vma
12124                               + input_section->output_offset
12125                               + rel->r_offset);
12126                 }
12127             }
12128           break;
12129
12130         case R_PPC64_COPY:
12131         case R_PPC64_GLOB_DAT:
12132         case R_PPC64_JMP_SLOT:
12133         case R_PPC64_JMP_IREL:
12134         case R_PPC64_RELATIVE:
12135           /* We shouldn't ever see these dynamic relocs in relocatable
12136              files.  */
12137           /* Fall through.  */
12138
12139         case R_PPC64_PLTGOT16:
12140         case R_PPC64_PLTGOT16_DS:
12141         case R_PPC64_PLTGOT16_HA:
12142         case R_PPC64_PLTGOT16_HI:
12143         case R_PPC64_PLTGOT16_LO:
12144         case R_PPC64_PLTGOT16_LO_DS:
12145         case R_PPC64_PLTREL32:
12146         case R_PPC64_PLTREL64:
12147           /* These ones haven't been implemented yet.  */
12148
12149           (*_bfd_error_handler)
12150             (_("%B: relocation %s is not supported for symbol %s."),
12151              input_bfd,
12152              ppc64_elf_howto_table[r_type]->name, sym_name);
12153
12154           bfd_set_error (bfd_error_invalid_operation);
12155           ret = FALSE;
12156           continue;
12157         }
12158
12159       /* Do any further special processing.  */
12160       switch (r_type)
12161         {
12162         default:
12163           break;
12164
12165         case R_PPC64_ADDR16_HA:
12166         case R_PPC64_REL16_HA:
12167         case R_PPC64_ADDR16_HIGHERA:
12168         case R_PPC64_ADDR16_HIGHESTA:
12169         case R_PPC64_TOC16_HA:
12170         case R_PPC64_SECTOFF_HA:
12171         case R_PPC64_TPREL16_HA:
12172         case R_PPC64_DTPREL16_HA:
12173         case R_PPC64_TPREL16_HIGHER:
12174         case R_PPC64_TPREL16_HIGHERA:
12175         case R_PPC64_TPREL16_HIGHEST:
12176         case R_PPC64_TPREL16_HIGHESTA:
12177         case R_PPC64_DTPREL16_HIGHER:
12178         case R_PPC64_DTPREL16_HIGHERA:
12179         case R_PPC64_DTPREL16_HIGHEST:
12180         case R_PPC64_DTPREL16_HIGHESTA:
12181           /* It's just possible that this symbol is a weak symbol
12182              that's not actually defined anywhere. In that case,
12183              'sec' would be NULL, and we should leave the symbol
12184              alone (it will be set to zero elsewhere in the link).  */
12185           if (sec == NULL)
12186             break;
12187           /* Fall thru */
12188
12189         case R_PPC64_GOT16_HA:
12190         case R_PPC64_PLTGOT16_HA:
12191         case R_PPC64_PLT16_HA:
12192         case R_PPC64_GOT_TLSGD16_HA:
12193         case R_PPC64_GOT_TLSLD16_HA:
12194         case R_PPC64_GOT_TPREL16_HA:
12195         case R_PPC64_GOT_DTPREL16_HA:
12196           /* Add 0x10000 if sign bit in 0:15 is set.
12197              Bits 0:15 are not used.  */
12198           addend += 0x8000;
12199           break;
12200
12201         case R_PPC64_ADDR16_DS:
12202         case R_PPC64_ADDR16_LO_DS:
12203         case R_PPC64_GOT16_DS:
12204         case R_PPC64_GOT16_LO_DS:
12205         case R_PPC64_PLT16_LO_DS:
12206         case R_PPC64_SECTOFF_DS:
12207         case R_PPC64_SECTOFF_LO_DS:
12208         case R_PPC64_TOC16_DS:
12209         case R_PPC64_TOC16_LO_DS:
12210         case R_PPC64_PLTGOT16_DS:
12211         case R_PPC64_PLTGOT16_LO_DS:
12212         case R_PPC64_GOT_TPREL16_DS:
12213         case R_PPC64_GOT_TPREL16_LO_DS:
12214         case R_PPC64_GOT_DTPREL16_DS:
12215         case R_PPC64_GOT_DTPREL16_LO_DS:
12216         case R_PPC64_TPREL16_DS:
12217         case R_PPC64_TPREL16_LO_DS:
12218         case R_PPC64_DTPREL16_DS:
12219         case R_PPC64_DTPREL16_LO_DS:
12220           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
12221           mask = 3;
12222           /* If this reloc is against an lq insn, then the value must be
12223              a multiple of 16.  This is somewhat of a hack, but the
12224              "correct" way to do this by defining _DQ forms of all the
12225              _DS relocs bloats all reloc switches in this file.  It
12226              doesn't seem to make much sense to use any of these relocs
12227              in data, so testing the insn should be safe.  */
12228           if ((insn & (0x3f << 26)) == (56u << 26))
12229             mask = 15;
12230           if (((relocation + addend) & mask) != 0)
12231             {
12232               (*_bfd_error_handler)
12233                 (_("%B: error: relocation %s not a multiple of %d"),
12234                  input_bfd,
12235                  ppc64_elf_howto_table[r_type]->name,
12236                  mask + 1);
12237               bfd_set_error (bfd_error_bad_value);
12238               ret = FALSE;
12239               continue;
12240             }
12241           break;
12242         }
12243
12244       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
12245          because such sections are not SEC_ALLOC and thus ld.so will
12246          not process them.  */
12247       if (unresolved_reloc
12248           && !((input_section->flags & SEC_DEBUGGING) != 0
12249                && h->elf.def_dynamic))
12250         {
12251           (*_bfd_error_handler)
12252             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
12253              input_bfd,
12254              input_section,
12255              (long) rel->r_offset,
12256              ppc64_elf_howto_table[(int) r_type]->name,
12257              h->elf.root.root.string);
12258           ret = FALSE;
12259         }
12260
12261       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
12262                                     input_bfd,
12263                                     input_section,
12264                                     contents,
12265                                     rel->r_offset,
12266                                     relocation,
12267                                     addend);
12268
12269       if (r != bfd_reloc_ok)
12270         {
12271           if (sym_name == NULL)
12272             sym_name = "(null)";
12273           if (r == bfd_reloc_overflow)
12274             {
12275               if (warned)
12276                 continue;
12277               if (h != NULL
12278                   && h->elf.root.type == bfd_link_hash_undefweak
12279                   && ppc64_elf_howto_table[r_type]->pc_relative)
12280                 {
12281                   /* Assume this is a call protected by other code that
12282                      detects the symbol is undefined.  If this is the case,
12283                      we can safely ignore the overflow.  If not, the
12284                      program is hosed anyway, and a little warning isn't
12285                      going to help.  */
12286
12287                   continue;
12288                 }
12289
12290               if (!((*info->callbacks->reloc_overflow)
12291                     (info, (h ? &h->elf.root : NULL), sym_name,
12292                      ppc64_elf_howto_table[r_type]->name,
12293                      orig_addend, input_bfd, input_section, rel->r_offset)))
12294                 return FALSE;
12295             }
12296           else
12297             {
12298               (*_bfd_error_handler)
12299                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
12300                  input_bfd,
12301                  input_section,
12302                  (long) rel->r_offset,
12303                  ppc64_elf_howto_table[r_type]->name,
12304                  sym_name,
12305                  (int) r);
12306               ret = FALSE;
12307             }
12308         }
12309     }
12310
12311   /* If we're emitting relocations, then shortly after this function
12312      returns, reloc offsets and addends for this section will be
12313      adjusted.  Worse, reloc symbol indices will be for the output
12314      file rather than the input.  Save a copy of the relocs for
12315      opd_entry_value.  */
12316   if (is_opd && (info->emitrelocations || info->relocatable))
12317     {
12318       bfd_size_type amt;
12319       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
12320       rel = bfd_alloc (input_bfd, amt);
12321       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
12322       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
12323       if (rel == NULL)
12324         return FALSE;
12325       memcpy (rel, relocs, amt);
12326     }
12327   return ret;
12328 }
12329
12330 /* Adjust the value of any local symbols in opd sections.  */
12331
12332 static int
12333 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
12334                               const char *name ATTRIBUTE_UNUSED,
12335                               Elf_Internal_Sym *elfsym,
12336                               asection *input_sec,
12337                               struct elf_link_hash_entry *h)
12338 {
12339   struct _opd_sec_data *opd;
12340   long adjust;
12341   bfd_vma value;
12342
12343   if (h != NULL)
12344     return 1;
12345
12346   opd = get_opd_info (input_sec);
12347   if (opd == NULL || opd->adjust == NULL)
12348     return 1;
12349
12350   value = elfsym->st_value - input_sec->output_offset;
12351   if (!info->relocatable)
12352     value -= input_sec->output_section->vma;
12353
12354   adjust = opd->adjust[value / 8];
12355   if (adjust == -1)
12356     return 2;
12357
12358   elfsym->st_value += adjust;
12359   return 1;
12360 }
12361
12362 /* Finish up dynamic symbol handling.  We set the contents of various
12363    dynamic sections here.  */
12364
12365 static bfd_boolean
12366 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12367                                  struct bfd_link_info *info,
12368                                  struct elf_link_hash_entry *h,
12369                                  Elf_Internal_Sym *sym)
12370 {
12371   struct ppc_link_hash_table *htab;
12372   struct plt_entry *ent;
12373   Elf_Internal_Rela rela;
12374   bfd_byte *loc;
12375
12376   htab = ppc_hash_table (info);
12377
12378   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12379     if (ent->plt.offset != (bfd_vma) -1)
12380       {
12381         /* This symbol has an entry in the procedure linkage
12382            table.  Set it up.  */
12383         if (!htab->elf.dynamic_sections_created
12384             || h->dynindx == -1)
12385           {
12386             BFD_ASSERT (h->type == STT_GNU_IFUNC
12387                         && h->def_regular
12388                         && (h->root.type == bfd_link_hash_defined
12389                             || h->root.type == bfd_link_hash_defweak));
12390             rela.r_offset = (htab->iplt->output_section->vma
12391                              + htab->iplt->output_offset
12392                              + ent->plt.offset);
12393             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
12394             rela.r_addend = (h->root.u.def.value
12395                              + h->root.u.def.section->output_offset
12396                              + h->root.u.def.section->output_section->vma
12397                              + ent->addend);
12398             loc = (htab->reliplt->contents
12399                    + (htab->reliplt->reloc_count++
12400                       * sizeof (Elf64_External_Rela)));
12401           }
12402         else
12403           {
12404             rela.r_offset = (htab->plt->output_section->vma
12405                              + htab->plt->output_offset
12406                              + ent->plt.offset);
12407             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12408             rela.r_addend = ent->addend;
12409             loc = (htab->relplt->contents
12410                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12411                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12412           }
12413         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12414       }
12415
12416   if (h->needs_copy)
12417     {
12418       /* This symbol needs a copy reloc.  Set it up.  */
12419
12420       if (h->dynindx == -1
12421           || (h->root.type != bfd_link_hash_defined
12422               && h->root.type != bfd_link_hash_defweak)
12423           || htab->relbss == NULL)
12424         abort ();
12425
12426       rela.r_offset = (h->root.u.def.value
12427                        + h->root.u.def.section->output_section->vma
12428                        + h->root.u.def.section->output_offset);
12429       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12430       rela.r_addend = 0;
12431       loc = htab->relbss->contents;
12432       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
12433       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12434     }
12435
12436   /* Mark some specially defined symbols as absolute.  */
12437   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12438     sym->st_shndx = SHN_ABS;
12439
12440   return TRUE;
12441 }
12442
12443 /* Used to decide how to sort relocs in an optimal manner for the
12444    dynamic linker, before writing them out.  */
12445
12446 static enum elf_reloc_type_class
12447 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
12448 {
12449   enum elf_ppc64_reloc_type r_type;
12450
12451   r_type = ELF64_R_TYPE (rela->r_info);
12452   switch (r_type)
12453     {
12454     case R_PPC64_RELATIVE:
12455       return reloc_class_relative;
12456     case R_PPC64_JMP_SLOT:
12457       return reloc_class_plt;
12458     case R_PPC64_COPY:
12459       return reloc_class_copy;
12460     default:
12461       return reloc_class_normal;
12462     }
12463 }
12464
12465 /* Finish up the dynamic sections.  */
12466
12467 static bfd_boolean
12468 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12469                                    struct bfd_link_info *info)
12470 {
12471   struct ppc_link_hash_table *htab;
12472   bfd *dynobj;
12473   asection *sdyn;
12474
12475   htab = ppc_hash_table (info);
12476   dynobj = htab->elf.dynobj;
12477   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12478
12479   if (htab->elf.dynamic_sections_created)
12480     {
12481       Elf64_External_Dyn *dyncon, *dynconend;
12482
12483       if (sdyn == NULL || htab->got == NULL)
12484         abort ();
12485
12486       dyncon = (Elf64_External_Dyn *) sdyn->contents;
12487       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
12488       for (; dyncon < dynconend; dyncon++)
12489         {
12490           Elf_Internal_Dyn dyn;
12491           asection *s;
12492
12493           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
12494
12495           switch (dyn.d_tag)
12496             {
12497             default:
12498               continue;
12499
12500             case DT_PPC64_GLINK:
12501               s = htab->glink;
12502               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12503               /* We stupidly defined DT_PPC64_GLINK to be the start
12504                  of glink rather than the first entry point, which is
12505                  what ld.so needs, and now have a bigger stub to
12506                  support automatic multiple TOCs.  */
12507               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
12508               break;
12509
12510             case DT_PPC64_OPD:
12511               s = bfd_get_section_by_name (output_bfd, ".opd");
12512               if (s == NULL)
12513                 continue;
12514               dyn.d_un.d_ptr = s->vma;
12515               break;
12516
12517             case DT_PPC64_OPDSZ:
12518               s = bfd_get_section_by_name (output_bfd, ".opd");
12519               if (s == NULL)
12520                 continue;
12521               dyn.d_un.d_val = s->size;
12522               break;
12523
12524             case DT_PLTGOT:
12525               s = htab->plt;
12526               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12527               break;
12528
12529             case DT_JMPREL:
12530               s = htab->relplt;
12531               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12532               break;
12533
12534             case DT_PLTRELSZ:
12535               dyn.d_un.d_val = htab->relplt->size;
12536               break;
12537
12538             case DT_RELASZ:
12539               /* Don't count procedure linkage table relocs in the
12540                  overall reloc count.  */
12541               s = htab->relplt;
12542               if (s == NULL)
12543                 continue;
12544               dyn.d_un.d_val -= s->size;
12545               break;
12546
12547             case DT_RELA:
12548               /* We may not be using the standard ELF linker script.
12549                  If .rela.plt is the first .rela section, we adjust
12550                  DT_RELA to not include it.  */
12551               s = htab->relplt;
12552               if (s == NULL)
12553                 continue;
12554               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
12555                 continue;
12556               dyn.d_un.d_ptr += s->size;
12557               break;
12558             }
12559
12560           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
12561         }
12562     }
12563
12564   if (htab->got != NULL && htab->got->size != 0)
12565     {
12566       /* Fill in the first entry in the global offset table.
12567          We use it to hold the link-time TOCbase.  */
12568       bfd_put_64 (output_bfd,
12569                   elf_gp (output_bfd) + TOC_BASE_OFF,
12570                   htab->got->contents);
12571
12572       /* Set .got entry size.  */
12573       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
12574     }
12575
12576   if (htab->plt != NULL && htab->plt->size != 0)
12577     {
12578       /* Set .plt entry size.  */
12579       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
12580         = PLT_ENTRY_SIZE;
12581     }
12582
12583   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
12584      brlt ourselves if emitrelocations.  */
12585   if (htab->brlt != NULL
12586       && htab->brlt->reloc_count != 0
12587       && !_bfd_elf_link_output_relocs (output_bfd,
12588                                        htab->brlt,
12589                                        &elf_section_data (htab->brlt)->rel_hdr,
12590                                        elf_section_data (htab->brlt)->relocs,
12591                                        NULL))
12592     return FALSE;
12593
12594   if (htab->glink != NULL
12595       && htab->glink->reloc_count != 0
12596       && !_bfd_elf_link_output_relocs (output_bfd,
12597                                        htab->glink,
12598                                        &elf_section_data (htab->glink)->rel_hdr,
12599                                        elf_section_data (htab->glink)->relocs,
12600                                        NULL))
12601     return FALSE;
12602
12603   /* We need to handle writing out multiple GOT sections ourselves,
12604      since we didn't add them to DYNOBJ.  We know dynobj is the first
12605      bfd.  */
12606   while ((dynobj = dynobj->link_next) != NULL)
12607     {
12608       asection *s;
12609
12610       if (!is_ppc64_elf (dynobj))
12611         continue;
12612
12613       s = ppc64_elf_tdata (dynobj)->got;
12614       if (s != NULL
12615           && s->size != 0
12616           && s->output_section != bfd_abs_section_ptr
12617           && !bfd_set_section_contents (output_bfd, s->output_section,
12618                                         s->contents, s->output_offset,
12619                                         s->size))
12620         return FALSE;
12621       s = ppc64_elf_tdata (dynobj)->relgot;
12622       if (s != NULL
12623           && s->size != 0
12624           && s->output_section != bfd_abs_section_ptr
12625           && !bfd_set_section_contents (output_bfd, s->output_section,
12626                                         s->contents, s->output_offset,
12627                                         s->size))
12628         return FALSE;
12629     }
12630
12631   return TRUE;
12632 }
12633
12634 #include "elf64-target.h"