contrib/binutils/bfd/elf64-ppc.c

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