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