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 bfd_boolean synthetic_relocatable;
2693
2694 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2695
2696 static int
2697 compare_symbols (const void *ap, const void *bp)
2698 {
2699   const asymbol *a = * (const asymbol **) ap;
2700   const asymbol *b = * (const asymbol **) bp;
2701
2702   /* Section symbols first.  */
2703   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2704     return -1;
2705   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2706     return 1;
2707
2708   /* then .opd symbols.  */
2709   if (strcmp (a->section->name, ".opd") == 0
2710       && strcmp (b->section->name, ".opd") != 0)
2711     return -1;
2712   if (strcmp (a->section->name, ".opd") != 0
2713       && strcmp (b->section->name, ".opd") == 0)
2714     return 1;
2715
2716   /* then other code symbols.  */
2717   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2718       == (SEC_CODE | SEC_ALLOC)
2719       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2720          != (SEC_CODE | SEC_ALLOC))
2721     return -1;
2722
2723   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2724       != (SEC_CODE | SEC_ALLOC)
2725       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2726          == (SEC_CODE | SEC_ALLOC))
2727     return 1;
2728
2729   if (synthetic_relocatable)
2730     {
2731       if (a->section->id < b->section->id)
2732         return -1;
2733
2734       if (a->section->id > b->section->id)
2735         return 1;
2736     }
2737
2738   if (a->value + a->section->vma < b->value + b->section->vma)
2739     return -1;
2740
2741   if (a->value + a->section->vma > b->value + b->section->vma)
2742     return 1;
2743
2744   /* For syms with the same value, prefer strong dynamic global function
2745      syms over other syms.  */
2746   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2747     return -1;
2748
2749   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2750     return 1;
2751
2752   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2753     return -1;
2754
2755   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2756     return 1;
2757
2758   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2759     return -1;
2760
2761   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2762     return 1;
2763
2764   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2765     return -1;
2766
2767   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2768     return 1;
2769
2770   return 0;
2771 }
2772
2773 /* Search SYMS for a symbol of the given VALUE.  */
2774
2775 static asymbol *
2776 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2777 {
2778   long mid;
2779
2780   if (id == -1)
2781     {
2782       while (lo < hi)
2783         {
2784           mid = (lo + hi) >> 1;
2785           if (syms[mid]->value + syms[mid]->section->vma < value)
2786             lo = mid + 1;
2787           else if (syms[mid]->value + syms[mid]->section->vma > value)
2788             hi = mid;
2789           else
2790             return syms[mid];
2791         }
2792     }
2793   else
2794     {
2795       while (lo < hi)
2796         {
2797           mid = (lo + hi) >> 1;
2798           if (syms[mid]->section->id < id)
2799             lo = mid + 1;
2800           else if (syms[mid]->section->id > id)
2801             hi = mid;
2802           else if (syms[mid]->value < value)
2803             lo = mid + 1;
2804           else if (syms[mid]->value > value)
2805             hi = mid;
2806           else
2807             return syms[mid];
2808         }
2809     }
2810   return NULL;
2811 }
2812
2813 static bfd_boolean
2814 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2815 {
2816   bfd_vma vma = *(bfd_vma *) ptr;
2817   return ((section->flags & SEC_ALLOC) != 0
2818           && section->vma <= vma
2819           && vma < section->vma + section->size);
2820 }
2821
2822 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2823    entry syms.  Also generate @plt symbols for the glink branch table.  */
2824
2825 static long
2826 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2827                                 long static_count, asymbol **static_syms,
2828                                 long dyn_count, asymbol **dyn_syms,
2829                                 asymbol **ret)
2830 {
2831   asymbol *s;
2832   long i;
2833   long count;
2834   char *names;
2835   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2836   asection *opd;
2837   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2838   asymbol **syms;
2839
2840   *ret = NULL;
2841
2842   opd = bfd_get_section_by_name (abfd, ".opd");
2843   if (opd == NULL)
2844     return 0;
2845
2846   symcount = static_count;
2847   if (!relocatable)
2848     symcount += dyn_count;
2849   if (symcount == 0)
2850     return 0;
2851
2852   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2853   if (syms == NULL)
2854     return -1;
2855
2856   if (!relocatable && static_count != 0 && dyn_count != 0)
2857     {
2858       /* Use both symbol tables.  */
2859       memcpy (syms, static_syms, static_count * sizeof (*syms));
2860       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2861     }
2862   else if (!relocatable && static_count == 0)
2863     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2864   else
2865     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2866
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 (strcmp (syms[i]->section->name, ".opd") == 0)
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 (strcmp (syms[i]->section->name, ".opd") != 0)
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           /* Ignore bogus symbols.  */
3037           if (syms[i]->value > opd->size - 8)
3038             continue;
3039
3040           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3041           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3042             {
3043               ++count;
3044               size += sizeof (asymbol);
3045               size += strlen (syms[i]->name) + 2;
3046             }
3047         }
3048
3049       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3050       if (dyn_count != 0
3051           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3052         {
3053           bfd_byte *dynbuf, *extdyn, *extdynend;
3054           size_t extdynsize;
3055           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3056
3057           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3058             goto free_contents_and_exit;
3059
3060           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3061           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3062
3063           extdyn = dynbuf;
3064           extdynend = extdyn + dynamic->size;
3065           for (; extdyn < extdynend; extdyn += extdynsize)
3066             {
3067               Elf_Internal_Dyn dyn;
3068               (*swap_dyn_in) (abfd, extdyn, &dyn);
3069
3070               if (dyn.d_tag == DT_NULL)
3071                 break;
3072
3073               if (dyn.d_tag == DT_PPC64_GLINK)
3074                 {
3075                   /* The first glink stub starts at offset 32; see comment in
3076                      ppc64_elf_finish_dynamic_sections. */
3077                   glink_vma = dyn.d_un.d_val + 32;
3078                   /* The .glink section usually does not survive the final
3079                      link; search for the section (usually .text) where the
3080                      glink stubs now reside.  */
3081                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3082                                                 &glink_vma);
3083                   break;
3084                 }
3085             }
3086
3087           free (dynbuf);
3088         }
3089
3090       if (glink != NULL)
3091         {
3092           /* Determine __glink trampoline by reading the relative branch
3093              from the first glink stub.  */
3094           bfd_byte buf[4];
3095           if (bfd_get_section_contents (abfd, glink, buf,
3096                                         glink_vma + 4 - glink->vma, 4))
3097             {
3098               unsigned int insn = bfd_get_32 (abfd, buf);
3099               insn ^= B_DOT;
3100               if ((insn & ~0x3fffffc) == 0)
3101                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3102             }
3103
3104           if (resolv_vma)
3105             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3106
3107           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3108           if (relplt != NULL)
3109             {
3110               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3111               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3112                 goto free_contents_and_exit;
3113
3114               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3115               size += plt_count * sizeof (asymbol);
3116
3117               p = relplt->relocation;
3118               for (i = 0; i < plt_count; i++, p++)
3119                 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3120             }
3121         }
3122
3123       s = *ret = bfd_malloc (size);
3124       if (s == NULL)
3125         goto free_contents_and_exit;
3126
3127       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3128
3129       for (i = secsymend; i < opdsymend; ++i)
3130         {
3131           bfd_vma ent;
3132
3133           if (syms[i]->value > opd->size - 8)
3134             continue;
3135
3136           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3137           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3138             {
3139               long lo, hi;
3140               size_t len;
3141               asection *sec = abfd->sections;
3142
3143               *s = *syms[i];
3144               lo = codesecsym;
3145               hi = codesecsymend;
3146               while (lo < hi)
3147                 {
3148                   long mid = (lo + hi) >> 1;
3149                   if (syms[mid]->section->vma < ent)
3150                     lo = mid + 1;
3151                   else if (syms[mid]->section->vma > ent)
3152                     hi = mid;
3153                   else
3154                     {
3155                       sec = syms[mid]->section;
3156                       break;
3157                     }
3158                 }
3159
3160               if (lo >= hi && lo > codesecsym)
3161                 sec = syms[lo - 1]->section;
3162
3163               for (; sec != NULL; sec = sec->next)
3164                 {
3165                   if (sec->vma > ent)
3166                     break;
3167                   if ((sec->flags & SEC_ALLOC) == 0
3168                       || (sec->flags & SEC_LOAD) == 0)
3169                     break;
3170                   if ((sec->flags & SEC_CODE) != 0)
3171                     s->section = sec;
3172                 }
3173               s->flags |= BSF_SYNTHETIC;
3174               s->value = ent - s->section->vma;
3175               s->name = names;
3176               *names++ = '.';
3177               len = strlen (syms[i]->name);
3178               memcpy (names, syms[i]->name, len + 1);
3179               names += len + 1;
3180               /* Have udata.p point back to the original symbol this
3181                  synthetic symbol was derived from.  */
3182               s->udata.p = syms[i];
3183               s++;
3184             }
3185         }
3186       free (contents);
3187
3188       if (glink != NULL && relplt != NULL)
3189         {
3190           if (resolv_vma)
3191             {
3192               /* Add a symbol for the main glink trampoline.  */
3193               memset (s, 0, sizeof *s);
3194               s->the_bfd = abfd;
3195               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3196               s->section = glink;
3197               s->value = resolv_vma - glink->vma;
3198               s->name = names;
3199               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3200               names += sizeof ("__glink_PLTresolve");
3201               s++;
3202               count++;
3203             }
3204
3205           /* FIXME: It would be very much nicer to put sym@plt on the
3206              stub rather than on the glink branch table entry.  The
3207              objdump disassembler would then use a sensible symbol
3208              name on plt calls.  The difficulty in doing so is
3209              a) finding the stubs, and,
3210              b) matching stubs against plt entries, and,
3211              c) there can be multiple stubs for a given plt entry.
3212
3213              Solving (a) could be done by code scanning, but older
3214              ppc64 binaries used different stubs to current code.
3215              (b) is the tricky one since you need to known the toc
3216              pointer for at least one function that uses a pic stub to
3217              be able to calculate the plt address referenced.
3218              (c) means gdb would need to set multiple breakpoints (or
3219              find the glink branch itself) when setting breakpoints
3220              for pending shared library loads.  */
3221           p = relplt->relocation;
3222           for (i = 0; i < plt_count; i++, p++)
3223             {
3224               size_t len;
3225
3226               *s = **p->sym_ptr_ptr;
3227               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3228                  we are defining a symbol, ensure one of them is set.  */
3229               if ((s->flags & BSF_LOCAL) == 0)
3230                 s->flags |= BSF_GLOBAL;
3231               s->flags |= BSF_SYNTHETIC;
3232               s->section = glink;
3233               s->value = glink_vma - glink->vma;
3234               s->name = names;
3235               s->udata.p = NULL;
3236               len = strlen ((*p->sym_ptr_ptr)->name);
3237               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3238               names += len;
3239               memcpy (names, "@plt", sizeof ("@plt"));
3240               names += sizeof ("@plt");
3241               s++;
3242               glink_vma += 8;
3243               if (i >= 0x8000)
3244                 glink_vma += 4;
3245             }
3246           count += plt_count;
3247         }
3248     }
3249
3250  done:
3251   free (syms);
3252   return count;
3253 }
3254 \f
3255 /* The following functions are specific to the ELF linker, while
3256    functions above are used generally.  Those named ppc64_elf_* are
3257    called by the main ELF linker code.  They appear in this file more
3258    or less in the order in which they are called.  eg.
3259    ppc64_elf_check_relocs is called early in the link process,
3260    ppc64_elf_finish_dynamic_sections is one of the last functions
3261    called.
3262
3263    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3264    functions have both a function code symbol and a function descriptor
3265    symbol.  A call to foo in a relocatable object file looks like:
3266
3267    .            .text
3268    .    x:
3269    .            bl      .foo
3270    .            nop
3271
3272    The function definition in another object file might be:
3273
3274    .            .section .opd
3275    .    foo:    .quad   .foo
3276    .            .quad   .TOC.@tocbase
3277    .            .quad   0
3278    .
3279    .            .text
3280    .    .foo:   blr
3281
3282    When the linker resolves the call during a static link, the branch
3283    unsurprisingly just goes to .foo and the .opd information is unused.
3284    If the function definition is in a shared library, things are a little
3285    different:  The call goes via a plt call stub, the opd information gets
3286    copied to the plt, and the linker patches the nop.
3287
3288    .    x:
3289    .            bl      .foo_stub
3290    .            ld      2,40(1)
3291    .
3292    .
3293    .    .foo_stub:
3294    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3295    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3296    .            std     2,40(1)                 # this is the general idea
3297    .            ld      11,0(12)
3298    .            ld      2,8(12)
3299    .            mtctr   11
3300    .            ld      11,16(12)
3301    .            bctr
3302    .
3303    .            .section .plt
3304    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3305
3306    The "reloc ()" notation is supposed to indicate that the linker emits
3307    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3308    copying.
3309
3310    What are the difficulties here?  Well, firstly, the relocations
3311    examined by the linker in check_relocs are against the function code
3312    sym .foo, while the dynamic relocation in the plt is emitted against
3313    the function descriptor symbol, foo.  Somewhere along the line, we need
3314    to carefully copy dynamic link information from one symbol to the other.
3315    Secondly, the generic part of the elf linker will make .foo a dynamic
3316    symbol as is normal for most other backends.  We need foo dynamic
3317    instead, at least for an application final link.  However, when
3318    creating a shared library containing foo, we need to have both symbols
3319    dynamic so that references to .foo are satisfied during the early
3320    stages of linking.  Otherwise the linker might decide to pull in a
3321    definition from some other object, eg. a static library.
3322
3323    Update: As of August 2004, we support a new convention.  Function
3324    calls may use the function descriptor symbol, ie. "bl foo".  This
3325    behaves exactly as "bl .foo".  */
3326
3327 /* The linker needs to keep track of the number of relocs that it
3328    decides to copy as dynamic relocs in check_relocs for each symbol.
3329    This is so that it can later discard them if they are found to be
3330    unnecessary.  We store the information in a field extending the
3331    regular ELF linker hash table.  */
3332
3333 struct ppc_dyn_relocs
3334 {
3335   struct ppc_dyn_relocs *next;
3336
3337   /* The input section of the reloc.  */
3338   asection *sec;
3339
3340   /* Total number of relocs copied for the input section.  */
3341   bfd_size_type count;
3342
3343   /* Number of pc-relative relocs copied for the input section.  */
3344   bfd_size_type pc_count;
3345 };
3346
3347 /* Track GOT entries needed for a given symbol.  We might need more
3348    than one got entry per symbol.  */
3349 struct got_entry
3350 {
3351   struct got_entry *next;
3352
3353   /* The symbol addend that we'll be placing in the GOT.  */
3354   bfd_vma addend;
3355
3356   /* Unlike other ELF targets, we use separate GOT entries for the same
3357      symbol referenced from different input files.  This is to support
3358      automatic multiple TOC/GOT sections, where the TOC base can vary
3359      from one input file to another.  FIXME: After group_sections we
3360      ought to merge entries within the group.
3361
3362      Point to the BFD owning this GOT entry.  */
3363   bfd *owner;
3364
3365   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3366      TLS_TPREL or TLS_DTPREL for tls entries.  */
3367   char tls_type;
3368
3369   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
3370   union
3371     {
3372       bfd_signed_vma refcount;
3373       bfd_vma offset;
3374     } got;
3375 };
3376
3377 /* The same for PLT.  */
3378 struct plt_entry
3379 {
3380   struct plt_entry *next;
3381
3382   bfd_vma addend;
3383
3384   union
3385     {
3386       bfd_signed_vma refcount;
3387       bfd_vma offset;
3388     } plt;
3389 };
3390
3391 /* Of those relocs that might be copied as dynamic relocs, this function
3392    selects those that must be copied when linking a shared library,
3393    even when the symbol is local.  */
3394
3395 static int
3396 must_be_dyn_reloc (struct bfd_link_info *info,
3397                    enum elf_ppc64_reloc_type r_type)
3398 {
3399   switch (r_type)
3400     {
3401     default:
3402       return 1;
3403
3404     case R_PPC64_REL32:
3405     case R_PPC64_REL64:
3406     case R_PPC64_REL30:
3407       return 0;
3408
3409     case R_PPC64_TPREL16:
3410     case R_PPC64_TPREL16_LO:
3411     case R_PPC64_TPREL16_HI:
3412     case R_PPC64_TPREL16_HA:
3413     case R_PPC64_TPREL16_DS:
3414     case R_PPC64_TPREL16_LO_DS:
3415     case R_PPC64_TPREL16_HIGHER:
3416     case R_PPC64_TPREL16_HIGHERA:
3417     case R_PPC64_TPREL16_HIGHEST:
3418     case R_PPC64_TPREL16_HIGHESTA:
3419     case R_PPC64_TPREL64:
3420       return !info->executable;
3421     }
3422 }
3423
3424 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3425    copying dynamic variables from a shared lib into an app's dynbss
3426    section, and instead use a dynamic relocation to point into the
3427    shared lib.  With code that gcc generates, it's vital that this be
3428    enabled;  In the PowerPC64 ABI, the address of a function is actually
3429    the address of a function descriptor, which resides in the .opd
3430    section.  gcc uses the descriptor directly rather than going via the
3431    GOT as some other ABI's do, which means that initialized function
3432    pointers must reference the descriptor.  Thus, a function pointer
3433    initialized to the address of a function in a shared library will
3434    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3435    redefines the function descriptor symbol to point to the copy.  This
3436    presents a problem as a plt entry for that function is also
3437    initialized from the function descriptor symbol and the copy reloc
3438    may not be initialized first.  */
3439 #define ELIMINATE_COPY_RELOCS 1
3440
3441 /* Section name for stubs is the associated section name plus this
3442    string.  */
3443 #define STUB_SUFFIX ".stub"
3444
3445 /* Linker stubs.
3446    ppc_stub_long_branch:
3447    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3448    destination, but a 24 bit branch in a stub section will reach.
3449    .    b       dest
3450
3451    ppc_stub_plt_branch:
3452    Similar to the above, but a 24 bit branch in the stub section won't
3453    reach its destination.
3454    .    addis   %r12,%r2,xxx@toc@ha
3455    .    ld      %r11,xxx@toc@l(%r12)
3456    .    mtctr   %r11
3457    .    bctr
3458
3459    ppc_stub_plt_call:
3460    Used to call a function in a shared library.  If it so happens that
3461    the plt entry referenced crosses a 64k boundary, then an extra
3462    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3463    .    addis   %r12,%r2,xxx@toc@ha
3464    .    std     %r2,40(%r1)
3465    .    ld      %r11,xxx+0@toc@l(%r12)
3466    .    mtctr   %r11
3467    .    ld      %r2,xxx+8@toc@l(%r12)
3468    .    ld      %r11,xxx+16@toc@l(%r12)
3469    .    bctr
3470
3471    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3472    code to adjust the value and save r2 to support multiple toc sections.
3473    A ppc_stub_long_branch with an r2 offset looks like:
3474    .    std     %r2,40(%r1)
3475    .    addis   %r2,%r2,off@ha
3476    .    addi    %r2,%r2,off@l
3477    .    b       dest
3478
3479    A ppc_stub_plt_branch with an r2 offset looks like:
3480    .    std     %r2,40(%r1)
3481    .    addis   %r12,%r2,xxx@toc@ha
3482    .    ld      %r11,xxx@toc@l(%r12)
3483    .    addis   %r2,%r2,off@ha
3484    .    addi    %r2,%r2,off@l
3485    .    mtctr   %r11
3486    .    bctr
3487
3488    In cases where the "addis" instruction would add zero, the "addis" is
3489    omitted and following instructions modified slightly in some cases.
3490 */
3491
3492 enum ppc_stub_type {
3493   ppc_stub_none,
3494   ppc_stub_long_branch,
3495   ppc_stub_long_branch_r2off,
3496   ppc_stub_plt_branch,
3497   ppc_stub_plt_branch_r2off,
3498   ppc_stub_plt_call
3499 };
3500
3501 struct ppc_stub_hash_entry {
3502
3503   /* Base hash table entry structure.  */
3504   struct bfd_hash_entry root;
3505
3506   enum ppc_stub_type stub_type;
3507
3508   /* The stub section.  */
3509   asection *stub_sec;
3510
3511   /* Offset within stub_sec of the beginning of this stub.  */
3512   bfd_vma stub_offset;
3513
3514   /* Given the symbol's value and its section we can determine its final
3515      value when building the stubs (so the stub knows where to jump.  */
3516   bfd_vma target_value;
3517   asection *target_section;
3518
3519   /* The symbol table entry, if any, that this was derived from.  */
3520   struct ppc_link_hash_entry *h;
3521
3522   /* And the reloc addend that this was derived from.  */
3523   bfd_vma addend;
3524
3525   /* Where this stub is being called from, or, in the case of combined
3526      stub sections, the first input section in the group.  */
3527   asection *id_sec;
3528 };
3529
3530 struct ppc_branch_hash_entry {
3531
3532   /* Base hash table entry structure.  */
3533   struct bfd_hash_entry root;
3534
3535   /* Offset within branch lookup table.  */
3536   unsigned int offset;
3537
3538   /* Generation marker.  */
3539   unsigned int iter;
3540 };
3541
3542 struct ppc_link_hash_entry
3543 {
3544   struct elf_link_hash_entry elf;
3545
3546   union {
3547     /* A pointer to the most recently used stub hash entry against this
3548        symbol.  */
3549     struct ppc_stub_hash_entry *stub_cache;
3550
3551     /* A pointer to the next symbol starting with a '.'  */
3552     struct ppc_link_hash_entry *next_dot_sym;
3553   } u;
3554
3555   /* Track dynamic relocs copied for this symbol.  */
3556   struct ppc_dyn_relocs *dyn_relocs;
3557
3558   /* Link between function code and descriptor symbols.  */
3559   struct ppc_link_hash_entry *oh;
3560
3561   /* Flag function code and descriptor symbols.  */
3562   unsigned int is_func:1;
3563   unsigned int is_func_descriptor:1;
3564   unsigned int fake:1;
3565
3566   /* Whether global opd/toc sym has been adjusted or not.
3567      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3568      should be set for all globals defined in any opd/toc section.  */
3569   unsigned int adjust_done:1;
3570
3571   /* Set if we twiddled this symbol to weak at some stage.  */
3572   unsigned int was_undefined:1;
3573
3574   /* Contexts in which symbol is used in the GOT (or TOC).
3575      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3576      corresponding relocs are encountered during check_relocs.
3577      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3578      indicate the corresponding GOT entry type is not needed.
3579      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3580      a TPREL one.  We use a separate flag rather than setting TPREL
3581      just for convenience in distinguishing the two cases.  */
3582 #define TLS_GD           1      /* GD reloc. */
3583 #define TLS_LD           2      /* LD reloc. */
3584 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3585 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3586 #define TLS_TLS         16      /* Any TLS reloc.  */
3587 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3588 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3589   char tls_mask;
3590 };
3591
3592 /* ppc64 ELF linker hash table.  */
3593
3594 struct ppc_link_hash_table
3595 {
3596   struct elf_link_hash_table elf;
3597
3598   /* The stub hash table.  */
3599   struct bfd_hash_table stub_hash_table;
3600
3601   /* Another hash table for plt_branch stubs.  */
3602   struct bfd_hash_table branch_hash_table;
3603
3604   /* Linker stub bfd.  */
3605   bfd *stub_bfd;
3606
3607   /* Linker call-backs.  */
3608   asection * (*add_stub_section) (const char *, asection *);
3609   void (*layout_sections_again) (void);
3610
3611   /* Array to keep track of which stub sections have been created, and
3612      information on stub grouping.  */
3613   struct map_stub {
3614     /* This is the section to which stubs in the group will be attached.  */
3615     asection *link_sec;
3616     /* The stub section.  */
3617     asection *stub_sec;
3618     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3619     bfd_vma toc_off;
3620   } *stub_group;
3621
3622   /* Temp used when calculating TOC pointers.  */
3623   bfd_vma toc_curr;
3624
3625   /* Highest input section id.  */
3626   int top_id;
3627
3628   /* Highest output section index.  */
3629   int top_index;
3630
3631   /* Used when adding symbols.  */
3632   struct ppc_link_hash_entry *dot_syms;
3633
3634   /* List of input sections for each output section.  */
3635   asection **input_list;
3636
3637   /* Short-cuts to get to dynamic linker sections.  */
3638   asection *got;
3639   asection *plt;
3640   asection *relplt;
3641   asection *dynbss;
3642   asection *relbss;
3643   asection *glink;
3644   asection *sfpr;
3645   asection *brlt;
3646   asection *relbrlt;
3647
3648   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3649   struct ppc_link_hash_entry *tls_get_addr;
3650   struct ppc_link_hash_entry *tls_get_addr_fd;
3651
3652   /* Statistics.  */
3653   unsigned long stub_count[ppc_stub_plt_call];
3654
3655   /* Number of stubs against global syms.  */
3656   unsigned long stub_globals;
3657
3658   /* Set if we should emit symbols for stubs.  */
3659   unsigned int emit_stub_syms:1;
3660
3661   /* Support for multiple toc sections.  */
3662   unsigned int no_multi_toc:1;
3663   unsigned int multi_toc_needed:1;
3664
3665   /* Set on error.  */
3666   unsigned int stub_error:1;
3667
3668   /* Temp used by ppc64_elf_process_dot_syms.  */
3669   unsigned int twiddled_syms:1;
3670
3671   /* Incremented every time we size stubs.  */
3672   unsigned int stub_iteration;
3673
3674   /* Small local sym to section mapping cache.  */
3675   struct sym_sec_cache sym_sec;
3676 };
3677
3678 /* Rename some of the generic section flags to better document how they
3679    are used here.  */
3680 #define has_toc_reloc has_gp_reloc
3681 #define makes_toc_func_call need_finalize_relax
3682 #define call_check_in_progress reloc_done
3683
3684 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3685
3686 #define ppc_hash_table(p) \
3687   ((struct ppc_link_hash_table *) ((p)->hash))
3688
3689 #define ppc_stub_hash_lookup(table, string, create, copy) \
3690   ((struct ppc_stub_hash_entry *) \
3691    bfd_hash_lookup ((table), (string), (create), (copy)))
3692
3693 #define ppc_branch_hash_lookup(table, string, create, copy) \
3694   ((struct ppc_branch_hash_entry *) \
3695    bfd_hash_lookup ((table), (string), (create), (copy)))
3696
3697 /* Create an entry in the stub hash table.  */
3698
3699 static struct bfd_hash_entry *
3700 stub_hash_newfunc (struct bfd_hash_entry *entry,
3701                    struct bfd_hash_table *table,
3702                    const char *string)
3703 {
3704   /* Allocate the structure if it has not already been allocated by a
3705      subclass.  */
3706   if (entry == NULL)
3707     {
3708       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3709       if (entry == NULL)
3710         return entry;
3711     }
3712
3713   /* Call the allocation method of the superclass.  */
3714   entry = bfd_hash_newfunc (entry, table, string);
3715   if (entry != NULL)
3716     {
3717       struct ppc_stub_hash_entry *eh;
3718
3719       /* Initialize the local fields.  */
3720       eh = (struct ppc_stub_hash_entry *) entry;
3721       eh->stub_type = ppc_stub_none;
3722       eh->stub_sec = NULL;
3723       eh->stub_offset = 0;
3724       eh->target_value = 0;
3725       eh->target_section = NULL;
3726       eh->h = NULL;
3727       eh->id_sec = NULL;
3728     }
3729
3730   return entry;
3731 }
3732
3733 /* Create an entry in the branch hash table.  */
3734
3735 static struct bfd_hash_entry *
3736 branch_hash_newfunc (struct bfd_hash_entry *entry,
3737                      struct bfd_hash_table *table,
3738                      const char *string)
3739 {
3740   /* Allocate the structure if it has not already been allocated by a
3741      subclass.  */
3742   if (entry == NULL)
3743     {
3744       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3745       if (entry == NULL)
3746         return entry;
3747     }
3748
3749   /* Call the allocation method of the superclass.  */
3750   entry = bfd_hash_newfunc (entry, table, string);
3751   if (entry != NULL)
3752     {
3753       struct ppc_branch_hash_entry *eh;
3754
3755       /* Initialize the local fields.  */
3756       eh = (struct ppc_branch_hash_entry *) entry;
3757       eh->offset = 0;
3758       eh->iter = 0;
3759     }
3760
3761   return entry;
3762 }
3763
3764 /* Create an entry in a ppc64 ELF linker hash table.  */
3765
3766 static struct bfd_hash_entry *
3767 link_hash_newfunc (struct bfd_hash_entry *entry,
3768                    struct bfd_hash_table *table,
3769                    const char *string)
3770 {
3771   /* Allocate the structure if it has not already been allocated by a
3772      subclass.  */
3773   if (entry == NULL)
3774     {
3775       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3776       if (entry == NULL)
3777         return entry;
3778     }
3779
3780   /* Call the allocation method of the superclass.  */
3781   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3782   if (entry != NULL)
3783     {
3784       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3785
3786       memset (&eh->u.stub_cache, 0,
3787               (sizeof (struct ppc_link_hash_entry)
3788                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3789
3790       /* When making function calls, old ABI code references function entry
3791          points (dot symbols), while new ABI code references the function
3792          descriptor symbol.  We need to make any combination of reference and
3793          definition work together, without breaking archive linking.
3794
3795          For a defined function "foo" and an undefined call to "bar":
3796          An old object defines "foo" and ".foo", references ".bar" (possibly
3797          "bar" too).
3798          A new object defines "foo" and references "bar".
3799
3800          A new object thus has no problem with its undefined symbols being
3801          satisfied by definitions in an old object.  On the other hand, the
3802          old object won't have ".bar" satisfied by a new object.
3803
3804          Keep a list of newly added dot-symbols.  */
3805
3806       if (string[0] == '.')
3807         {
3808           struct ppc_link_hash_table *htab;
3809
3810           htab = (struct ppc_link_hash_table *) table;
3811           eh->u.next_dot_sym = htab->dot_syms;
3812           htab->dot_syms = eh;
3813         }
3814     }
3815
3816   return entry;
3817 }
3818
3819 /* Create a ppc64 ELF linker hash table.  */
3820
3821 static struct bfd_link_hash_table *
3822 ppc64_elf_link_hash_table_create (bfd *abfd)
3823 {
3824   struct ppc_link_hash_table *htab;
3825   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3826
3827   htab = bfd_zmalloc (amt);
3828   if (htab == NULL)
3829     return NULL;
3830
3831   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3832                                       sizeof (struct ppc_link_hash_entry)))
3833     {
3834       free (htab);
3835       return NULL;
3836     }
3837
3838   /* Init the stub hash table too.  */
3839   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3840                             sizeof (struct ppc_stub_hash_entry)))
3841     return NULL;
3842
3843   /* And the branch hash table.  */
3844   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3845                             sizeof (struct ppc_branch_hash_entry)))
3846     return NULL;
3847
3848   /* Initializing two fields of the union is just cosmetic.  We really
3849      only care about glist, but when compiled on a 32-bit host the
3850      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3851      debugger inspection of these fields look nicer.  */
3852   htab->elf.init_got_refcount.refcount = 0;
3853   htab->elf.init_got_refcount.glist = NULL;
3854   htab->elf.init_plt_refcount.refcount = 0;
3855   htab->elf.init_plt_refcount.glist = NULL;
3856   htab->elf.init_got_offset.offset = 0;
3857   htab->elf.init_got_offset.glist = NULL;
3858   htab->elf.init_plt_offset.offset = 0;
3859   htab->elf.init_plt_offset.glist = NULL;
3860
3861   return &htab->elf.root;
3862 }
3863
3864 /* Free the derived linker hash table.  */
3865
3866 static void
3867 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3868 {
3869   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3870
3871   bfd_hash_table_free (&ret->stub_hash_table);
3872   bfd_hash_table_free (&ret->branch_hash_table);
3873   _bfd_generic_link_hash_table_free (hash);
3874 }
3875
3876 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3877
3878 void
3879 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3880 {
3881   struct ppc_link_hash_table *htab;
3882
3883   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3884
3885 /* Always hook our dynamic sections into the first bfd, which is the
3886    linker created stub bfd.  This ensures that the GOT header is at
3887    the start of the output TOC section.  */
3888   htab = ppc_hash_table (info);
3889   htab->stub_bfd = abfd;
3890   htab->elf.dynobj = abfd;
3891 }
3892
3893 /* Build a name for an entry in the stub hash table.  */
3894
3895 static char *
3896 ppc_stub_name (const asection *input_section,
3897                const asection *sym_sec,
3898                const struct ppc_link_hash_entry *h,
3899                const Elf_Internal_Rela *rel)
3900 {
3901   char *stub_name;
3902   bfd_size_type len;
3903
3904   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3905      offsets from a sym as a branch target?  In fact, we could
3906      probably assume the addend is always zero.  */
3907   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3908
3909   if (h)
3910     {
3911       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3912       stub_name = bfd_malloc (len);
3913       if (stub_name == NULL)
3914         return stub_name;
3915
3916       sprintf (stub_name, "%08x.%s+%x",
3917                input_section->id & 0xffffffff,
3918                h->elf.root.root.string,
3919                (int) rel->r_addend & 0xffffffff);
3920     }
3921   else
3922     {
3923       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3924       stub_name = bfd_malloc (len);
3925       if (stub_name == NULL)
3926         return stub_name;
3927
3928       sprintf (stub_name, "%08x.%x:%x+%x",
3929                input_section->id & 0xffffffff,
3930                sym_sec->id & 0xffffffff,
3931                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3932                (int) rel->r_addend & 0xffffffff);
3933     }
3934   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3935     stub_name[len - 2] = 0;
3936   return stub_name;
3937 }
3938
3939 /* Look up an entry in the stub hash.  Stub entries are cached because
3940    creating the stub name takes a bit of time.  */
3941
3942 static struct ppc_stub_hash_entry *
3943 ppc_get_stub_entry (const asection *input_section,
3944                     const asection *sym_sec,
3945                     struct ppc_link_hash_entry *h,
3946                     const Elf_Internal_Rela *rel,
3947                     struct ppc_link_hash_table *htab)
3948 {
3949   struct ppc_stub_hash_entry *stub_entry;
3950   const asection *id_sec;
3951
3952   /* If this input section is part of a group of sections sharing one
3953      stub section, then use the id of the first section in the group.
3954      Stub names need to include a section id, as there may well be
3955      more than one stub used to reach say, printf, and we need to
3956      distinguish between them.  */
3957   id_sec = htab->stub_group[input_section->id].link_sec;
3958
3959   if (h != NULL && h->u.stub_cache != NULL
3960       && h->u.stub_cache->h == h
3961       && h->u.stub_cache->id_sec == id_sec)
3962     {
3963       stub_entry = h->u.stub_cache;
3964     }
3965   else
3966     {
3967       char *stub_name;
3968
3969       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3970       if (stub_name == NULL)
3971         return NULL;
3972
3973       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3974                                          stub_name, FALSE, FALSE);
3975       if (h != NULL)
3976         h->u.stub_cache = stub_entry;
3977
3978       free (stub_name);
3979     }
3980
3981   return stub_entry;
3982 }
3983
3984 /* Add a new stub entry to the stub hash.  Not all fields of the new
3985    stub entry are initialised.  */
3986
3987 static struct ppc_stub_hash_entry *
3988 ppc_add_stub (const char *stub_name,
3989               asection *section,
3990               struct ppc_link_hash_table *htab)
3991 {
3992   asection *link_sec;
3993   asection *stub_sec;
3994   struct ppc_stub_hash_entry *stub_entry;
3995
3996   link_sec = htab->stub_group[section->id].link_sec;
3997   stub_sec = htab->stub_group[section->id].stub_sec;
3998   if (stub_sec == NULL)
3999     {
4000       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4001       if (stub_sec == NULL)
4002         {
4003           size_t namelen;
4004           bfd_size_type len;
4005           char *s_name;
4006
4007           namelen = strlen (link_sec->name);
4008           len = namelen + sizeof (STUB_SUFFIX);
4009           s_name = bfd_alloc (htab->stub_bfd, len);
4010           if (s_name == NULL)
4011             return NULL;
4012
4013           memcpy (s_name, link_sec->name, namelen);
4014           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4015           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4016           if (stub_sec == NULL)
4017             return NULL;
4018           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4019         }
4020       htab->stub_group[section->id].stub_sec = stub_sec;
4021     }
4022
4023   /* Enter this entry into the linker stub hash table.  */
4024   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4025                                      TRUE, FALSE);
4026   if (stub_entry == NULL)
4027     {
4028       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4029                              section->owner, stub_name);
4030       return NULL;
4031     }
4032
4033   stub_entry->stub_sec = stub_sec;
4034   stub_entry->stub_offset = 0;
4035   stub_entry->id_sec = link_sec;
4036   return stub_entry;
4037 }
4038
4039 /* Create sections for linker generated code.  */
4040
4041 static bfd_boolean
4042 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4043 {
4044   struct ppc_link_hash_table *htab;
4045   flagword flags;
4046
4047   htab = ppc_hash_table (info);
4048
4049   /* Create .sfpr for code to save and restore fp regs.  */
4050   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4051            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4052   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4053                                                    flags);
4054   if (htab->sfpr == NULL
4055       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4056     return FALSE;
4057
4058   /* Create .glink for lazy dynamic linking support.  */
4059   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4060                                                     flags);
4061   if (htab->glink == NULL
4062       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4063     return FALSE;
4064
4065   /* Create branch lookup table for plt_branch stubs.  */
4066   flags = (SEC_ALLOC | SEC_LOAD
4067            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4068   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4069                                                    flags);
4070   if (htab->brlt == NULL
4071       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4072     return FALSE;
4073
4074   if (!info->shared)
4075     return TRUE;
4076
4077   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4078            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4079   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4080                                                       ".rela.branch_lt",
4081                                                       flags);
4082   if (!htab->relbrlt
4083       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4084     return FALSE;
4085
4086   return TRUE;
4087 }
4088
4089 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4090    not already done.  */
4091
4092 static bfd_boolean
4093 create_got_section (bfd *abfd, struct bfd_link_info *info)
4094 {
4095   asection *got, *relgot;
4096   flagword flags;
4097   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4098
4099   if (!is_ppc64_elf (abfd))
4100     return FALSE;
4101
4102   if (!htab->got)
4103     {
4104       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4105         return FALSE;
4106
4107       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4108       if (!htab->got)
4109         abort ();
4110     }
4111
4112   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4113            | SEC_LINKER_CREATED);
4114
4115   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4116   if (!got
4117       || !bfd_set_section_alignment (abfd, got, 3))
4118     return FALSE;
4119
4120   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4121                                                flags | SEC_READONLY);
4122   if (!relgot
4123       || ! bfd_set_section_alignment (abfd, relgot, 3))
4124     return FALSE;
4125
4126   ppc64_elf_tdata (abfd)->got = got;
4127   ppc64_elf_tdata (abfd)->relgot = relgot;
4128   return TRUE;
4129 }
4130
4131 /* Create the dynamic sections, and set up shortcuts.  */
4132
4133 static bfd_boolean
4134 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4135 {
4136   struct ppc_link_hash_table *htab;
4137
4138   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4139     return FALSE;
4140
4141   htab = ppc_hash_table (info);
4142   if (!htab->got)
4143     htab->got = bfd_get_section_by_name (dynobj, ".got");
4144   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4145   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4146   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4147   if (!info->shared)
4148     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4149
4150   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4151       || (!info->shared && !htab->relbss))
4152     abort ();
4153
4154   return TRUE;
4155 }
4156
4157 /* Merge PLT info on FROM with that on TO.  */
4158
4159 static void
4160 move_plt_plist (struct ppc_link_hash_entry *from,
4161                 struct ppc_link_hash_entry *to)
4162 {
4163   if (from->elf.plt.plist != NULL)
4164     {
4165       if (to->elf.plt.plist != NULL)
4166         {
4167           struct plt_entry **entp;
4168           struct plt_entry *ent;
4169
4170           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4171             {
4172               struct plt_entry *dent;
4173
4174               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4175                 if (dent->addend == ent->addend)
4176                   {
4177                     dent->plt.refcount += ent->plt.refcount;
4178                     *entp = ent->next;
4179                     break;
4180                   }
4181               if (dent == NULL)
4182                 entp = &ent->next;
4183             }
4184           *entp = to->elf.plt.plist;
4185         }
4186
4187       to->elf.plt.plist = from->elf.plt.plist;
4188       from->elf.plt.plist = NULL;
4189     }
4190 }
4191
4192 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4193
4194 static void
4195 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4196                                 struct elf_link_hash_entry *dir,
4197                                 struct elf_link_hash_entry *ind)
4198 {
4199   struct ppc_link_hash_entry *edir, *eind;
4200
4201   edir = (struct ppc_link_hash_entry *) dir;
4202   eind = (struct ppc_link_hash_entry *) ind;
4203
4204   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4205   if (eind->dyn_relocs != NULL)
4206     {
4207       if (edir->dyn_relocs != NULL)
4208         {
4209           struct ppc_dyn_relocs **pp;
4210           struct ppc_dyn_relocs *p;
4211
4212           /* Add reloc counts against the indirect sym to the direct sym
4213              list.  Merge any entries against the same section.  */
4214           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4215             {
4216               struct ppc_dyn_relocs *q;
4217
4218               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4219                 if (q->sec == p->sec)
4220                   {
4221                     q->pc_count += p->pc_count;
4222                     q->count += p->count;
4223                     *pp = p->next;
4224                     break;
4225                   }
4226               if (q == NULL)
4227                 pp = &p->next;
4228             }
4229           *pp = edir->dyn_relocs;
4230         }
4231
4232       edir->dyn_relocs = eind->dyn_relocs;
4233       eind->dyn_relocs = NULL;
4234     }
4235
4236   edir->is_func |= eind->is_func;
4237   edir->is_func_descriptor |= eind->is_func_descriptor;
4238   edir->tls_mask |= eind->tls_mask;
4239
4240   /* If called to transfer flags for a weakdef during processing
4241      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4242      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4243   if (!(ELIMINATE_COPY_RELOCS
4244         && eind->elf.root.type != bfd_link_hash_indirect
4245         && edir->elf.dynamic_adjusted))
4246     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4247
4248   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4249   edir->elf.ref_regular |= eind->elf.ref_regular;
4250   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4251   edir->elf.needs_plt |= eind->elf.needs_plt;
4252
4253   /* If we were called to copy over info for a weak sym, that's all.  */
4254   if (eind->elf.root.type != bfd_link_hash_indirect)
4255     return;
4256
4257   /* Copy over got entries that we may have already seen to the
4258      symbol which just became indirect.  */
4259   if (eind->elf.got.glist != NULL)
4260     {
4261       if (edir->elf.got.glist != NULL)
4262         {
4263           struct got_entry **entp;
4264           struct got_entry *ent;
4265
4266           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4267             {
4268               struct got_entry *dent;
4269
4270               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4271                 if (dent->addend == ent->addend
4272                     && dent->owner == ent->owner
4273                     && dent->tls_type == ent->tls_type)
4274                   {
4275                     dent->got.refcount += ent->got.refcount;
4276                     *entp = ent->next;
4277                     break;
4278                   }
4279               if (dent == NULL)
4280                 entp = &ent->next;
4281             }
4282           *entp = edir->elf.got.glist;
4283         }
4284
4285       edir->elf.got.glist = eind->elf.got.glist;
4286       eind->elf.got.glist = NULL;
4287     }
4288
4289   /* And plt entries.  */
4290   move_plt_plist (eind, edir);
4291
4292   if (eind->elf.dynindx != -1)
4293     {
4294       if (edir->elf.dynindx != -1)
4295         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4296                                 edir->elf.dynstr_index);
4297       edir->elf.dynindx = eind->elf.dynindx;
4298       edir->elf.dynstr_index = eind->elf.dynstr_index;
4299       eind->elf.dynindx = -1;
4300       eind->elf.dynstr_index = 0;
4301     }
4302 }
4303
4304 /* Find the function descriptor hash entry from the given function code
4305    hash entry FH.  Link the entries via their OH fields.  */
4306
4307 static struct ppc_link_hash_entry *
4308 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4309 {
4310   struct ppc_link_hash_entry *fdh = fh->oh;
4311
4312   if (fdh == NULL)
4313     {
4314       const char *fd_name = fh->elf.root.root.string + 1;
4315
4316       fdh = (struct ppc_link_hash_entry *)
4317         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4318       if (fdh != NULL)
4319         {
4320           fdh->is_func_descriptor = 1;
4321           fdh->oh = fh;
4322           fh->is_func = 1;
4323           fh->oh = fdh;
4324         }
4325     }
4326
4327   return fdh;
4328 }
4329
4330 /* Make a fake function descriptor sym for the code sym FH.  */
4331
4332 static struct ppc_link_hash_entry *
4333 make_fdh (struct bfd_link_info *info,
4334           struct ppc_link_hash_entry *fh)
4335 {
4336   bfd *abfd;
4337   asymbol *newsym;
4338   struct bfd_link_hash_entry *bh;
4339   struct ppc_link_hash_entry *fdh;
4340
4341   abfd = fh->elf.root.u.undef.abfd;
4342   newsym = bfd_make_empty_symbol (abfd);
4343   newsym->name = fh->elf.root.root.string + 1;
4344   newsym->section = bfd_und_section_ptr;
4345   newsym->value = 0;
4346   newsym->flags = BSF_WEAK;
4347
4348   bh = NULL;
4349   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4350                                          newsym->flags, newsym->section,
4351                                          newsym->value, NULL, FALSE, FALSE,
4352                                          &bh))
4353     return NULL;
4354
4355   fdh = (struct ppc_link_hash_entry *) bh;
4356   fdh->elf.non_elf = 0;
4357   fdh->fake = 1;
4358   fdh->is_func_descriptor = 1;
4359   fdh->oh = fh;
4360   fh->is_func = 1;
4361   fh->oh = fdh;
4362   return fdh;
4363 }
4364
4365 /* Fix function descriptor symbols defined in .opd sections to be
4366    function type.  */
4367
4368 static bfd_boolean
4369 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4370                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
4371                            Elf_Internal_Sym *isym,
4372                            const char **name ATTRIBUTE_UNUSED,
4373                            flagword *flags ATTRIBUTE_UNUSED,
4374                            asection **sec,
4375                            bfd_vma *value ATTRIBUTE_UNUSED)
4376 {
4377   if (*sec != NULL
4378       && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4379     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4380
4381   return TRUE;
4382 }
4383
4384 /* This function makes an old ABI object reference to ".bar" cause the
4385    inclusion of a new ABI object archive that defines "bar".
4386    NAME is a symbol defined in an archive.  Return a symbol in the hash
4387    table that might be satisfied by the archive symbols.  */
4388
4389 static struct elf_link_hash_entry *
4390 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4391                                  struct bfd_link_info *info,
4392                                  const char *name)
4393 {
4394   struct elf_link_hash_entry *h;
4395   char *dot_name;
4396   size_t len;
4397
4398   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4399   if (h != NULL
4400       /* Don't return this sym if it is a fake function descriptor
4401          created by add_symbol_adjust.  */
4402       && !(h->root.type == bfd_link_hash_undefweak
4403            && ((struct ppc_link_hash_entry *) h)->fake))
4404     return h;
4405
4406   if (name[0] == '.')
4407     return h;
4408
4409   len = strlen (name);
4410   dot_name = bfd_alloc (abfd, len + 2);
4411   if (dot_name == NULL)
4412     return (struct elf_link_hash_entry *) 0 - 1;
4413   dot_name[0] = '.';
4414   memcpy (dot_name + 1, name, len + 1);
4415   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4416   bfd_release (abfd, dot_name);
4417   return h;
4418 }
4419
4420 /* This function satisfies all old ABI object references to ".bar" if a
4421    new ABI object defines "bar".  Well, at least, undefined dot symbols
4422    are made weak.  This stops later archive searches from including an
4423    object if we already have a function descriptor definition.  It also
4424    prevents the linker complaining about undefined symbols.
4425    We also check and correct mismatched symbol visibility here.  The
4426    most restrictive visibility of the function descriptor and the
4427    function entry symbol is used.  */
4428
4429 static bfd_boolean
4430 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4431 {
4432   struct ppc_link_hash_table *htab;
4433   struct ppc_link_hash_entry *fdh;
4434
4435   if (eh->elf.root.type == bfd_link_hash_indirect)
4436     return TRUE;
4437
4438   if (eh->elf.root.type == bfd_link_hash_warning)
4439     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4440
4441   if (eh->elf.root.root.string[0] != '.')
4442     abort ();
4443
4444   htab = ppc_hash_table (info);
4445   fdh = get_fdh (eh, htab);
4446   if (fdh == NULL
4447       && !info->relocatable
4448       && (eh->elf.root.type == bfd_link_hash_undefined
4449           || eh->elf.root.type == bfd_link_hash_undefweak)
4450       && eh->elf.ref_regular)
4451     {
4452       /* Make an undefweak function descriptor sym, which is enough to
4453          pull in an --as-needed shared lib, but won't cause link
4454          errors.  Archives are handled elsewhere.  */
4455       fdh = make_fdh (info, eh);
4456       if (fdh == NULL)
4457         return FALSE;
4458       else
4459         fdh->elf.ref_regular = 1;
4460     }
4461   else if (fdh != NULL)
4462     {
4463       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4464       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4465       if (entry_vis < descr_vis)
4466         fdh->elf.other += entry_vis - descr_vis;
4467       else if (entry_vis > descr_vis)
4468         eh->elf.other += descr_vis - entry_vis;
4469
4470       if ((fdh->elf.root.type == bfd_link_hash_defined
4471            || fdh->elf.root.type == bfd_link_hash_defweak)
4472           && eh->elf.root.type == bfd_link_hash_undefined)
4473         {
4474           eh->elf.root.type = bfd_link_hash_undefweak;
4475           eh->was_undefined = 1;
4476           htab->twiddled_syms = 1;
4477         }
4478     }
4479
4480   return TRUE;
4481 }
4482
4483 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4484
4485 static bfd_boolean
4486 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4487 {
4488   struct ppc_link_hash_table *htab;
4489   struct ppc_link_hash_entry **p, *eh;
4490
4491   htab = ppc_hash_table (info);
4492   if (!is_ppc64_elf (info->output_bfd))
4493     return TRUE;
4494
4495   if (is_ppc64_elf (ibfd))
4496     {
4497       p = &htab->dot_syms;
4498       while ((eh = *p) != NULL)
4499         {
4500           *p = NULL;
4501           if (!add_symbol_adjust (eh, info))
4502             return FALSE;
4503           p = &eh->u.next_dot_sym;
4504         }
4505     }
4506
4507   /* Clear the list for non-ppc64 input files.  */
4508   p = &htab->dot_syms;
4509   while ((eh = *p) != NULL)
4510     {
4511       *p = NULL;
4512       p = &eh->u.next_dot_sym;
4513     }
4514
4515   /* We need to fix the undefs list for any syms we have twiddled to
4516      undef_weak.  */
4517   if (htab->twiddled_syms)
4518     {
4519       bfd_link_repair_undef_list (&htab->elf.root);
4520       htab->twiddled_syms = 0;
4521     }
4522   return TRUE;
4523 }
4524
4525 /* Undo hash table changes when an --as-needed input file is determined
4526    not to be needed.  */
4527
4528 static bfd_boolean
4529 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4530                              struct bfd_link_info *info)
4531 {
4532   ppc_hash_table (info)->dot_syms = NULL;
4533   return TRUE;
4534 }
4535
4536 static bfd_boolean
4537 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4538                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4539 {
4540   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4541   char *local_got_tls_masks;
4542
4543   if (local_got_ents == NULL)
4544     {
4545       bfd_size_type size = symtab_hdr->sh_info;
4546
4547       size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4548       local_got_ents = bfd_zalloc (abfd, size);
4549       if (local_got_ents == NULL)
4550         return FALSE;
4551       elf_local_got_ents (abfd) = local_got_ents;
4552     }
4553
4554   if ((tls_type & TLS_EXPLICIT) == 0)
4555     {
4556       struct got_entry *ent;
4557
4558       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4559         if (ent->addend == r_addend
4560             && ent->owner == abfd
4561             && ent->tls_type == tls_type)
4562           break;
4563       if (ent == NULL)
4564         {
4565           bfd_size_type amt = sizeof (*ent);
4566           ent = bfd_alloc (abfd, amt);
4567           if (ent == NULL)
4568             return FALSE;
4569           ent->next = local_got_ents[r_symndx];
4570           ent->addend = r_addend;
4571           ent->owner = abfd;
4572           ent->tls_type = tls_type;
4573           ent->got.refcount = 0;
4574           local_got_ents[r_symndx] = ent;
4575         }
4576       ent->got.refcount += 1;
4577     }
4578
4579   local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4580   local_got_tls_masks[r_symndx] |= tls_type;
4581   return TRUE;
4582 }
4583
4584 static bfd_boolean
4585 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4586 {
4587   struct plt_entry *ent;
4588
4589   for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4590     if (ent->addend == addend)
4591       break;
4592   if (ent == NULL)
4593     {
4594       bfd_size_type amt = sizeof (*ent);
4595       ent = bfd_alloc (abfd, amt);
4596       if (ent == NULL)
4597         return FALSE;
4598       ent->next = eh->elf.plt.plist;
4599       ent->addend = addend;
4600       ent->plt.refcount = 0;
4601       eh->elf.plt.plist = ent;
4602     }
4603   ent->plt.refcount += 1;
4604   eh->elf.needs_plt = 1;
4605   if (eh->elf.root.root.string[0] == '.'
4606       && eh->elf.root.root.string[1] != '\0')
4607     eh->is_func = 1;
4608   return TRUE;
4609 }
4610
4611 /* Look through the relocs for a section during the first phase, and
4612    calculate needed space in the global offset table, procedure
4613    linkage table, and dynamic reloc sections.  */
4614
4615 static bfd_boolean
4616 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4617                         asection *sec, const Elf_Internal_Rela *relocs)
4618 {
4619   struct ppc_link_hash_table *htab;
4620   Elf_Internal_Shdr *symtab_hdr;
4621   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4622   const Elf_Internal_Rela *rel;
4623   const Elf_Internal_Rela *rel_end;
4624   asection *sreloc;
4625   asection **opd_sym_map;
4626   struct elf_link_hash_entry *tga, *dottga;
4627
4628   if (info->relocatable)
4629     return TRUE;
4630
4631   /* Don't do anything special with non-loaded, non-alloced sections.
4632      In particular, any relocs in such sections should not affect GOT
4633      and PLT reference counting (ie. we don't allow them to create GOT
4634      or PLT entries), there's no possibility or desire to optimize TLS
4635      relocs, and there's not much point in propagating relocs to shared
4636      libs that the dynamic linker won't relocate.  */
4637   if ((sec->flags & SEC_ALLOC) == 0)
4638     return TRUE;
4639
4640   BFD_ASSERT (is_ppc64_elf (abfd));
4641
4642   htab = ppc_hash_table (info);
4643   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4644                               FALSE, FALSE, TRUE);
4645   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4646                                  FALSE, FALSE, TRUE);
4647   symtab_hdr = &elf_symtab_hdr (abfd);
4648
4649   sym_hashes = elf_sym_hashes (abfd);
4650   sym_hashes_end = (sym_hashes
4651                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4652                     - symtab_hdr->sh_info);
4653
4654   sreloc = NULL;
4655   opd_sym_map = NULL;
4656   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4657     {
4658       /* Garbage collection needs some extra help with .opd sections.
4659          We don't want to necessarily keep everything referenced by
4660          relocs in .opd, as that would keep all functions.  Instead,
4661          if we reference an .opd symbol (a function descriptor), we
4662          want to keep the function code symbol's section.  This is
4663          easy for global symbols, but for local syms we need to keep
4664          information about the associated function section.  */
4665       bfd_size_type amt;
4666
4667       amt = sec->size * sizeof (*opd_sym_map) / 8;
4668       opd_sym_map = bfd_zalloc (abfd, amt);
4669       if (opd_sym_map == NULL)
4670         return FALSE;
4671       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4672       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4673       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4674     }
4675
4676   if (htab->sfpr == NULL
4677       && !create_linkage_sections (htab->elf.dynobj, info))
4678     return FALSE;
4679
4680   rel_end = relocs + sec->reloc_count;
4681   for (rel = relocs; rel < rel_end; rel++)
4682     {
4683       unsigned long r_symndx;
4684       struct elf_link_hash_entry *h;
4685       enum elf_ppc64_reloc_type r_type;
4686       int tls_type;
4687       struct _ppc64_elf_section_data *ppc64_sec;
4688
4689       r_symndx = ELF64_R_SYM (rel->r_info);
4690       if (r_symndx < symtab_hdr->sh_info)
4691         h = NULL;
4692       else
4693         {
4694           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4695           while (h->root.type == bfd_link_hash_indirect
4696                  || h->root.type == bfd_link_hash_warning)
4697             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4698         }
4699
4700       tls_type = 0;
4701       r_type = ELF64_R_TYPE (rel->r_info);
4702       if (h != NULL && (h == tga || h == dottga))
4703         switch (r_type)
4704           {
4705           default:
4706             break;
4707
4708           case R_PPC64_REL24:
4709           case R_PPC64_REL14:
4710           case R_PPC64_REL14_BRTAKEN:
4711           case R_PPC64_REL14_BRNTAKEN:
4712           case R_PPC64_ADDR24:
4713           case R_PPC64_ADDR14:
4714           case R_PPC64_ADDR14_BRTAKEN:
4715           case R_PPC64_ADDR14_BRNTAKEN:
4716             if (rel != relocs
4717                 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4718                     || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4719               /* We have a new-style __tls_get_addr call with a marker
4720                  reloc.  */
4721               ;
4722             else
4723               /* Mark this section as having an old-style call.  */
4724               sec->has_tls_get_addr_call = 1;
4725             break;
4726           }
4727
4728       switch (r_type)
4729         {
4730         case R_PPC64_TLSGD:
4731         case R_PPC64_TLSLD:
4732           /* These special tls relocs tie a call to __tls_get_addr with
4733              its parameter symbol.  */
4734           break;
4735
4736         case R_PPC64_GOT_TLSLD16:
4737         case R_PPC64_GOT_TLSLD16_LO:
4738         case R_PPC64_GOT_TLSLD16_HI:
4739         case R_PPC64_GOT_TLSLD16_HA:
4740           tls_type = TLS_TLS | TLS_LD;
4741           goto dogottls;
4742
4743         case R_PPC64_GOT_TLSGD16:
4744         case R_PPC64_GOT_TLSGD16_LO:
4745         case R_PPC64_GOT_TLSGD16_HI:
4746         case R_PPC64_GOT_TLSGD16_HA:
4747           tls_type = TLS_TLS | TLS_GD;
4748           goto dogottls;
4749
4750         case R_PPC64_GOT_TPREL16_DS:
4751         case R_PPC64_GOT_TPREL16_LO_DS:
4752         case R_PPC64_GOT_TPREL16_HI:
4753         case R_PPC64_GOT_TPREL16_HA:
4754           if (!info->executable)
4755             info->flags |= DF_STATIC_TLS;
4756           tls_type = TLS_TLS | TLS_TPREL;
4757           goto dogottls;
4758
4759         case R_PPC64_GOT_DTPREL16_DS:
4760         case R_PPC64_GOT_DTPREL16_LO_DS:
4761         case R_PPC64_GOT_DTPREL16_HI:
4762         case R_PPC64_GOT_DTPREL16_HA:
4763           tls_type = TLS_TLS | TLS_DTPREL;
4764         dogottls:
4765           sec->has_tls_reloc = 1;
4766           /* Fall thru */
4767
4768         case R_PPC64_GOT16:
4769         case R_PPC64_GOT16_DS:
4770         case R_PPC64_GOT16_HA:
4771         case R_PPC64_GOT16_HI:
4772         case R_PPC64_GOT16_LO:
4773         case R_PPC64_GOT16_LO_DS:
4774           /* This symbol requires a global offset table entry.  */
4775           sec->has_toc_reloc = 1;
4776           if (ppc64_elf_tdata (abfd)->got == NULL
4777               && !create_got_section (abfd, info))
4778             return FALSE;
4779
4780           if (h != NULL)
4781             {
4782               struct ppc_link_hash_entry *eh;
4783               struct got_entry *ent;
4784
4785               eh = (struct ppc_link_hash_entry *) h;
4786               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4787                 if (ent->addend == rel->r_addend
4788                     && ent->owner == abfd
4789                     && ent->tls_type == tls_type)
4790                   break;
4791               if (ent == NULL)
4792                 {
4793                   bfd_size_type amt = sizeof (*ent);
4794                   ent = bfd_alloc (abfd, amt);
4795                   if (ent == NULL)
4796                     return FALSE;
4797                   ent->next = eh->elf.got.glist;
4798                   ent->addend = rel->r_addend;
4799                   ent->owner = abfd;
4800                   ent->tls_type = tls_type;
4801                   ent->got.refcount = 0;
4802                   eh->elf.got.glist = ent;
4803                 }
4804               ent->got.refcount += 1;
4805               eh->tls_mask |= tls_type;
4806             }
4807           else
4808             /* This is a global offset table entry for a local symbol.  */
4809             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4810                                         rel->r_addend, tls_type))
4811               return FALSE;
4812           break;
4813
4814         case R_PPC64_PLT16_HA:
4815         case R_PPC64_PLT16_HI:
4816         case R_PPC64_PLT16_LO:
4817         case R_PPC64_PLT32:
4818         case R_PPC64_PLT64:
4819           /* This symbol requires a procedure linkage table entry.  We
4820              actually build the entry in adjust_dynamic_symbol,
4821              because this might be a case of linking PIC code without
4822              linking in any dynamic objects, in which case we don't
4823              need to generate a procedure linkage table after all.  */
4824           if (h == NULL)
4825             {
4826               /* It does not make sense to have a procedure linkage
4827                  table entry for a local symbol.  */
4828               bfd_set_error (bfd_error_bad_value);
4829               return FALSE;
4830             }
4831           else
4832             if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4833                                   rel->r_addend))
4834               return FALSE;
4835           break;
4836
4837           /* The following relocations don't need to propagate the
4838              relocation if linking a shared object since they are
4839              section relative.  */
4840         case R_PPC64_SECTOFF:
4841         case R_PPC64_SECTOFF_LO:
4842         case R_PPC64_SECTOFF_HI:
4843         case R_PPC64_SECTOFF_HA:
4844         case R_PPC64_SECTOFF_DS:
4845         case R_PPC64_SECTOFF_LO_DS:
4846         case R_PPC64_DTPREL16:
4847         case R_PPC64_DTPREL16_LO:
4848         case R_PPC64_DTPREL16_HI:
4849         case R_PPC64_DTPREL16_HA:
4850         case R_PPC64_DTPREL16_DS:
4851         case R_PPC64_DTPREL16_LO_DS:
4852         case R_PPC64_DTPREL16_HIGHER:
4853         case R_PPC64_DTPREL16_HIGHERA:
4854         case R_PPC64_DTPREL16_HIGHEST:
4855         case R_PPC64_DTPREL16_HIGHESTA:
4856           break;
4857
4858           /* Nor do these.  */
4859         case R_PPC64_TOC16:
4860         case R_PPC64_TOC16_LO:
4861         case R_PPC64_TOC16_HI:
4862         case R_PPC64_TOC16_HA:
4863         case R_PPC64_TOC16_DS:
4864         case R_PPC64_TOC16_LO_DS:
4865           sec->has_toc_reloc = 1;
4866           break;
4867
4868           /* This relocation describes the C++ object vtable hierarchy.
4869              Reconstruct it for later use during GC.  */
4870         case R_PPC64_GNU_VTINHERIT:
4871           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4872             return FALSE;
4873           break;
4874
4875           /* This relocation describes which C++ vtable entries are actually
4876              used.  Record for later use during GC.  */
4877         case R_PPC64_GNU_VTENTRY:
4878           BFD_ASSERT (h != NULL);
4879           if (h != NULL
4880               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4881             return FALSE;
4882           break;
4883
4884         case R_PPC64_REL14:
4885         case R_PPC64_REL14_BRTAKEN:
4886         case R_PPC64_REL14_BRNTAKEN:
4887           {
4888             asection *dest = NULL;
4889
4890             /* Heuristic: If jumping outside our section, chances are
4891                we are going to need a stub.  */
4892             if (h != NULL)
4893               {
4894                 /* If the sym is weak it may be overridden later, so
4895                    don't assume we know where a weak sym lives.  */
4896                 if (h->root.type == bfd_link_hash_defined)
4897                   dest = h->root.u.def.section;
4898               }
4899             else
4900               dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4901                                                 sec, r_symndx);
4902             if (dest != sec)
4903               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
4904           }
4905           /* Fall through.  */
4906
4907         case R_PPC64_REL24:
4908           if (h != NULL)
4909             {
4910               /* We may need a .plt entry if the function this reloc
4911                  refers to is in a shared lib.  */
4912               if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4913                                     rel->r_addend))
4914                 return FALSE;
4915               if (h == tga || h == dottga)
4916                 sec->has_tls_reloc = 1;
4917             }
4918           break;
4919
4920         case R_PPC64_TPREL64:
4921           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4922           if (!info->executable)
4923             info->flags |= DF_STATIC_TLS;
4924           goto dotlstoc;
4925
4926         case R_PPC64_DTPMOD64:
4927           if (rel + 1 < rel_end
4928               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4929               && rel[1].r_offset == rel->r_offset + 8)
4930             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4931           else
4932             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4933           goto dotlstoc;
4934
4935         case R_PPC64_DTPREL64:
4936           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4937           if (rel != relocs
4938               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4939               && rel[-1].r_offset == rel->r_offset - 8)
4940             /* This is the second reloc of a dtpmod, dtprel pair.
4941                Don't mark with TLS_DTPREL.  */
4942             goto dodyn;
4943
4944         dotlstoc:
4945           sec->has_tls_reloc = 1;
4946           if (h != NULL)
4947             {
4948               struct ppc_link_hash_entry *eh;
4949               eh = (struct ppc_link_hash_entry *) h;
4950               eh->tls_mask |= tls_type;
4951             }
4952           else
4953             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4954                                         rel->r_addend, tls_type))
4955               return FALSE;
4956
4957           ppc64_sec = ppc64_elf_section_data (sec);
4958           if (ppc64_sec->sec_type != sec_toc)
4959             {
4960               bfd_size_type amt;
4961
4962               /* One extra to simplify get_tls_mask.  */
4963               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
4964               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
4965               if (ppc64_sec->u.toc.symndx == NULL)
4966                 return FALSE;
4967               amt = sec->size * sizeof (bfd_vma) / 8;
4968               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
4969               if (ppc64_sec->u.toc.add == NULL)
4970                 return FALSE;
4971               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
4972               ppc64_sec->sec_type = sec_toc;
4973             }
4974           BFD_ASSERT (rel->r_offset % 8 == 0);
4975           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
4976           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
4977
4978           /* Mark the second slot of a GD or LD entry.
4979              -1 to indicate GD and -2 to indicate LD.  */
4980           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4981             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
4982           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4983             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
4984           goto dodyn;
4985
4986         case R_PPC64_TPREL16:
4987         case R_PPC64_TPREL16_LO:
4988         case R_PPC64_TPREL16_HI:
4989         case R_PPC64_TPREL16_HA:
4990         case R_PPC64_TPREL16_DS:
4991         case R_PPC64_TPREL16_LO_DS:
4992         case R_PPC64_TPREL16_HIGHER:
4993         case R_PPC64_TPREL16_HIGHERA:
4994         case R_PPC64_TPREL16_HIGHEST:
4995         case R_PPC64_TPREL16_HIGHESTA:
4996           if (info->shared)
4997             {
4998               if (!info->executable)
4999                 info->flags |= DF_STATIC_TLS;
5000               goto dodyn;
5001             }
5002           break;
5003
5004         case R_PPC64_ADDR64:
5005           if (opd_sym_map != NULL
5006               && rel + 1 < rel_end
5007               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5008             {
5009               if (h != NULL)
5010                 {
5011                   if (h->root.root.string[0] == '.'
5012                       && h->root.root.string[1] != 0
5013                       && get_fdh ((struct ppc_link_hash_entry *) h, htab))
5014                     ;
5015                   else
5016                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5017                 }
5018               else
5019                 {
5020                   asection *s;
5021
5022                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
5023                                                  r_symndx);
5024                   if (s == NULL)
5025                     return FALSE;
5026                   else if (s != sec)
5027                     opd_sym_map[rel->r_offset / 8] = s;
5028                 }
5029             }
5030           /* Fall through.  */
5031
5032         case R_PPC64_REL30:
5033         case R_PPC64_REL32:
5034         case R_PPC64_REL64:
5035         case R_PPC64_ADDR14:
5036         case R_PPC64_ADDR14_BRNTAKEN:
5037         case R_PPC64_ADDR14_BRTAKEN:
5038         case R_PPC64_ADDR16:
5039         case R_PPC64_ADDR16_DS:
5040         case R_PPC64_ADDR16_HA:
5041         case R_PPC64_ADDR16_HI:
5042         case R_PPC64_ADDR16_HIGHER:
5043         case R_PPC64_ADDR16_HIGHERA:
5044         case R_PPC64_ADDR16_HIGHEST:
5045         case R_PPC64_ADDR16_HIGHESTA:
5046         case R_PPC64_ADDR16_LO:
5047         case R_PPC64_ADDR16_LO_DS:
5048         case R_PPC64_ADDR24:
5049         case R_PPC64_ADDR32:
5050         case R_PPC64_UADDR16:
5051         case R_PPC64_UADDR32:
5052         case R_PPC64_UADDR64:
5053         case R_PPC64_TOC:
5054           if (h != NULL && !info->shared)
5055             /* We may need a copy reloc.  */
5056             h->non_got_ref = 1;
5057
5058           /* Don't propagate .opd relocs.  */
5059           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5060             break;
5061
5062           /* If we are creating a shared library, and this is a reloc
5063              against a global symbol, or a non PC relative reloc
5064              against a local symbol, then we need to copy the reloc
5065              into the shared library.  However, if we are linking with
5066              -Bsymbolic, we do not need to copy a reloc against a
5067              global symbol which is defined in an object we are
5068              including in the link (i.e., DEF_REGULAR is set).  At
5069              this point we have not seen all the input files, so it is
5070              possible that DEF_REGULAR is not set now but will be set
5071              later (it is never cleared).  In case of a weak definition,
5072              DEF_REGULAR may be cleared later by a strong definition in
5073              a shared library.  We account for that possibility below by
5074              storing information in the dyn_relocs field of the hash
5075              table entry.  A similar situation occurs when creating
5076              shared libraries and symbol visibility changes render the
5077              symbol local.
5078
5079              If on the other hand, we are creating an executable, we
5080              may need to keep relocations for symbols satisfied by a
5081              dynamic library if we manage to avoid copy relocs for the
5082              symbol.  */
5083         dodyn:
5084           if ((info->shared
5085                && (must_be_dyn_reloc (info, r_type)
5086                    || (h != NULL
5087                        && (! info->symbolic
5088                            || h->root.type == bfd_link_hash_defweak
5089                            || !h->def_regular))))
5090               || (ELIMINATE_COPY_RELOCS
5091                   && !info->shared
5092                   && h != NULL
5093                   && (h->root.type == bfd_link_hash_defweak
5094                       || !h->def_regular)))
5095             {
5096               struct ppc_dyn_relocs *p;
5097               struct ppc_dyn_relocs **head;
5098
5099               /* We must copy these reloc types into the output file.
5100                  Create a reloc section in dynobj and make room for
5101                  this reloc.  */
5102               if (sreloc == NULL)
5103                 {
5104                   sreloc = _bfd_elf_make_dynamic_reloc_section
5105                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5106
5107                   if (sreloc == NULL)
5108                     return FALSE;
5109                 }
5110
5111               /* If this is a global symbol, we count the number of
5112                  relocations we need for this symbol.  */
5113               if (h != NULL)
5114                 {
5115                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5116                 }
5117               else
5118                 {
5119                   /* Track dynamic relocs needed for local syms too.
5120                      We really need local syms available to do this
5121                      easily.  Oh well.  */
5122
5123                   asection *s;
5124                   void *vpp;
5125
5126                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
5127                                                  sec, r_symndx);
5128                   if (s == NULL)
5129                     return FALSE;
5130
5131                   vpp = &elf_section_data (s)->local_dynrel;
5132                   head = (struct ppc_dyn_relocs **) vpp;
5133                 }
5134
5135               p = *head;
5136               if (p == NULL || p->sec != sec)
5137                 {
5138                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5139                   if (p == NULL)
5140                     return FALSE;
5141                   p->next = *head;
5142                   *head = p;
5143                   p->sec = sec;
5144                   p->count = 0;
5145                   p->pc_count = 0;
5146                 }
5147
5148               p->count += 1;
5149               if (!must_be_dyn_reloc (info, r_type))
5150                 p->pc_count += 1;
5151             }
5152           break;
5153
5154         default:
5155           break;
5156         }
5157     }
5158
5159   return TRUE;
5160 }
5161
5162 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5163    of the code entry point, and its section.  */
5164
5165 static bfd_vma
5166 opd_entry_value (asection *opd_sec,
5167                  bfd_vma offset,
5168                  asection **code_sec,
5169                  bfd_vma *code_off)
5170 {
5171   bfd *opd_bfd = opd_sec->owner;
5172   Elf_Internal_Rela *relocs;
5173   Elf_Internal_Rela *lo, *hi, *look;
5174   bfd_vma val;
5175
5176   /* No relocs implies we are linking a --just-symbols object.  */
5177   if (opd_sec->reloc_count == 0)
5178     {
5179       bfd_vma val;
5180
5181       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5182         return (bfd_vma) -1;
5183
5184       if (code_sec != NULL)
5185         {
5186           asection *sec, *likely = NULL;
5187           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5188             if (sec->vma <= val
5189                 && (sec->flags & SEC_LOAD) != 0
5190                 && (sec->flags & SEC_ALLOC) != 0)
5191               likely = sec;
5192           if (likely != NULL)
5193             {
5194               *code_sec = likely;
5195               if (code_off != NULL)
5196                 *code_off = val - likely->vma;
5197             }
5198         }
5199       return val;
5200     }
5201
5202   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5203
5204   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5205   if (relocs == NULL)
5206     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5207
5208   /* Go find the opd reloc at the sym address.  */
5209   lo = relocs;
5210   BFD_ASSERT (lo != NULL);
5211   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5212   val = (bfd_vma) -1;
5213   while (lo < hi)
5214     {
5215       look = lo + (hi - lo) / 2;
5216       if (look->r_offset < offset)
5217         lo = look + 1;
5218       else if (look->r_offset > offset)
5219         hi = look;
5220       else
5221         {
5222           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5223
5224           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5225               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5226             {
5227               unsigned long symndx = ELF64_R_SYM (look->r_info);
5228               asection *sec;
5229
5230               if (symndx < symtab_hdr->sh_info)
5231                 {
5232                   Elf_Internal_Sym *sym;
5233
5234                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5235                   if (sym == NULL)
5236                     {
5237                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5238                                                   symtab_hdr->sh_info,
5239                                                   0, NULL, NULL, NULL);
5240                       if (sym == NULL)
5241                         break;
5242                       symtab_hdr->contents = (bfd_byte *) sym;
5243                     }
5244
5245                   sym += symndx;
5246                   val = sym->st_value;
5247                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5248                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5249                 }
5250               else
5251                 {
5252                   struct elf_link_hash_entry **sym_hashes;
5253                   struct elf_link_hash_entry *rh;
5254
5255                   sym_hashes = elf_sym_hashes (opd_bfd);
5256                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5257                   while (rh->root.type == bfd_link_hash_indirect
5258                          || rh->root.type == bfd_link_hash_warning)
5259                     rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
5260                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5261                               || rh->root.type == bfd_link_hash_defweak);
5262                   val = rh->root.u.def.value;
5263                   sec = rh->root.u.def.section;
5264                 }
5265               val += look->r_addend;
5266               if (code_off != NULL)
5267                 *code_off = val;
5268               if (code_sec != NULL)
5269                 *code_sec = sec;
5270               if (sec != NULL && sec->output_section != NULL)
5271                 val += sec->output_section->vma + sec->output_offset;
5272             }
5273           break;
5274         }
5275     }
5276
5277   return val;
5278 }
5279
5280 /* Mark all our entry sym sections, both opd and code section.  */
5281
5282 static void
5283 ppc64_elf_gc_keep (struct bfd_link_info *info)
5284 {
5285   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5286   struct bfd_sym_chain *sym;
5287
5288   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5289     {
5290       struct ppc_link_hash_entry *eh;
5291       asection *sec;
5292
5293       eh = (struct ppc_link_hash_entry *)
5294         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5295       if (eh == NULL)
5296         continue;
5297       if (eh->elf.root.type != bfd_link_hash_defined
5298           && eh->elf.root.type != bfd_link_hash_defweak)
5299         continue;
5300
5301       if (eh->is_func_descriptor
5302           && (eh->oh->elf.root.type == bfd_link_hash_defined
5303               || eh->oh->elf.root.type == bfd_link_hash_defweak))
5304         {
5305           sec = eh->oh->elf.root.u.def.section;
5306           sec->flags |= SEC_KEEP;
5307         }
5308       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5309                && opd_entry_value (eh->elf.root.u.def.section,
5310                                    eh->elf.root.u.def.value,
5311                                    &sec, NULL) != (bfd_vma) -1)
5312         sec->flags |= SEC_KEEP;
5313
5314       sec = eh->elf.root.u.def.section;
5315       sec->flags |= SEC_KEEP;
5316     }
5317 }
5318
5319 /* Mark sections containing dynamically referenced symbols.  When
5320    building shared libraries, we must assume that any visible symbol is
5321    referenced.  */
5322
5323 static bfd_boolean
5324 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5325 {
5326   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5327   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5328
5329   if (eh->elf.root.type == bfd_link_hash_warning)
5330     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5331
5332   /* Dynamic linking info is on the func descriptor sym.  */
5333   if (eh->oh != NULL
5334       && eh->oh->is_func_descriptor
5335       && (eh->oh->elf.root.type == bfd_link_hash_defined
5336           || eh->oh->elf.root.type == bfd_link_hash_defweak))
5337     eh = eh->oh;
5338
5339   if ((eh->elf.root.type == bfd_link_hash_defined
5340        || eh->elf.root.type == bfd_link_hash_defweak)
5341       && (eh->elf.ref_dynamic
5342           || (!info->executable
5343               && eh->elf.def_regular
5344               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5345               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5346     {
5347       asection *code_sec;
5348
5349       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5350
5351       /* Function descriptor syms cause the associated
5352          function code sym section to be marked.  */
5353       if (eh->is_func_descriptor
5354           && (eh->oh->elf.root.type == bfd_link_hash_defined
5355               || eh->oh->elf.root.type == bfd_link_hash_defweak))
5356         eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5357       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5358                && opd_entry_value (eh->elf.root.u.def.section,
5359                                    eh->elf.root.u.def.value,
5360                                    &code_sec, NULL) != (bfd_vma) -1)
5361         code_sec->flags |= SEC_KEEP;
5362     }
5363
5364   return TRUE;
5365 }
5366
5367 /* Return the section that should be marked against GC for a given
5368    relocation.  */
5369
5370 static asection *
5371 ppc64_elf_gc_mark_hook (asection *sec,
5372                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
5373                         Elf_Internal_Rela *rel,
5374                         struct elf_link_hash_entry *h,
5375                         Elf_Internal_Sym *sym)
5376 {
5377   asection *rsec;
5378
5379   /* Syms return NULL if we're marking .opd, so we avoid marking all
5380      function sections, as all functions are referenced in .opd.  */
5381   rsec = NULL;
5382   if (get_opd_info (sec) != NULL)
5383     return rsec;
5384
5385   if (h != NULL)
5386     {
5387       enum elf_ppc64_reloc_type r_type;
5388       struct ppc_link_hash_entry *eh;
5389
5390       r_type = ELF64_R_TYPE (rel->r_info);
5391       switch (r_type)
5392         {
5393         case R_PPC64_GNU_VTINHERIT:
5394         case R_PPC64_GNU_VTENTRY:
5395           break;
5396
5397         default:
5398           switch (h->root.type)
5399             {
5400             case bfd_link_hash_defined:
5401             case bfd_link_hash_defweak:
5402               eh = (struct ppc_link_hash_entry *) h;
5403               if (eh->oh != NULL
5404                   && eh->oh->is_func_descriptor
5405                   && (eh->oh->elf.root.type == bfd_link_hash_defined
5406                       || eh->oh->elf.root.type == bfd_link_hash_defweak))
5407                 eh = eh->oh;
5408
5409               /* Function descriptor syms cause the associated
5410                  function code sym section to be marked.  */
5411               if (eh->is_func_descriptor
5412                   && (eh->oh->elf.root.type == bfd_link_hash_defined
5413                       || eh->oh->elf.root.type == bfd_link_hash_defweak))
5414                 {
5415                   /* They also mark their opd section.  */
5416                   eh->elf.root.u.def.section->gc_mark = 1;
5417
5418                   rsec = eh->oh->elf.root.u.def.section;
5419                 }
5420               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5421                        && opd_entry_value (eh->elf.root.u.def.section,
5422                                            eh->elf.root.u.def.value,
5423                                            &rsec, NULL) != (bfd_vma) -1)
5424                 eh->elf.root.u.def.section->gc_mark = 1;
5425               else
5426                 rsec = h->root.u.def.section;
5427               break;
5428
5429             case bfd_link_hash_common:
5430               rsec = h->root.u.c.p->section;
5431               break;
5432
5433             default:
5434               break;
5435             }
5436         }
5437     }
5438   else
5439     {
5440       struct _opd_sec_data *opd;
5441
5442       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5443       opd = get_opd_info (rsec);
5444       if (opd != NULL && opd->func_sec != NULL)
5445         {
5446           rsec->gc_mark = 1;
5447
5448           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5449         }
5450     }
5451
5452   return rsec;
5453 }
5454
5455 /* Update the .got, .plt. and dynamic reloc reference counts for the
5456    section being removed.  */
5457
5458 static bfd_boolean
5459 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5460                          asection *sec, const Elf_Internal_Rela *relocs)
5461 {
5462   struct ppc_link_hash_table *htab;
5463   Elf_Internal_Shdr *symtab_hdr;
5464   struct elf_link_hash_entry **sym_hashes;
5465   struct got_entry **local_got_ents;
5466   const Elf_Internal_Rela *rel, *relend;
5467
5468   if (info->relocatable)
5469     return TRUE;
5470
5471   if ((sec->flags & SEC_ALLOC) == 0)
5472     return TRUE;
5473
5474   elf_section_data (sec)->local_dynrel = NULL;
5475
5476   htab = ppc_hash_table (info);
5477   symtab_hdr = &elf_symtab_hdr (abfd);
5478   sym_hashes = elf_sym_hashes (abfd);
5479   local_got_ents = elf_local_got_ents (abfd);
5480
5481   relend = relocs + sec->reloc_count;
5482   for (rel = relocs; rel < relend; rel++)
5483     {
5484       unsigned long r_symndx;
5485       enum elf_ppc64_reloc_type r_type;
5486       struct elf_link_hash_entry *h = NULL;
5487       char tls_type = 0;
5488
5489       r_symndx = ELF64_R_SYM (rel->r_info);
5490       r_type = ELF64_R_TYPE (rel->r_info);
5491       if (r_symndx >= symtab_hdr->sh_info)
5492         {
5493           struct ppc_link_hash_entry *eh;
5494           struct ppc_dyn_relocs **pp;
5495           struct ppc_dyn_relocs *p;
5496
5497           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5498           while (h->root.type == bfd_link_hash_indirect
5499                  || h->root.type == bfd_link_hash_warning)
5500             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5501           eh = (struct ppc_link_hash_entry *) h;
5502
5503           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5504             if (p->sec == sec)
5505               {
5506                 /* Everything must go for SEC.  */
5507                 *pp = p->next;
5508                 break;
5509               }
5510         }
5511
5512       switch (r_type)
5513         {
5514         case R_PPC64_GOT_TLSLD16:
5515         case R_PPC64_GOT_TLSLD16_LO:
5516         case R_PPC64_GOT_TLSLD16_HI:
5517         case R_PPC64_GOT_TLSLD16_HA:
5518           tls_type = TLS_TLS | TLS_LD;
5519           goto dogot;
5520
5521         case R_PPC64_GOT_TLSGD16:
5522         case R_PPC64_GOT_TLSGD16_LO:
5523         case R_PPC64_GOT_TLSGD16_HI:
5524         case R_PPC64_GOT_TLSGD16_HA:
5525           tls_type = TLS_TLS | TLS_GD;
5526           goto dogot;
5527
5528         case R_PPC64_GOT_TPREL16_DS:
5529         case R_PPC64_GOT_TPREL16_LO_DS:
5530         case R_PPC64_GOT_TPREL16_HI:
5531         case R_PPC64_GOT_TPREL16_HA:
5532           tls_type = TLS_TLS | TLS_TPREL;
5533           goto dogot;
5534
5535         case R_PPC64_GOT_DTPREL16_DS:
5536         case R_PPC64_GOT_DTPREL16_LO_DS:
5537         case R_PPC64_GOT_DTPREL16_HI:
5538         case R_PPC64_GOT_DTPREL16_HA:
5539           tls_type = TLS_TLS | TLS_DTPREL;
5540           goto dogot;
5541
5542         case R_PPC64_GOT16:
5543         case R_PPC64_GOT16_DS:
5544         case R_PPC64_GOT16_HA:
5545         case R_PPC64_GOT16_HI:
5546         case R_PPC64_GOT16_LO:
5547         case R_PPC64_GOT16_LO_DS:
5548         dogot:
5549           {
5550             struct got_entry *ent;
5551
5552             if (h != NULL)
5553               ent = h->got.glist;
5554             else
5555               ent = local_got_ents[r_symndx];
5556
5557             for (; ent != NULL; ent = ent->next)
5558               if (ent->addend == rel->r_addend
5559                   && ent->owner == abfd
5560                   && ent->tls_type == tls_type)
5561                 break;
5562             if (ent == NULL)
5563               abort ();
5564             if (ent->got.refcount > 0)
5565               ent->got.refcount -= 1;
5566           }
5567           break;
5568
5569         case R_PPC64_PLT16_HA:
5570         case R_PPC64_PLT16_HI:
5571         case R_PPC64_PLT16_LO:
5572         case R_PPC64_PLT32:
5573         case R_PPC64_PLT64:
5574         case R_PPC64_REL14:
5575         case R_PPC64_REL14_BRNTAKEN:
5576         case R_PPC64_REL14_BRTAKEN:
5577         case R_PPC64_REL24:
5578           if (h != NULL)
5579             {
5580               struct plt_entry *ent;
5581
5582               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5583                 if (ent->addend == rel->r_addend)
5584                   break;
5585               if (ent == NULL)
5586                 abort ();
5587               if (ent->plt.refcount > 0)
5588                 ent->plt.refcount -= 1;
5589             }
5590           break;
5591
5592         default:
5593           break;
5594         }
5595     }
5596   return TRUE;
5597 }
5598
5599 /* The maximum size of .sfpr.  */
5600 #define SFPR_MAX (218*4)
5601
5602 struct sfpr_def_parms
5603 {
5604   const char name[12];
5605   unsigned char lo, hi;
5606   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5607   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5608 };
5609
5610 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5611
5612 static unsigned int
5613 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5614 {
5615   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5616   unsigned int i;
5617   size_t len = strlen (parm->name);
5618   bfd_boolean writing = FALSE;
5619   char sym[16];
5620
5621   memcpy (sym, parm->name, len);
5622   sym[len + 2] = 0;
5623
5624   for (i = parm->lo; i <= parm->hi; i++)
5625     {
5626       struct elf_link_hash_entry *h;
5627
5628       sym[len + 0] = i / 10 + '0';
5629       sym[len + 1] = i % 10 + '0';
5630       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5631       if (h != NULL
5632           && !h->def_regular)
5633         {
5634           h->root.type = bfd_link_hash_defined;
5635           h->root.u.def.section = htab->sfpr;
5636           h->root.u.def.value = htab->sfpr->size;
5637           h->type = STT_FUNC;
5638           h->def_regular = 1;
5639           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5640           writing = TRUE;
5641           if (htab->sfpr->contents == NULL)
5642             {
5643               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5644               if (htab->sfpr->contents == NULL)
5645                 return FALSE;
5646             }
5647         }
5648       if (writing)
5649         {
5650           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5651           if (i != parm->hi)
5652             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5653           else
5654             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5655           htab->sfpr->size = p - htab->sfpr->contents;
5656         }
5657     }
5658
5659   return TRUE;
5660 }
5661
5662 static bfd_byte *
5663 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5664 {
5665   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5666   return p + 4;
5667 }
5668
5669 static bfd_byte *
5670 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5671 {
5672   p = savegpr0 (abfd, p, r);
5673   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5674   p = p + 4;
5675   bfd_put_32 (abfd, BLR, p);
5676   return p + 4;
5677 }
5678
5679 static bfd_byte *
5680 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5681 {
5682   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5683   return p + 4;
5684 }
5685
5686 static bfd_byte *
5687 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5688 {
5689   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5690   p = p + 4;
5691   p = restgpr0 (abfd, p, r);
5692   bfd_put_32 (abfd, MTLR_R0, p);
5693   p = p + 4;
5694   if (r == 29)
5695     {
5696       p = restgpr0 (abfd, p, 30);
5697       p = restgpr0 (abfd, p, 31);
5698     }
5699   bfd_put_32 (abfd, BLR, p);
5700   return p + 4;
5701 }
5702
5703 static bfd_byte *
5704 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5705 {
5706   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5707   return p + 4;
5708 }
5709
5710 static bfd_byte *
5711 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5712 {
5713   p = savegpr1 (abfd, p, r);
5714   bfd_put_32 (abfd, BLR, p);
5715   return p + 4;
5716 }
5717
5718 static bfd_byte *
5719 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5720 {
5721   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5722   return p + 4;
5723 }
5724
5725 static bfd_byte *
5726 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5727 {
5728   p = restgpr1 (abfd, p, r);
5729   bfd_put_32 (abfd, BLR, p);
5730   return p + 4;
5731 }
5732
5733 static bfd_byte *
5734 savefpr (bfd *abfd, bfd_byte *p, int r)
5735 {
5736   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5737   return p + 4;
5738 }
5739
5740 static bfd_byte *
5741 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5742 {
5743   p = savefpr (abfd, p, r);
5744   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5745   p = p + 4;
5746   bfd_put_32 (abfd, BLR, p);
5747   return p + 4;
5748 }
5749
5750 static bfd_byte *
5751 restfpr (bfd *abfd, bfd_byte *p, int r)
5752 {
5753   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5754   return p + 4;
5755 }
5756
5757 static bfd_byte *
5758 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5759 {
5760   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5761   p = p + 4;
5762   p = restfpr (abfd, p, r);
5763   bfd_put_32 (abfd, MTLR_R0, p);
5764   p = p + 4;
5765   if (r == 29)
5766     {
5767       p = restfpr (abfd, p, 30);
5768       p = restfpr (abfd, p, 31);
5769     }
5770   bfd_put_32 (abfd, BLR, p);
5771   return p + 4;
5772 }
5773
5774 static bfd_byte *
5775 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5776 {
5777   p = savefpr (abfd, p, r);
5778   bfd_put_32 (abfd, BLR, p);
5779   return p + 4;
5780 }
5781
5782 static bfd_byte *
5783 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5784 {
5785   p = restfpr (abfd, p, r);
5786   bfd_put_32 (abfd, BLR, p);
5787   return p + 4;
5788 }
5789
5790 static bfd_byte *
5791 savevr (bfd *abfd, bfd_byte *p, int r)
5792 {
5793   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5794   p = p + 4;
5795   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5796   return p + 4;
5797 }
5798
5799 static bfd_byte *
5800 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5801 {
5802   p = savevr (abfd, p, r);
5803   bfd_put_32 (abfd, BLR, p);
5804   return p + 4;
5805 }
5806
5807 static bfd_byte *
5808 restvr (bfd *abfd, bfd_byte *p, int r)
5809 {
5810   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5811   p = p + 4;
5812   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5813   return p + 4;
5814 }
5815
5816 static bfd_byte *
5817 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5818 {
5819   p = restvr (abfd, p, r);
5820   bfd_put_32 (abfd, BLR, p);
5821   return p + 4;
5822 }
5823
5824 /* Called via elf_link_hash_traverse to transfer dynamic linking
5825    information on function code symbol entries to their corresponding
5826    function descriptor symbol entries.  */
5827
5828 static bfd_boolean
5829 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5830 {
5831   struct bfd_link_info *info;
5832   struct ppc_link_hash_table *htab;
5833   struct plt_entry *ent;
5834   struct ppc_link_hash_entry *fh;
5835   struct ppc_link_hash_entry *fdh;
5836   bfd_boolean force_local;
5837
5838   fh = (struct ppc_link_hash_entry *) h;
5839   if (fh->elf.root.type == bfd_link_hash_indirect)
5840     return TRUE;
5841
5842   if (fh->elf.root.type == bfd_link_hash_warning)
5843     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5844
5845   info = inf;
5846   htab = ppc_hash_table (info);
5847
5848   /* Resolve undefined references to dot-symbols as the value
5849      in the function descriptor, if we have one in a regular object.
5850      This is to satisfy cases like ".quad .foo".  Calls to functions
5851      in dynamic objects are handled elsewhere.  */
5852   if (fh->elf.root.type == bfd_link_hash_undefweak
5853       && fh->was_undefined
5854       && (fh->oh->elf.root.type == bfd_link_hash_defined
5855           || fh->oh->elf.root.type == bfd_link_hash_defweak)
5856       && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5857       && opd_entry_value (fh->oh->elf.root.u.def.section,
5858                           fh->oh->elf.root.u.def.value,
5859                           &fh->elf.root.u.def.section,
5860                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
5861     {
5862       fh->elf.root.type = fh->oh->elf.root.type;
5863       fh->elf.forced_local = 1;
5864       fh->elf.def_regular = fh->oh->elf.def_regular;
5865       fh->elf.def_dynamic = fh->oh->elf.def_dynamic;
5866     }
5867
5868   /* If this is a function code symbol, transfer dynamic linking
5869      information to the function descriptor symbol.  */
5870   if (!fh->is_func)
5871     return TRUE;
5872
5873   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5874     if (ent->plt.refcount > 0)
5875       break;
5876   if (ent == NULL
5877       || fh->elf.root.root.string[0] != '.'
5878       || fh->elf.root.root.string[1] == '\0')
5879     return TRUE;
5880
5881   /* Find the corresponding function descriptor symbol.  Create it
5882      as undefined if necessary.  */
5883
5884   fdh = get_fdh (fh, htab);
5885   if (fdh != NULL)
5886     while (fdh->elf.root.type == bfd_link_hash_indirect
5887            || fdh->elf.root.type == bfd_link_hash_warning)
5888       fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5889
5890   if (fdh == NULL
5891       && !info->executable
5892       && (fh->elf.root.type == bfd_link_hash_undefined
5893           || fh->elf.root.type == bfd_link_hash_undefweak))
5894     {
5895       fdh = make_fdh (info, fh);
5896       if (fdh == NULL)
5897         return FALSE;
5898     }
5899
5900   /* Fake function descriptors are made undefweak.  If the function
5901      code symbol is strong undefined, make the fake sym the same.
5902      If the function code symbol is defined, then force the fake
5903      descriptor local;  We can't support overriding of symbols in a
5904      shared library on a fake descriptor.  */
5905
5906   if (fdh != NULL
5907       && fdh->fake
5908       && fdh->elf.root.type == bfd_link_hash_undefweak)
5909     {
5910       if (fh->elf.root.type == bfd_link_hash_undefined)
5911         {
5912           fdh->elf.root.type = bfd_link_hash_undefined;
5913           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5914         }
5915       else if (fh->elf.root.type == bfd_link_hash_defined
5916                || fh->elf.root.type == bfd_link_hash_defweak)
5917         {
5918           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5919         }
5920     }
5921
5922   if (fdh != NULL
5923       && !fdh->elf.forced_local
5924       && (!info->executable
5925           || fdh->elf.def_dynamic
5926           || fdh->elf.ref_dynamic
5927           || (fdh->elf.root.type == bfd_link_hash_undefweak
5928               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5929     {
5930       if (fdh->elf.dynindx == -1)
5931         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5932           return FALSE;
5933       fdh->elf.ref_regular |= fh->elf.ref_regular;
5934       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5935       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5936       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5937       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5938         {
5939           move_plt_plist (fh, fdh);
5940           fdh->elf.needs_plt = 1;
5941         }
5942       fdh->is_func_descriptor = 1;
5943       fdh->oh = fh;
5944       fh->oh = fdh;
5945     }
5946
5947   /* Now that the info is on the function descriptor, clear the
5948      function code sym info.  Any function code syms for which we
5949      don't have a definition in a regular file, we force local.
5950      This prevents a shared library from exporting syms that have
5951      been imported from another library.  Function code syms that
5952      are really in the library we must leave global to prevent the
5953      linker dragging in a definition from a static library.  */
5954   force_local = (!fh->elf.def_regular
5955                  || fdh == NULL
5956                  || !fdh->elf.def_regular
5957                  || fdh->elf.forced_local);
5958   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5959
5960   return TRUE;
5961 }
5962
5963 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
5964    this hook to a) provide some gcc support functions, and b) transfer
5965    dynamic linking information gathered so far on function code symbol
5966    entries, to their corresponding function descriptor symbol entries.  */
5967
5968 static bfd_boolean
5969 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5970                             struct bfd_link_info *info)
5971 {
5972   struct ppc_link_hash_table *htab;
5973   unsigned int i;
5974   const struct sfpr_def_parms funcs[] =
5975     {
5976       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5977       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5978       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5979       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5980       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5981       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5982       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5983       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5984       { "._savef", 14, 31, savefpr, savefpr1_tail },
5985       { "._restf", 14, 31, restfpr, restfpr1_tail },
5986       { "_savevr_", 20, 31, savevr, savevr_tail },
5987       { "_restvr_", 20, 31, restvr, restvr_tail }
5988     };
5989
5990   htab = ppc_hash_table (info);
5991   if (htab->sfpr == NULL)
5992     /* We don't have any relocs.  */
5993     return TRUE;
5994
5995   /* Provide any missing _save* and _rest* functions.  */
5996   htab->sfpr->size = 0;
5997   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5998     if (!sfpr_define (info, &funcs[i]))
5999       return FALSE;
6000
6001   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6002
6003   if (htab->sfpr->size == 0)
6004     htab->sfpr->flags |= SEC_EXCLUDE;
6005
6006   return TRUE;
6007 }
6008
6009 /* Adjust a symbol defined by a dynamic object and referenced by a
6010    regular object.  The current definition is in some section of the
6011    dynamic object, but we're not including those sections.  We have to
6012    change the definition to something the rest of the link can
6013    understand.  */
6014
6015 static bfd_boolean
6016 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6017                                  struct elf_link_hash_entry *h)
6018 {
6019   struct ppc_link_hash_table *htab;
6020   asection *s;
6021
6022   htab = ppc_hash_table (info);
6023
6024   /* Deal with function syms.  */
6025   if (h->type == STT_FUNC
6026       || h->needs_plt)
6027     {
6028       /* Clear procedure linkage table information for any symbol that
6029          won't need a .plt entry.  */
6030       struct plt_entry *ent;
6031       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6032         if (ent->plt.refcount > 0)
6033           break;
6034       if (ent == NULL
6035           || SYMBOL_CALLS_LOCAL (info, h)
6036           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6037               && h->root.type == bfd_link_hash_undefweak))
6038         {
6039           h->plt.plist = NULL;
6040           h->needs_plt = 0;
6041         }
6042     }
6043   else
6044     h->plt.plist = NULL;
6045
6046   /* If this is a weak symbol, and there is a real definition, the
6047      processor independent code will have arranged for us to see the
6048      real definition first, and we can just use the same value.  */
6049   if (h->u.weakdef != NULL)
6050     {
6051       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6052                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6053       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6054       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6055       if (ELIMINATE_COPY_RELOCS)
6056         h->non_got_ref = h->u.weakdef->non_got_ref;
6057       return TRUE;
6058     }
6059
6060   /* If we are creating a shared library, we must presume that the
6061      only references to the symbol are via the global offset table.
6062      For such cases we need not do anything here; the relocations will
6063      be handled correctly by relocate_section.  */
6064   if (info->shared)
6065     return TRUE;
6066
6067   /* If there are no references to this symbol that do not use the
6068      GOT, we don't need to generate a copy reloc.  */
6069   if (!h->non_got_ref)
6070     return TRUE;
6071
6072   /* Don't generate a copy reloc for symbols defined in the executable.  */
6073   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6074     return TRUE;
6075
6076   if (ELIMINATE_COPY_RELOCS)
6077     {
6078       struct ppc_link_hash_entry * eh;
6079       struct ppc_dyn_relocs *p;
6080
6081       eh = (struct ppc_link_hash_entry *) h;
6082       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6083         {
6084           s = p->sec->output_section;
6085           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6086             break;
6087         }
6088
6089       /* If we didn't find any dynamic relocs in read-only sections, then
6090          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6091       if (p == NULL)
6092         {
6093           h->non_got_ref = 0;
6094           return TRUE;
6095         }
6096     }
6097
6098   if (h->plt.plist != NULL)
6099     {
6100       /* We should never get here, but unfortunately there are versions
6101          of gcc out there that improperly (for this ABI) put initialized
6102          function pointers, vtable refs and suchlike in read-only
6103          sections.  Allow them to proceed, but warn that this might
6104          break at runtime.  */
6105       (*_bfd_error_handler)
6106         (_("copy reloc against `%s' requires lazy plt linking; "
6107            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6108          h->root.root.string);
6109     }
6110
6111   /* This is a reference to a symbol defined by a dynamic object which
6112      is not a function.  */
6113
6114   if (h->size == 0)
6115     {
6116       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6117                              h->root.root.string);
6118       return TRUE;
6119     }
6120
6121   /* We must allocate the symbol in our .dynbss section, which will
6122      become part of the .bss section of the executable.  There will be
6123      an entry for this symbol in the .dynsym section.  The dynamic
6124      object will contain position independent code, so all references
6125      from the dynamic object to this symbol will go through the global
6126      offset table.  The dynamic linker will use the .dynsym entry to
6127      determine the address it must put in the global offset table, so
6128      both the dynamic object and the regular object will refer to the
6129      same memory location for the variable.  */
6130
6131   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6132      to copy the initial value out of the dynamic object and into the
6133      runtime process image.  We need to remember the offset into the
6134      .rela.bss section we are going to use.  */
6135   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6136     {
6137       htab->relbss->size += sizeof (Elf64_External_Rela);
6138       h->needs_copy = 1;
6139     }
6140
6141   s = htab->dynbss;
6142
6143   return _bfd_elf_adjust_dynamic_copy (h, s);
6144 }
6145
6146 /* If given a function descriptor symbol, hide both the function code
6147    sym and the descriptor.  */
6148 static void
6149 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6150                        struct elf_link_hash_entry *h,
6151                        bfd_boolean force_local)
6152 {
6153   struct ppc_link_hash_entry *eh;
6154   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6155
6156   eh = (struct ppc_link_hash_entry *) h;
6157   if (eh->is_func_descriptor)
6158     {
6159       struct ppc_link_hash_entry *fh = eh->oh;
6160
6161       if (fh == NULL)
6162         {
6163           const char *p, *q;
6164           struct ppc_link_hash_table *htab;
6165           char save;
6166
6167           /* We aren't supposed to use alloca in BFD because on
6168              systems which do not have alloca the version in libiberty
6169              calls xmalloc, which might cause the program to crash
6170              when it runs out of memory.  This function doesn't have a
6171              return status, so there's no way to gracefully return an
6172              error.  So cheat.  We know that string[-1] can be safely
6173              accessed;  It's either a string in an ELF string table,
6174              or allocated in an objalloc structure.  */
6175
6176           p = eh->elf.root.root.string - 1;
6177           save = *p;
6178           *(char *) p = '.';
6179           htab = ppc_hash_table (info);
6180           fh = (struct ppc_link_hash_entry *)
6181             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6182           *(char *) p = save;
6183
6184           /* Unfortunately, if it so happens that the string we were
6185              looking for was allocated immediately before this string,
6186              then we overwrote the string terminator.  That's the only
6187              reason the lookup should fail.  */
6188           if (fh == NULL)
6189             {
6190               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6191               while (q >= eh->elf.root.root.string && *q == *p)
6192                 --q, --p;
6193               if (q < eh->elf.root.root.string && *p == '.')
6194                 fh = (struct ppc_link_hash_entry *)
6195                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6196             }
6197           if (fh != NULL)
6198             {
6199               eh->oh = fh;
6200               fh->oh = eh;
6201             }
6202         }
6203       if (fh != NULL)
6204         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6205     }
6206 }
6207
6208 static bfd_boolean
6209 get_sym_h (struct elf_link_hash_entry **hp,
6210            Elf_Internal_Sym **symp,
6211            asection **symsecp,
6212            char **tls_maskp,
6213            Elf_Internal_Sym **locsymsp,
6214            unsigned long r_symndx,
6215            bfd *ibfd)
6216 {
6217   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6218
6219   if (r_symndx >= symtab_hdr->sh_info)
6220     {
6221       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6222       struct elf_link_hash_entry *h;
6223
6224       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6225       while (h->root.type == bfd_link_hash_indirect
6226              || h->root.type == bfd_link_hash_warning)
6227         h = (struct elf_link_hash_entry *) h->root.u.i.link;
6228
6229       if (hp != NULL)
6230         *hp = h;
6231
6232       if (symp != NULL)
6233         *symp = NULL;
6234
6235       if (symsecp != NULL)
6236         {
6237           asection *symsec = NULL;
6238           if (h->root.type == bfd_link_hash_defined
6239               || h->root.type == bfd_link_hash_defweak)
6240             symsec = h->root.u.def.section;
6241           *symsecp = symsec;
6242         }
6243
6244       if (tls_maskp != NULL)
6245         {
6246           struct ppc_link_hash_entry *eh;
6247
6248           eh = (struct ppc_link_hash_entry *) h;
6249           *tls_maskp = &eh->tls_mask;
6250         }
6251     }
6252   else
6253     {
6254       Elf_Internal_Sym *sym;
6255       Elf_Internal_Sym *locsyms = *locsymsp;
6256
6257       if (locsyms == NULL)
6258         {
6259           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6260           if (locsyms == NULL)
6261             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6262                                             symtab_hdr->sh_info,
6263                                             0, NULL, NULL, NULL);
6264           if (locsyms == NULL)
6265             return FALSE;
6266           *locsymsp = locsyms;
6267         }
6268       sym = locsyms + r_symndx;
6269
6270       if (hp != NULL)
6271         *hp = NULL;
6272
6273       if (symp != NULL)
6274         *symp = sym;
6275
6276       if (symsecp != NULL)
6277         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6278
6279       if (tls_maskp != NULL)
6280         {
6281           struct got_entry **lgot_ents;
6282           char *tls_mask;
6283
6284           tls_mask = NULL;
6285           lgot_ents = elf_local_got_ents (ibfd);
6286           if (lgot_ents != NULL)
6287             {
6288               char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
6289               tls_mask = &lgot_masks[r_symndx];
6290             }
6291           *tls_maskp = tls_mask;
6292         }
6293     }
6294   return TRUE;
6295 }
6296
6297 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6298    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6299    type suitable for optimization, and 1 otherwise.  */
6300
6301 static int
6302 get_tls_mask (char **tls_maskp,
6303               unsigned long *toc_symndx,
6304               bfd_vma *toc_addend,
6305               Elf_Internal_Sym **locsymsp,
6306               const Elf_Internal_Rela *rel,
6307               bfd *ibfd)
6308 {
6309   unsigned long r_symndx;
6310   int next_r;
6311   struct elf_link_hash_entry *h;
6312   Elf_Internal_Sym *sym;
6313   asection *sec;
6314   bfd_vma off;
6315
6316   r_symndx = ELF64_R_SYM (rel->r_info);
6317   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6318     return 0;
6319
6320   if ((*tls_maskp != NULL && **tls_maskp != 0)
6321       || sec == NULL
6322       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6323     return 1;
6324
6325   /* Look inside a TOC section too.  */
6326   if (h != NULL)
6327     {
6328       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6329       off = h->root.u.def.value;
6330     }
6331   else
6332     off = sym->st_value;
6333   off += rel->r_addend;
6334   BFD_ASSERT (off % 8 == 0);
6335   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6336   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6337   if (toc_symndx != NULL)
6338     *toc_symndx = r_symndx;
6339   if (toc_addend != NULL)
6340     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6341   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6342     return 0;
6343   if ((h == NULL
6344        || ((h->root.type == bfd_link_hash_defined
6345             || h->root.type == bfd_link_hash_defweak)
6346            && !h->def_dynamic))
6347       && (next_r == -1 || next_r == -2))
6348     return 1 - next_r;
6349   return 1;
6350 }
6351
6352 /* Adjust all global syms defined in opd sections.  In gcc generated
6353    code for the old ABI, these will already have been done.  */
6354
6355 static bfd_boolean
6356 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6357 {
6358   struct ppc_link_hash_entry *eh;
6359   asection *sym_sec;
6360   struct _opd_sec_data *opd;
6361
6362   if (h->root.type == bfd_link_hash_indirect)
6363     return TRUE;
6364
6365   if (h->root.type == bfd_link_hash_warning)
6366     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6367
6368   if (h->root.type != bfd_link_hash_defined
6369       && h->root.type != bfd_link_hash_defweak)
6370     return TRUE;
6371
6372   eh = (struct ppc_link_hash_entry *) h;
6373   if (eh->adjust_done)
6374     return TRUE;
6375
6376   sym_sec = eh->elf.root.u.def.section;
6377   opd = get_opd_info (sym_sec);
6378   if (opd != NULL && opd->adjust != NULL)
6379     {
6380       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6381       if (adjust == -1)
6382         {
6383           /* This entry has been deleted.  */
6384           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6385           if (dsec == NULL)
6386             {
6387               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6388                 if (elf_discarded_section (dsec))
6389                   {
6390                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6391                     break;
6392                   }
6393             }
6394           eh->elf.root.u.def.value = 0;
6395           eh->elf.root.u.def.section = dsec;
6396         }
6397       else
6398         eh->elf.root.u.def.value += adjust;
6399       eh->adjust_done = 1;
6400     }
6401   return TRUE;
6402 }
6403
6404 /* Handles decrementing dynamic reloc counts for the reloc specified by
6405    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6406    have already been determined.  */
6407
6408 static bfd_boolean
6409 dec_dynrel_count (bfd_vma r_info,
6410                   asection *sec,
6411                   struct bfd_link_info *info,
6412                   Elf_Internal_Sym **local_syms,
6413                   struct elf_link_hash_entry *h,
6414                   asection *sym_sec)
6415 {
6416   enum elf_ppc64_reloc_type r_type;
6417   struct ppc_dyn_relocs *p;
6418   struct ppc_dyn_relocs **pp;
6419
6420   /* Can this reloc be dynamic?  This switch, and later tests here
6421      should be kept in sync with the code in check_relocs.  */
6422   r_type = ELF64_R_TYPE (r_info);
6423   switch (r_type)
6424     {
6425     default:
6426       return TRUE;
6427
6428     case R_PPC64_TPREL16:
6429     case R_PPC64_TPREL16_LO:
6430     case R_PPC64_TPREL16_HI:
6431     case R_PPC64_TPREL16_HA:
6432     case R_PPC64_TPREL16_DS:
6433     case R_PPC64_TPREL16_LO_DS:
6434     case R_PPC64_TPREL16_HIGHER:
6435     case R_PPC64_TPREL16_HIGHERA:
6436     case R_PPC64_TPREL16_HIGHEST:
6437     case R_PPC64_TPREL16_HIGHESTA:
6438       if (!info->shared)
6439         return TRUE;
6440
6441     case R_PPC64_TPREL64:
6442     case R_PPC64_DTPMOD64:
6443     case R_PPC64_DTPREL64:
6444     case R_PPC64_ADDR64:
6445     case R_PPC64_REL30:
6446     case R_PPC64_REL32:
6447     case R_PPC64_REL64:
6448     case R_PPC64_ADDR14:
6449     case R_PPC64_ADDR14_BRNTAKEN:
6450     case R_PPC64_ADDR14_BRTAKEN:
6451     case R_PPC64_ADDR16:
6452     case R_PPC64_ADDR16_DS:
6453     case R_PPC64_ADDR16_HA:
6454     case R_PPC64_ADDR16_HI:
6455     case R_PPC64_ADDR16_HIGHER:
6456     case R_PPC64_ADDR16_HIGHERA:
6457     case R_PPC64_ADDR16_HIGHEST:
6458     case R_PPC64_ADDR16_HIGHESTA:
6459     case R_PPC64_ADDR16_LO:
6460     case R_PPC64_ADDR16_LO_DS:
6461     case R_PPC64_ADDR24:
6462     case R_PPC64_ADDR32:
6463     case R_PPC64_UADDR16:
6464     case R_PPC64_UADDR32:
6465     case R_PPC64_UADDR64:
6466     case R_PPC64_TOC:
6467       break;
6468     }
6469
6470   if (local_syms != NULL)
6471     {
6472       unsigned long r_symndx;
6473       Elf_Internal_Sym *sym;
6474       bfd *ibfd = sec->owner;
6475
6476       r_symndx = ELF64_R_SYM (r_info);
6477       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6478         return FALSE;
6479     }
6480
6481   if ((info->shared
6482        && (must_be_dyn_reloc (info, r_type)
6483            || (h != NULL
6484                && (!info->symbolic
6485                    || h->root.type == bfd_link_hash_defweak
6486                    || !h->def_regular))))
6487       || (ELIMINATE_COPY_RELOCS
6488           && !info->shared
6489           && h != NULL
6490           && (h->root.type == bfd_link_hash_defweak
6491               || !h->def_regular)))
6492     ;
6493   else
6494     return TRUE;
6495
6496   if (h != NULL)
6497     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6498   else
6499     {
6500       if (sym_sec != NULL)
6501         {
6502           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6503           pp = (struct ppc_dyn_relocs **) vpp;
6504         }
6505       else
6506         {
6507           void *vpp = &elf_section_data (sec)->local_dynrel;
6508           pp = (struct ppc_dyn_relocs **) vpp;
6509         }
6510
6511       /* elf_gc_sweep may have already removed all dyn relocs associated
6512          with local syms for a given section.  Don't report a dynreloc
6513          miscount.  */
6514       if (*pp == NULL)
6515         return TRUE;
6516     }
6517
6518   while ((p = *pp) != NULL)
6519     {
6520       if (p->sec == sec)
6521         {
6522           if (!must_be_dyn_reloc (info, r_type))
6523             p->pc_count -= 1;
6524           p->count -= 1;
6525           if (p->count == 0)
6526             *pp = p->next;
6527           return TRUE;
6528         }
6529       pp = &p->next;
6530     }
6531
6532   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6533                            sec->owner, sec);
6534   bfd_set_error (bfd_error_bad_value);
6535   return FALSE;
6536 }
6537
6538 /* Remove unused Official Procedure Descriptor entries.  Currently we
6539    only remove those associated with functions in discarded link-once
6540    sections, or weakly defined functions that have been overridden.  It
6541    would be possible to remove many more entries for statically linked
6542    applications.  */
6543
6544 bfd_boolean
6545 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6546                     bfd_boolean non_overlapping)
6547 {
6548   bfd *ibfd;
6549   bfd_boolean some_edited = FALSE;
6550   asection *need_pad = NULL;
6551
6552   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6553     {
6554       asection *sec;
6555       Elf_Internal_Rela *relstart, *rel, *relend;
6556       Elf_Internal_Shdr *symtab_hdr;
6557       Elf_Internal_Sym *local_syms;
6558       struct elf_link_hash_entry **sym_hashes;
6559       bfd_vma offset;
6560       struct _opd_sec_data *opd;
6561       bfd_boolean need_edit, add_aux_fields;
6562       bfd_size_type cnt_16b = 0;
6563
6564       sec = bfd_get_section_by_name (ibfd, ".opd");
6565       if (sec == NULL || sec->size == 0)
6566         continue;
6567
6568       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6569         continue;
6570
6571       if (sec->output_section == bfd_abs_section_ptr)
6572         continue;
6573
6574       /* Look through the section relocs.  */
6575       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6576         continue;
6577
6578       local_syms = NULL;
6579       symtab_hdr = &elf_symtab_hdr (ibfd);
6580       sym_hashes = elf_sym_hashes (ibfd);
6581
6582       /* Read the relocations.  */
6583       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6584                                             info->keep_memory);
6585       if (relstart == NULL)
6586         return FALSE;
6587
6588       /* First run through the relocs to check they are sane, and to
6589          determine whether we need to edit this opd section.  */
6590       need_edit = FALSE;
6591       need_pad = sec;
6592       offset = 0;
6593       relend = relstart + sec->reloc_count;
6594       for (rel = relstart; rel < relend; )
6595         {
6596           enum elf_ppc64_reloc_type r_type;
6597           unsigned long r_symndx;
6598           asection *sym_sec;
6599           struct elf_link_hash_entry *h;
6600           Elf_Internal_Sym *sym;
6601
6602           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6603              only interested in the reloc pointing to a function entry
6604              point.  */
6605           if (rel->r_offset != offset
6606               || rel + 1 >= relend
6607               || (rel + 1)->r_offset != offset + 8)
6608             {
6609               /* If someone messes with .opd alignment then after a
6610                  "ld -r" we might have padding in the middle of .opd.
6611                  Also, there's nothing to prevent someone putting
6612                  something silly in .opd with the assembler.  No .opd
6613                  optimization for them!  */
6614             broken_opd:
6615               (*_bfd_error_handler)
6616                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6617               need_edit = FALSE;
6618               break;
6619             }
6620
6621           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6622               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6623             {
6624               (*_bfd_error_handler)
6625                 (_("%B: unexpected reloc type %u in .opd section"),
6626                  ibfd, r_type);
6627               need_edit = FALSE;
6628               break;
6629             }
6630
6631           r_symndx = ELF64_R_SYM (rel->r_info);
6632           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6633                           r_symndx, ibfd))
6634             goto error_ret;
6635
6636           if (sym_sec == NULL || sym_sec->owner == NULL)
6637             {
6638               const char *sym_name;
6639               if (h != NULL)
6640                 sym_name = h->root.root.string;
6641               else
6642                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6643                                              sym_sec);
6644
6645               (*_bfd_error_handler)
6646                 (_("%B: undefined sym `%s' in .opd section"),
6647                  ibfd, sym_name);
6648               need_edit = FALSE;
6649               break;
6650             }
6651
6652           /* opd entries are always for functions defined in the
6653              current input bfd.  If the symbol isn't defined in the
6654              input bfd, then we won't be using the function in this
6655              bfd;  It must be defined in a linkonce section in another
6656              bfd, or is weak.  It's also possible that we are
6657              discarding the function due to a linker script /DISCARD/,
6658              which we test for via the output_section.  */
6659           if (sym_sec->owner != ibfd
6660               || sym_sec->output_section == bfd_abs_section_ptr)
6661             need_edit = TRUE;
6662
6663           rel += 2;
6664           if (rel == relend
6665               || (rel + 1 == relend && rel->r_offset == offset + 16))
6666             {
6667               if (sec->size == offset + 24)
6668                 {
6669                   need_pad = NULL;
6670                   break;
6671                 }
6672               if (rel == relend && sec->size == offset + 16)
6673                 {
6674                   cnt_16b++;
6675                   break;
6676                 }
6677               goto broken_opd;
6678             }
6679
6680           if (rel->r_offset == offset + 24)
6681             offset += 24;
6682           else if (rel->r_offset != offset + 16)
6683             goto broken_opd;
6684           else if (rel + 1 < relend
6685                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6686                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6687             {
6688               offset += 16;
6689               cnt_16b++;
6690             }
6691           else if (rel + 2 < relend
6692                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6693                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6694             {
6695               offset += 24;
6696               rel += 1;
6697             }
6698           else
6699             goto broken_opd;
6700         }
6701
6702       add_aux_fields = non_overlapping && cnt_16b > 0;
6703
6704       if (need_edit || add_aux_fields)
6705         {
6706           Elf_Internal_Rela *write_rel;
6707           bfd_byte *rptr, *wptr;
6708           bfd_byte *new_contents = NULL;
6709           bfd_boolean skip;
6710           long opd_ent_size;
6711           bfd_size_type amt;
6712
6713           amt = sec->size * sizeof (long) / 8;
6714           opd = &ppc64_elf_section_data (sec)->u.opd;
6715           opd->adjust = bfd_zalloc (obfd, amt);
6716           if (opd->adjust == NULL)
6717             return FALSE;
6718           ppc64_elf_section_data (sec)->sec_type = sec_opd;
6719
6720           /* This seems a waste of time as input .opd sections are all
6721              zeros as generated by gcc, but I suppose there's no reason
6722              this will always be so.  We might start putting something in
6723              the third word of .opd entries.  */
6724           if ((sec->flags & SEC_IN_MEMORY) == 0)
6725             {
6726               bfd_byte *loc;
6727               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6728                 {
6729                   if (loc != NULL)
6730                     free (loc);
6731                 error_ret:
6732                   if (local_syms != NULL
6733                       && symtab_hdr->contents != (unsigned char *) local_syms)
6734                     free (local_syms);
6735                   if (elf_section_data (sec)->relocs != relstart)
6736                     free (relstart);
6737                   return FALSE;
6738                 }
6739               sec->contents = loc;
6740               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6741             }
6742
6743           elf_section_data (sec)->relocs = relstart;
6744
6745           new_contents = sec->contents;
6746           if (add_aux_fields)
6747             {
6748               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6749               if (new_contents == NULL)
6750                 return FALSE;
6751               need_pad = FALSE;
6752             }
6753           wptr = new_contents;
6754           rptr = sec->contents;
6755
6756           write_rel = relstart;
6757           skip = FALSE;
6758           offset = 0;
6759           opd_ent_size = 0;
6760           for (rel = relstart; rel < relend; rel++)
6761             {
6762               unsigned long r_symndx;
6763               asection *sym_sec;
6764               struct elf_link_hash_entry *h;
6765               Elf_Internal_Sym *sym;
6766
6767               r_symndx = ELF64_R_SYM (rel->r_info);
6768               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6769                               r_symndx, ibfd))
6770                 goto error_ret;
6771
6772               if (rel->r_offset == offset)
6773                 {
6774                   struct ppc_link_hash_entry *fdh = NULL;
6775
6776                   /* See if the .opd entry is full 24 byte or
6777                      16 byte (with fd_aux entry overlapped with next
6778                      fd_func).  */
6779                   opd_ent_size = 24;
6780                   if ((rel + 2 == relend && sec->size == offset + 16)
6781                       || (rel + 3 < relend
6782                           && rel[2].r_offset == offset + 16
6783                           && rel[3].r_offset == offset + 24
6784                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6785                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6786                     opd_ent_size = 16;
6787
6788                   if (h != NULL
6789                       && h->root.root.string[0] == '.')
6790                     {
6791                       fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6792                                      ppc_hash_table (info));
6793                       if (fdh != NULL
6794                           && fdh->elf.root.type != bfd_link_hash_defined
6795                           && fdh->elf.root.type != bfd_link_hash_defweak)
6796                         fdh = NULL;
6797                     }
6798
6799                   skip = (sym_sec->owner != ibfd
6800                           || sym_sec->output_section == bfd_abs_section_ptr);
6801                   if (skip)
6802                     {
6803                       if (fdh != NULL && sym_sec->owner == ibfd)
6804                         {
6805                           /* Arrange for the function descriptor sym
6806                              to be dropped.  */
6807                           fdh->elf.root.u.def.value = 0;
6808                           fdh->elf.root.u.def.section = sym_sec;
6809                         }
6810                       opd->adjust[rel->r_offset / 8] = -1;
6811                     }
6812                   else
6813                     {
6814                       /* We'll be keeping this opd entry.  */
6815
6816                       if (fdh != NULL)
6817                         {
6818                           /* Redefine the function descriptor symbol to
6819                              this location in the opd section.  It is
6820                              necessary to update the value here rather
6821                              than using an array of adjustments as we do
6822                              for local symbols, because various places
6823                              in the generic ELF code use the value
6824                              stored in u.def.value.  */
6825                           fdh->elf.root.u.def.value = wptr - new_contents;
6826                           fdh->adjust_done = 1;
6827                         }
6828
6829                       /* Local syms are a bit tricky.  We could
6830                          tweak them as they can be cached, but
6831                          we'd need to look through the local syms
6832                          for the function descriptor sym which we
6833                          don't have at the moment.  So keep an
6834                          array of adjustments.  */
6835                       opd->adjust[rel->r_offset / 8]
6836                         = (wptr - new_contents) - (rptr - sec->contents);
6837
6838                       if (wptr != rptr)
6839                         memcpy (wptr, rptr, opd_ent_size);
6840                       wptr += opd_ent_size;
6841                       if (add_aux_fields && opd_ent_size == 16)
6842                         {
6843                           memset (wptr, '\0', 8);
6844                           wptr += 8;
6845                         }
6846                     }
6847                   rptr += opd_ent_size;
6848                   offset += opd_ent_size;
6849                 }
6850
6851               if (skip)
6852                 {
6853                   if (!NO_OPD_RELOCS
6854                       && !info->relocatable
6855                       && !dec_dynrel_count (rel->r_info, sec, info,
6856                                             NULL, h, sym_sec))
6857                     goto error_ret;
6858                 }
6859               else
6860                 {
6861                   /* We need to adjust any reloc offsets to point to the
6862                      new opd entries.  While we're at it, we may as well
6863                      remove redundant relocs.  */
6864                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
6865                   if (write_rel != rel)
6866                     memcpy (write_rel, rel, sizeof (*rel));
6867                   ++write_rel;
6868                 }
6869             }
6870
6871           sec->size = wptr - new_contents;
6872           sec->reloc_count = write_rel - relstart;
6873           if (add_aux_fields)
6874             {
6875               free (sec->contents);
6876               sec->contents = new_contents;
6877             }
6878
6879           /* Fudge the header size too, as this is used later in
6880              elf_bfd_final_link if we are emitting relocs.  */
6881           elf_section_data (sec)->rel_hdr.sh_size
6882             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6883           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6884           some_edited = TRUE;
6885         }
6886       else if (elf_section_data (sec)->relocs != relstart)
6887         free (relstart);
6888
6889       if (local_syms != NULL
6890           && symtab_hdr->contents != (unsigned char *) local_syms)
6891         {
6892           if (!info->keep_memory)
6893             free (local_syms);
6894           else
6895             symtab_hdr->contents = (unsigned char *) local_syms;
6896         }
6897     }
6898
6899   if (some_edited)
6900     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6901
6902   /* If we are doing a final link and the last .opd entry is just 16 byte
6903      long, add a 8 byte padding after it.  */
6904   if (need_pad != NULL && !info->relocatable)
6905     {
6906       bfd_byte *p;
6907
6908       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6909         {
6910           BFD_ASSERT (need_pad->size > 0);
6911
6912           p = bfd_malloc (need_pad->size + 8);
6913           if (p == NULL)
6914             return FALSE;
6915
6916           if (! bfd_get_section_contents (need_pad->owner, need_pad,
6917                                           p, 0, need_pad->size))
6918             return FALSE;
6919
6920           need_pad->contents = p;
6921           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6922         }
6923       else
6924         {
6925           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6926           if (p == NULL)
6927             return FALSE;
6928
6929           need_pad->contents = p;
6930         }
6931
6932       memset (need_pad->contents + need_pad->size, 0, 8);
6933       need_pad->size += 8;
6934     }
6935
6936   return TRUE;
6937 }
6938
6939 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
6940
6941 asection *
6942 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6943 {
6944   struct ppc_link_hash_table *htab;
6945
6946   htab = ppc_hash_table (info);
6947   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
6948                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
6949                                               FALSE, FALSE, TRUE));
6950   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
6951                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
6952                                                  FALSE, FALSE, TRUE));
6953   return _bfd_elf_tls_setup (obfd, info);
6954 }
6955
6956 /* Return TRUE iff REL is a branch reloc with a global symbol matching
6957    HASH1 or HASH2.  */
6958
6959 static bfd_boolean
6960 branch_reloc_hash_match (const bfd *ibfd,
6961                          const Elf_Internal_Rela *rel,
6962                          const struct ppc_link_hash_entry *hash1,
6963                          const struct ppc_link_hash_entry *hash2)
6964 {
6965   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6966   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
6967   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
6968
6969   if (r_symndx >= symtab_hdr->sh_info
6970       && (r_type == R_PPC64_REL24
6971           || r_type == R_PPC64_REL14
6972           || r_type == R_PPC64_REL14_BRTAKEN
6973           || r_type == R_PPC64_REL14_BRNTAKEN
6974           || r_type == R_PPC64_ADDR24
6975           || r_type == R_PPC64_ADDR14
6976           || r_type == R_PPC64_ADDR14_BRTAKEN
6977           || r_type == R_PPC64_ADDR14_BRNTAKEN))
6978     {
6979       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6980       struct elf_link_hash_entry *h;
6981
6982       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6983       while (h->root.type == bfd_link_hash_indirect
6984              || h->root.type == bfd_link_hash_warning)
6985         h = (struct elf_link_hash_entry *) h->root.u.i.link;
6986       if (h == &hash1->elf || h == &hash2->elf)
6987         return TRUE;
6988     }
6989   return FALSE;
6990 }
6991
6992 /* Run through all the TLS relocs looking for optimization
6993    opportunities.  The linker has been hacked (see ppc64elf.em) to do
6994    a preliminary section layout so that we know the TLS segment
6995    offsets.  We can't optimize earlier because some optimizations need
6996    to know the tp offset, and we need to optimize before allocating
6997    dynamic relocations.  */
6998
6999 bfd_boolean
7000 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7001 {
7002   bfd *ibfd;
7003   asection *sec;
7004   struct ppc_link_hash_table *htab;
7005   int pass;
7006
7007   if (info->relocatable || !info->executable)
7008     return TRUE;
7009
7010   htab = ppc_hash_table (info);
7011   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7012     {
7013       Elf_Internal_Sym *locsyms = NULL;
7014       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7015       unsigned char *toc_ref = NULL;
7016
7017       /* Look at all the sections for this file.  Make two passes over
7018          the relocs.  On the first pass, mark toc entries involved
7019          with tls relocs, and check that tls relocs involved in
7020          setting up a tls_get_addr call are indeed followed by such a
7021          call.  If they are not, exclude them from the optimizations
7022          done on the second pass.  */
7023       for (pass = 0; pass < 2; ++pass)
7024         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7025           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7026             {
7027               Elf_Internal_Rela *relstart, *rel, *relend;
7028
7029               /* Read the relocations.  */
7030               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7031                                                     info->keep_memory);
7032               if (relstart == NULL)
7033                 return FALSE;
7034
7035               relend = relstart + sec->reloc_count;
7036               for (rel = relstart; rel < relend; rel++)
7037                 {
7038                   enum elf_ppc64_reloc_type r_type;
7039                   unsigned long r_symndx;
7040                   struct elf_link_hash_entry *h;
7041                   Elf_Internal_Sym *sym;
7042                   asection *sym_sec;
7043                   char *tls_mask;
7044                   char tls_set, tls_clear, tls_type = 0;
7045                   bfd_vma value;
7046                   bfd_boolean ok_tprel, is_local;
7047                   long toc_ref_index = 0;
7048                   int expecting_tls_get_addr = 0;
7049
7050                   r_symndx = ELF64_R_SYM (rel->r_info);
7051                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7052                                   r_symndx, ibfd))
7053                     {
7054                     err_free_rel:
7055                       if (elf_section_data (sec)->relocs != relstart)
7056                         free (relstart);
7057                       if (toc_ref != NULL)
7058                         free (toc_ref);
7059                       if (locsyms != NULL
7060                           && (elf_symtab_hdr (ibfd).contents
7061                               != (unsigned char *) locsyms))
7062                         free (locsyms);
7063                       return FALSE;
7064                     }
7065
7066                   if (h != NULL)
7067                     {
7068                       if (h->root.type != bfd_link_hash_defined
7069                           && h->root.type != bfd_link_hash_defweak)
7070                         continue;
7071                       value = h->root.u.def.value;
7072                     }
7073                   else
7074                     /* Symbols referenced by TLS relocs must be of type
7075                        STT_TLS.  So no need for .opd local sym adjust.  */
7076                     value = sym->st_value;
7077
7078                   ok_tprel = FALSE;
7079                   is_local = FALSE;
7080                   if (h == NULL
7081                       || !h->def_dynamic)
7082                     {
7083                       is_local = TRUE;
7084                       value += sym_sec->output_offset;
7085                       value += sym_sec->output_section->vma;
7086                       value -= htab->elf.tls_sec->vma;
7087                       ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7088                                   < (bfd_vma) 1 << 32);
7089                     }
7090
7091                   r_type = ELF64_R_TYPE (rel->r_info);
7092                   switch (r_type)
7093                     {
7094                     case R_PPC64_GOT_TLSLD16:
7095                     case R_PPC64_GOT_TLSLD16_LO:
7096                       expecting_tls_get_addr = 1;
7097                       /* Fall thru */
7098
7099                     case R_PPC64_GOT_TLSLD16_HI:
7100                     case R_PPC64_GOT_TLSLD16_HA:
7101                       /* These relocs should never be against a symbol
7102                          defined in a shared lib.  Leave them alone if
7103                          that turns out to be the case.  */
7104                       if (!is_local)
7105                         continue;
7106
7107                       /* LD -> LE */
7108                       tls_set = 0;
7109                       tls_clear = TLS_LD;
7110                       tls_type = TLS_TLS | TLS_LD;
7111                       break;
7112
7113                     case R_PPC64_GOT_TLSGD16:
7114                     case R_PPC64_GOT_TLSGD16_LO:
7115                       expecting_tls_get_addr = 1;
7116                       /* Fall thru */
7117
7118                     case R_PPC64_GOT_TLSGD16_HI:
7119                     case R_PPC64_GOT_TLSGD16_HA:
7120                       if (ok_tprel)
7121                         /* GD -> LE */
7122                         tls_set = 0;
7123                       else
7124                         /* GD -> IE */
7125                         tls_set = TLS_TLS | TLS_TPRELGD;
7126                       tls_clear = TLS_GD;
7127                       tls_type = TLS_TLS | TLS_GD;
7128                       break;
7129
7130                     case R_PPC64_GOT_TPREL16_DS:
7131                     case R_PPC64_GOT_TPREL16_LO_DS:
7132                     case R_PPC64_GOT_TPREL16_HI:
7133                     case R_PPC64_GOT_TPREL16_HA:
7134                       if (ok_tprel)
7135                         {
7136                           /* IE -> LE */
7137                           tls_set = 0;
7138                           tls_clear = TLS_TPREL;
7139                           tls_type = TLS_TLS | TLS_TPREL;
7140                           break;
7141                         }
7142                       continue;
7143
7144                     case R_PPC64_TOC16:
7145                     case R_PPC64_TOC16_LO:
7146                     case R_PPC64_TLS:
7147                     case R_PPC64_TLSGD:
7148                     case R_PPC64_TLSLD:
7149                       if (sym_sec == NULL || sym_sec != toc)
7150                         continue;
7151
7152                       /* Mark this toc entry as referenced by a TLS
7153                          code sequence.  We can do that now in the
7154                          case of R_PPC64_TLS, and after checking for
7155                          tls_get_addr for the TOC16 relocs.  */
7156                       if (toc_ref == NULL)
7157                         {
7158                           toc_ref = bfd_zmalloc (toc->size / 8);
7159                           if (toc_ref == NULL)
7160                             goto err_free_rel;
7161                         }
7162                       if (h != NULL)
7163                         value = h->root.u.def.value;
7164                       else
7165                         value = sym->st_value;
7166                       value += rel->r_addend;
7167                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7168                       toc_ref_index = value / 8;
7169                       if (r_type == R_PPC64_TLS
7170                           || r_type == R_PPC64_TLSGD
7171                           || r_type == R_PPC64_TLSLD)
7172                         {
7173                           toc_ref[toc_ref_index] = 1;
7174                           continue;
7175                         }
7176
7177                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7178                         continue;
7179
7180                       tls_set = 0;
7181                       tls_clear = 0;
7182                       expecting_tls_get_addr = 2;
7183                       break;
7184
7185                     case R_PPC64_TPREL64:
7186                       if (pass == 0
7187                           || sec != toc
7188                           || toc_ref == NULL
7189                           || !toc_ref[rel->r_offset / 8])
7190                         continue;
7191                       if (ok_tprel)
7192                         {
7193                           /* IE -> LE */
7194                           tls_set = TLS_EXPLICIT;
7195                           tls_clear = TLS_TPREL;
7196                           break;
7197                         }
7198                       continue;
7199
7200                     case R_PPC64_DTPMOD64:
7201                       if (pass == 0
7202                           || sec != toc
7203                           || toc_ref == NULL
7204                           || !toc_ref[rel->r_offset / 8])
7205                         continue;
7206                       if (rel + 1 < relend
7207                           && (rel[1].r_info
7208                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7209                           && rel[1].r_offset == rel->r_offset + 8)
7210                         {
7211                           if (ok_tprel)
7212                             /* GD -> LE */
7213                             tls_set = TLS_EXPLICIT | TLS_GD;
7214                           else
7215                             /* GD -> IE */
7216                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7217                           tls_clear = TLS_GD;
7218                         }
7219                       else
7220                         {
7221                           if (!is_local)
7222                             continue;
7223
7224                           /* LD -> LE */
7225                           tls_set = TLS_EXPLICIT;
7226                           tls_clear = TLS_LD;
7227                         }
7228                       break;
7229
7230                     default:
7231                       continue;
7232                     }
7233
7234                   if (pass == 0)
7235                     {
7236                       if (!expecting_tls_get_addr
7237                           || !sec->has_tls_get_addr_call)
7238                         continue;
7239
7240                       if (rel + 1 < relend
7241                           && branch_reloc_hash_match (ibfd, rel + 1,
7242                                                       htab->tls_get_addr,
7243                                                       htab->tls_get_addr_fd))
7244                         {
7245                           if (expecting_tls_get_addr == 2)
7246                             {
7247                               /* Check for toc tls entries.  */
7248                               char *toc_tls;
7249                               int retval;
7250
7251                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7252                                                      &locsyms,
7253                                                      rel, ibfd);
7254                               if (retval == 0)
7255                                 goto err_free_rel;
7256                               if (retval > 1 && toc_tls != NULL)
7257                                 toc_ref[toc_ref_index] = 1;
7258                             }
7259                           continue;
7260                         }
7261
7262                       if (expecting_tls_get_addr != 1)
7263                         continue;
7264
7265                       /* Uh oh, we didn't find the expected call.  We
7266                          could just mark this symbol to exclude it
7267                          from tls optimization but it's safer to skip
7268                          the entire section.  */
7269                       sec->has_tls_reloc = 0;
7270                       break;
7271                     }
7272
7273                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7274                     {
7275                       struct plt_entry *ent;
7276                       for (ent = htab->tls_get_addr->elf.plt.plist;
7277                            ent != NULL;
7278                            ent = ent->next)
7279                         if (ent->addend == 0)
7280                           {
7281                             if (ent->plt.refcount > 0)
7282                               {
7283                                 ent->plt.refcount -= 1;
7284                                 expecting_tls_get_addr = 0;
7285                               }
7286                             break;
7287                           }
7288                     }
7289
7290                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7291                     {
7292                       struct plt_entry *ent;
7293                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7294                            ent != NULL;
7295                            ent = ent->next)
7296                         if (ent->addend == 0)
7297                           {
7298                             if (ent->plt.refcount > 0)
7299                               ent->plt.refcount -= 1;
7300                             break;
7301                           }
7302                     }
7303
7304                   if (tls_clear == 0)
7305                     continue;
7306
7307                   if ((tls_set & TLS_EXPLICIT) == 0)
7308                     {
7309                       struct got_entry *ent;
7310
7311                       /* Adjust got entry for this reloc.  */
7312                       if (h != NULL)
7313                         ent = h->got.glist;
7314                       else
7315                         ent = elf_local_got_ents (ibfd)[r_symndx];
7316
7317                       for (; ent != NULL; ent = ent->next)
7318                         if (ent->addend == rel->r_addend
7319                             && ent->owner == ibfd
7320                             && ent->tls_type == tls_type)
7321                           break;
7322                       if (ent == NULL)
7323                         abort ();
7324
7325                       if (tls_set == 0)
7326                         {
7327                           /* We managed to get rid of a got entry.  */
7328                           if (ent->got.refcount > 0)
7329                             ent->got.refcount -= 1;
7330                         }
7331                     }
7332                   else
7333                     {
7334                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7335                          we'll lose one or two dyn relocs.  */
7336                       if (!dec_dynrel_count (rel->r_info, sec, info,
7337                                              NULL, h, sym_sec))
7338                         return FALSE;
7339
7340                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7341                         {
7342                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7343                                                  NULL, h, sym_sec))
7344                             return FALSE;
7345                         }
7346                     }
7347
7348                   *tls_mask |= tls_set;
7349                   *tls_mask &= ~tls_clear;
7350                 }
7351
7352               if (elf_section_data (sec)->relocs != relstart)
7353                 free (relstart);
7354             }
7355
7356       if (toc_ref != NULL)
7357         free (toc_ref);
7358
7359       if (locsyms != NULL
7360           && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7361         {
7362           if (!info->keep_memory)
7363             free (locsyms);
7364           else
7365             elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7366         }
7367     }
7368   return TRUE;
7369 }
7370
7371 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7372    the values of any global symbols in a toc section that has been
7373    edited.  Globals in toc sections should be a rarity, so this function
7374    sets a flag if any are found in toc sections other than the one just
7375    edited, so that futher hash table traversals can be avoided.  */
7376
7377 struct adjust_toc_info
7378 {
7379   asection *toc;
7380   unsigned long *skip;
7381   bfd_boolean global_toc_syms;
7382 };
7383
7384 static bfd_boolean
7385 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7386 {
7387   struct ppc_link_hash_entry *eh;
7388   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7389
7390   if (h->root.type == bfd_link_hash_indirect)
7391     return TRUE;
7392
7393   if (h->root.type == bfd_link_hash_warning)
7394     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7395
7396   if (h->root.type != bfd_link_hash_defined
7397       && h->root.type != bfd_link_hash_defweak)
7398     return TRUE;
7399
7400   eh = (struct ppc_link_hash_entry *) h;
7401   if (eh->adjust_done)
7402     return TRUE;
7403
7404   if (eh->elf.root.u.def.section == toc_inf->toc)
7405     {
7406       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7407       if (skip != (unsigned long) -1)
7408         eh->elf.root.u.def.value -= skip;
7409       else
7410         {
7411           (*_bfd_error_handler)
7412             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7413           eh->elf.root.u.def.section = &bfd_abs_section;
7414           eh->elf.root.u.def.value = 0;
7415         }
7416       eh->adjust_done = 1;
7417     }
7418   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7419     toc_inf->global_toc_syms = TRUE;
7420
7421   return TRUE;
7422 }
7423
7424 /* Examine all relocs referencing .toc sections in order to remove
7425    unused .toc entries.  */
7426
7427 bfd_boolean
7428 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7429 {
7430   bfd *ibfd;
7431   struct adjust_toc_info toc_inf;
7432
7433   toc_inf.global_toc_syms = TRUE;
7434   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7435     {
7436       asection *toc, *sec;
7437       Elf_Internal_Shdr *symtab_hdr;
7438       Elf_Internal_Sym *local_syms;
7439       struct elf_link_hash_entry **sym_hashes;
7440       Elf_Internal_Rela *relstart, *rel;
7441       unsigned long *skip, *drop;
7442       unsigned char *used;
7443       unsigned char *keep, last, some_unused;
7444
7445       toc = bfd_get_section_by_name (ibfd, ".toc");
7446       if (toc == NULL
7447           || toc->size == 0
7448           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7449           || elf_discarded_section (toc))
7450         continue;
7451
7452       local_syms = NULL;
7453       symtab_hdr = &elf_symtab_hdr (ibfd);
7454       sym_hashes = elf_sym_hashes (ibfd);
7455
7456       /* Look at sections dropped from the final link.  */
7457       skip = NULL;
7458       relstart = NULL;
7459       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7460         {
7461           if (sec->reloc_count == 0
7462               || !elf_discarded_section (sec)
7463               || get_opd_info (sec)
7464               || (sec->flags & SEC_ALLOC) == 0
7465               || (sec->flags & SEC_DEBUGGING) != 0)
7466             continue;
7467
7468           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7469           if (relstart == NULL)
7470             goto error_ret;
7471
7472           /* Run through the relocs to see which toc entries might be
7473              unused.  */
7474           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7475             {
7476               enum elf_ppc64_reloc_type r_type;
7477               unsigned long r_symndx;
7478               asection *sym_sec;
7479               struct elf_link_hash_entry *h;
7480               Elf_Internal_Sym *sym;
7481               bfd_vma val;
7482
7483               r_type = ELF64_R_TYPE (rel->r_info);
7484               switch (r_type)
7485                 {
7486                 default:
7487                   continue;
7488
7489                 case R_PPC64_TOC16:
7490                 case R_PPC64_TOC16_LO:
7491                 case R_PPC64_TOC16_HI:
7492                 case R_PPC64_TOC16_HA:
7493                 case R_PPC64_TOC16_DS:
7494                 case R_PPC64_TOC16_LO_DS:
7495                   break;
7496                 }
7497
7498               r_symndx = ELF64_R_SYM (rel->r_info);
7499               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7500                               r_symndx, ibfd))
7501                 goto error_ret;
7502
7503               if (sym_sec != toc)
7504                 continue;
7505
7506               if (h != NULL)
7507                 val = h->root.u.def.value;
7508               else
7509                 val = sym->st_value;
7510               val += rel->r_addend;
7511
7512               if (val >= toc->size)
7513                 continue;
7514
7515               /* Anything in the toc ought to be aligned to 8 bytes.
7516                  If not, don't mark as unused.  */
7517               if (val & 7)
7518                 continue;
7519
7520               if (skip == NULL)
7521                 {
7522                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7523                   if (skip == NULL)
7524                     goto error_ret;
7525                 }
7526
7527               skip[val >> 3] = 1;
7528             }
7529
7530           if (elf_section_data (sec)->relocs != relstart)
7531             free (relstart);
7532         }
7533
7534       if (skip == NULL)
7535         continue;
7536
7537       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7538       if (used == NULL)
7539         {
7540         error_ret:
7541           if (local_syms != NULL
7542               && symtab_hdr->contents != (unsigned char *) local_syms)
7543             free (local_syms);
7544           if (sec != NULL
7545               && relstart != NULL
7546               && elf_section_data (sec)->relocs != relstart)
7547             free (relstart);
7548           if (skip != NULL)
7549             free (skip);
7550           return FALSE;
7551         }
7552
7553       /* Now check all kept sections that might reference the toc.
7554          Check the toc itself last.  */
7555       for (sec = (ibfd->sections == toc && toc->next ? toc->next
7556                   : ibfd->sections);
7557            sec != NULL;
7558            sec = (sec == toc ? NULL
7559                   : sec->next == NULL ? toc
7560                   : sec->next == toc && toc->next ? toc->next
7561                   : sec->next))
7562         {
7563           int repeat;
7564
7565           if (sec->reloc_count == 0
7566               || elf_discarded_section (sec)
7567               || get_opd_info (sec)
7568               || (sec->flags & SEC_ALLOC) == 0
7569               || (sec->flags & SEC_DEBUGGING) != 0)
7570             continue;
7571
7572           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7573           if (relstart == NULL)
7574             goto error_ret;
7575
7576           /* Mark toc entries referenced as used.  */
7577           repeat = 0;
7578           do
7579             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7580               {
7581                 enum elf_ppc64_reloc_type r_type;
7582                 unsigned long r_symndx;
7583                 asection *sym_sec;
7584                 struct elf_link_hash_entry *h;
7585                 Elf_Internal_Sym *sym;
7586                 bfd_vma val;
7587
7588                 r_type = ELF64_R_TYPE (rel->r_info);
7589                 switch (r_type)
7590                   {
7591                   case R_PPC64_TOC16:
7592                   case R_PPC64_TOC16_LO:
7593                   case R_PPC64_TOC16_HI:
7594                   case R_PPC64_TOC16_HA:
7595                   case R_PPC64_TOC16_DS:
7596                   case R_PPC64_TOC16_LO_DS:
7597                     /* In case we're taking addresses of toc entries.  */
7598                   case R_PPC64_ADDR64:
7599                     break;
7600
7601                   default:
7602                     continue;
7603                   }
7604
7605                 r_symndx = ELF64_R_SYM (rel->r_info);
7606                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7607                                 r_symndx, ibfd))
7608                   {
7609                     free (used);
7610                     goto error_ret;
7611                   }
7612
7613                 if (sym_sec != toc)
7614                   continue;
7615
7616                 if (h != NULL)
7617                   val = h->root.u.def.value;
7618                 else
7619                   val = sym->st_value;
7620                 val += rel->r_addend;
7621
7622                 if (val >= toc->size)
7623                   continue;
7624
7625                 /* For the toc section, we only mark as used if
7626                    this entry itself isn't unused.  */
7627                 if (sec == toc
7628                     && !used[val >> 3]
7629                     && (used[rel->r_offset >> 3]
7630                         || !skip[rel->r_offset >> 3]))
7631                   /* Do all the relocs again, to catch reference
7632                      chains.  */
7633                   repeat = 1;
7634
7635                 used[val >> 3] = 1;
7636               }
7637           while (repeat);
7638         }
7639
7640       /* Merge the used and skip arrays.  Assume that TOC
7641          doublewords not appearing as either used or unused belong
7642          to to an entry more than one doubleword in size.  */
7643       for (drop = skip, keep = used, last = 0, some_unused = 0;
7644            drop < skip + (toc->size + 7) / 8;
7645            ++drop, ++keep)
7646         {
7647           if (*keep)
7648             {
7649               *drop = 0;
7650               last = 0;
7651             }
7652           else if (*drop)
7653             {
7654               some_unused = 1;
7655               last = 1;
7656             }
7657           else
7658             *drop = last;
7659         }
7660
7661       free (used);
7662
7663       if (some_unused)
7664         {
7665           bfd_byte *contents, *src;
7666           unsigned long off;
7667
7668           /* Shuffle the toc contents, and at the same time convert the
7669              skip array from booleans into offsets.  */
7670           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7671             goto error_ret;
7672
7673           elf_section_data (toc)->this_hdr.contents = contents;
7674
7675           for (src = contents, off = 0, drop = skip;
7676                src < contents + toc->size;
7677                src += 8, ++drop)
7678             {
7679               if (*drop)
7680                 {
7681                   *drop = (unsigned long) -1;
7682                   off += 8;
7683                 }
7684               else if (off != 0)
7685                 {
7686                   *drop = off;
7687                   memcpy (src - off, src, 8);
7688                 }
7689             }
7690           toc->rawsize = toc->size;
7691           toc->size = src - contents - off;
7692
7693           if (toc->reloc_count != 0)
7694             {
7695               Elf_Internal_Rela *wrel;
7696               bfd_size_type sz;
7697
7698               /* Read toc relocs.  */
7699               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7700                                                     TRUE);
7701               if (relstart == NULL)
7702                 goto error_ret;
7703
7704               /* Remove unused toc relocs, and adjust those we keep.  */
7705               wrel = relstart;
7706               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7707                 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7708                   {
7709                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7710                     wrel->r_info = rel->r_info;
7711                     wrel->r_addend = rel->r_addend;
7712                     ++wrel;
7713                   }
7714                 else if (!dec_dynrel_count (rel->r_info, toc, info,
7715                                             &local_syms, NULL, NULL))
7716                   goto error_ret;
7717
7718               toc->reloc_count = wrel - relstart;
7719               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7720               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7721               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7722             }
7723
7724           /* Adjust addends for relocs against the toc section sym.  */
7725           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7726             {
7727               if (sec->reloc_count == 0
7728                   || elf_discarded_section (sec))
7729                 continue;
7730
7731               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7732                                                     TRUE);
7733               if (relstart == NULL)
7734                 goto error_ret;
7735
7736               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7737                 {
7738                   enum elf_ppc64_reloc_type r_type;
7739                   unsigned long r_symndx;
7740                   asection *sym_sec;
7741                   struct elf_link_hash_entry *h;
7742                   Elf_Internal_Sym *sym;
7743
7744                   r_type = ELF64_R_TYPE (rel->r_info);
7745                   switch (r_type)
7746                     {
7747                     default:
7748                       continue;
7749
7750                     case R_PPC64_TOC16:
7751                     case R_PPC64_TOC16_LO:
7752                     case R_PPC64_TOC16_HI:
7753                     case R_PPC64_TOC16_HA:
7754                     case R_PPC64_TOC16_DS:
7755                     case R_PPC64_TOC16_LO_DS:
7756                     case R_PPC64_ADDR64:
7757                       break;
7758                     }
7759
7760                   r_symndx = ELF64_R_SYM (rel->r_info);
7761                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7762                                   r_symndx, ibfd))
7763                     goto error_ret;
7764
7765                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
7766                     continue;
7767
7768                   rel->r_addend -= skip[rel->r_addend >> 3];
7769                 }
7770             }
7771
7772           /* We shouldn't have local or global symbols defined in the TOC,
7773              but handle them anyway.  */
7774           if (local_syms != NULL)
7775             {
7776               Elf_Internal_Sym *sym;
7777
7778               for (sym = local_syms;
7779                    sym < local_syms + symtab_hdr->sh_info;
7780                    ++sym)
7781                 if (sym->st_value != 0
7782                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7783                   {
7784                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
7785                       sym->st_value -= skip[sym->st_value >> 3];
7786                     else
7787                       {
7788                         (*_bfd_error_handler)
7789                           (_("%s defined in removed toc entry"),
7790                            bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7791                                              NULL));
7792                         sym->st_value = 0;
7793                         sym->st_shndx = SHN_ABS;
7794                       }
7795                     symtab_hdr->contents = (unsigned char *) local_syms;
7796                   }
7797             }
7798
7799           /* Finally, adjust any global syms defined in the toc.  */
7800           if (toc_inf.global_toc_syms)
7801             {
7802               toc_inf.toc = toc;
7803               toc_inf.skip = skip;
7804               toc_inf.global_toc_syms = FALSE;
7805               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7806                                       &toc_inf);
7807             }
7808         }
7809
7810       if (local_syms != NULL
7811           && symtab_hdr->contents != (unsigned char *) local_syms)
7812         {
7813           if (!info->keep_memory)
7814             free (local_syms);
7815           else
7816             symtab_hdr->contents = (unsigned char *) local_syms;
7817         }
7818       free (skip);
7819     }
7820
7821   return TRUE;
7822 }
7823
7824 /* Allocate space in .plt, .got and associated reloc sections for
7825    dynamic relocs.  */
7826
7827 static bfd_boolean
7828 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7829 {
7830   struct bfd_link_info *info;
7831   struct ppc_link_hash_table *htab;
7832   asection *s;
7833   struct ppc_link_hash_entry *eh;
7834   struct ppc_dyn_relocs *p;
7835   struct got_entry *gent;
7836
7837   if (h->root.type == bfd_link_hash_indirect)
7838     return TRUE;
7839
7840   if (h->root.type == bfd_link_hash_warning)
7841     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7842
7843   info = (struct bfd_link_info *) inf;
7844   htab = ppc_hash_table (info);
7845
7846   if (htab->elf.dynamic_sections_created
7847       && h->dynindx != -1
7848       && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7849     {
7850       struct plt_entry *pent;
7851       bfd_boolean doneone = FALSE;
7852       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7853         if (pent->plt.refcount > 0)
7854           {
7855             /* If this is the first .plt entry, make room for the special
7856                first entry.  */
7857             s = htab->plt;
7858             if (s->size == 0)
7859               s->size += PLT_INITIAL_ENTRY_SIZE;
7860
7861             pent->plt.offset = s->size;
7862
7863             /* Make room for this entry.  */
7864             s->size += PLT_ENTRY_SIZE;
7865
7866             /* Make room for the .glink code.  */
7867             s = htab->glink;
7868             if (s->size == 0)
7869               s->size += GLINK_CALL_STUB_SIZE;
7870             /* We need bigger stubs past index 32767.  */
7871             if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7872               s->size += 4;
7873             s->size += 2*4;
7874
7875             /* We also need to make an entry in the .rela.plt section.  */
7876             s = htab->relplt;
7877             s->size += sizeof (Elf64_External_Rela);
7878             doneone = TRUE;
7879           }
7880         else
7881           pent->plt.offset = (bfd_vma) -1;
7882       if (!doneone)
7883         {
7884           h->plt.plist = NULL;
7885           h->needs_plt = 0;
7886         }
7887     }
7888   else
7889     {
7890       h->plt.plist = NULL;
7891       h->needs_plt = 0;
7892     }
7893
7894   eh = (struct ppc_link_hash_entry *) h;
7895   /* Run through the TLS GD got entries first if we're changing them
7896      to TPREL.  */
7897   if ((eh->tls_mask & TLS_TPRELGD) != 0)
7898     for (gent = h->got.glist; gent != NULL; gent = gent->next)
7899       if (gent->got.refcount > 0
7900           && (gent->tls_type & TLS_GD) != 0)
7901         {
7902           /* This was a GD entry that has been converted to TPREL.  If
7903              there happens to be a TPREL entry we can use that one.  */
7904           struct got_entry *ent;
7905           for (ent = h->got.glist; ent != NULL; ent = ent->next)
7906             if (ent->got.refcount > 0
7907                 && (ent->tls_type & TLS_TPREL) != 0
7908                 && ent->addend == gent->addend
7909                 && ent->owner == gent->owner)
7910               {
7911                 gent->got.refcount = 0;
7912                 break;
7913               }
7914
7915           /* If not, then we'll be using our own TPREL entry.  */
7916           if (gent->got.refcount != 0)
7917             gent->tls_type = TLS_TLS | TLS_TPREL;
7918         }
7919
7920   for (gent = h->got.glist; gent != NULL; gent = gent->next)
7921     if (gent->got.refcount > 0)
7922       {
7923         bfd_boolean dyn;
7924
7925         /* Make sure this symbol is output as a dynamic symbol.
7926            Undefined weak syms won't yet be marked as dynamic,
7927            nor will all TLS symbols.  */
7928         if (h->dynindx == -1
7929             && !h->forced_local
7930             && htab->elf.dynamic_sections_created)
7931           {
7932             if (! bfd_elf_link_record_dynamic_symbol (info, h))
7933               return FALSE;
7934           }
7935
7936         if ((gent->tls_type & TLS_LD) != 0
7937             && !h->def_dynamic)
7938           {
7939             ppc64_tlsld_got (gent->owner)->refcount += 1;
7940             gent->got.offset = (bfd_vma) -1;
7941             continue;
7942           }
7943
7944         if (!is_ppc64_elf (gent->owner))
7945           continue;
7946
7947         s = ppc64_elf_tdata (gent->owner)->got;
7948         gent->got.offset = s->size;
7949         s->size
7950           += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7951         dyn = htab->elf.dynamic_sections_created;
7952         if ((info->shared
7953              || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7954             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7955                 || h->root.type != bfd_link_hash_undefweak))
7956           ppc64_elf_tdata (gent->owner)->relgot->size
7957             += (gent->tls_type & eh->tls_mask & TLS_GD
7958                 ? 2 * sizeof (Elf64_External_Rela)
7959                 : sizeof (Elf64_External_Rela));
7960       }
7961     else
7962       gent->got.offset = (bfd_vma) -1;
7963
7964   if (eh->dyn_relocs == NULL
7965       || !htab->elf.dynamic_sections_created)
7966     return TRUE;
7967
7968   /* In the shared -Bsymbolic case, discard space allocated for
7969      dynamic pc-relative relocs against symbols which turn out to be
7970      defined in regular objects.  For the normal shared case, discard
7971      space for relocs that have become local due to symbol visibility
7972      changes.  */
7973
7974   if (info->shared)
7975     {
7976       /* Relocs that use pc_count are those that appear on a call insn,
7977          or certain REL relocs (see must_be_dyn_reloc) that can be
7978          generated via assembly.  We want calls to protected symbols to
7979          resolve directly to the function rather than going via the plt.
7980          If people want function pointer comparisons to work as expected
7981          then they should avoid writing weird assembly.  */
7982       if (SYMBOL_CALLS_LOCAL (info, h))
7983         {
7984           struct ppc_dyn_relocs **pp;
7985
7986           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7987             {
7988               p->count -= p->pc_count;
7989               p->pc_count = 0;
7990               if (p->count == 0)
7991                 *pp = p->next;
7992               else
7993                 pp = &p->next;
7994             }
7995         }
7996
7997       /* Also discard relocs on undefined weak syms with non-default
7998          visibility.  */
7999       if (eh->dyn_relocs != NULL
8000           && h->root.type == bfd_link_hash_undefweak)
8001         {
8002           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8003             eh->dyn_relocs = NULL;
8004
8005           /* Make sure this symbol is output as a dynamic symbol.
8006              Undefined weak syms won't yet be marked as dynamic.  */
8007           else if (h->dynindx == -1
8008                    && !h->forced_local)
8009             {
8010               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8011                 return FALSE;
8012             }
8013         }
8014     }
8015   else if (ELIMINATE_COPY_RELOCS)
8016     {
8017       /* For the non-shared case, discard space for relocs against
8018          symbols which turn out to need copy relocs or are not
8019          dynamic.  */
8020
8021       if (!h->non_got_ref
8022           && !h->def_regular)
8023         {
8024           /* Make sure this symbol is output as a dynamic symbol.
8025              Undefined weak syms won't yet be marked as dynamic.  */
8026           if (h->dynindx == -1
8027               && !h->forced_local)
8028             {
8029               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8030                 return FALSE;
8031             }
8032
8033           /* If that succeeded, we know we'll be keeping all the
8034              relocs.  */
8035           if (h->dynindx != -1)
8036             goto keep;
8037         }
8038
8039       eh->dyn_relocs = NULL;
8040
8041     keep: ;
8042     }
8043
8044   /* Finally, allocate space.  */
8045   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8046     {
8047       asection *sreloc = elf_section_data (p->sec)->sreloc;
8048       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8049     }
8050
8051   return TRUE;
8052 }
8053
8054 /* Find any dynamic relocs that apply to read-only sections.  */
8055
8056 static bfd_boolean
8057 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8058 {
8059   struct ppc_link_hash_entry *eh;
8060   struct ppc_dyn_relocs *p;
8061
8062   if (h->root.type == bfd_link_hash_warning)
8063     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8064
8065   eh = (struct ppc_link_hash_entry *) h;
8066   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8067     {
8068       asection *s = p->sec->output_section;
8069
8070       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8071         {
8072           struct bfd_link_info *info = inf;
8073
8074           info->flags |= DF_TEXTREL;
8075
8076           /* Not an error, just cut short the traversal.  */
8077           return FALSE;
8078         }
8079     }
8080   return TRUE;
8081 }
8082
8083 /* Set the sizes of the dynamic sections.  */
8084
8085 static bfd_boolean
8086 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8087                                  struct bfd_link_info *info)
8088 {
8089   struct ppc_link_hash_table *htab;
8090   bfd *dynobj;
8091   asection *s;
8092   bfd_boolean relocs;
8093   bfd *ibfd;
8094
8095   htab = ppc_hash_table (info);
8096   dynobj = htab->elf.dynobj;
8097   if (dynobj == NULL)
8098     abort ();
8099
8100   if (htab->elf.dynamic_sections_created)
8101     {
8102       /* Set the contents of the .interp section to the interpreter.  */
8103       if (info->executable)
8104         {
8105           s = bfd_get_section_by_name (dynobj, ".interp");
8106           if (s == NULL)
8107             abort ();
8108           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8109           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8110         }
8111     }
8112
8113   /* Set up .got offsets for local syms, and space for local dynamic
8114      relocs.  */
8115   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8116     {
8117       struct got_entry **lgot_ents;
8118       struct got_entry **end_lgot_ents;
8119       char *lgot_masks;
8120       bfd_size_type locsymcount;
8121       Elf_Internal_Shdr *symtab_hdr;
8122       asection *srel;
8123
8124       if (!is_ppc64_elf (ibfd))
8125         continue;
8126
8127       for (s = ibfd->sections; s != NULL; s = s->next)
8128         {
8129           struct ppc_dyn_relocs *p;
8130
8131           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8132             {
8133               if (!bfd_is_abs_section (p->sec)
8134                   && bfd_is_abs_section (p->sec->output_section))
8135                 {
8136                   /* Input section has been discarded, either because
8137                      it is a copy of a linkonce section or due to
8138                      linker script /DISCARD/, so we'll be discarding
8139                      the relocs too.  */
8140                 }
8141               else if (p->count != 0)
8142                 {
8143                   srel = elf_section_data (p->sec)->sreloc;
8144                   srel->size += p->count * sizeof (Elf64_External_Rela);
8145                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8146                     info->flags |= DF_TEXTREL;
8147                 }
8148             }
8149         }
8150
8151       lgot_ents = elf_local_got_ents (ibfd);
8152       if (!lgot_ents)
8153         continue;
8154
8155       symtab_hdr = &elf_symtab_hdr (ibfd);
8156       locsymcount = symtab_hdr->sh_info;
8157       end_lgot_ents = lgot_ents + locsymcount;
8158       lgot_masks = (char *) end_lgot_ents;
8159       s = ppc64_elf_tdata (ibfd)->got;
8160       srel = ppc64_elf_tdata (ibfd)->relgot;
8161       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8162         {
8163           struct got_entry *ent;
8164
8165           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8166             if (ent->got.refcount > 0)
8167               {
8168                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8169                   {
8170                     ppc64_tlsld_got (ibfd)->refcount += 1;
8171                     ent->got.offset = (bfd_vma) -1;
8172                   }
8173                 else
8174                   {
8175                     ent->got.offset = s->size;
8176                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8177                       {
8178                         s->size += 16;
8179                         if (info->shared)
8180                           srel->size += 2 * sizeof (Elf64_External_Rela);
8181                       }
8182                     else
8183                       {
8184                         s->size += 8;
8185                         if (info->shared)
8186                           srel->size += sizeof (Elf64_External_Rela);
8187                       }
8188                   }
8189               }
8190             else
8191               ent->got.offset = (bfd_vma) -1;
8192         }
8193     }
8194
8195   /* Allocate global sym .plt and .got entries, and space for global
8196      sym dynamic relocs.  */
8197   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8198
8199   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8200     {
8201       if (!is_ppc64_elf (ibfd))
8202         continue;
8203
8204       if (ppc64_tlsld_got (ibfd)->refcount > 0)
8205         {
8206           s = ppc64_elf_tdata (ibfd)->got;
8207           ppc64_tlsld_got (ibfd)->offset = s->size;
8208           s->size += 16;
8209           if (info->shared)
8210             {
8211               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8212               srel->size += sizeof (Elf64_External_Rela);
8213             }
8214         }
8215       else
8216         ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8217     }
8218
8219   /* We now have determined the sizes of the various dynamic sections.
8220      Allocate memory for them.  */
8221   relocs = FALSE;
8222   for (s = dynobj->sections; s != NULL; s = s->next)
8223     {
8224       if ((s->flags & SEC_LINKER_CREATED) == 0)
8225         continue;
8226
8227       if (s == htab->brlt || s == htab->relbrlt)
8228         /* These haven't been allocated yet;  don't strip.  */
8229         continue;
8230       else if (s == htab->got
8231                || s == htab->plt
8232                || s == htab->glink
8233                || s == htab->dynbss)
8234         {
8235           /* Strip this section if we don't need it; see the
8236              comment below.  */
8237         }
8238       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8239         {
8240           if (s->size != 0)
8241             {
8242               if (s != htab->relplt)
8243                 relocs = TRUE;
8244
8245               /* We use the reloc_count field as a counter if we need
8246                  to copy relocs into the output file.  */
8247               s->reloc_count = 0;
8248             }
8249         }
8250       else
8251         {
8252           /* It's not one of our sections, so don't allocate space.  */
8253           continue;
8254         }
8255
8256       if (s->size == 0)
8257         {
8258           /* If we don't need this section, strip it from the
8259              output file.  This is mostly to handle .rela.bss and
8260              .rela.plt.  We must create both sections in
8261              create_dynamic_sections, because they must be created
8262              before the linker maps input sections to output
8263              sections.  The linker does that before
8264              adjust_dynamic_symbol is called, and it is that
8265              function which decides whether anything needs to go
8266              into these sections.  */
8267           s->flags |= SEC_EXCLUDE;
8268           continue;
8269         }
8270
8271       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8272         continue;
8273
8274       /* Allocate memory for the section contents.  We use bfd_zalloc
8275          here in case unused entries are not reclaimed before the
8276          section's contents are written out.  This should not happen,
8277          but this way if it does we get a R_PPC64_NONE reloc in .rela
8278          sections instead of garbage.
8279          We also rely on the section contents being zero when writing
8280          the GOT.  */
8281       s->contents = bfd_zalloc (dynobj, s->size);
8282       if (s->contents == NULL)
8283         return FALSE;
8284     }
8285
8286   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8287     {
8288       if (!is_ppc64_elf (ibfd))
8289         continue;
8290
8291       s = ppc64_elf_tdata (ibfd)->got;
8292       if (s != NULL && s != htab->got)
8293         {
8294           if (s->size == 0)
8295             s->flags |= SEC_EXCLUDE;
8296           else
8297             {
8298               s->contents = bfd_zalloc (ibfd, s->size);
8299               if (s->contents == NULL)
8300                 return FALSE;
8301             }
8302         }
8303       s = ppc64_elf_tdata (ibfd)->relgot;
8304       if (s != NULL)
8305         {
8306           if (s->size == 0)
8307             s->flags |= SEC_EXCLUDE;
8308           else
8309             {
8310               s->contents = bfd_zalloc (ibfd, s->size);
8311               if (s->contents == NULL)
8312                 return FALSE;
8313               relocs = TRUE;
8314               s->reloc_count = 0;
8315             }
8316         }
8317     }
8318
8319   if (htab->elf.dynamic_sections_created)
8320     {
8321       /* Add some entries to the .dynamic section.  We fill in the
8322          values later, in ppc64_elf_finish_dynamic_sections, but we
8323          must add the entries now so that we get the correct size for
8324          the .dynamic section.  The DT_DEBUG entry is filled in by the
8325          dynamic linker and used by the debugger.  */
8326 #define add_dynamic_entry(TAG, VAL) \
8327   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8328
8329       if (info->executable)
8330         {
8331           if (!add_dynamic_entry (DT_DEBUG, 0))
8332             return FALSE;
8333         }
8334
8335       if (htab->plt != NULL && htab->plt->size != 0)
8336         {
8337           if (!add_dynamic_entry (DT_PLTGOT, 0)
8338               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8339               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8340               || !add_dynamic_entry (DT_JMPREL, 0)
8341               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8342             return FALSE;
8343         }
8344
8345       if (NO_OPD_RELOCS)
8346         {
8347           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8348               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8349             return FALSE;
8350         }
8351
8352       if (relocs)
8353         {
8354           if (!add_dynamic_entry (DT_RELA, 0)
8355               || !add_dynamic_entry (DT_RELASZ, 0)
8356               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8357             return FALSE;
8358
8359           /* If any dynamic relocs apply to a read-only section,
8360              then we need a DT_TEXTREL entry.  */
8361           if ((info->flags & DF_TEXTREL) == 0)
8362             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8363
8364           if ((info->flags & DF_TEXTREL) != 0)
8365             {
8366               if (!add_dynamic_entry (DT_TEXTREL, 0))
8367                 return FALSE;
8368             }
8369         }
8370     }
8371 #undef add_dynamic_entry
8372
8373   return TRUE;
8374 }
8375
8376 /* Determine the type of stub needed, if any, for a call.  */
8377
8378 static inline enum ppc_stub_type
8379 ppc_type_of_stub (asection *input_sec,
8380                   const Elf_Internal_Rela *rel,
8381                   struct ppc_link_hash_entry **hash,
8382                   bfd_vma destination)
8383 {
8384   struct ppc_link_hash_entry *h = *hash;
8385   bfd_vma location;
8386   bfd_vma branch_offset;
8387   bfd_vma max_branch_offset;
8388   enum elf_ppc64_reloc_type r_type;
8389
8390   if (h != NULL)
8391     {
8392       struct ppc_link_hash_entry *fdh = h;
8393       if (fdh->oh != NULL
8394           && fdh->oh->is_func_descriptor)
8395         fdh = fdh->oh;
8396
8397       if (fdh->elf.dynindx != -1)
8398         {
8399           struct plt_entry *ent;
8400
8401           for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8402             if (ent->addend == rel->r_addend
8403                 && ent->plt.offset != (bfd_vma) -1)
8404               {
8405                 *hash = fdh;
8406                 return ppc_stub_plt_call;
8407               }
8408         }
8409
8410       /* Here, we know we don't have a plt entry.  If we don't have a
8411          either a defined function descriptor or a defined entry symbol
8412          in a regular object file, then it is pointless trying to make
8413          any other type of stub.  */
8414       if (!((fdh->elf.root.type == bfd_link_hash_defined
8415             || fdh->elf.root.type == bfd_link_hash_defweak)
8416             && fdh->elf.root.u.def.section->output_section != NULL)
8417           && !((h->elf.root.type == bfd_link_hash_defined
8418                 || h->elf.root.type == bfd_link_hash_defweak)
8419                && h->elf.root.u.def.section->output_section != NULL))
8420         return ppc_stub_none;
8421     }
8422
8423   /* Determine where the call point is.  */
8424   location = (input_sec->output_offset
8425               + input_sec->output_section->vma
8426               + rel->r_offset);
8427
8428   branch_offset = destination - location;
8429   r_type = ELF64_R_TYPE (rel->r_info);
8430
8431   /* Determine if a long branch stub is needed.  */
8432   max_branch_offset = 1 << 25;
8433   if (r_type != R_PPC64_REL24)
8434     max_branch_offset = 1 << 15;
8435
8436   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8437     /* We need a stub.  Figure out whether a long_branch or plt_branch
8438        is needed later.  */
8439     return ppc_stub_long_branch;
8440
8441   return ppc_stub_none;
8442 }
8443
8444 /* Build a .plt call stub.  */
8445
8446 static inline bfd_byte *
8447 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8448 {
8449 #define PPC_LO(v) ((v) & 0xffff)
8450 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8451 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8452
8453   if (PPC_HA (offset) != 0)
8454     {
8455       if (r != NULL)
8456         {
8457           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8458           r[1].r_offset = r[0].r_offset + 8;
8459           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8460           r[1].r_addend = r[0].r_addend;
8461           if (PPC_HA (offset + 16) != PPC_HA (offset))
8462             {
8463               r[2].r_offset = r[1].r_offset + 4;
8464               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8465               r[2].r_addend = r[0].r_addend;
8466             }
8467           else
8468             {
8469               r[2].r_offset = r[1].r_offset + 8;
8470               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8471               r[2].r_addend = r[0].r_addend + 8;
8472               r[3].r_offset = r[2].r_offset + 4;
8473               r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8474               r[3].r_addend = r[0].r_addend + 16;
8475             }
8476         }
8477       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
8478       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8479       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
8480       if (PPC_HA (offset + 16) != PPC_HA (offset))
8481         {
8482           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8483           offset = 0;
8484         }
8485       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8486       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
8487       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8488       bfd_put_32 (obfd, BCTR, p),                               p += 4;
8489     }
8490   else
8491     {
8492       if (r != NULL)
8493         {
8494           r[0].r_offset += 4;
8495           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8496           if (PPC_HA (offset + 16) != PPC_HA (offset))
8497             {
8498               r[1].r_offset = r[0].r_offset + 4;
8499               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8500               r[1].r_addend = r[0].r_addend;
8501             }
8502           else
8503             {
8504               r[1].r_offset = r[0].r_offset + 8;
8505               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8506               r[1].r_addend = r[0].r_addend + 16;
8507               r[2].r_offset = r[1].r_offset + 4;
8508               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8509               r[2].r_addend = r[0].r_addend + 8;
8510             }
8511         }
8512       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8513       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
8514       if (PPC_HA (offset + 16) != PPC_HA (offset))
8515         {
8516           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
8517           offset = 0;
8518         }
8519       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8520       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
8521       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
8522       bfd_put_32 (obfd, BCTR, p),                               p += 4;
8523     }
8524   return p;
8525 }
8526
8527 static Elf_Internal_Rela *
8528 get_relocs (asection *sec, int count)
8529 {
8530   Elf_Internal_Rela *relocs;
8531   struct bfd_elf_section_data *elfsec_data;
8532
8533   elfsec_data = elf_section_data (sec);
8534   relocs = elfsec_data->relocs;
8535   if (relocs == NULL)
8536     {
8537       bfd_size_type relsize;
8538       relsize = sec->reloc_count * sizeof (*relocs);
8539       relocs = bfd_alloc (sec->owner, relsize);
8540       if (relocs == NULL)
8541         return NULL;
8542       elfsec_data->relocs = relocs;
8543       elfsec_data->rel_hdr.sh_size = (sec->reloc_count
8544                                       * sizeof (Elf64_External_Rela));
8545       elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
8546       sec->reloc_count = 0;
8547     }
8548   relocs += sec->reloc_count;
8549   sec->reloc_count += count;
8550   return relocs;
8551 }
8552
8553 static bfd_boolean
8554 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8555 {
8556   struct ppc_stub_hash_entry *stub_entry;
8557   struct ppc_branch_hash_entry *br_entry;
8558   struct bfd_link_info *info;
8559   struct ppc_link_hash_table *htab;
8560   bfd_byte *loc;
8561   bfd_byte *p;
8562   struct plt_entry *ent;
8563   bfd_vma dest, off;
8564   int size;
8565   Elf_Internal_Rela *r;
8566
8567   /* Massage our args to the form they really have.  */
8568   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8569   info = in_arg;
8570
8571   htab = ppc_hash_table (info);
8572
8573   /* Make a note of the offset within the stubs for this entry.  */
8574   stub_entry->stub_offset = stub_entry->stub_sec->size;
8575   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8576
8577   htab->stub_count[stub_entry->stub_type - 1] += 1;
8578   switch (stub_entry->stub_type)
8579     {
8580     case ppc_stub_long_branch:
8581     case ppc_stub_long_branch_r2off:
8582       /* Branches are relative.  This is where we are going to.  */
8583       off = dest = (stub_entry->target_value
8584                     + stub_entry->target_section->output_offset
8585                     + stub_entry->target_section->output_section->vma);
8586
8587       /* And this is where we are coming from.  */
8588       off -= (stub_entry->stub_offset
8589               + stub_entry->stub_sec->output_offset
8590               + stub_entry->stub_sec->output_section->vma);
8591
8592       size = 4;
8593       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8594         {
8595           bfd_vma r2off;
8596
8597           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8598                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
8599           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8600           loc += 4;
8601           size = 12;
8602           if (PPC_HA (r2off) != 0)
8603             {
8604               size = 16;
8605               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8606               loc += 4;
8607             }
8608           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8609           loc += 4;
8610           off -= size - 4;
8611         }
8612       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8613
8614       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8615         {
8616           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8617                                  stub_entry->root.string);
8618           htab->stub_error = TRUE;
8619           return FALSE;
8620         }
8621
8622       if (info->emitrelocations)
8623         {
8624           r = get_relocs (stub_entry->stub_sec, 1);
8625           if (r == NULL)
8626             return FALSE;
8627           r->r_offset = loc - stub_entry->stub_sec->contents;
8628           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8629           r->r_addend = dest;
8630           if (stub_entry->h != NULL)
8631             {
8632               struct elf_link_hash_entry **hashes;
8633               unsigned long symndx;
8634               struct ppc_link_hash_entry *h;
8635
8636               hashes = elf_sym_hashes (htab->stub_bfd);
8637               if (hashes == NULL)
8638                 {
8639                   bfd_size_type hsize;
8640
8641                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8642                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
8643                   if (hashes == NULL)
8644                     return FALSE;
8645                   elf_sym_hashes (htab->stub_bfd) = hashes;
8646                   htab->stub_globals = 1;
8647                 }
8648               symndx = htab->stub_globals++;
8649               h = stub_entry->h;
8650               hashes[symndx] = &h->elf;
8651               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8652               if (h->oh != NULL && h->oh->is_func)
8653                 h = h->oh;
8654               if (h->elf.root.u.def.section != stub_entry->target_section)
8655                 /* H is an opd symbol.  The addend must be zero.  */
8656                 r->r_addend = 0;
8657               else
8658                 {
8659                   off = (h->elf.root.u.def.value
8660                          + h->elf.root.u.def.section->output_offset
8661                          + h->elf.root.u.def.section->output_section->vma);
8662                   r->r_addend -= off;
8663                 }
8664             }
8665         }
8666       break;
8667
8668     case ppc_stub_plt_branch:
8669     case ppc_stub_plt_branch_r2off:
8670       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8671                                          stub_entry->root.string + 9,
8672                                          FALSE, FALSE);
8673       if (br_entry == NULL)
8674         {
8675           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8676                                  stub_entry->root.string);
8677           htab->stub_error = TRUE;
8678           return FALSE;
8679         }
8680
8681       dest = (stub_entry->target_value
8682               + stub_entry->target_section->output_offset
8683               + stub_entry->target_section->output_section->vma);
8684
8685       bfd_put_64 (htab->brlt->owner, dest,
8686                   htab->brlt->contents + br_entry->offset);
8687
8688       if (br_entry->iter == htab->stub_iteration)
8689         {
8690           br_entry->iter = 0;
8691
8692           if (htab->relbrlt != NULL)
8693             {
8694               /* Create a reloc for the branch lookup table entry.  */
8695               Elf_Internal_Rela rela;
8696               bfd_byte *rl;
8697
8698               rela.r_offset = (br_entry->offset
8699                                + htab->brlt->output_offset
8700                                + htab->brlt->output_section->vma);
8701               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8702               rela.r_addend = dest;
8703
8704               rl = htab->relbrlt->contents;
8705               rl += (htab->relbrlt->reloc_count++
8706                      * sizeof (Elf64_External_Rela));
8707               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8708             }
8709           else if (info->emitrelocations)
8710             {
8711               r = get_relocs (htab->brlt, 1);
8712               if (r == NULL)
8713                 return FALSE;
8714               /* brlt, being SEC_LINKER_CREATED does not go through the
8715                  normal reloc processing.  Symbols and offsets are not
8716                  translated from input file to output file form, so
8717                  set up the offset per the output file.  */
8718               r->r_offset = (br_entry->offset
8719                              + htab->brlt->output_offset
8720                              + htab->brlt->output_section->vma);
8721               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8722               r->r_addend = dest;
8723             }
8724         }
8725
8726       dest = (br_entry->offset
8727               + htab->brlt->output_offset
8728               + htab->brlt->output_section->vma);
8729
8730       off = (dest
8731              - elf_gp (htab->brlt->output_section->owner)
8732              - htab->stub_group[stub_entry->id_sec->id].toc_off);
8733
8734       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8735         {
8736           (*_bfd_error_handler)
8737             (_("linkage table error against `%s'"),
8738              stub_entry->root.string);
8739           bfd_set_error (bfd_error_bad_value);
8740           htab->stub_error = TRUE;
8741           return FALSE;
8742         }
8743
8744       if (info->emitrelocations)
8745         {
8746           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
8747           if (r == NULL)
8748             return FALSE;
8749           r[0].r_offset = loc - stub_entry->stub_sec->contents;
8750           if (bfd_big_endian (info->output_bfd))
8751             r[0].r_offset += 2;
8752           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
8753             r[0].r_offset += 4;
8754           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8755           r[0].r_addend = dest;
8756           if (PPC_HA (off) != 0)
8757             {
8758               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8759               r[1].r_offset = r[0].r_offset + 4;
8760               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8761               r[1].r_addend = r[0].r_addend;
8762             }
8763         }
8764
8765       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8766         {
8767           if (PPC_HA (off) != 0)
8768             {
8769               size = 16;
8770               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8771               loc += 4;
8772               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8773             }
8774           else
8775             {
8776               size = 12;
8777               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8778             }
8779         }
8780       else
8781         {
8782           bfd_vma r2off;
8783
8784           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8785                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
8786           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8787           loc += 4;
8788           size = 20;
8789           if (PPC_HA (off) != 0)
8790             {
8791               size += 4;
8792               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8793               loc += 4;
8794               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8795               loc += 4;
8796             }
8797           else
8798             {
8799               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8800               loc += 4;
8801             }
8802
8803           if (PPC_HA (r2off) != 0)
8804             {
8805               size += 4;
8806               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8807               loc += 4;
8808             }
8809           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8810         }
8811       loc += 4;
8812       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
8813       loc += 4;
8814       bfd_put_32 (htab->stub_bfd, BCTR, loc);
8815       break;
8816
8817     case ppc_stub_plt_call:
8818       /* Do the best we can for shared libraries built without
8819          exporting ".foo" for each "foo".  This can happen when symbol
8820          versioning scripts strip all bar a subset of symbols.  */
8821       if (stub_entry->h->oh != NULL
8822           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
8823           && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
8824         {
8825           /* Point the symbol at the stub.  There may be multiple stubs,
8826              we don't really care;  The main thing is to make this sym
8827              defined somewhere.  Maybe defining the symbol in the stub
8828              section is a silly idea.  If we didn't do this, htab->top_id
8829              could disappear.  */
8830           stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8831           stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8832           stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
8833         }
8834
8835       /* Now build the stub.  */
8836       dest = (bfd_vma) -1;
8837       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8838         if (ent->addend == stub_entry->addend)
8839           {
8840             dest = ent->plt.offset;
8841             break;
8842           }
8843       if (dest >= (bfd_vma) -2)
8844         abort ();
8845
8846       dest &= ~ (bfd_vma) 1;
8847       dest += (htab->plt->output_offset
8848                + htab->plt->output_section->vma);
8849
8850       off = (dest
8851              - elf_gp (htab->plt->output_section->owner)
8852              - htab->stub_group[stub_entry->id_sec->id].toc_off);
8853
8854       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8855         {
8856           (*_bfd_error_handler)
8857             (_("linkage table error against `%s'"),
8858              stub_entry->h->elf.root.root.string);
8859           bfd_set_error (bfd_error_bad_value);
8860           htab->stub_error = TRUE;
8861           return FALSE;
8862         }
8863
8864       r = NULL;
8865       if (info->emitrelocations)
8866         {
8867           r = get_relocs (stub_entry->stub_sec,
8868                           (2 + (PPC_HA (off) != 0)
8869                            + (PPC_HA (off + 16) == PPC_HA (off))));
8870           if (r == NULL)
8871             return FALSE;
8872           r[0].r_offset = loc - stub_entry->stub_sec->contents;
8873           if (bfd_big_endian (info->output_bfd))
8874             r[0].r_offset += 2;
8875           r[0].r_addend = dest;
8876         }
8877       p = build_plt_stub (htab->stub_bfd, loc, off, r);
8878       size = p - loc;
8879       break;
8880
8881     default:
8882       BFD_FAIL ();
8883       return FALSE;
8884     }
8885
8886   stub_entry->stub_sec->size += size;
8887
8888   if (htab->emit_stub_syms)
8889     {
8890       struct elf_link_hash_entry *h;
8891       size_t len1, len2;
8892       char *name;
8893       const char *const stub_str[] = { "long_branch",
8894                                        "long_branch_r2off",
8895                                        "plt_branch",
8896                                        "plt_branch_r2off",
8897                                        "plt_call" };
8898
8899       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8900       len2 = strlen (stub_entry->root.string);
8901       name = bfd_malloc (len1 + len2 + 2);
8902       if (name == NULL)
8903         return FALSE;
8904       memcpy (name, stub_entry->root.string, 9);
8905       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8906       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8907       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8908       if (h == NULL)
8909         return FALSE;
8910       if (h->root.type == bfd_link_hash_new)
8911         {
8912           h->root.type = bfd_link_hash_defined;
8913           h->root.u.def.section = stub_entry->stub_sec;
8914           h->root.u.def.value = stub_entry->stub_offset;
8915           h->ref_regular = 1;
8916           h->def_regular = 1;
8917           h->ref_regular_nonweak = 1;
8918           h->forced_local = 1;
8919           h->non_elf = 0;
8920         }
8921     }
8922
8923   return TRUE;
8924 }
8925
8926 /* As above, but don't actually build the stub.  Just bump offset so
8927    we know stub section sizes, and select plt_branch stubs where
8928    long_branch stubs won't do.  */
8929
8930 static bfd_boolean
8931 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8932 {
8933   struct ppc_stub_hash_entry *stub_entry;
8934   struct bfd_link_info *info;
8935   struct ppc_link_hash_table *htab;
8936   bfd_vma off;
8937   int size;
8938
8939   /* Massage our args to the form they really have.  */
8940   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8941   info = in_arg;
8942
8943   htab = ppc_hash_table (info);
8944
8945   if (stub_entry->stub_type == ppc_stub_plt_call)
8946     {
8947       struct plt_entry *ent;
8948       off = (bfd_vma) -1;
8949       for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8950         if (ent->addend == stub_entry->addend)
8951           {
8952             off = ent->plt.offset & ~(bfd_vma) 1;
8953             break;
8954           }
8955       if (off >= (bfd_vma) -2)
8956         abort ();
8957       off += (htab->plt->output_offset
8958               + htab->plt->output_section->vma
8959               - elf_gp (htab->plt->output_section->owner)
8960               - htab->stub_group[stub_entry->id_sec->id].toc_off);
8961
8962       size = PLT_CALL_STUB_SIZE;
8963       if (PPC_HA (off) == 0)
8964         size -= 4;
8965       if (PPC_HA (off + 16) != PPC_HA (off))
8966         size += 4;
8967       if (info->emitrelocations)
8968         {
8969           stub_entry->stub_sec->reloc_count
8970             += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
8971           stub_entry->stub_sec->flags |= SEC_RELOC;
8972         }
8973     }
8974   else
8975     {
8976       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8977          variants.  */
8978       bfd_vma r2off = 0;
8979
8980       off = (stub_entry->target_value
8981              + stub_entry->target_section->output_offset
8982              + stub_entry->target_section->output_section->vma);
8983       off -= (stub_entry->stub_sec->size
8984               + stub_entry->stub_sec->output_offset
8985               + stub_entry->stub_sec->output_section->vma);
8986
8987       /* Reset the stub type from the plt variant in case we now
8988          can reach with a shorter stub.  */
8989       if (stub_entry->stub_type >= ppc_stub_plt_branch)
8990         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8991
8992       size = 4;
8993       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8994         {
8995           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8996                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
8997           size = 12;
8998           if (PPC_HA (r2off) != 0)
8999             size = 16;
9000           off -= size - 4;
9001         }
9002
9003       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9004       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9005         {
9006           struct ppc_branch_hash_entry *br_entry;
9007
9008           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9009                                              stub_entry->root.string + 9,
9010                                              TRUE, FALSE);
9011           if (br_entry == NULL)
9012             {
9013               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9014                                      stub_entry->root.string);
9015               htab->stub_error = TRUE;
9016               return FALSE;
9017             }
9018
9019           if (br_entry->iter != htab->stub_iteration)
9020             {
9021               br_entry->iter = htab->stub_iteration;
9022               br_entry->offset = htab->brlt->size;
9023               htab->brlt->size += 8;
9024
9025               if (htab->relbrlt != NULL)
9026                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9027               else if (info->emitrelocations)
9028                 {
9029                   htab->brlt->reloc_count += 1;
9030                   htab->brlt->flags |= SEC_RELOC;
9031                 }
9032             }
9033
9034           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9035           off = (br_entry->offset
9036                  + htab->brlt->output_offset
9037                  + htab->brlt->output_section->vma
9038                  - elf_gp (htab->brlt->output_section->owner)
9039                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
9040
9041           if (info->emitrelocations)
9042             {
9043               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9044               stub_entry->stub_sec->flags |= SEC_RELOC;
9045             }
9046
9047           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9048             {
9049               size = 12;
9050               if (PPC_HA (off) != 0)
9051                 size = 16;
9052             }
9053           else
9054             {
9055               size = 20;
9056               if (PPC_HA (off) != 0)
9057                 size += 4;
9058
9059               if (PPC_HA (r2off) != 0)
9060                 size += 4;
9061             }
9062         }
9063       else if (info->emitrelocations)
9064         {
9065           stub_entry->stub_sec->reloc_count += 1;
9066           stub_entry->stub_sec->flags |= SEC_RELOC;
9067         }
9068     }
9069
9070   stub_entry->stub_sec->size += size;
9071   return TRUE;
9072 }
9073
9074 /* Set up various things so that we can make a list of input sections
9075    for each output section included in the link.  Returns -1 on error,
9076    0 when no stubs will be needed, and 1 on success.  */
9077
9078 int
9079 ppc64_elf_setup_section_lists (bfd *output_bfd,
9080                                struct bfd_link_info *info,
9081                                int no_multi_toc)
9082 {
9083   bfd *input_bfd;
9084   int top_id, top_index, id;
9085   asection *section;
9086   asection **input_list;
9087   bfd_size_type amt;
9088   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9089
9090   htab->no_multi_toc = no_multi_toc;
9091
9092   if (htab->brlt == NULL)
9093     return 0;
9094
9095   /* Find the top input section id.  */
9096   for (input_bfd = info->input_bfds, top_id = 3;
9097        input_bfd != NULL;
9098        input_bfd = input_bfd->link_next)
9099     {
9100       for (section = input_bfd->sections;
9101            section != NULL;
9102            section = section->next)
9103         {
9104           if (top_id < section->id)
9105             top_id = section->id;
9106         }
9107     }
9108
9109   htab->top_id = top_id;
9110   amt = sizeof (struct map_stub) * (top_id + 1);
9111   htab->stub_group = bfd_zmalloc (amt);
9112   if (htab->stub_group == NULL)
9113     return -1;
9114
9115   /* Set toc_off for com, und, abs and ind sections.  */
9116   for (id = 0; id < 3; id++)
9117     htab->stub_group[id].toc_off = TOC_BASE_OFF;
9118
9119   elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
9120
9121   /* We can't use output_bfd->section_count here to find the top output
9122      section index as some sections may have been removed, and
9123      strip_excluded_output_sections doesn't renumber the indices.  */
9124   for (section = output_bfd->sections, top_index = 0;
9125        section != NULL;
9126        section = section->next)
9127     {
9128       if (top_index < section->index)
9129         top_index = section->index;
9130     }
9131
9132   htab->top_index = top_index;
9133   amt = sizeof (asection *) * (top_index + 1);
9134   input_list = bfd_zmalloc (amt);
9135   htab->input_list = input_list;
9136   if (input_list == NULL)
9137     return -1;
9138
9139   return 1;
9140 }
9141
9142 /* The linker repeatedly calls this function for each TOC input section
9143    and linker generated GOT section.  Group input bfds such that the toc
9144    within a group is less than 64k in size.  Will break with cute linker
9145    scripts that play games with dot in the output toc section.  */
9146
9147 void
9148 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9149 {
9150   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9151
9152   if (!htab->no_multi_toc)
9153     {
9154       bfd_vma addr = isec->output_offset + isec->output_section->vma;
9155       bfd_vma off = addr - htab->toc_curr;
9156
9157       if (off + isec->size > 0x10000)
9158         htab->toc_curr = addr;
9159
9160       elf_gp (isec->owner) = (htab->toc_curr
9161                               - elf_gp (isec->output_section->owner)
9162                               + TOC_BASE_OFF);
9163     }
9164 }
9165
9166 /* Called after the last call to the above function.  */
9167
9168 void
9169 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
9170 {
9171   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9172
9173   htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
9174
9175   /* toc_curr tracks the TOC offset used for code sections below in
9176      ppc64_elf_next_input_section.  Start off at 0x8000.  */
9177   htab->toc_curr = TOC_BASE_OFF;
9178 }
9179
9180 /* No toc references were found in ISEC.  If the code in ISEC makes no
9181    calls, then there's no need to use toc adjusting stubs when branching
9182    into ISEC.  Actually, indirect calls from ISEC are OK as they will
9183    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
9184    needed, and 2 if a cyclical call-graph was found but no other reason
9185    for a stub was detected.  If called from the top level, a return of
9186    2 means the same as a return of 0.  */
9187
9188 static int
9189 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9190 {
9191   Elf_Internal_Rela *relstart, *rel;
9192   Elf_Internal_Sym *local_syms;
9193   int ret;
9194   struct ppc_link_hash_table *htab;
9195
9196   /* We know none of our code bearing sections will need toc stubs.  */
9197   if ((isec->flags & SEC_LINKER_CREATED) != 0)
9198     return 0;
9199
9200   if (isec->size == 0)
9201     return 0;
9202
9203   if (isec->output_section == NULL)
9204     return 0;
9205
9206   if (isec->reloc_count == 0)
9207     return 0;
9208
9209   relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
9210                                         info->keep_memory);
9211   if (relstart == NULL)
9212     return -1;
9213
9214   /* Look for branches to outside of this section.  */
9215   local_syms = NULL;
9216   ret = 0;
9217   htab = ppc_hash_table (info);
9218   for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9219     {
9220       enum elf_ppc64_reloc_type r_type;
9221       unsigned long r_symndx;
9222       struct elf_link_hash_entry *h;
9223       struct ppc_link_hash_entry *eh;
9224       Elf_Internal_Sym *sym;
9225       asection *sym_sec;
9226       struct _opd_sec_data *opd;
9227       bfd_vma sym_value;
9228       bfd_vma dest;
9229
9230       r_type = ELF64_R_TYPE (rel->r_info);
9231       if (r_type != R_PPC64_REL24
9232           && r_type != R_PPC64_REL14
9233           && r_type != R_PPC64_REL14_BRTAKEN
9234           && r_type != R_PPC64_REL14_BRNTAKEN)
9235         continue;
9236
9237       r_symndx = ELF64_R_SYM (rel->r_info);
9238       if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9239                       isec->owner))
9240         {
9241           ret = -1;
9242           break;
9243         }
9244
9245       /* Calls to dynamic lib functions go through a plt call stub
9246          that uses r2.  */
9247       eh = (struct ppc_link_hash_entry *) h;
9248       if (eh != NULL
9249           && (eh->elf.plt.plist != NULL
9250               || (eh->oh != NULL
9251                   && eh->oh->elf.plt.plist != NULL)))
9252         {
9253           ret = 1;
9254           break;
9255         }
9256
9257       if (sym_sec == NULL)
9258         /* Ignore other undefined symbols.  */
9259         continue;
9260
9261       /* Assume branches to other sections not included in the link need
9262          stubs too, to cover -R and absolute syms.  */
9263       if (sym_sec->output_section == NULL)
9264         {
9265           ret = 1;
9266           break;
9267         }
9268
9269       if (h == NULL)
9270         sym_value = sym->st_value;
9271       else
9272         {
9273           if (h->root.type != bfd_link_hash_defined
9274               && h->root.type != bfd_link_hash_defweak)
9275             abort ();
9276           sym_value = h->root.u.def.value;
9277         }
9278       sym_value += rel->r_addend;
9279
9280       /* If this branch reloc uses an opd sym, find the code section.  */
9281       opd = get_opd_info (sym_sec);
9282       if (opd != NULL)
9283         {
9284           if (h == NULL && opd->adjust != NULL)
9285             {
9286               long adjust;
9287
9288               adjust = opd->adjust[sym->st_value / 8];
9289               if (adjust == -1)
9290                 /* Assume deleted functions won't ever be called.  */
9291                 continue;
9292               sym_value += adjust;
9293             }
9294
9295           dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9296           if (dest == (bfd_vma) -1)
9297             continue;
9298         }
9299       else
9300         dest = (sym_value
9301                 + sym_sec->output_offset
9302                 + sym_sec->output_section->vma);
9303
9304       /* Ignore branch to self.  */
9305       if (sym_sec == isec)
9306         continue;
9307
9308       /* If the called function uses the toc, we need a stub.  */
9309       if (sym_sec->has_toc_reloc
9310           || sym_sec->makes_toc_func_call)
9311         {
9312           ret = 1;
9313           break;
9314         }
9315
9316       /* Assume any branch that needs a long branch stub might in fact
9317          need a plt_branch stub.  A plt_branch stub uses r2.  */
9318       else if (dest - (isec->output_offset
9319                        + isec->output_section->vma
9320                        + rel->r_offset) + (1 << 25) >= (2 << 25))
9321         {
9322           ret = 1;
9323           break;
9324         }
9325
9326       /* If calling back to a section in the process of being tested, we
9327          can't say for sure that no toc adjusting stubs are needed, so
9328          don't return zero.  */
9329       else if (sym_sec->call_check_in_progress)
9330         ret = 2;
9331
9332       /* Branches to another section that itself doesn't have any TOC
9333          references are OK.  Recursively call ourselves to check.  */
9334       else if (sym_sec->id <= htab->top_id
9335                && htab->stub_group[sym_sec->id].toc_off == 0)
9336         {
9337           int recur;
9338
9339           /* Mark current section as indeterminate, so that other
9340              sections that call back to current won't be marked as
9341              known.  */
9342           isec->call_check_in_progress = 1;
9343           recur = toc_adjusting_stub_needed (info, sym_sec);
9344           isec->call_check_in_progress = 0;
9345
9346           if (recur < 0)
9347             {
9348               /* An error.  Exit.  */
9349               ret = -1;
9350               break;
9351             }
9352           else if (recur <= 1)
9353             {
9354               /* Known result.  Mark as checked and set section flag.  */
9355               htab->stub_group[sym_sec->id].toc_off = 1;
9356               if (recur != 0)
9357                 {
9358                   sym_sec->makes_toc_func_call = 1;
9359                   ret = 1;
9360                   break;
9361                 }
9362             }
9363           else
9364             {
9365               /* Unknown result.  Continue checking.  */
9366               ret = 2;
9367             }
9368         }
9369     }
9370
9371   if (local_syms != NULL
9372       && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
9373     free (local_syms);
9374   if (elf_section_data (isec)->relocs != relstart)
9375     free (relstart);
9376
9377   return ret;
9378 }
9379
9380 /* The linker repeatedly calls this function for each input section,
9381    in the order that input sections are linked into output sections.
9382    Build lists of input sections to determine groupings between which
9383    we may insert linker stubs.  */
9384
9385 bfd_boolean
9386 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
9387 {
9388   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9389
9390   if ((isec->output_section->flags & SEC_CODE) != 0
9391       && isec->output_section->index <= htab->top_index)
9392     {
9393       asection **list = htab->input_list + isec->output_section->index;
9394       /* Steal the link_sec pointer for our list.  */
9395 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
9396       /* This happens to make the list in reverse order,
9397          which is what we want.  */
9398       PREV_SEC (isec) = *list;
9399       *list = isec;
9400     }
9401
9402   if (htab->multi_toc_needed)
9403     {
9404       /* If a code section has a function that uses the TOC then we need
9405          to use the right TOC (obviously).  Also, make sure that .opd gets
9406          the correct TOC value for R_PPC64_TOC relocs that don't have or
9407          can't find their function symbol (shouldn't ever happen now).
9408          Also specially treat .fixup for the linux kernel.  .fixup
9409          contains branches, but only back to the function that hit an
9410          exception.  */
9411       if (isec->has_toc_reloc
9412           || (isec->flags & SEC_CODE) == 0
9413           || strcmp (isec->name, ".fixup") == 0)
9414         {
9415           if (elf_gp (isec->owner) != 0)
9416             htab->toc_curr = elf_gp (isec->owner);
9417         }
9418       else if (htab->stub_group[isec->id].toc_off == 0)
9419         {
9420           int ret = toc_adjusting_stub_needed (info, isec);
9421           if (ret < 0)
9422             return FALSE;
9423           else
9424             isec->makes_toc_func_call = ret & 1;
9425         }
9426     }
9427
9428   /* Functions that don't use the TOC can belong in any TOC group.
9429      Use the last TOC base.  This happens to make _init and _fini
9430      pasting work.  */
9431   htab->stub_group[isec->id].toc_off = htab->toc_curr;
9432   return TRUE;
9433 }
9434
9435 /* See whether we can group stub sections together.  Grouping stub
9436    sections may result in fewer stubs.  More importantly, we need to
9437    put all .init* and .fini* stubs at the beginning of the .init or
9438    .fini output sections respectively, because glibc splits the
9439    _init and _fini functions into multiple parts.  Putting a stub in
9440    the middle of a function is not a good idea.  */
9441
9442 static void
9443 group_sections (struct ppc_link_hash_table *htab,
9444                 bfd_size_type stub_group_size,
9445                 bfd_boolean stubs_always_before_branch)
9446 {
9447   asection **list;
9448   bfd_size_type stub14_group_size;
9449   bfd_boolean suppress_size_errors;
9450
9451   suppress_size_errors = FALSE;
9452   stub14_group_size = stub_group_size;
9453   if (stub_group_size == 1)
9454     {
9455       /* Default values.  */
9456       if (stubs_always_before_branch)
9457         {
9458           stub_group_size = 0x1e00000;
9459           stub14_group_size = 0x7800;
9460         }
9461       else
9462         {
9463           stub_group_size = 0x1c00000;
9464           stub14_group_size = 0x7000;
9465         }
9466       suppress_size_errors = TRUE;
9467     }
9468
9469   list = htab->input_list + htab->top_index;
9470   do
9471     {
9472       asection *tail = *list;
9473       while (tail != NULL)
9474         {
9475           asection *curr;
9476           asection *prev;
9477           bfd_size_type total;
9478           bfd_boolean big_sec;
9479           bfd_vma curr_toc;
9480
9481           curr = tail;
9482           total = tail->size;
9483           big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9484                              ? stub14_group_size : stub_group_size);
9485           if (big_sec && !suppress_size_errors)
9486             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9487                                      tail->owner, tail);
9488           curr_toc = htab->stub_group[tail->id].toc_off;
9489
9490           while ((prev = PREV_SEC (curr)) != NULL
9491                  && ((total += curr->output_offset - prev->output_offset)
9492                      < (ppc64_elf_section_data (prev)->has_14bit_branch
9493                         ? stub14_group_size : stub_group_size))
9494                  && htab->stub_group[prev->id].toc_off == curr_toc)
9495             curr = prev;
9496
9497           /* OK, the size from the start of CURR to the end is less
9498              than stub_group_size and thus can be handled by one stub
9499              section.  (or the tail section is itself larger than
9500              stub_group_size, in which case we may be toast.)  We
9501              should really be keeping track of the total size of stubs
9502              added here, as stubs contribute to the final output
9503              section size.  That's a little tricky, and this way will
9504              only break if stubs added make the total size more than
9505              2^25, ie. for the default stub_group_size, if stubs total
9506              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
9507           do
9508             {
9509               prev = PREV_SEC (tail);
9510               /* Set up this stub group.  */
9511               htab->stub_group[tail->id].link_sec = curr;
9512             }
9513           while (tail != curr && (tail = prev) != NULL);
9514
9515           /* But wait, there's more!  Input sections up to stub_group_size
9516              bytes before the stub section can be handled by it too.
9517              Don't do this if we have a really large section after the
9518              stubs, as adding more stubs increases the chance that
9519              branches may not reach into the stub section.  */
9520           if (!stubs_always_before_branch && !big_sec)
9521             {
9522               total = 0;
9523               while (prev != NULL
9524                      && ((total += tail->output_offset - prev->output_offset)
9525                          < (ppc64_elf_section_data (prev)->has_14bit_branch
9526                             ? stub14_group_size : stub_group_size))
9527                      && htab->stub_group[prev->id].toc_off == curr_toc)
9528                 {
9529                   tail = prev;
9530                   prev = PREV_SEC (tail);
9531                   htab->stub_group[tail->id].link_sec = curr;
9532                 }
9533             }
9534           tail = prev;
9535         }
9536     }
9537   while (list-- != htab->input_list);
9538   free (htab->input_list);
9539 #undef PREV_SEC
9540 }
9541
9542 /* Determine and set the size of the stub section for a final link.
9543
9544    The basic idea here is to examine all the relocations looking for
9545    PC-relative calls to a target that is unreachable with a "bl"
9546    instruction.  */
9547
9548 bfd_boolean
9549 ppc64_elf_size_stubs (bfd *output_bfd,
9550                       struct bfd_link_info *info,
9551                       bfd_signed_vma group_size,
9552                       asection *(*add_stub_section) (const char *, asection *),
9553                       void (*layout_sections_again) (void))
9554 {
9555   bfd_size_type stub_group_size;
9556   bfd_boolean stubs_always_before_branch;
9557   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9558
9559   /* Stash our params away.  */
9560   htab->add_stub_section = add_stub_section;
9561   htab->layout_sections_again = layout_sections_again;
9562   stubs_always_before_branch = group_size < 0;
9563   if (group_size < 0)
9564     stub_group_size = -group_size;
9565   else
9566     stub_group_size = group_size;
9567
9568   group_sections (htab, stub_group_size, stubs_always_before_branch);
9569
9570   while (1)
9571     {
9572       bfd *input_bfd;
9573       unsigned int bfd_indx;
9574       asection *stub_sec;
9575
9576       htab->stub_iteration += 1;
9577
9578       for (input_bfd = info->input_bfds, bfd_indx = 0;
9579            input_bfd != NULL;
9580            input_bfd = input_bfd->link_next, bfd_indx++)
9581         {
9582           Elf_Internal_Shdr *symtab_hdr;
9583           asection *section;
9584           Elf_Internal_Sym *local_syms = NULL;
9585
9586           if (!is_ppc64_elf (input_bfd))
9587             continue;
9588
9589           /* We'll need the symbol table in a second.  */
9590           symtab_hdr = &elf_symtab_hdr (input_bfd);
9591           if (symtab_hdr->sh_info == 0)
9592             continue;
9593
9594           /* Walk over each section attached to the input bfd.  */
9595           for (section = input_bfd->sections;
9596                section != NULL;
9597                section = section->next)
9598             {
9599               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
9600
9601               /* If there aren't any relocs, then there's nothing more
9602                  to do.  */
9603               if ((section->flags & SEC_RELOC) == 0
9604                   || (section->flags & SEC_ALLOC) == 0
9605                   || (section->flags & SEC_LOAD) == 0
9606                   || (section->flags & SEC_CODE) == 0
9607                   || section->reloc_count == 0)
9608                 continue;
9609
9610               /* If this section is a link-once section that will be
9611                  discarded, then don't create any stubs.  */
9612               if (section->output_section == NULL
9613                   || section->output_section->owner != output_bfd)
9614                 continue;
9615
9616               /* Get the relocs.  */
9617               internal_relocs
9618                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9619                                              info->keep_memory);
9620               if (internal_relocs == NULL)
9621                 goto error_ret_free_local;
9622
9623               /* Now examine each relocation.  */
9624               irela = internal_relocs;
9625               irelaend = irela + section->reloc_count;
9626               for (; irela < irelaend; irela++)
9627                 {
9628                   enum elf_ppc64_reloc_type r_type;
9629                   unsigned int r_indx;
9630                   enum ppc_stub_type stub_type;
9631                   struct ppc_stub_hash_entry *stub_entry;
9632                   asection *sym_sec, *code_sec;
9633                   bfd_vma sym_value;
9634                   bfd_vma destination;
9635                   bfd_boolean ok_dest;
9636                   struct ppc_link_hash_entry *hash;
9637                   struct ppc_link_hash_entry *fdh;
9638                   struct elf_link_hash_entry *h;
9639                   Elf_Internal_Sym *sym;
9640                   char *stub_name;
9641                   const asection *id_sec;
9642                   struct _opd_sec_data *opd;
9643
9644                   r_type = ELF64_R_TYPE (irela->r_info);
9645                   r_indx = ELF64_R_SYM (irela->r_info);
9646
9647                   if (r_type >= R_PPC64_max)
9648                     {
9649                       bfd_set_error (bfd_error_bad_value);
9650                       goto error_ret_free_internal;
9651                     }
9652
9653                   /* Only look for stubs on branch instructions.  */
9654                   if (r_type != R_PPC64_REL24
9655                       && r_type != R_PPC64_REL14
9656                       && r_type != R_PPC64_REL14_BRTAKEN
9657                       && r_type != R_PPC64_REL14_BRNTAKEN)
9658                     continue;
9659
9660                   /* Now determine the call target, its name, value,
9661                      section.  */
9662                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9663                                   r_indx, input_bfd))
9664                     goto error_ret_free_internal;
9665                   hash = (struct ppc_link_hash_entry *) h;
9666
9667                   ok_dest = FALSE;
9668                   fdh = NULL;
9669                   sym_value = 0;
9670                   if (hash == NULL)
9671                     {
9672                       sym_value = sym->st_value;
9673                       ok_dest = TRUE;
9674                     }
9675                   else if (hash->elf.root.type == bfd_link_hash_defined
9676                            || hash->elf.root.type == bfd_link_hash_defweak)
9677                     {
9678                       sym_value = hash->elf.root.u.def.value;
9679                       if (sym_sec->output_section != NULL)
9680                         ok_dest = TRUE;
9681                     }
9682                   else if (hash->elf.root.type == bfd_link_hash_undefweak
9683                            || hash->elf.root.type == bfd_link_hash_undefined)
9684                     {
9685                       /* Recognise an old ABI func code entry sym, and
9686                          use the func descriptor sym instead if it is
9687                          defined.  */
9688                       if (hash->elf.root.root.string[0] == '.'
9689                           && (fdh = get_fdh (hash, htab)) != NULL)
9690                         {
9691                           if (fdh->elf.root.type == bfd_link_hash_defined
9692                               || fdh->elf.root.type == bfd_link_hash_defweak)
9693                             {
9694                               sym_sec = fdh->elf.root.u.def.section;
9695                               sym_value = fdh->elf.root.u.def.value;
9696                               if (sym_sec->output_section != NULL)
9697                                 ok_dest = TRUE;
9698                             }
9699                           else
9700                             fdh = NULL;
9701                         }
9702                     }
9703                   else
9704                     {
9705                       bfd_set_error (bfd_error_bad_value);
9706                       goto error_ret_free_internal;
9707                     }
9708
9709                   destination = 0;
9710                   if (ok_dest)
9711                     {
9712                       sym_value += irela->r_addend;
9713                       destination = (sym_value
9714                                      + sym_sec->output_offset
9715                                      + sym_sec->output_section->vma);
9716                     }
9717
9718                   code_sec = sym_sec;
9719                   opd = get_opd_info (sym_sec);
9720                   if (opd != NULL)
9721                     {
9722                       bfd_vma dest;
9723
9724                       if (hash == NULL && opd->adjust != NULL)
9725                         {
9726                           long adjust = opd->adjust[sym_value / 8];
9727                           if (adjust == -1)
9728                             continue;
9729                           sym_value += adjust;
9730                         }
9731                       dest = opd_entry_value (sym_sec, sym_value,
9732                                               &code_sec, &sym_value);
9733                       if (dest != (bfd_vma) -1)
9734                         {
9735                           destination = dest;
9736                           if (fdh != NULL)
9737                             {
9738                               /* Fixup old ABI sym to point at code
9739                                  entry.  */
9740                               hash->elf.root.type = bfd_link_hash_defweak;
9741                               hash->elf.root.u.def.section = code_sec;
9742                               hash->elf.root.u.def.value = sym_value;
9743                             }
9744                         }
9745                     }
9746
9747                   /* Determine what (if any) linker stub is needed.  */
9748                   stub_type = ppc_type_of_stub (section, irela, &hash,
9749                                                 destination);
9750
9751                   if (stub_type != ppc_stub_plt_call)
9752                     {
9753                       /* Check whether we need a TOC adjusting stub.
9754                          Since the linker pastes together pieces from
9755                          different object files when creating the
9756                          _init and _fini functions, it may be that a
9757                          call to what looks like a local sym is in
9758                          fact a call needing a TOC adjustment.  */
9759                       if (code_sec != NULL
9760                           && code_sec->output_section != NULL
9761                           && (htab->stub_group[code_sec->id].toc_off
9762                               != htab->stub_group[section->id].toc_off)
9763                           && (code_sec->has_toc_reloc
9764                               || code_sec->makes_toc_func_call))
9765                         stub_type = ppc_stub_long_branch_r2off;
9766                     }
9767
9768                   if (stub_type == ppc_stub_none)
9769                     continue;
9770
9771                   /* __tls_get_addr calls might be eliminated.  */
9772                   if (stub_type != ppc_stub_plt_call
9773                       && hash != NULL
9774                       && (hash == htab->tls_get_addr
9775                           || hash == htab->tls_get_addr_fd)
9776                       && section->has_tls_reloc
9777                       && irela != internal_relocs)
9778                     {
9779                       /* Get tls info.  */
9780                       char *tls_mask;
9781
9782                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
9783                                          irela - 1, input_bfd))
9784                         goto error_ret_free_internal;
9785                       if (*tls_mask != 0)
9786                         continue;
9787                     }
9788
9789                   /* Support for grouping stub sections.  */
9790                   id_sec = htab->stub_group[section->id].link_sec;
9791
9792                   /* Get the name of this stub.  */
9793                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9794                   if (!stub_name)
9795                     goto error_ret_free_internal;
9796
9797                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
9798                                                      stub_name, FALSE, FALSE);
9799                   if (stub_entry != NULL)
9800                     {
9801                       /* The proper stub has already been created.  */
9802                       free (stub_name);
9803                       continue;
9804                     }
9805
9806                   stub_entry = ppc_add_stub (stub_name, section, htab);
9807                   if (stub_entry == NULL)
9808                     {
9809                       free (stub_name);
9810                     error_ret_free_internal:
9811                       if (elf_section_data (section)->relocs == NULL)
9812                         free (internal_relocs);
9813                     error_ret_free_local:
9814                       if (local_syms != NULL
9815                           && (symtab_hdr->contents
9816                               != (unsigned char *) local_syms))
9817                         free (local_syms);
9818                       return FALSE;
9819                     }
9820
9821                   stub_entry->stub_type = stub_type;
9822                   stub_entry->target_value = sym_value;
9823                   stub_entry->target_section = code_sec;
9824                   stub_entry->h = hash;
9825                   stub_entry->addend = irela->r_addend;
9826
9827                   if (stub_entry->h != NULL)
9828                     htab->stub_globals += 1;
9829                 }
9830
9831               /* We're done with the internal relocs, free them.  */
9832               if (elf_section_data (section)->relocs != internal_relocs)
9833                 free (internal_relocs);
9834             }
9835
9836           if (local_syms != NULL
9837               && symtab_hdr->contents != (unsigned char *) local_syms)
9838             {
9839               if (!info->keep_memory)
9840                 free (local_syms);
9841               else
9842                 symtab_hdr->contents = (unsigned char *) local_syms;
9843             }
9844         }
9845
9846       /* We may have added some stubs.  Find out the new size of the
9847          stub sections.  */
9848       for (stub_sec = htab->stub_bfd->sections;
9849            stub_sec != NULL;
9850            stub_sec = stub_sec->next)
9851         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9852           {
9853             stub_sec->rawsize = stub_sec->size;
9854             stub_sec->size = 0;
9855             stub_sec->reloc_count = 0;
9856             stub_sec->flags &= ~SEC_RELOC;
9857           }
9858
9859       htab->brlt->size = 0;
9860       htab->brlt->reloc_count = 0;
9861       htab->brlt->flags &= ~SEC_RELOC;
9862       if (htab->relbrlt != NULL)
9863         htab->relbrlt->size = 0;
9864
9865       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
9866
9867       if (info->emitrelocations
9868           && htab->glink != NULL && htab->glink->size != 0)
9869         {
9870           htab->glink->reloc_count = 1;
9871           htab->glink->flags |= SEC_RELOC;
9872         }
9873
9874       for (stub_sec = htab->stub_bfd->sections;
9875            stub_sec != NULL;
9876            stub_sec = stub_sec->next)
9877         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9878             && stub_sec->rawsize != stub_sec->size)
9879           break;
9880
9881       /* Exit from this loop when no stubs have been added, and no stubs
9882          have changed size.  */
9883       if (stub_sec == NULL)
9884         break;
9885
9886       /* Ask the linker to do its stuff.  */
9887       (*htab->layout_sections_again) ();
9888     }
9889
9890   /* It would be nice to strip htab->brlt from the output if the
9891      section is empty, but it's too late.  If we strip sections here,
9892      the dynamic symbol table is corrupted since the section symbol
9893      for the stripped section isn't written.  */
9894
9895   return TRUE;
9896 }
9897
9898 /* Called after we have determined section placement.  If sections
9899    move, we'll be called again.  Provide a value for TOCstart.  */
9900
9901 bfd_vma
9902 ppc64_elf_toc (bfd *obfd)
9903 {
9904   asection *s;
9905   bfd_vma TOCstart;
9906
9907   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9908      order.  The TOC starts where the first of these sections starts.  */
9909   s = bfd_get_section_by_name (obfd, ".got");
9910   if (s == NULL)
9911     s = bfd_get_section_by_name (obfd, ".toc");
9912   if (s == NULL)
9913     s = bfd_get_section_by_name (obfd, ".tocbss");
9914   if (s == NULL)
9915     s = bfd_get_section_by_name (obfd, ".plt");
9916   if (s == NULL)
9917     {
9918       /* This may happen for
9919          o  references to TOC base (SYM@toc / TOC[tc0]) without a
9920          .toc directive
9921          o  bad linker script
9922          o --gc-sections and empty TOC sections
9923
9924          FIXME: Warn user?  */
9925
9926       /* Look for a likely section.  We probably won't even be
9927          using TOCstart.  */
9928       for (s = obfd->sections; s != NULL; s = s->next)
9929         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9930             == (SEC_ALLOC | SEC_SMALL_DATA))
9931           break;
9932       if (s == NULL)
9933         for (s = obfd->sections; s != NULL; s = s->next)
9934           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9935               == (SEC_ALLOC | SEC_SMALL_DATA))
9936             break;
9937       if (s == NULL)
9938         for (s = obfd->sections; s != NULL; s = s->next)
9939           if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9940             break;
9941       if (s == NULL)
9942         for (s = obfd->sections; s != NULL; s = s->next)
9943           if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9944             break;
9945     }
9946
9947   TOCstart = 0;
9948   if (s != NULL)
9949     TOCstart = s->output_section->vma + s->output_offset;
9950
9951   return TOCstart;
9952 }
9953
9954 /* Build all the stubs associated with the current output file.
9955    The stubs are kept in a hash table attached to the main linker
9956    hash table.  This function is called via gldelf64ppc_finish.  */
9957
9958 bfd_boolean
9959 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9960                        struct bfd_link_info *info,
9961                        char **stats)
9962 {
9963   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9964   asection *stub_sec;
9965   bfd_byte *p;
9966   int stub_sec_count = 0;
9967
9968   htab->emit_stub_syms = emit_stub_syms;
9969
9970   /* Allocate memory to hold the linker stubs.  */
9971   for (stub_sec = htab->stub_bfd->sections;
9972        stub_sec != NULL;
9973        stub_sec = stub_sec->next)
9974     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9975         && stub_sec->size != 0)
9976       {
9977         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9978         if (stub_sec->contents == NULL)
9979           return FALSE;
9980         /* We want to check that built size is the same as calculated
9981            size.  rawsize is a convenient location to use.  */
9982         stub_sec->rawsize = stub_sec->size;
9983         stub_sec->size = 0;
9984       }
9985
9986   if (htab->glink != NULL && htab->glink->size != 0)
9987     {
9988       unsigned int indx;
9989       bfd_vma plt0;
9990
9991       /* Build the .glink plt call stub.  */
9992       if (htab->emit_stub_syms)
9993         {
9994           struct elf_link_hash_entry *h;
9995           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
9996                                     TRUE, FALSE, FALSE);
9997           if (h == NULL)
9998             return FALSE;
9999           if (h->root.type == bfd_link_hash_new)
10000             {
10001               h->root.type = bfd_link_hash_defined;
10002               h->root.u.def.section = htab->glink;
10003               h->root.u.def.value = 8;
10004               h->ref_regular = 1;
10005               h->def_regular = 1;
10006               h->ref_regular_nonweak = 1;
10007               h->forced_local = 1;
10008               h->non_elf = 0;
10009             }
10010         }
10011       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10012       if (info->emitrelocations)
10013         {
10014           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10015           if (r == NULL)
10016             return FALSE;
10017           r->r_offset = (htab->glink->output_offset
10018                          + htab->glink->output_section->vma);
10019           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10020           r->r_addend = plt0;
10021         }
10022       p = htab->glink->contents;
10023       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
10024       bfd_put_64 (htab->glink->owner, plt0, p);
10025       p += 8;
10026       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
10027       p += 4;
10028       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
10029       p += 4;
10030       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
10031       p += 4;
10032       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
10033       p += 4;
10034       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
10035       p += 4;
10036       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
10037       p += 4;
10038       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
10039       p += 4;
10040       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
10041       p += 4;
10042       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
10043       p += 4;
10044       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
10045       p += 4;
10046       bfd_put_32 (htab->glink->owner, BCTR, p);
10047       p += 4;
10048       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10049         {
10050           bfd_put_32 (htab->glink->owner, NOP, p);
10051           p += 4;
10052         }
10053
10054       /* Build the .glink lazy link call stubs.  */
10055       indx = 0;
10056       while (p < htab->glink->contents + htab->glink->size)
10057         {
10058           if (indx < 0x8000)
10059             {
10060               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
10061               p += 4;
10062             }
10063           else
10064             {
10065               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
10066               p += 4;
10067               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
10068               p += 4;
10069             }
10070           bfd_put_32 (htab->glink->owner,
10071                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
10072           indx++;
10073           p += 4;
10074         }
10075       htab->glink->rawsize = p - htab->glink->contents;
10076     }
10077
10078   if (htab->brlt->size != 0)
10079     {
10080       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
10081                                          htab->brlt->size);
10082       if (htab->brlt->contents == NULL)
10083         return FALSE;
10084     }
10085   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
10086     {
10087       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
10088                                             htab->relbrlt->size);
10089       if (htab->relbrlt->contents == NULL)
10090         return FALSE;
10091     }
10092
10093   /* Build the stubs as directed by the stub hash table.  */
10094   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
10095
10096   if (htab->relbrlt != NULL)
10097     htab->relbrlt->reloc_count = 0;
10098
10099   for (stub_sec = htab->stub_bfd->sections;
10100        stub_sec != NULL;
10101        stub_sec = stub_sec->next)
10102     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10103       {
10104         stub_sec_count += 1;
10105         if (stub_sec->rawsize != stub_sec->size)
10106           break;
10107       }
10108
10109   if (stub_sec != NULL
10110       || htab->glink->rawsize != htab->glink->size)
10111     {
10112       htab->stub_error = TRUE;
10113       (*_bfd_error_handler) (_("stubs don't match calculated size"));
10114     }
10115
10116   if (htab->stub_error)
10117     return FALSE;
10118
10119   if (stats != NULL)
10120     {
10121       *stats = bfd_malloc (500);
10122       if (*stats == NULL)
10123         return FALSE;
10124
10125       sprintf (*stats, _("linker stubs in %u group%s\n"
10126                          "  branch       %lu\n"
10127                          "  toc adjust   %lu\n"
10128                          "  long branch  %lu\n"
10129                          "  long toc adj %lu\n"
10130                          "  plt call     %lu"),
10131                stub_sec_count,
10132                stub_sec_count == 1 ? "" : "s",
10133                htab->stub_count[ppc_stub_long_branch - 1],
10134                htab->stub_count[ppc_stub_long_branch_r2off - 1],
10135                htab->stub_count[ppc_stub_plt_branch - 1],
10136                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
10137                htab->stub_count[ppc_stub_plt_call - 1]);
10138     }
10139   return TRUE;
10140 }
10141
10142 /* This function undoes the changes made by add_symbol_adjust.  */
10143
10144 static bfd_boolean
10145 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10146 {
10147   struct ppc_link_hash_entry *eh;
10148
10149   if (h->root.type == bfd_link_hash_indirect)
10150     return TRUE;
10151
10152   if (h->root.type == bfd_link_hash_warning)
10153     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10154
10155   eh = (struct ppc_link_hash_entry *) h;
10156   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
10157     return TRUE;
10158
10159   eh->elf.root.type = bfd_link_hash_undefined;
10160   return TRUE;
10161 }
10162
10163 void
10164 ppc64_elf_restore_symbols (struct bfd_link_info *info)
10165 {
10166   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10167   elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
10168 }
10169
10170 /* What to do when ld finds relocations against symbols defined in
10171    discarded sections.  */
10172
10173 static unsigned int
10174 ppc64_elf_action_discarded (asection *sec)
10175 {
10176   if (strcmp (".opd", sec->name) == 0)
10177     return 0;
10178
10179   if (strcmp (".toc", sec->name) == 0)
10180     return 0;
10181
10182   if (strcmp (".toc1", sec->name) == 0)
10183     return 0;
10184
10185   return _bfd_elf_default_action_discarded (sec);
10186 }
10187
10188 /* The RELOCATE_SECTION function is called by the ELF backend linker
10189    to handle the relocations for a section.
10190
10191    The relocs are always passed as Rela structures; if the section
10192    actually uses Rel structures, the r_addend field will always be
10193    zero.
10194
10195    This function is responsible for adjust the section contents as
10196    necessary, and (if using Rela relocs and generating a
10197    relocatable output file) adjusting the reloc addend as
10198    necessary.
10199
10200    This function does not have to worry about setting the reloc
10201    address or the reloc symbol index.
10202
10203    LOCAL_SYMS is a pointer to the swapped in local symbols.
10204
10205    LOCAL_SECTIONS is an array giving the section in the input file
10206    corresponding to the st_shndx field of each local symbol.
10207
10208    The global hash table entry for the global symbols can be found
10209    via elf_sym_hashes (input_bfd).
10210
10211    When generating relocatable output, this function must handle
10212    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
10213    going to be the section symbol corresponding to the output
10214    section, which means that the addend must be adjusted
10215    accordingly.  */
10216
10217 static bfd_boolean
10218 ppc64_elf_relocate_section (bfd *output_bfd,
10219                             struct bfd_link_info *info,
10220                             bfd *input_bfd,
10221                             asection *input_section,
10222                             bfd_byte *contents,
10223                             Elf_Internal_Rela *relocs,
10224                             Elf_Internal_Sym *local_syms,
10225                             asection **local_sections)
10226 {
10227   struct ppc_link_hash_table *htab;
10228   Elf_Internal_Shdr *symtab_hdr;
10229   struct elf_link_hash_entry **sym_hashes;
10230   Elf_Internal_Rela *rel;
10231   Elf_Internal_Rela *relend;
10232   Elf_Internal_Rela outrel;
10233   bfd_byte *loc;
10234   struct got_entry **local_got_ents;
10235   bfd_vma TOCstart;
10236   bfd_boolean ret = TRUE;
10237   bfd_boolean is_opd;
10238   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
10239   bfd_boolean is_power4 = FALSE;
10240   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
10241
10242   /* Initialize howto table if needed.  */
10243   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
10244     ppc_howto_init ();
10245
10246   htab = ppc_hash_table (info);
10247
10248   /* Don't relocate stub sections.  */
10249   if (input_section->owner == htab->stub_bfd)
10250     return TRUE;
10251
10252   BFD_ASSERT (is_ppc64_elf (input_bfd));
10253
10254   local_got_ents = elf_local_got_ents (input_bfd);
10255   TOCstart = elf_gp (output_bfd);
10256   symtab_hdr = &elf_symtab_hdr (input_bfd);
10257   sym_hashes = elf_sym_hashes (input_bfd);
10258   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
10259
10260   rel = relocs;
10261   relend = relocs + input_section->reloc_count;
10262   for (; rel < relend; rel++)
10263     {
10264       enum elf_ppc64_reloc_type r_type;
10265       bfd_vma addend, orig_addend;
10266       bfd_reloc_status_type r;
10267       Elf_Internal_Sym *sym;
10268       asection *sec;
10269       struct elf_link_hash_entry *h_elf;
10270       struct ppc_link_hash_entry *h;
10271       struct ppc_link_hash_entry *fdh;
10272       const char *sym_name;
10273       unsigned long r_symndx, toc_symndx;
10274       bfd_vma toc_addend;
10275       char tls_mask, tls_gd, tls_type;
10276       char sym_type;
10277       bfd_vma relocation;
10278       bfd_boolean unresolved_reloc;
10279       bfd_boolean warned;
10280       unsigned long insn, mask;
10281       struct ppc_stub_hash_entry *stub_entry;
10282       bfd_vma max_br_offset;
10283       bfd_vma from;
10284
10285       r_type = ELF64_R_TYPE (rel->r_info);
10286       r_symndx = ELF64_R_SYM (rel->r_info);
10287
10288       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10289          symbol of the previous ADDR64 reloc.  The symbol gives us the
10290          proper TOC base to use.  */
10291       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10292           && rel != relocs
10293           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10294           && is_opd)
10295         r_symndx = ELF64_R_SYM (rel[-1].r_info);
10296
10297       sym = NULL;
10298       sec = NULL;
10299       h_elf = NULL;
10300       sym_name = NULL;
10301       unresolved_reloc = FALSE;
10302       warned = FALSE;
10303       orig_addend = rel->r_addend;
10304
10305       if (r_symndx < symtab_hdr->sh_info)
10306         {
10307           /* It's a local symbol.  */
10308           struct _opd_sec_data *opd;
10309
10310           sym = local_syms + r_symndx;
10311           sec = local_sections[r_symndx];
10312           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
10313           sym_type = ELF64_ST_TYPE (sym->st_info);
10314           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10315           opd = get_opd_info (sec);
10316           if (opd != NULL && opd->adjust != NULL)
10317             {
10318               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
10319               if (adjust == -1)
10320                 relocation = 0;
10321               else
10322                 {
10323                   /* If this is a relocation against the opd section sym
10324                      and we have edited .opd, adjust the reloc addend so
10325                      that ld -r and ld --emit-relocs output is correct.
10326                      If it is a reloc against some other .opd symbol,
10327                      then the symbol value will be adjusted later.  */
10328                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10329                     rel->r_addend += adjust;
10330                   else
10331                     relocation += adjust;
10332                 }
10333             }
10334         }
10335       else
10336         {
10337           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10338                                    r_symndx, symtab_hdr, sym_hashes,
10339                                    h_elf, sec, relocation,
10340                                    unresolved_reloc, warned);
10341           sym_name = h_elf->root.root.string;
10342           sym_type = h_elf->type;
10343         }
10344       h = (struct ppc_link_hash_entry *) h_elf;
10345
10346       if (sec != NULL && elf_discarded_section (sec))
10347         {
10348           /* For relocs against symbols from removed linkonce sections,
10349              or sections discarded by a linker script, we just want the
10350              section contents zeroed.  Avoid any special processing.  */
10351           _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10352                                contents + rel->r_offset);
10353           rel->r_info = 0;
10354           rel->r_addend = 0;
10355           continue;
10356         }
10357
10358       if (info->relocatable)
10359         continue;
10360
10361       /* TLS optimizations.  Replace instruction sequences and relocs
10362          based on information we collected in tls_optimize.  We edit
10363          RELOCS so that --emit-relocs will output something sensible
10364          for the final instruction stream.  */
10365       tls_mask = 0;
10366       tls_gd = 0;
10367       toc_symndx = 0;
10368       if (h != NULL)
10369         tls_mask = h->tls_mask;
10370       else if (local_got_ents != NULL)
10371         {
10372           char *lgot_masks;
10373           lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
10374           tls_mask = lgot_masks[r_symndx];
10375         }
10376       if (tls_mask == 0
10377           && (r_type == R_PPC64_TLS
10378               || r_type == R_PPC64_TLSGD
10379               || r_type == R_PPC64_TLSLD))
10380         {
10381           /* Check for toc tls entries.  */
10382           char *toc_tls;
10383
10384           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10385                              &local_syms, rel, input_bfd))
10386             return FALSE;
10387
10388           if (toc_tls)
10389             tls_mask = *toc_tls;
10390         }
10391
10392       /* Check that tls relocs are used with tls syms, and non-tls
10393          relocs are used with non-tls syms.  */
10394       if (r_symndx != 0
10395           && r_type != R_PPC64_NONE
10396           && (h == NULL
10397               || h->elf.root.type == bfd_link_hash_defined
10398               || h->elf.root.type == bfd_link_hash_defweak)
10399           && (IS_PPC64_TLS_RELOC (r_type)
10400               != (sym_type == STT_TLS
10401                   || (sym_type == STT_SECTION
10402                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
10403         {
10404           if (tls_mask != 0
10405               && (r_type == R_PPC64_TLS
10406                   || r_type == R_PPC64_TLSGD
10407                   || r_type == R_PPC64_TLSLD))
10408             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
10409             ;
10410           else
10411             (*_bfd_error_handler)
10412               (!IS_PPC64_TLS_RELOC (r_type)
10413                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10414                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10415                input_bfd,
10416                input_section,
10417                (long) rel->r_offset,
10418                ppc64_elf_howto_table[r_type]->name,
10419                sym_name);
10420         }
10421
10422       /* Ensure reloc mapping code below stays sane.  */
10423       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10424           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10425           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
10426           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10427           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10428           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10429           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
10430           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10431           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10432           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10433         abort ();
10434
10435       switch (r_type)
10436         {
10437         default:
10438           break;
10439
10440         case R_PPC64_TOC16:
10441         case R_PPC64_TOC16_LO:
10442         case R_PPC64_TOC16_DS:
10443         case R_PPC64_TOC16_LO_DS:
10444           {
10445             /* Check for toc tls entries.  */
10446             char *toc_tls;
10447             int retval;
10448
10449             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10450                                    &local_syms, rel, input_bfd);
10451             if (retval == 0)
10452               return FALSE;
10453
10454             if (toc_tls)
10455               {
10456                 tls_mask = *toc_tls;
10457                 if (r_type == R_PPC64_TOC16_DS
10458                     || r_type == R_PPC64_TOC16_LO_DS)
10459                   {
10460                     if (tls_mask != 0
10461                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10462                       goto toctprel;
10463                   }
10464                 else
10465                   {
10466                     /* If we found a GD reloc pair, then we might be
10467                        doing a GD->IE transition.  */
10468                     if (retval == 2)
10469                       {
10470                         tls_gd = TLS_TPRELGD;
10471                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10472                           goto tls_ldgd_opt;
10473                       }
10474                     else if (retval == 3)
10475                       {
10476                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10477                           goto tls_ldgd_opt;
10478                       }
10479                   }
10480               }
10481           }
10482           break;
10483
10484         case R_PPC64_GOT_TPREL16_DS:
10485         case R_PPC64_GOT_TPREL16_LO_DS:
10486           if (tls_mask != 0
10487               && (tls_mask & TLS_TPREL) == 0)
10488             {
10489             toctprel:
10490               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
10491               insn &= 31 << 21;
10492               insn |= 0x3c0d0000;       /* addis 0,13,0 */
10493               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
10494               r_type = R_PPC64_TPREL16_HA;
10495               if (toc_symndx != 0)
10496                 {
10497                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10498                   rel->r_addend = toc_addend;
10499                   /* We changed the symbol.  Start over in order to
10500                      get h, sym, sec etc. right.  */
10501                   rel--;
10502                   continue;
10503                 }
10504               else
10505                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10506             }
10507           break;
10508
10509         case R_PPC64_TLS:
10510           if (tls_mask != 0
10511               && (tls_mask & TLS_TPREL) == 0)
10512             {
10513               bfd_vma rtra;
10514               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
10515               if ((insn & ((0x3f << 26) | (31 << 11)))
10516                   == ((31 << 26) | (13 << 11)))
10517                 rtra = insn & ((1 << 26) - (1 << 16));
10518               else if ((insn & ((0x3f << 26) | (31 << 16)))
10519                        == ((31 << 26) | (13 << 16)))
10520                 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
10521               else
10522                 abort ();
10523               if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
10524                 /* add -> addi.  */
10525                 insn = 14 << 26;
10526               else if ((insn & (31 << 1)) == 23 << 1
10527                        && ((insn & (31 << 6)) < 14 << 6
10528                            || ((insn & (31 << 6)) >= 16 << 6
10529                                && (insn & (31 << 6)) < 24 << 6)))
10530                 /* load and store indexed -> dform.  */
10531                 insn = (32 | ((insn >> 6) & 31)) << 26;
10532               else if ((insn & (31 << 1)) == 21 << 1
10533                        && (insn & (0x1a << 6)) == 0)
10534                 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu.  */
10535                 insn = (((58 | ((insn >> 6) & 4)) << 26)
10536                         | ((insn >> 6) & 1));
10537               else if ((insn & (31 << 1)) == 21 << 1
10538                        && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10539                 /* lwax -> lwa.  */
10540                 insn = (58 << 26) | 2;
10541               else
10542                 abort ();
10543               insn |= rtra;
10544               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10545               /* Was PPC64_TLS which sits on insn boundary, now
10546                  PPC64_TPREL16_LO which is at low-order half-word.  */
10547               rel->r_offset += d_offset;
10548               r_type = R_PPC64_TPREL16_LO;
10549               if (toc_symndx != 0)
10550                 {
10551                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10552                   rel->r_addend = toc_addend;
10553                   /* We changed the symbol.  Start over in order to
10554                      get h, sym, sec etc. right.  */
10555                   rel--;
10556                   continue;
10557                 }
10558               else
10559                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10560             }
10561           break;
10562
10563         case R_PPC64_GOT_TLSGD16_HI:
10564         case R_PPC64_GOT_TLSGD16_HA:
10565           tls_gd = TLS_TPRELGD;
10566           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10567             goto tls_gdld_hi;
10568           break;
10569
10570         case R_PPC64_GOT_TLSLD16_HI:
10571         case R_PPC64_GOT_TLSLD16_HA:
10572           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10573             {
10574             tls_gdld_hi:
10575               if ((tls_mask & tls_gd) != 0)
10576                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10577                           + R_PPC64_GOT_TPREL16_DS);
10578               else
10579                 {
10580                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10581                   rel->r_offset -= d_offset;
10582                   r_type = R_PPC64_NONE;
10583                 }
10584               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10585             }
10586           break;
10587
10588         case R_PPC64_GOT_TLSGD16:
10589         case R_PPC64_GOT_TLSGD16_LO:
10590           tls_gd = TLS_TPRELGD;
10591           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10592             goto tls_ldgd_opt;
10593           break;
10594
10595         case R_PPC64_GOT_TLSLD16:
10596         case R_PPC64_GOT_TLSLD16_LO:
10597           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10598             {
10599               unsigned int insn1, insn2, insn3;
10600               bfd_vma offset;
10601
10602             tls_ldgd_opt:
10603               offset = (bfd_vma) -1;
10604               /* If not using the newer R_PPC64_TLSGD/LD to mark
10605                  __tls_get_addr calls, we must trust that the call
10606                  stays with its arg setup insns, ie. that the next
10607                  reloc is the __tls_get_addr call associated with
10608                  the current reloc.  Edit both insns.  */
10609               if (input_section->has_tls_get_addr_call
10610                   && rel + 1 < relend
10611                   && branch_reloc_hash_match (input_bfd, rel + 1,
10612                                               htab->tls_get_addr,
10613                                               htab->tls_get_addr_fd))
10614                 offset = rel[1].r_offset;
10615               if ((tls_mask & tls_gd) != 0)
10616                 {
10617                   /* IE */
10618                   insn1 = bfd_get_32 (output_bfd,
10619                                       contents + rel->r_offset - d_offset);
10620                   insn1 &= (1 << 26) - (1 << 2);
10621                   insn1 |= 58 << 26;    /* ld */
10622                   insn2 = 0x7c636a14;   /* add 3,3,13 */
10623                   if (offset != (bfd_vma) -1)
10624                     rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10625                                                   R_PPC64_NONE);
10626                   if ((tls_mask & TLS_EXPLICIT) == 0)
10627                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10628                               + R_PPC64_GOT_TPREL16_DS);
10629                   else
10630                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10631                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10632                 }
10633               else
10634                 {
10635                   /* LE */
10636                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
10637                   insn2 = 0x38630000;   /* addi 3,3,0 */
10638                   if (tls_gd == 0)
10639                     {
10640                       /* Was an LD reloc.  */
10641                       if (toc_symndx)
10642                         sec = local_sections[toc_symndx];
10643                       for (r_symndx = 0;
10644                            r_symndx < symtab_hdr->sh_info;
10645                            r_symndx++)
10646                         if (local_sections[r_symndx] == sec)
10647                           break;
10648                       if (r_symndx >= symtab_hdr->sh_info)
10649                         r_symndx = 0;
10650                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10651                       if (r_symndx != 0)
10652                         rel->r_addend -= (local_syms[r_symndx].st_value
10653                                           + sec->output_offset
10654                                           + sec->output_section->vma);
10655                     }
10656                   else if (toc_symndx != 0)
10657                     {
10658                       r_symndx = toc_symndx;
10659                       rel->r_addend = toc_addend;
10660                     }
10661                   r_type = R_PPC64_TPREL16_HA;
10662                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10663                   if (offset != (bfd_vma) -1)
10664                     {
10665                       rel[1].r_info = ELF64_R_INFO (r_symndx,
10666                                                     R_PPC64_TPREL16_LO);
10667                       rel[1].r_offset = offset + d_offset;
10668                       rel[1].r_addend = rel->r_addend;
10669                     }
10670                 }
10671               bfd_put_32 (output_bfd, insn1,
10672                           contents + rel->r_offset - d_offset);
10673               if (offset != (bfd_vma) -1)
10674                 {
10675                   insn3 = bfd_get_32 (output_bfd,
10676                                       contents + offset + 4);
10677                   if (insn3 == NOP
10678                       || insn3 == CROR_151515 || insn3 == CROR_313131)
10679                     {
10680                       rel[1].r_offset += 4;
10681                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10682                       insn2 = NOP;
10683                     }
10684                   bfd_put_32 (output_bfd, insn2, contents + offset);
10685                 }
10686               if ((tls_mask & tls_gd) == 0
10687                   && (tls_gd == 0 || toc_symndx != 0))
10688                 {
10689                   /* We changed the symbol.  Start over in order
10690                      to get h, sym, sec etc. right.  */
10691                   rel--;
10692                   continue;
10693                 }
10694             }
10695           break;
10696
10697         case R_PPC64_TLSGD:
10698           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10699             {
10700               unsigned int insn2, insn3;
10701               bfd_vma offset = rel->r_offset;
10702
10703               if ((tls_mask & TLS_TPRELGD) != 0)
10704                 {
10705                   /* IE */
10706                   r_type = R_PPC64_NONE;
10707                   insn2 = 0x7c636a14;   /* add 3,3,13 */
10708                 }
10709               else
10710                 {
10711                   /* LE */
10712                   if (toc_symndx != 0)
10713                     {
10714                       r_symndx = toc_symndx;
10715                       rel->r_addend = toc_addend;
10716                     }
10717                   r_type = R_PPC64_TPREL16_LO;
10718                   rel->r_offset = offset + d_offset;
10719                   insn2 = 0x38630000;   /* addi 3,3,0 */
10720                 }
10721               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10722               /* Zap the reloc on the _tls_get_addr call too.  */
10723               BFD_ASSERT (offset == rel[1].r_offset);
10724               rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10725                                             R_PPC64_NONE);
10726               insn3 = bfd_get_32 (output_bfd,
10727                                   contents + offset + 4);
10728               if (insn3 == NOP
10729                   || insn3 == CROR_151515 || insn3 == CROR_313131)
10730                 {
10731                   rel->r_offset += 4;
10732                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10733                   insn2 = NOP;
10734                 }
10735               bfd_put_32 (output_bfd, insn2, contents + offset);
10736               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
10737                 {
10738                   rel--;
10739                   continue;
10740                 }
10741             }
10742           break;
10743
10744         case R_PPC64_TLSLD:
10745           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10746             {
10747               unsigned int insn2, insn3;
10748               bfd_vma offset = rel->r_offset;
10749
10750               if (toc_symndx)
10751                 sec = local_sections[toc_symndx];
10752               for (r_symndx = 0;
10753                    r_symndx < symtab_hdr->sh_info;
10754                    r_symndx++)
10755                 if (local_sections[r_symndx] == sec)
10756                   break;
10757               if (r_symndx >= symtab_hdr->sh_info)
10758                 r_symndx = 0;
10759               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10760               if (r_symndx != 0)
10761                 rel->r_addend -= (local_syms[r_symndx].st_value
10762                                   + sec->output_offset
10763                                   + sec->output_section->vma);
10764
10765               r_type = R_PPC64_TPREL16_LO;
10766               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10767               rel->r_offset = offset + d_offset;
10768               /* Zap the reloc on the _tls_get_addr call too.  */
10769               BFD_ASSERT (offset == rel[1].r_offset);
10770               rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10771                                             R_PPC64_NONE);
10772               insn2 = 0x38630000;       /* addi 3,3,0 */
10773               insn3 = bfd_get_32 (output_bfd,
10774                                   contents + offset + 4);
10775               if (insn3 == NOP
10776                   || insn3 == CROR_151515 || insn3 == CROR_313131)
10777                 {
10778                   rel->r_offset += 4;
10779                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10780                   insn2 = NOP;
10781                 }
10782               bfd_put_32 (output_bfd, insn2, contents + offset);
10783               rel--;
10784               continue;
10785             }
10786           break;
10787
10788         case R_PPC64_DTPMOD64:
10789           if (rel + 1 < relend
10790               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10791               && rel[1].r_offset == rel->r_offset + 8)
10792             {
10793               if ((tls_mask & TLS_GD) == 0)
10794                 {
10795                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10796                   if ((tls_mask & TLS_TPRELGD) != 0)
10797                     r_type = R_PPC64_TPREL64;
10798                   else
10799                     {
10800                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10801                       r_type = R_PPC64_NONE;
10802                     }
10803                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10804                 }
10805             }
10806           else
10807             {
10808               if ((tls_mask & TLS_LD) == 0)
10809                 {
10810                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10811                   r_type = R_PPC64_NONE;
10812                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10813                 }
10814             }
10815           break;
10816
10817         case R_PPC64_TPREL64:
10818           if ((tls_mask & TLS_TPREL) == 0)
10819             {
10820               r_type = R_PPC64_NONE;
10821               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10822             }
10823           break;
10824         }
10825
10826       /* Handle other relocations that tweak non-addend part of insn.  */
10827       insn = 0;
10828       max_br_offset = 1 << 25;
10829       addend = rel->r_addend;
10830       switch (r_type)
10831         {
10832         default:
10833           break;
10834
10835           /* Branch taken prediction relocations.  */
10836         case R_PPC64_ADDR14_BRTAKEN:
10837         case R_PPC64_REL14_BRTAKEN:
10838           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
10839           /* Fall thru.  */
10840
10841           /* Branch not taken prediction relocations.  */
10842         case R_PPC64_ADDR14_BRNTAKEN:
10843         case R_PPC64_REL14_BRNTAKEN:
10844           insn |= bfd_get_32 (output_bfd,
10845                               contents + rel->r_offset) & ~(0x01 << 21);
10846           /* Fall thru.  */
10847
10848         case R_PPC64_REL14:
10849           max_br_offset = 1 << 15;
10850           /* Fall thru.  */
10851
10852         case R_PPC64_REL24:
10853           /* Calls to functions with a different TOC, such as calls to
10854              shared objects, need to alter the TOC pointer.  This is
10855              done using a linkage stub.  A REL24 branching to these
10856              linkage stubs needs to be followed by a nop, as the nop
10857              will be replaced with an instruction to restore the TOC
10858              base pointer.  */
10859           stub_entry = NULL;
10860           fdh = h;
10861           if (((h != NULL
10862                 && (((fdh = h->oh) != NULL
10863                      && fdh->elf.plt.plist != NULL)
10864                     || (fdh = h)->elf.plt.plist != NULL))
10865                || (sec != NULL
10866                    && sec->output_section != NULL
10867                    && sec->id <= htab->top_id
10868                    && (htab->stub_group[sec->id].toc_off
10869                        != htab->stub_group[input_section->id].toc_off)))
10870               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10871                                                    rel, htab)) != NULL
10872               && (stub_entry->stub_type == ppc_stub_plt_call
10873                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10874                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10875             {
10876               bfd_boolean can_plt_call = FALSE;
10877
10878               if (rel->r_offset + 8 <= input_section->size)
10879                 {
10880                   unsigned long nop;
10881                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10882                   if (nop == NOP
10883                       || nop == CROR_151515 || nop == CROR_313131)
10884                     {
10885                       bfd_put_32 (input_bfd, LD_R2_40R1,
10886                                   contents + rel->r_offset + 4);
10887                       can_plt_call = TRUE;
10888                     }
10889                 }
10890
10891               if (!can_plt_call)
10892                 {
10893                   if (stub_entry->stub_type == ppc_stub_plt_call)
10894                     {
10895                       /* If this is a plain branch rather than a branch
10896                          and link, don't require a nop.  However, don't
10897                          allow tail calls in a shared library as they
10898                          will result in r2 being corrupted.  */
10899                       unsigned long br;
10900                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10901                       if (info->executable && (br & 1) == 0)
10902                         can_plt_call = TRUE;
10903                       else
10904                         stub_entry = NULL;
10905                     }
10906                   else if (h != NULL
10907                            && strcmp (h->elf.root.root.string,
10908                                       ".__libc_start_main") == 0)
10909                     {
10910                       /* Allow crt1 branch to go via a toc adjusting stub.  */
10911                       can_plt_call = TRUE;
10912                     }
10913                   else
10914                     {
10915                       if (strcmp (input_section->output_section->name,
10916                                   ".init") == 0
10917                           || strcmp (input_section->output_section->name,
10918                                      ".fini") == 0)
10919                         (*_bfd_error_handler)
10920                           (_("%B(%A+0x%lx): automatic multiple TOCs "
10921                              "not supported using your crt files; "
10922                              "recompile with -mminimal-toc or upgrade gcc"),
10923                            input_bfd,
10924                            input_section,
10925                            (long) rel->r_offset);
10926                       else
10927                         (*_bfd_error_handler)
10928                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10929                              "does not allow automatic multiple TOCs; "
10930                              "recompile with -mminimal-toc or "
10931                              "-fno-optimize-sibling-calls, "
10932                              "or make `%s' extern"),
10933                            input_bfd,
10934                            input_section,
10935                            (long) rel->r_offset,
10936                            sym_name,
10937                            sym_name);
10938                       bfd_set_error (bfd_error_bad_value);
10939                       ret = FALSE;
10940                     }
10941                 }
10942
10943               if (can_plt_call
10944                   && stub_entry->stub_type == ppc_stub_plt_call)
10945                 unresolved_reloc = FALSE;
10946             }
10947
10948           if (stub_entry == NULL
10949               && get_opd_info (sec) != NULL)
10950             {
10951               /* The branch destination is the value of the opd entry. */
10952               bfd_vma off = (relocation + addend
10953                              - sec->output_section->vma
10954                              - sec->output_offset);
10955               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10956               if (dest != (bfd_vma) -1)
10957                 {
10958                   relocation = dest;
10959                   addend = 0;
10960                 }
10961             }
10962
10963           /* If the branch is out of reach we ought to have a long
10964              branch stub.  */
10965           from = (rel->r_offset
10966                   + input_section->output_offset
10967                   + input_section->output_section->vma);
10968
10969           if (stub_entry == NULL
10970               && (relocation + addend - from + max_br_offset
10971                   >= 2 * max_br_offset)
10972               && r_type != R_PPC64_ADDR14_BRTAKEN
10973               && r_type != R_PPC64_ADDR14_BRNTAKEN)
10974             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10975                                              htab);
10976
10977           if (stub_entry != NULL)
10978             {
10979               /* Munge up the value and addend so that we call the stub
10980                  rather than the procedure directly.  */
10981               relocation = (stub_entry->stub_offset
10982                             + stub_entry->stub_sec->output_offset
10983                             + stub_entry->stub_sec->output_section->vma);
10984               addend = 0;
10985             }
10986
10987           if (insn != 0)
10988             {
10989               if (is_power4)
10990                 {
10991                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
10992                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
10993                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
10994                   if ((insn & (0x14 << 21)) == (0x04 << 21))
10995                     insn |= 0x02 << 21;
10996                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
10997                     insn |= 0x08 << 21;
10998                   else
10999                     break;
11000                 }
11001               else
11002                 {
11003                   /* Invert 'y' bit if not the default.  */
11004                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
11005                     insn ^= 0x01 << 21;
11006                 }
11007
11008               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11009             }
11010
11011           /* NOP out calls to undefined weak functions.
11012              We can thus call a weak function without first
11013              checking whether the function is defined.  */
11014           else if (h != NULL
11015                    && h->elf.root.type == bfd_link_hash_undefweak
11016                    && r_type == R_PPC64_REL24
11017                    && relocation == 0
11018                    && addend == 0)
11019             {
11020               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11021               continue;
11022             }
11023           break;
11024         }
11025
11026       /* Set `addend'.  */
11027       tls_type = 0;
11028       switch (r_type)
11029         {
11030         default:
11031           (*_bfd_error_handler)
11032             (_("%B: unknown relocation type %d for symbol %s"),
11033              input_bfd, (int) r_type, sym_name);
11034
11035           bfd_set_error (bfd_error_bad_value);
11036           ret = FALSE;
11037           continue;
11038
11039         case R_PPC64_NONE:
11040         case R_PPC64_TLS:
11041         case R_PPC64_TLSGD:
11042         case R_PPC64_TLSLD:
11043         case R_PPC64_GNU_VTINHERIT:
11044         case R_PPC64_GNU_VTENTRY:
11045           continue;
11046
11047           /* GOT16 relocations.  Like an ADDR16 using the symbol's
11048              address in the GOT as relocation value instead of the
11049              symbol's value itself.  Also, create a GOT entry for the
11050              symbol and put the symbol value there.  */
11051         case R_PPC64_GOT_TLSGD16:
11052         case R_PPC64_GOT_TLSGD16_LO:
11053         case R_PPC64_GOT_TLSGD16_HI:
11054         case R_PPC64_GOT_TLSGD16_HA:
11055           tls_type = TLS_TLS | TLS_GD;
11056           goto dogot;
11057
11058         case R_PPC64_GOT_TLSLD16:
11059         case R_PPC64_GOT_TLSLD16_LO:
11060         case R_PPC64_GOT_TLSLD16_HI:
11061         case R_PPC64_GOT_TLSLD16_HA:
11062           tls_type = TLS_TLS | TLS_LD;
11063           goto dogot;
11064
11065         case R_PPC64_GOT_TPREL16_DS:
11066         case R_PPC64_GOT_TPREL16_LO_DS:
11067         case R_PPC64_GOT_TPREL16_HI:
11068         case R_PPC64_GOT_TPREL16_HA:
11069           tls_type = TLS_TLS | TLS_TPREL;
11070           goto dogot;
11071
11072         case R_PPC64_GOT_DTPREL16_DS:
11073         case R_PPC64_GOT_DTPREL16_LO_DS:
11074         case R_PPC64_GOT_DTPREL16_HI:
11075         case R_PPC64_GOT_DTPREL16_HA:
11076           tls_type = TLS_TLS | TLS_DTPREL;
11077           goto dogot;
11078
11079         case R_PPC64_GOT16:
11080         case R_PPC64_GOT16_LO:
11081         case R_PPC64_GOT16_HI:
11082         case R_PPC64_GOT16_HA:
11083         case R_PPC64_GOT16_DS:
11084         case R_PPC64_GOT16_LO_DS:
11085         dogot:
11086           {
11087             /* Relocation is to the entry for this symbol in the global
11088                offset table.  */
11089             asection *got;
11090             bfd_vma *offp;
11091             bfd_vma off;
11092             unsigned long indx = 0;
11093
11094             if (tls_type == (TLS_TLS | TLS_LD)
11095                 && (h == NULL
11096                     || !h->elf.def_dynamic))
11097               offp = &ppc64_tlsld_got (input_bfd)->offset;
11098             else
11099               {
11100                 struct got_entry *ent;
11101
11102                 if (h != NULL)
11103                   {
11104                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
11105                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
11106                                                           &h->elf)
11107                         || (info->shared
11108                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
11109                       /* This is actually a static link, or it is a
11110                          -Bsymbolic link and the symbol is defined
11111                          locally, or the symbol was forced to be local
11112                          because of a version file.  */
11113                       ;
11114                     else
11115                       {
11116                         indx = h->elf.dynindx;
11117                         unresolved_reloc = FALSE;
11118                       }
11119                     ent = h->elf.got.glist;
11120                   }
11121                 else
11122                   {
11123                     if (local_got_ents == NULL)
11124                       abort ();
11125                     ent = local_got_ents[r_symndx];
11126                   }
11127
11128                 for (; ent != NULL; ent = ent->next)
11129                   if (ent->addend == orig_addend
11130                       && ent->owner == input_bfd
11131                       && ent->tls_type == tls_type)
11132                     break;
11133                 if (ent == NULL)
11134                   abort ();
11135                 offp = &ent->got.offset;
11136               }
11137
11138             got = ppc64_elf_tdata (input_bfd)->got;
11139             if (got == NULL)
11140               abort ();
11141
11142             /* The offset must always be a multiple of 8.  We use the
11143                least significant bit to record whether we have already
11144                processed this entry.  */
11145             off = *offp;
11146             if ((off & 1) != 0)
11147               off &= ~1;
11148             else
11149               {
11150                 /* Generate relocs for the dynamic linker, except in
11151                    the case of TLSLD where we'll use one entry per
11152                    module.  */
11153                 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
11154
11155                 *offp = off | 1;
11156                 if ((info->shared || indx != 0)
11157                     && (offp == &ppc64_tlsld_got (input_bfd)->offset
11158                         || h == NULL
11159                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11160                         || h->elf.root.type != bfd_link_hash_undefweak))
11161                   {
11162                     outrel.r_offset = (got->output_section->vma
11163                                        + got->output_offset
11164                                        + off);
11165                     outrel.r_addend = addend;
11166                     if (tls_type & (TLS_LD | TLS_GD))
11167                       {
11168                         outrel.r_addend = 0;
11169                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
11170                         if (tls_type == (TLS_TLS | TLS_GD))
11171                           {
11172                             loc = relgot->contents;
11173                             loc += (relgot->reloc_count++
11174                                     * sizeof (Elf64_External_Rela));
11175                             bfd_elf64_swap_reloca_out (output_bfd,
11176                                                        &outrel, loc);
11177                             outrel.r_offset += 8;
11178                             outrel.r_addend = addend;
11179                             outrel.r_info
11180                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11181                           }
11182                       }
11183                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
11184                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11185                     else if (tls_type == (TLS_TLS | TLS_TPREL))
11186                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
11187                     else if (indx == 0)
11188                       {
11189                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
11190
11191                         /* Write the .got section contents for the sake
11192                            of prelink.  */
11193                         loc = got->contents + off;
11194                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
11195                                     loc);
11196                       }
11197                     else
11198                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
11199
11200                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
11201                       {
11202                         outrel.r_addend += relocation;
11203                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
11204                           outrel.r_addend -= htab->elf.tls_sec->vma;
11205                       }
11206                     loc = relgot->contents;
11207                     loc += (relgot->reloc_count++
11208                             * sizeof (Elf64_External_Rela));
11209                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11210                   }
11211
11212                 /* Init the .got section contents here if we're not
11213                    emitting a reloc.  */
11214                 else
11215                   {
11216                     relocation += addend;
11217                     if (tls_type == (TLS_TLS | TLS_LD))
11218                       relocation = 1;
11219                     else if (tls_type != 0)
11220                       {
11221                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
11222                         if (tls_type == (TLS_TLS | TLS_TPREL))
11223                           relocation += DTP_OFFSET - TP_OFFSET;
11224
11225                         if (tls_type == (TLS_TLS | TLS_GD))
11226                           {
11227                             bfd_put_64 (output_bfd, relocation,
11228                                         got->contents + off + 8);
11229                             relocation = 1;
11230                           }
11231                       }
11232
11233                     bfd_put_64 (output_bfd, relocation,
11234                                 got->contents + off);
11235                   }
11236               }
11237
11238             if (off >= (bfd_vma) -2)
11239               abort ();
11240
11241             relocation = got->output_offset + off;
11242
11243             /* TOC base (r2) is TOC start plus 0x8000.  */
11244             addend = -TOC_BASE_OFF;
11245           }
11246           break;
11247
11248         case R_PPC64_PLT16_HA:
11249         case R_PPC64_PLT16_HI:
11250         case R_PPC64_PLT16_LO:
11251         case R_PPC64_PLT32:
11252         case R_PPC64_PLT64:
11253           /* Relocation is to the entry for this symbol in the
11254              procedure linkage table.  */
11255
11256           /* Resolve a PLT reloc against a local symbol directly,
11257              without using the procedure linkage table.  */
11258           if (h == NULL)
11259             break;
11260
11261           /* It's possible that we didn't make a PLT entry for this
11262              symbol.  This happens when statically linking PIC code,
11263              or when using -Bsymbolic.  Go find a match if there is a
11264              PLT entry.  */
11265           if (htab->plt != NULL)
11266             {
11267               struct plt_entry *ent;
11268               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
11269                 if (ent->addend == orig_addend
11270                     && ent->plt.offset != (bfd_vma) -1)
11271                   {
11272                     relocation = (htab->plt->output_section->vma
11273                                   + htab->plt->output_offset
11274                                   + ent->plt.offset);
11275                     unresolved_reloc = FALSE;
11276                   }
11277             }
11278           break;
11279
11280         case R_PPC64_TOC:
11281           /* Relocation value is TOC base.  */
11282           relocation = TOCstart;
11283           if (r_symndx == 0)
11284             relocation += htab->stub_group[input_section->id].toc_off;
11285           else if (unresolved_reloc)
11286             ;
11287           else if (sec != NULL && sec->id <= htab->top_id)
11288             relocation += htab->stub_group[sec->id].toc_off;
11289           else
11290             unresolved_reloc = TRUE;
11291           goto dodyn;
11292
11293           /* TOC16 relocs.  We want the offset relative to the TOC base,
11294              which is the address of the start of the TOC plus 0x8000.
11295              The TOC consists of sections .got, .toc, .tocbss, and .plt,
11296              in this order.  */
11297         case R_PPC64_TOC16:
11298         case R_PPC64_TOC16_LO:
11299         case R_PPC64_TOC16_HI:
11300         case R_PPC64_TOC16_DS:
11301         case R_PPC64_TOC16_LO_DS:
11302         case R_PPC64_TOC16_HA:
11303           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
11304           break;
11305
11306           /* Relocate against the beginning of the section.  */
11307         case R_PPC64_SECTOFF:
11308         case R_PPC64_SECTOFF_LO:
11309         case R_PPC64_SECTOFF_HI:
11310         case R_PPC64_SECTOFF_DS:
11311         case R_PPC64_SECTOFF_LO_DS:
11312         case R_PPC64_SECTOFF_HA:
11313           if (sec != NULL)
11314             addend -= sec->output_section->vma;
11315           break;
11316
11317         case R_PPC64_REL14:
11318         case R_PPC64_REL14_BRNTAKEN:
11319         case R_PPC64_REL14_BRTAKEN:
11320         case R_PPC64_REL24:
11321           break;
11322
11323         case R_PPC64_TPREL16:
11324         case R_PPC64_TPREL16_LO:
11325         case R_PPC64_TPREL16_HI:
11326         case R_PPC64_TPREL16_HA:
11327         case R_PPC64_TPREL16_DS:
11328         case R_PPC64_TPREL16_LO_DS:
11329         case R_PPC64_TPREL16_HIGHER:
11330         case R_PPC64_TPREL16_HIGHERA:
11331         case R_PPC64_TPREL16_HIGHEST:
11332         case R_PPC64_TPREL16_HIGHESTA:
11333           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11334           if (info->shared)
11335             /* The TPREL16 relocs shouldn't really be used in shared
11336                libs as they will result in DT_TEXTREL being set, but
11337                support them anyway.  */
11338             goto dodyn;
11339           break;
11340
11341         case R_PPC64_DTPREL16:
11342         case R_PPC64_DTPREL16_LO:
11343         case R_PPC64_DTPREL16_HI:
11344         case R_PPC64_DTPREL16_HA:
11345         case R_PPC64_DTPREL16_DS:
11346         case R_PPC64_DTPREL16_LO_DS:
11347         case R_PPC64_DTPREL16_HIGHER:
11348         case R_PPC64_DTPREL16_HIGHERA:
11349         case R_PPC64_DTPREL16_HIGHEST:
11350         case R_PPC64_DTPREL16_HIGHESTA:
11351           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11352           break;
11353
11354         case R_PPC64_DTPMOD64:
11355           relocation = 1;
11356           addend = 0;
11357           goto dodyn;
11358
11359         case R_PPC64_TPREL64:
11360           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11361           goto dodyn;
11362
11363         case R_PPC64_DTPREL64:
11364           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11365           /* Fall thru */
11366
11367           /* Relocations that may need to be propagated if this is a
11368              dynamic object.  */
11369         case R_PPC64_REL30:
11370         case R_PPC64_REL32:
11371         case R_PPC64_REL64:
11372         case R_PPC64_ADDR14:
11373         case R_PPC64_ADDR14_BRNTAKEN:
11374         case R_PPC64_ADDR14_BRTAKEN:
11375         case R_PPC64_ADDR16:
11376         case R_PPC64_ADDR16_DS:
11377         case R_PPC64_ADDR16_HA:
11378         case R_PPC64_ADDR16_HI:
11379         case R_PPC64_ADDR16_HIGHER:
11380         case R_PPC64_ADDR16_HIGHERA:
11381         case R_PPC64_ADDR16_HIGHEST:
11382         case R_PPC64_ADDR16_HIGHESTA:
11383         case R_PPC64_ADDR16_LO:
11384         case R_PPC64_ADDR16_LO_DS:
11385         case R_PPC64_ADDR24:
11386         case R_PPC64_ADDR32:
11387         case R_PPC64_ADDR64:
11388         case R_PPC64_UADDR16:
11389         case R_PPC64_UADDR32:
11390         case R_PPC64_UADDR64:
11391         dodyn:
11392           if ((input_section->flags & SEC_ALLOC) == 0)
11393             break;
11394
11395           if (NO_OPD_RELOCS && is_opd)
11396             break;
11397
11398           if ((info->shared
11399                && (h == NULL
11400                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11401                    || h->elf.root.type != bfd_link_hash_undefweak)
11402                && (must_be_dyn_reloc (info, r_type)
11403                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
11404               || (ELIMINATE_COPY_RELOCS
11405                   && !info->shared
11406                   && h != NULL
11407                   && h->elf.dynindx != -1
11408                   && !h->elf.non_got_ref
11409                   && !h->elf.def_regular))
11410             {
11411               Elf_Internal_Rela outrel;
11412               bfd_boolean skip, relocate;
11413               asection *sreloc;
11414               bfd_byte *loc;
11415               bfd_vma out_off;
11416
11417               /* When generating a dynamic object, these relocations
11418                  are copied into the output file to be resolved at run
11419                  time.  */
11420
11421               skip = FALSE;
11422               relocate = FALSE;
11423
11424               out_off = _bfd_elf_section_offset (output_bfd, info,
11425                                                  input_section, rel->r_offset);
11426               if (out_off == (bfd_vma) -1)
11427                 skip = TRUE;
11428               else if (out_off == (bfd_vma) -2)
11429                 skip = TRUE, relocate = TRUE;
11430               out_off += (input_section->output_section->vma
11431                           + input_section->output_offset);
11432               outrel.r_offset = out_off;
11433               outrel.r_addend = rel->r_addend;
11434
11435               /* Optimize unaligned reloc use.  */
11436               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11437                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11438                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11439               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11440                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11441                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11442               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11443                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11444                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11445
11446               if (skip)
11447                 memset (&outrel, 0, sizeof outrel);
11448               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
11449                        && !is_opd
11450                        && r_type != R_PPC64_TOC)
11451                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
11452               else
11453                 {
11454                   /* This symbol is local, or marked to become local,
11455                      or this is an opd section reloc which must point
11456                      at a local function.  */
11457                   outrel.r_addend += relocation;
11458                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
11459                     {
11460                       if (is_opd && h != NULL)
11461                         {
11462                           /* Lie about opd entries.  This case occurs
11463                              when building shared libraries and we
11464                              reference a function in another shared
11465                              lib.  The same thing happens for a weak
11466                              definition in an application that's
11467                              overridden by a strong definition in a
11468                              shared lib.  (I believe this is a generic
11469                              bug in binutils handling of weak syms.)
11470                              In these cases we won't use the opd
11471                              entry in this lib.  */
11472                           unresolved_reloc = FALSE;
11473                         }
11474                       outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11475
11476                       /* We need to relocate .opd contents for ld.so.
11477                          Prelink also wants simple and consistent rules
11478                          for relocs.  This make all RELATIVE relocs have
11479                          *r_offset equal to r_addend.  */
11480                       relocate = TRUE;
11481                     }
11482                   else
11483                     {
11484                       long indx = 0;
11485
11486                       if (r_symndx == 0 || bfd_is_abs_section (sec))
11487                         ;
11488                       else if (sec == NULL || sec->owner == NULL)
11489                         {
11490                           bfd_set_error (bfd_error_bad_value);
11491                           return FALSE;
11492                         }
11493                       else
11494                         {
11495                           asection *osec;
11496
11497                           osec = sec->output_section;
11498                           indx = elf_section_data (osec)->dynindx;
11499
11500                           if (indx == 0)
11501                             {
11502                               if ((osec->flags & SEC_READONLY) == 0
11503                                   && htab->elf.data_index_section != NULL)
11504                                 osec = htab->elf.data_index_section;
11505                               else
11506                                 osec = htab->elf.text_index_section;
11507                               indx = elf_section_data (osec)->dynindx;
11508                             }
11509                           BFD_ASSERT (indx != 0);
11510
11511                           /* We are turning this relocation into one
11512                              against a section symbol, so subtract out
11513                              the output section's address but not the
11514                              offset of the input section in the output
11515                              section.  */
11516                           outrel.r_addend -= osec->vma;
11517                         }
11518
11519                       outrel.r_info = ELF64_R_INFO (indx, r_type);
11520                     }
11521                 }
11522
11523               sreloc = elf_section_data (input_section)->sreloc;
11524               if (sreloc == NULL)
11525                 abort ();
11526
11527               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
11528                   >= sreloc->size)
11529                 abort ();
11530               loc = sreloc->contents;
11531               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
11532               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11533
11534               /* If this reloc is against an external symbol, it will
11535                  be computed at runtime, so there's no need to do
11536                  anything now.  However, for the sake of prelink ensure
11537                  that the section contents are a known value.  */
11538               if (! relocate)
11539                 {
11540                   unresolved_reloc = FALSE;
11541                   /* The value chosen here is quite arbitrary as ld.so
11542                      ignores section contents except for the special
11543                      case of .opd where the contents might be accessed
11544                      before relocation.  Choose zero, as that won't
11545                      cause reloc overflow.  */
11546                   relocation = 0;
11547                   addend = 0;
11548                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
11549                      to improve backward compatibility with older
11550                      versions of ld.  */
11551                   if (r_type == R_PPC64_ADDR64)
11552                     addend = outrel.r_addend;
11553                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
11554                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
11555                     addend = (input_section->output_section->vma
11556                               + input_section->output_offset
11557                               + rel->r_offset);
11558                 }
11559             }
11560           break;
11561
11562         case R_PPC64_COPY:
11563         case R_PPC64_GLOB_DAT:
11564         case R_PPC64_JMP_SLOT:
11565         case R_PPC64_RELATIVE:
11566           /* We shouldn't ever see these dynamic relocs in relocatable
11567              files.  */
11568           /* Fall through.  */
11569
11570         case R_PPC64_PLTGOT16:
11571         case R_PPC64_PLTGOT16_DS:
11572         case R_PPC64_PLTGOT16_HA:
11573         case R_PPC64_PLTGOT16_HI:
11574         case R_PPC64_PLTGOT16_LO:
11575         case R_PPC64_PLTGOT16_LO_DS:
11576         case R_PPC64_PLTREL32:
11577         case R_PPC64_PLTREL64:
11578           /* These ones haven't been implemented yet.  */
11579
11580           (*_bfd_error_handler)
11581             (_("%B: relocation %s is not supported for symbol %s."),
11582              input_bfd,
11583              ppc64_elf_howto_table[r_type]->name, sym_name);
11584
11585           bfd_set_error (bfd_error_invalid_operation);
11586           ret = FALSE;
11587           continue;
11588         }
11589
11590       /* Do any further special processing.  */
11591       switch (r_type)
11592         {
11593         default:
11594           break;
11595
11596         case R_PPC64_ADDR16_HA:
11597         case R_PPC64_ADDR16_HIGHERA:
11598         case R_PPC64_ADDR16_HIGHESTA:
11599         case R_PPC64_TOC16_HA:
11600         case R_PPC64_SECTOFF_HA:
11601         case R_PPC64_TPREL16_HA:
11602         case R_PPC64_DTPREL16_HA:
11603         case R_PPC64_TPREL16_HIGHER:
11604         case R_PPC64_TPREL16_HIGHERA:
11605         case R_PPC64_TPREL16_HIGHEST:
11606         case R_PPC64_TPREL16_HIGHESTA:
11607         case R_PPC64_DTPREL16_HIGHER:
11608         case R_PPC64_DTPREL16_HIGHERA:
11609         case R_PPC64_DTPREL16_HIGHEST:
11610         case R_PPC64_DTPREL16_HIGHESTA:
11611           /* It's just possible that this symbol is a weak symbol
11612              that's not actually defined anywhere. In that case,
11613              'sec' would be NULL, and we should leave the symbol
11614              alone (it will be set to zero elsewhere in the link).  */
11615           if (sec == NULL)
11616             break;
11617           /* Fall thru */
11618
11619         case R_PPC64_GOT16_HA:
11620         case R_PPC64_PLTGOT16_HA:
11621         case R_PPC64_PLT16_HA:
11622         case R_PPC64_GOT_TLSGD16_HA:
11623         case R_PPC64_GOT_TLSLD16_HA:
11624         case R_PPC64_GOT_TPREL16_HA:
11625         case R_PPC64_GOT_DTPREL16_HA:
11626           /* Add 0x10000 if sign bit in 0:15 is set.
11627              Bits 0:15 are not used.  */
11628           addend += 0x8000;
11629           break;
11630
11631         case R_PPC64_ADDR16_DS:
11632         case R_PPC64_ADDR16_LO_DS:
11633         case R_PPC64_GOT16_DS:
11634         case R_PPC64_GOT16_LO_DS:
11635         case R_PPC64_PLT16_LO_DS:
11636         case R_PPC64_SECTOFF_DS:
11637         case R_PPC64_SECTOFF_LO_DS:
11638         case R_PPC64_TOC16_DS:
11639         case R_PPC64_TOC16_LO_DS:
11640         case R_PPC64_PLTGOT16_DS:
11641         case R_PPC64_PLTGOT16_LO_DS:
11642         case R_PPC64_GOT_TPREL16_DS:
11643         case R_PPC64_GOT_TPREL16_LO_DS:
11644         case R_PPC64_GOT_DTPREL16_DS:
11645         case R_PPC64_GOT_DTPREL16_LO_DS:
11646         case R_PPC64_TPREL16_DS:
11647         case R_PPC64_TPREL16_LO_DS:
11648         case R_PPC64_DTPREL16_DS:
11649         case R_PPC64_DTPREL16_LO_DS:
11650           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11651           mask = 3;
11652           /* If this reloc is against an lq insn, then the value must be
11653              a multiple of 16.  This is somewhat of a hack, but the
11654              "correct" way to do this by defining _DQ forms of all the
11655              _DS relocs bloats all reloc switches in this file.  It
11656              doesn't seem to make much sense to use any of these relocs
11657              in data, so testing the insn should be safe.  */
11658           if ((insn & (0x3f << 26)) == (56u << 26))
11659             mask = 15;
11660           if (((relocation + addend) & mask) != 0)
11661             {
11662               (*_bfd_error_handler)
11663                 (_("%B: error: relocation %s not a multiple of %d"),
11664                  input_bfd,
11665                  ppc64_elf_howto_table[r_type]->name,
11666                  mask + 1);
11667               bfd_set_error (bfd_error_bad_value);
11668               ret = FALSE;
11669               continue;
11670             }
11671           break;
11672         }
11673
11674       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11675          because such sections are not SEC_ALLOC and thus ld.so will
11676          not process them.  */
11677       if (unresolved_reloc
11678           && !((input_section->flags & SEC_DEBUGGING) != 0
11679                && h->elf.def_dynamic))
11680         {
11681           (*_bfd_error_handler)
11682             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11683              input_bfd,
11684              input_section,
11685              (long) rel->r_offset,
11686              ppc64_elf_howto_table[(int) r_type]->name,
11687              h->elf.root.root.string);
11688           ret = FALSE;
11689         }
11690
11691       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11692                                     input_bfd,
11693                                     input_section,
11694                                     contents,
11695                                     rel->r_offset,
11696                                     relocation,
11697                                     addend);
11698
11699       if (r != bfd_reloc_ok)
11700         {
11701           if (sym_name == NULL)
11702             sym_name = "(null)";
11703           if (r == bfd_reloc_overflow)
11704             {
11705               if (warned)
11706                 continue;
11707               if (h != NULL
11708                   && h->elf.root.type == bfd_link_hash_undefweak
11709                   && ppc64_elf_howto_table[r_type]->pc_relative)
11710                 {
11711                   /* Assume this is a call protected by other code that
11712                      detects the symbol is undefined.  If this is the case,
11713                      we can safely ignore the overflow.  If not, the
11714                      program is hosed anyway, and a little warning isn't
11715                      going to help.  */
11716
11717                   continue;
11718                 }
11719
11720               if (!((*info->callbacks->reloc_overflow)
11721                     (info, (h ? &h->elf.root : NULL), sym_name,
11722                      ppc64_elf_howto_table[r_type]->name,
11723                      orig_addend, input_bfd, input_section, rel->r_offset)))
11724                 return FALSE;
11725             }
11726           else
11727             {
11728               (*_bfd_error_handler)
11729                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11730                  input_bfd,
11731                  input_section,
11732                  (long) rel->r_offset,
11733                  ppc64_elf_howto_table[r_type]->name,
11734                  sym_name,
11735                  (int) r);
11736               ret = FALSE;
11737             }
11738         }
11739     }
11740
11741   /* If we're emitting relocations, then shortly after this function
11742      returns, reloc offsets and addends for this section will be
11743      adjusted.  Worse, reloc symbol indices will be for the output
11744      file rather than the input.  Save a copy of the relocs for
11745      opd_entry_value.  */
11746   if (is_opd && (info->emitrelocations || info->relocatable))
11747     {
11748       bfd_size_type amt;
11749       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11750       rel = bfd_alloc (input_bfd, amt);
11751       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11752       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11753       if (rel == NULL)
11754         return FALSE;
11755       memcpy (rel, relocs, amt);
11756     }
11757   return ret;
11758 }
11759
11760 /* Adjust the value of any local symbols in opd sections.  */
11761
11762 static int
11763 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11764                               const char *name ATTRIBUTE_UNUSED,
11765                               Elf_Internal_Sym *elfsym,
11766                               asection *input_sec,
11767                               struct elf_link_hash_entry *h)
11768 {
11769   struct _opd_sec_data *opd;
11770   long adjust;
11771   bfd_vma value;
11772
11773   if (h != NULL)
11774     return 1;
11775
11776   opd = get_opd_info (input_sec);
11777   if (opd == NULL || opd->adjust == NULL)
11778     return 1;
11779
11780   value = elfsym->st_value - input_sec->output_offset;
11781   if (!info->relocatable)
11782     value -= input_sec->output_section->vma;
11783
11784   adjust = opd->adjust[value / 8];
11785   if (adjust == -1)
11786     return 2;
11787
11788   elfsym->st_value += adjust;
11789   return 1;
11790 }
11791
11792 /* Finish up dynamic symbol handling.  We set the contents of various
11793    dynamic sections here.  */
11794
11795 static bfd_boolean
11796 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11797                                  struct bfd_link_info *info,
11798                                  struct elf_link_hash_entry *h,
11799                                  Elf_Internal_Sym *sym)
11800 {
11801   struct ppc_link_hash_table *htab;
11802   struct plt_entry *ent;
11803   Elf_Internal_Rela rela;
11804   bfd_byte *loc;
11805
11806   htab = ppc_hash_table (info);
11807
11808   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11809     if (ent->plt.offset != (bfd_vma) -1)
11810       {
11811         /* This symbol has an entry in the procedure linkage
11812            table.  Set it up.  */
11813
11814         if (htab->plt == NULL
11815             || htab->relplt == NULL
11816             || htab->glink == NULL)
11817           abort ();
11818
11819         /* Create a JMP_SLOT reloc to inform the dynamic linker to
11820            fill in the PLT entry.  */
11821         rela.r_offset = (htab->plt->output_section->vma
11822                          + htab->plt->output_offset
11823                          + ent->plt.offset);
11824         rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11825         rela.r_addend = ent->addend;
11826
11827         loc = htab->relplt->contents;
11828         loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11829                 * sizeof (Elf64_External_Rela));
11830         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11831       }
11832
11833   if (h->needs_copy)
11834     {
11835       Elf_Internal_Rela rela;
11836       bfd_byte *loc;
11837
11838       /* This symbol needs a copy reloc.  Set it up.  */
11839
11840       if (h->dynindx == -1
11841           || (h->root.type != bfd_link_hash_defined
11842               && h->root.type != bfd_link_hash_defweak)
11843           || htab->relbss == NULL)
11844         abort ();
11845
11846       rela.r_offset = (h->root.u.def.value
11847                        + h->root.u.def.section->output_section->vma
11848                        + h->root.u.def.section->output_offset);
11849       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11850       rela.r_addend = 0;
11851       loc = htab->relbss->contents;
11852       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11853       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11854     }
11855
11856   /* Mark some specially defined symbols as absolute.  */
11857   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11858     sym->st_shndx = SHN_ABS;
11859
11860   return TRUE;
11861 }
11862
11863 /* Used to decide how to sort relocs in an optimal manner for the
11864    dynamic linker, before writing them out.  */
11865
11866 static enum elf_reloc_type_class
11867 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11868 {
11869   enum elf_ppc64_reloc_type r_type;
11870
11871   r_type = ELF64_R_TYPE (rela->r_info);
11872   switch (r_type)
11873     {
11874     case R_PPC64_RELATIVE:
11875       return reloc_class_relative;
11876     case R_PPC64_JMP_SLOT:
11877       return reloc_class_plt;
11878     case R_PPC64_COPY:
11879       return reloc_class_copy;
11880     default:
11881       return reloc_class_normal;
11882     }
11883 }
11884
11885 /* Finish up the dynamic sections.  */
11886
11887 static bfd_boolean
11888 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11889                                    struct bfd_link_info *info)
11890 {
11891   struct ppc_link_hash_table *htab;
11892   bfd *dynobj;
11893   asection *sdyn;
11894
11895   htab = ppc_hash_table (info);
11896   dynobj = htab->elf.dynobj;
11897   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11898
11899   if (htab->elf.dynamic_sections_created)
11900     {
11901       Elf64_External_Dyn *dyncon, *dynconend;
11902
11903       if (sdyn == NULL || htab->got == NULL)
11904         abort ();
11905
11906       dyncon = (Elf64_External_Dyn *) sdyn->contents;
11907       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11908       for (; dyncon < dynconend; dyncon++)
11909         {
11910           Elf_Internal_Dyn dyn;
11911           asection *s;
11912
11913           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11914
11915           switch (dyn.d_tag)
11916             {
11917             default:
11918               continue;
11919
11920             case DT_PPC64_GLINK:
11921               s = htab->glink;
11922               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11923               /* We stupidly defined DT_PPC64_GLINK to be the start
11924                  of glink rather than the first entry point, which is
11925                  what ld.so needs, and now have a bigger stub to
11926                  support automatic multiple TOCs.  */
11927               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11928               break;
11929
11930             case DT_PPC64_OPD:
11931               s = bfd_get_section_by_name (output_bfd, ".opd");
11932               if (s == NULL)
11933                 continue;
11934               dyn.d_un.d_ptr = s->vma;
11935               break;
11936
11937             case DT_PPC64_OPDSZ:
11938               s = bfd_get_section_by_name (output_bfd, ".opd");
11939               if (s == NULL)
11940                 continue;
11941               dyn.d_un.d_val = s->size;
11942               break;
11943
11944             case DT_PLTGOT:
11945               s = htab->plt;
11946               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11947               break;
11948
11949             case DT_JMPREL:
11950               s = htab->relplt;
11951               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11952               break;
11953
11954             case DT_PLTRELSZ:
11955               dyn.d_un.d_val = htab->relplt->size;
11956               break;
11957
11958             case DT_RELASZ:
11959               /* Don't count procedure linkage table relocs in the
11960                  overall reloc count.  */
11961               s = htab->relplt;
11962               if (s == NULL)
11963                 continue;
11964               dyn.d_un.d_val -= s->size;
11965               break;
11966
11967             case DT_RELA:
11968               /* We may not be using the standard ELF linker script.
11969                  If .rela.plt is the first .rela section, we adjust
11970                  DT_RELA to not include it.  */
11971               s = htab->relplt;
11972               if (s == NULL)
11973                 continue;
11974               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11975                 continue;
11976               dyn.d_un.d_ptr += s->size;
11977               break;
11978             }
11979
11980           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11981         }
11982     }
11983
11984   if (htab->got != NULL && htab->got->size != 0)
11985     {
11986       /* Fill in the first entry in the global offset table.
11987          We use it to hold the link-time TOCbase.  */
11988       bfd_put_64 (output_bfd,
11989                   elf_gp (output_bfd) + TOC_BASE_OFF,
11990                   htab->got->contents);
11991
11992       /* Set .got entry size.  */
11993       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11994     }
11995
11996   if (htab->plt != NULL && htab->plt->size != 0)
11997     {
11998       /* Set .plt entry size.  */
11999       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
12000         = PLT_ENTRY_SIZE;
12001     }
12002
12003   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
12004      brlt ourselves if emitrelocations.  */
12005   if (htab->brlt != NULL
12006       && htab->brlt->reloc_count != 0
12007       && !_bfd_elf_link_output_relocs (output_bfd,
12008                                        htab->brlt,
12009                                        &elf_section_data (htab->brlt)->rel_hdr,
12010                                        elf_section_data (htab->brlt)->relocs,
12011                                        NULL))
12012     return FALSE;
12013
12014   if (htab->glink != NULL
12015       && htab->glink->reloc_count != 0
12016       && !_bfd_elf_link_output_relocs (output_bfd,
12017                                        htab->glink,
12018                                        &elf_section_data (htab->glink)->rel_hdr,
12019                                        elf_section_data (htab->glink)->relocs,
12020                                        NULL))
12021     return FALSE;
12022
12023   /* We need to handle writing out multiple GOT sections ourselves,
12024      since we didn't add them to DYNOBJ.  We know dynobj is the first
12025      bfd.  */
12026   while ((dynobj = dynobj->link_next) != NULL)
12027     {
12028       asection *s;
12029
12030       if (!is_ppc64_elf (dynobj))
12031         continue;
12032
12033       s = ppc64_elf_tdata (dynobj)->got;
12034       if (s != NULL
12035           && s->size != 0
12036           && s->output_section != bfd_abs_section_ptr
12037           && !bfd_set_section_contents (output_bfd, s->output_section,
12038                                         s->contents, s->output_offset,
12039                                         s->size))
12040         return FALSE;
12041       s = ppc64_elf_tdata (dynobj)->relgot;
12042       if (s != NULL
12043           && s->size != 0
12044           && s->output_section != bfd_abs_section_ptr
12045           && !bfd_set_section_contents (output_bfd, s->output_section,
12046                                         s->contents, s->output_offset,
12047                                         s->size))
12048         return FALSE;
12049     }
12050
12051   return TRUE;
12052 }
12053
12054 #include "elf64-target.h"