bfd/elf64-ppc.c

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