bfd/elf64-ppc.c

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