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