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