bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010 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.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *);
  58
  59 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_MACHINE_CODE        EM_PPC64
  65 #define ELF_MAXPAGESIZE         0x10000
  66 #define ELF_COMMONPAGESIZE      0x1000
  67 #define elf_info_to_howto       ppc64_elf_info_to_howto
  68
  69 #define elf_backend_want_got_sym 0
  70 #define elf_backend_want_plt_sym 0
  71 #define elf_backend_plt_alignment 3
  72 #define elf_backend_plt_not_loaded 1
  73 #define elf_backend_got_header_size 8
  74 #define elf_backend_can_gc_sections 1
  75 #define elf_backend_can_refcount 1
  76 #define elf_backend_rela_normal 1
  77 #define elf_backend_default_execstack 0
  78
  79 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  80 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
  82 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  83 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  84 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  85 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  86 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  87
  88 #define elf_backend_object_p                  ppc64_elf_object_p
  89 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  90 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  91 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  92 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  93 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  94 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  95 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  96 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
  97 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  98 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  99 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 100 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 101 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 102 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 103 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 104 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 105 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 106 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 107 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 108 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 109 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 110 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 111 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 112 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 113 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 114 #define elf_backend_special_sections          ppc64_elf_special_sections
 115 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 116
 117 /* The name of the dynamic interpreter.  This is put in the .interp
 118    section.  */
 119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 120
 121 /* The size in bytes of an entry in the procedure linkage table.  */
 122 #define PLT_ENTRY_SIZE 24
 123
 124 /* The initial size of the plt reserved for the dynamic linker.  */
 125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 126
 127 /* TOC base pointers offset from start of TOC.  */
 128 #define TOC_BASE_OFF    0x8000
 129
 130 /* Offset of tp and dtp pointers from start of TLS block.  */
 131 #define TP_OFFSET       0x7000
 132 #define DTP_OFFSET      0x8000
 133
 134 /* .plt call stub instructions.  The normal stub is like this, but
 135    sometimes the .plt entry crosses a 64k boundary and we need to
 136    insert an addi to adjust r12.  */
 137 #define PLT_CALL_STUB_SIZE (7*4)
 138 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 139 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 140 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 141 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 142 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 143                                         /* ld    %r11,xxx+16@l(%r12) */
 144 #define BCTR            0x4e800420      /* bctr                      */
 145
 146
 147 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 148 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 149 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 150 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 151
 152 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 153 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 154
 155 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 156
 157 /* glink call stub instructions.  We enter with the index in R0.  */
 158 #define GLINK_CALL_STUB_SIZE (16*4)
 159                                         /* 0:                           */
 160                                         /*  .quad plt0-1f               */
 161                                         /* __glink:                     */
 162 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 163 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 164                                         /* 1:                           */
 165 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 166 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 167 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 168 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 169                                         /*  ld %11,0(%12)               */
 170                                         /*  ld %2,8(%12)                */
 171                                         /*  mtctr %11                   */
 172                                         /*  ld %11,16(%12)              */
 173                                         /*  bctr                        */
 174
 175 /* Pad with this.  */
 176 #define NOP             0x60000000
 177
 178 /* Some other nops.  */
 179 #define CROR_151515     0x4def7b82
 180 #define CROR_313131     0x4ffffb82
 181
 182 /* .glink entries for the first 32k functions are two instructions.  */
 183 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 184 #define B_DOT           0x48000000      /* b     .              */
 185
 186 /* After that, we need two instructions to load the index, followed by
 187    a branch.  */
 188 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 189 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 190
 191 /* Instructions used by the save and restore reg functions.  */
 192 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 193 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 194 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 195 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 196 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 197 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 198 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 199 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 200 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 201 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 202 #define BLR             0x4e800020      /* blr                  */
 203
 204 /* Since .opd is an array of descriptors and each entry will end up
 205    with identical R_PPC64_RELATIVE relocs, there is really no need to
 206    propagate .opd relocs;  The dynamic linker should be taught to
 207    relocate .opd without reloc entries.  */
 208 #ifndef NO_OPD_RELOCS
 209 #define NO_OPD_RELOCS 0
 210 #endif
 211 \f
 212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 213
 214 /* Relocation HOWTO's.  */
 215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 216
 217 static reloc_howto_type ppc64_elf_howto_raw[] = {
 218   /* This reloc does nothing.  */
 219   HOWTO (R_PPC64_NONE,          /* type */
 220          0,                     /* rightshift */
 221          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          FALSE,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_dont, /* complain_on_overflow */
 226          bfd_elf_generic_reloc, /* special_function */
 227          "R_PPC64_NONE",        /* name */
 228          FALSE,                 /* partial_inplace */
 229          0,                     /* src_mask */
 230          0,                     /* dst_mask */
 231          FALSE),                /* pcrel_offset */
 232
 233   /* A standard 32 bit relocation.  */
 234   HOWTO (R_PPC64_ADDR32,        /* type */
 235          0,                     /* rightshift */
 236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          32,                    /* bitsize */
 238          FALSE,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_bitfield, /* complain_on_overflow */
 241          bfd_elf_generic_reloc, /* special_function */
 242          "R_PPC64_ADDR32",      /* name */
 243          FALSE,                 /* partial_inplace */
 244          0,                     /* src_mask */
 245          0xffffffff,            /* dst_mask */
 246          FALSE),                /* pcrel_offset */
 247
 248   /* An absolute 26 bit branch; the lower two bits must be zero.
 249      FIXME: we don't check that, we just clear them.  */
 250   HOWTO (R_PPC64_ADDR24,        /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          26,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_bitfield, /* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_PPC64_ADDR24",      /* name */
 259          FALSE,                 /* partial_inplace */
 260          0,                     /* src_mask */
 261          0x03fffffc,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   /* A standard 16 bit relocation.  */
 265   HOWTO (R_PPC64_ADDR16,        /* type */
 266          0,                     /* rightshift */
 267          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          16,                    /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_bitfield, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_ADDR16",      /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0xffff,                /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A 16 bit relocation without overflow.  */
 280   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 281          0,                     /* rightshift */
 282          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          16,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_dont,/* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR16_LO",   /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffff,                /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* Bits 16-31 of an address.  */
 295   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 296          16,                    /* rightshift */
 297          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_dont, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC64_ADDR16_HI",   /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0xffff,                /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 310      bits, treated as a signed number, is negative.  */
 311   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 312          16,                    /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_dont, /* complain_on_overflow */
 318          ppc64_elf_ha_reloc,    /* special_function */
 319          "R_PPC64_ADDR16_HA",   /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* An absolute 16 bit branch; the lower two bits must be zero.
 326      FIXME: we don't check that, we just clear them.  */
 327   HOWTO (R_PPC64_ADDR14,        /* type */
 328          0,                     /* rightshift */
 329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 330          16,                    /* bitsize */
 331          FALSE,                 /* pc_relative */
 332          0,                     /* bitpos */
 333          complain_overflow_bitfield, /* complain_on_overflow */
 334          ppc64_elf_branch_reloc, /* special_function */
 335          "R_PPC64_ADDR14",      /* name */
 336          FALSE,                 /* partial_inplace */
 337          0,                     /* src_mask */
 338          0x0000fffc,            /* dst_mask */
 339          FALSE),                /* pcrel_offset */
 340
 341   /* An absolute 16 bit branch, for which bit 10 should be set to
 342      indicate that the branch is expected to be taken.  The lower two
 343      bits must be zero.  */
 344   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          16,                    /* bitsize */
 348          FALSE,                 /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_bitfield, /* complain_on_overflow */
 351          ppc64_elf_brtaken_reloc, /* special_function */
 352          "R_PPC64_ADDR14_BRTAKEN",/* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x0000fffc,            /* dst_mask */
 356          FALSE),                /* pcrel_offset */
 357
 358   /* An absolute 16 bit branch, for which bit 10 should be set to
 359      indicate that the branch is not expected to be taken.  The lower
 360      two bits must be zero.  */
 361   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 362          0,                     /* rightshift */
 363          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_bitfield, /* complain_on_overflow */
 368          ppc64_elf_brtaken_reloc, /* special_function */
 369          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0x0000fffc,            /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* A relative 26 bit branch; the lower two bits must be zero.  */
 376   HOWTO (R_PPC64_REL24,         /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          26,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          ppc64_elf_branch_reloc, /* special_function */
 384          "R_PPC64_REL24",       /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0x03fffffc,            /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch; the lower two bits must be zero.  */
 391   HOWTO (R_PPC64_REL14,         /* type */
 392          0,                     /* rightshift */
 393          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 394          16,                    /* bitsize */
 395          TRUE,                  /* pc_relative */
 396          0,                     /* bitpos */
 397          complain_overflow_signed, /* complain_on_overflow */
 398          ppc64_elf_branch_reloc, /* special_function */
 399          "R_PPC64_REL14",       /* name */
 400          FALSE,                 /* partial_inplace */
 401          0,                     /* src_mask */
 402          0x0000fffc,            /* dst_mask */
 403          TRUE),                 /* pcrel_offset */
 404
 405   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 406      the branch is expected to be taken.  The lower two bits must be
 407      zero.  */
 408   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          ppc64_elf_brtaken_reloc, /* special_function */
 416          "R_PPC64_REL14_BRTAKEN", /* name */
 417          FALSE,                 /* partial_inplace */
 418          0,                     /* src_mask */
 419          0x0000fffc,            /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 423      the branch is not expected to be taken.  The lower two bits must
 424      be zero.  */
 425   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 426          0,                     /* rightshift */
 427          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          TRUE,                  /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_signed, /* complain_on_overflow */
 432          ppc64_elf_brtaken_reloc, /* special_function */
 433          "R_PPC64_REL14_BRNTAKEN",/* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0x0000fffc,            /* dst_mask */
 437          TRUE),                 /* pcrel_offset */
 438
 439   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 440      symbol.  */
 441   HOWTO (R_PPC64_GOT16,         /* type */
 442          0,                     /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_unhandled_reloc, /* special_function */
 449          "R_PPC64_GOT16",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                /* pcrel_offset */
 454
 455   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC64_GOT16_LO,      /* type */
 458          0,                     /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          ppc64_elf_unhandled_reloc, /* special_function */
 465          "R_PPC64_GOT16_LO",    /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 472      the symbol.  */
 473   HOWTO (R_PPC64_GOT16_HI,      /* type */
 474          16,                    /* rightshift */
 475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          16,                    /* bitsize */
 477          FALSE,                 /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_dont,/* complain_on_overflow */
 480          ppc64_elf_unhandled_reloc, /* special_function */
 481          "R_PPC64_GOT16_HI",    /* name */
 482          FALSE,                 /* partial_inplace */
 483          0,                     /* src_mask */
 484          0xffff,                /* dst_mask */
 485          FALSE),                /* pcrel_offset */
 486
 487   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 488      the symbol.  */
 489   HOWTO (R_PPC64_GOT16_HA,      /* type */
 490          16,                    /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_dont,/* complain_on_overflow */
 496          ppc64_elf_unhandled_reloc, /* special_function */
 497          "R_PPC64_GOT16_HA",    /* name */
 498          FALSE,                 /* partial_inplace */
 499          0,                     /* src_mask */
 500          0xffff,                /* dst_mask */
 501          FALSE),                /* pcrel_offset */
 502
 503   /* This is used only by the dynamic linker.  The symbol should exist
 504      both in the object being run and in some shared library.  The
 505      dynamic linker copies the data addressed by the symbol from the
 506      shared library into the object, because the object being
 507      run has to have the data at some particular address.  */
 508   HOWTO (R_PPC64_COPY,          /* type */
 509          0,                     /* rightshift */
 510          0,                     /* this one is variable size */
 511          0,                     /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_COPY",        /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0,                     /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR64, but used when setting global offset table
 523      entries.  */
 524   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 525          0,                     /* rightshift */
 526          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 527          64,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_dont, /* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc,  /* special_function */
 532          "R_PPC64_GLOB_DAT",    /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          ONES (64),             /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Created by the link editor.  Marks a procedure linkage table
 539      entry for a symbol.  */
 540   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 541          0,                     /* rightshift */
 542          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          0,                     /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_JMP_SLOT",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0,                     /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Used only by the dynamic linker.  When the object is run, this
 555      doubleword64 is set to the load address of the object, plus the
 556      addend.  */
 557   HOWTO (R_PPC64_RELATIVE,      /* type */
 558          0,                     /* rightshift */
 559          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 560          64,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_dont, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC64_RELATIVE",    /* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          ONES (64),             /* dst_mask */
 569          FALSE),                /* pcrel_offset */
 570
 571   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 572   HOWTO (R_PPC64_UADDR32,       /* type */
 573          0,                     /* rightshift */
 574          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          32,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_bitfield, /* complain_on_overflow */
 579          bfd_elf_generic_reloc, /* special_function */
 580          "R_PPC64_UADDR32",     /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffffffff,            /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 587   HOWTO (R_PPC64_UADDR16,       /* type */
 588          0,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          16,                    /* bitsize */
 591          FALSE,                 /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_bitfield, /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_PPC64_UADDR16",     /* name */
 596          FALSE,                 /* partial_inplace */
 597          0,                     /* src_mask */
 598          0xffff,                /* dst_mask */
 599          FALSE),                /* pcrel_offset */
 600
 601   /* 32-bit PC relative.  */
 602   HOWTO (R_PPC64_REL32,         /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 609          complain_overflow_signed, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_REL32",       /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          0xffffffff,            /* dst_mask */
 615          TRUE),                 /* pcrel_offset */
 616
 617   /* 32-bit relocation to the symbol's procedure linkage table.  */
 618   HOWTO (R_PPC64_PLT32,         /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          ppc64_elf_unhandled_reloc, /* special_function */
 626          "R_PPC64_PLT32",       /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 633      FIXME: R_PPC64_PLTREL32 not supported.  */
 634   HOWTO (R_PPC64_PLTREL32,      /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          TRUE,                  /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_signed, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_PPC64_PLTREL32",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          TRUE),                 /* pcrel_offset */
 647
 648   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC64_PLT16_LO,      /* type */
 651          0,                     /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          ppc64_elf_unhandled_reloc, /* special_function */
 658          "R_PPC64_PLT16_LO",    /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 665      the symbol.  */
 666   HOWTO (R_PPC64_PLT16_HI,      /* type */
 667          16,                    /* rightshift */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          16,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_dont, /* complain_on_overflow */
 673          ppc64_elf_unhandled_reloc, /* special_function */
 674          "R_PPC64_PLT16_HI",    /* name */
 675          FALSE,                 /* partial_inplace */
 676          0,                     /* src_mask */
 677          0xffff,                /* dst_mask */
 678          FALSE),                /* pcrel_offset */
 679
 680   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 681      the symbol.  */
 682   HOWTO (R_PPC64_PLT16_HA,      /* type */
 683          16,                    /* rightshift */
 684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          16,                    /* bitsize */
 686          FALSE,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_dont, /* complain_on_overflow */
 689          ppc64_elf_unhandled_reloc, /* special_function */
 690          "R_PPC64_PLT16_HA",    /* name */
 691          FALSE,                 /* partial_inplace */
 692          0,                     /* src_mask */
 693          0xffff,                /* dst_mask */
 694          FALSE),                /* pcrel_offset */
 695
 696   /* 16-bit section relative relocation.  */
 697   HOWTO (R_PPC64_SECTOFF,       /* type */
 698          0,                     /* rightshift */
 699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 700          16,                    /* bitsize */
 701          FALSE,                 /* pc_relative */
 702          0,                     /* bitpos */
 703          complain_overflow_bitfield, /* complain_on_overflow */
 704          ppc64_elf_sectoff_reloc, /* special_function */
 705          "R_PPC64_SECTOFF",     /* name */
 706          FALSE,                 /* partial_inplace */
 707          0,                     /* src_mask */
 708          0xffff,                /* dst_mask */
 709          FALSE),                /* pcrel_offset */
 710
 711   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 712   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 713          0,                     /* rightshift */
 714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 715          16,                    /* bitsize */
 716          FALSE,                 /* pc_relative */
 717          0,                     /* bitpos */
 718          complain_overflow_dont, /* complain_on_overflow */
 719          ppc64_elf_sectoff_reloc, /* special_function */
 720          "R_PPC64_SECTOFF_LO",  /* name */
 721          FALSE,                 /* partial_inplace */
 722          0,                     /* src_mask */
 723          0xffff,                /* dst_mask */
 724          FALSE),                /* pcrel_offset */
 725
 726   /* 16-bit upper half section relative relocation.  */
 727   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          ppc64_elf_sectoff_reloc, /* special_function */
 735          "R_PPC64_SECTOFF_HI",  /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit upper half adjusted section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 743          16,                    /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_dont, /* complain_on_overflow */
 749          ppc64_elf_sectoff_ha_reloc, /* special_function */
 750          "R_PPC64_SECTOFF_HA",  /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 757   HOWTO (R_PPC64_REL30,         /* type */
 758          2,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          30,                    /* bitsize */
 761          TRUE,                  /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_PPC64_REL30",       /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xfffffffc,            /* dst_mask */
 769          TRUE),                 /* pcrel_offset */
 770
 771   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 772
 773   /* A standard 64-bit relocation.  */
 774   HOWTO (R_PPC64_ADDR64,        /* type */
 775          0,                     /* rightshift */
 776          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 777          64,                    /* bitsize */
 778          FALSE,                 /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_dont, /* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_PPC64_ADDR64",      /* name */
 783          FALSE,                 /* partial_inplace */
 784          0,                     /* src_mask */
 785          ONES (64),             /* dst_mask */
 786          FALSE),                /* pcrel_offset */
 787
 788   /* The bits 32-47 of an address.  */
 789   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 790          32,                    /* rightshift */
 791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 792          16,                    /* bitsize */
 793          FALSE,                 /* pc_relative */
 794          0,                     /* bitpos */
 795          complain_overflow_dont, /* complain_on_overflow */
 796          bfd_elf_generic_reloc, /* special_function */
 797          "R_PPC64_ADDR16_HIGHER", /* name */
 798          FALSE,                 /* partial_inplace */
 799          0,                     /* src_mask */
 800          0xffff,                /* dst_mask */
 801          FALSE),                /* pcrel_offset */
 802
 803   /* The bits 32-47 of an address, plus 1 if the contents of the low
 804      16 bits, treated as a signed number, is negative.  */
 805   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 806          32,                    /* rightshift */
 807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 808          16,                    /* bitsize */
 809          FALSE,                 /* pc_relative */
 810          0,                     /* bitpos */
 811          complain_overflow_dont, /* complain_on_overflow */
 812          ppc64_elf_ha_reloc,    /* special_function */
 813          "R_PPC64_ADDR16_HIGHERA", /* name */
 814          FALSE,                 /* partial_inplace */
 815          0,                     /* src_mask */
 816          0xffff,                /* dst_mask */
 817          FALSE),                /* pcrel_offset */
 818
 819   /* The bits 48-63 of an address.  */
 820   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 821          48,                    /* rightshift */
 822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 823          16,                    /* bitsize */
 824          FALSE,                 /* pc_relative */
 825          0,                     /* bitpos */
 826          complain_overflow_dont, /* complain_on_overflow */
 827          bfd_elf_generic_reloc, /* special_function */
 828          "R_PPC64_ADDR16_HIGHEST", /* name */
 829          FALSE,                 /* partial_inplace */
 830          0,                     /* src_mask */
 831          0xffff,                /* dst_mask */
 832          FALSE),                /* pcrel_offset */
 833
 834   /* The bits 48-63 of an address, plus 1 if the contents of the low
 835      16 bits, treated as a signed number, is negative.  */
 836   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 837          48,                    /* rightshift */
 838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 839          16,                    /* bitsize */
 840          FALSE,                 /* pc_relative */
 841          0,                     /* bitpos */
 842          complain_overflow_dont, /* complain_on_overflow */
 843          ppc64_elf_ha_reloc,    /* special_function */
 844          "R_PPC64_ADDR16_HIGHESTA", /* name */
 845          FALSE,                 /* partial_inplace */
 846          0,                     /* src_mask */
 847          0xffff,                /* dst_mask */
 848          FALSE),                /* pcrel_offset */
 849
 850   /* Like ADDR64, but may be unaligned.  */
 851   HOWTO (R_PPC64_UADDR64,       /* type */
 852          0,                     /* rightshift */
 853          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 854          64,                    /* bitsize */
 855          FALSE,                 /* pc_relative */
 856          0,                     /* bitpos */
 857          complain_overflow_dont, /* complain_on_overflow */
 858          bfd_elf_generic_reloc, /* special_function */
 859          "R_PPC64_UADDR64",     /* name */
 860          FALSE,                 /* partial_inplace */
 861          0,                     /* src_mask */
 862          ONES (64),             /* dst_mask */
 863          FALSE),                /* pcrel_offset */
 864
 865   /* 64-bit relative relocation.  */
 866   HOWTO (R_PPC64_REL64,         /* type */
 867          0,                     /* rightshift */
 868          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 869          64,                    /* bitsize */
 870          TRUE,                  /* pc_relative */
 871          0,                     /* bitpos */
 872          complain_overflow_dont, /* complain_on_overflow */
 873          bfd_elf_generic_reloc, /* special_function */
 874          "R_PPC64_REL64",       /* name */
 875          FALSE,                 /* partial_inplace */
 876          0,                     /* src_mask */
 877          ONES (64),             /* dst_mask */
 878          TRUE),                 /* pcrel_offset */
 879
 880   /* 64-bit relocation to the symbol's procedure linkage table.  */
 881   HOWTO (R_PPC64_PLT64,         /* type */
 882          0,                     /* rightshift */
 883          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 884          64,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_unhandled_reloc, /* special_function */
 889          "R_PPC64_PLT64",       /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          ONES (64),             /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* 64-bit PC relative relocation to the symbol's procedure linkage
 896      table.  */
 897   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 898   HOWTO (R_PPC64_PLTREL64,      /* type */
 899          0,                     /* rightshift */
 900          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 901          64,                    /* bitsize */
 902          TRUE,                  /* pc_relative */
 903          0,                     /* bitpos */
 904          complain_overflow_dont, /* complain_on_overflow */
 905          ppc64_elf_unhandled_reloc, /* special_function */
 906          "R_PPC64_PLTREL64",    /* name */
 907          FALSE,                 /* partial_inplace */
 908          0,                     /* src_mask */
 909          ONES (64),             /* dst_mask */
 910          TRUE),                 /* pcrel_offset */
 911
 912   /* 16 bit TOC-relative relocation.  */
 913
 914   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 915   HOWTO (R_PPC64_TOC16,         /* type */
 916          0,                     /* rightshift */
 917          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 918          16,                    /* bitsize */
 919          FALSE,                 /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_signed, /* complain_on_overflow */
 922          ppc64_elf_toc_reloc,   /* special_function */
 923          "R_PPC64_TOC16",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          0xffff,                /* dst_mask */
 927          FALSE),                /* pcrel_offset */
 928
 929   /* 16 bit TOC-relative relocation without overflow.  */
 930
 931   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 932   HOWTO (R_PPC64_TOC16_LO,      /* type */
 933          0,                     /* rightshift */
 934          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 935          16,                    /* bitsize */
 936          FALSE,                 /* pc_relative */
 937          0,                     /* bitpos */
 938          complain_overflow_dont, /* complain_on_overflow */
 939          ppc64_elf_toc_reloc,   /* special_function */
 940          "R_PPC64_TOC16_LO",    /* name */
 941          FALSE,                 /* partial_inplace */
 942          0,                     /* src_mask */
 943          0xffff,                /* dst_mask */
 944          FALSE),                /* pcrel_offset */
 945
 946   /* 16 bit TOC-relative relocation, high 16 bits.  */
 947
 948   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 949   HOWTO (R_PPC64_TOC16_HI,      /* type */
 950          16,                    /* rightshift */
 951          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 952          16,                    /* bitsize */
 953          FALSE,                 /* pc_relative */
 954          0,                     /* bitpos */
 955          complain_overflow_dont, /* complain_on_overflow */
 956          ppc64_elf_toc_reloc,   /* special_function */
 957          "R_PPC64_TOC16_HI",    /* name */
 958          FALSE,                 /* partial_inplace */
 959          0,                     /* src_mask */
 960          0xffff,                /* dst_mask */
 961          FALSE),                /* pcrel_offset */
 962
 963   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 964      contents of the low 16 bits, treated as a signed number, is
 965      negative.  */
 966
 967   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 968   HOWTO (R_PPC64_TOC16_HA,      /* type */
 969          16,                    /* rightshift */
 970          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 971          16,                    /* bitsize */
 972          FALSE,                 /* pc_relative */
 973          0,                     /* bitpos */
 974          complain_overflow_dont, /* complain_on_overflow */
 975          ppc64_elf_toc_ha_reloc, /* special_function */
 976          "R_PPC64_TOC16_HA",    /* name */
 977          FALSE,                 /* partial_inplace */
 978          0,                     /* src_mask */
 979          0xffff,                /* dst_mask */
 980          FALSE),                /* pcrel_offset */
 981
 982   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 983
 984   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 985   HOWTO (R_PPC64_TOC,           /* type */
 986          0,                     /* rightshift */
 987          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 988          64,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_bitfield, /* complain_on_overflow */
 992          ppc64_elf_toc64_reloc, /* special_function */
 993          "R_PPC64_TOC",         /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          ONES (64),             /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* Like R_PPC64_GOT16, but also informs the link editor that the
1000      value to relocate may (!) refer to a PLT entry which the link
1001      editor (a) may replace with the symbol value.  If the link editor
1002      is unable to fully resolve the symbol, it may (b) create a PLT
1003      entry and store the address to the new PLT entry in the GOT.
1004      This permits lazy resolution of function symbols at run time.
1005      The link editor may also skip all of this and just (c) emit a
1006      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1007   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1008     HOWTO (R_PPC64_PLTGOT16,    /* type */
1009          0,                     /* rightshift */
1010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          16,                    /* bitsize */
1012          FALSE,                 /* pc_relative */
1013          0,                     /* bitpos */
1014          complain_overflow_signed, /* complain_on_overflow */
1015          ppc64_elf_unhandled_reloc, /* special_function */
1016          "R_PPC64_PLTGOT16",    /* name */
1017          FALSE,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0xffff,                /* dst_mask */
1020          FALSE),                /* pcrel_offset */
1021
1022   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1023   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1024   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1025          0,                     /* rightshift */
1026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1027          16,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_unhandled_reloc, /* special_function */
1032          "R_PPC64_PLTGOT16_LO", /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          0xffff,                /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1039   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1040   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1041          16,                    /* rightshift */
1042          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1043          16,                    /* bitsize */
1044          FALSE,                 /* pc_relative */
1045          0,                     /* bitpos */
1046          complain_overflow_dont, /* complain_on_overflow */
1047          ppc64_elf_unhandled_reloc, /* special_function */
1048          "R_PPC64_PLTGOT16_HI", /* name */
1049          FALSE,                 /* partial_inplace */
1050          0,                     /* src_mask */
1051          0xffff,                /* dst_mask */
1052          FALSE),                /* pcrel_offset */
1053
1054   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055      1 if the contents of the low 16 bits, treated as a signed number,
1056      is negative.  */
1057   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1058   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1059          16,                    /* rightshift */
1060          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1061          16,                    /* bitsize */
1062          FALSE,                 /* pc_relative */
1063          0,                     /* bitpos */
1064          complain_overflow_dont,/* complain_on_overflow */
1065          ppc64_elf_unhandled_reloc, /* special_function */
1066          "R_PPC64_PLTGOT16_HA", /* name */
1067          FALSE,                 /* partial_inplace */
1068          0,                     /* src_mask */
1069          0xffff,                /* dst_mask */
1070          FALSE),                /* pcrel_offset */
1071
1072   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1073   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_bitfield, /* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_PPC64_ADDR16_DS",   /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xfffc,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1088   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1089          0,                     /* rightshift */
1090          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1091          16,                    /* bitsize */
1092          FALSE,                 /* pc_relative */
1093          0,                     /* bitpos */
1094          complain_overflow_dont,/* complain_on_overflow */
1095          bfd_elf_generic_reloc, /* special_function */
1096          "R_PPC64_ADDR16_LO_DS",/* name */
1097          FALSE,                 /* partial_inplace */
1098          0,                     /* src_mask */
1099          0xfffc,                /* dst_mask */
1100          FALSE),                /* pcrel_offset */
1101
1102   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1103   HOWTO (R_PPC64_GOT16_DS,      /* type */
1104          0,                     /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_GOT16_DS",    /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xfffc,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_dont, /* complain_on_overflow */
1125          ppc64_elf_unhandled_reloc, /* special_function */
1126          "R_PPC64_GOT16_LO_DS", /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont, /* complain_on_overflow */
1140          ppc64_elf_unhandled_reloc, /* special_function */
1141          "R_PPC64_PLT16_LO_DS", /* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_bitfield, /* complain_on_overflow */
1155          ppc64_elf_sectoff_reloc, /* special_function */
1156          "R_PPC64_SECTOFF_DS",  /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_sectoff_reloc, /* special_function */
1171          "R_PPC64_SECTOFF_LO_DS",/* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_TOC16_DS,      /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_signed, /* complain_on_overflow */
1185          ppc64_elf_toc_reloc,   /* special_function */
1186          "R_PPC64_TOC16_DS",    /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont, /* complain_on_overflow */
1200          ppc64_elf_toc_reloc,   /* special_function */
1201          "R_PPC64_TOC16_LO_DS", /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1208   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1209   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1210          0,                     /* rightshift */
1211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1212          16,                    /* bitsize */
1213          FALSE,                 /* pc_relative */
1214          0,                     /* bitpos */
1215          complain_overflow_signed, /* complain_on_overflow */
1216          ppc64_elf_unhandled_reloc, /* special_function */
1217          "R_PPC64_PLTGOT16_DS", /* name */
1218          FALSE,                 /* partial_inplace */
1219          0,                     /* src_mask */
1220          0xfffc,                /* dst_mask */
1221          FALSE),                /* pcrel_offset */
1222
1223   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1224   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1225   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226          0,                     /* rightshift */
1227          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1228          16,                    /* bitsize */
1229          FALSE,                 /* pc_relative */
1230          0,                     /* bitpos */
1231          complain_overflow_dont, /* complain_on_overflow */
1232          ppc64_elf_unhandled_reloc, /* special_function */
1233          "R_PPC64_PLTGOT16_LO_DS",/* name */
1234          FALSE,                 /* partial_inplace */
1235          0,                     /* src_mask */
1236          0xfffc,                /* dst_mask */
1237          FALSE),                /* pcrel_offset */
1238
1239   /* Marker relocs for TLS.  */
1240   HOWTO (R_PPC64_TLS,
1241          0,                     /* rightshift */
1242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1243          32,                    /* bitsize */
1244          FALSE,                 /* pc_relative */
1245          0,                     /* bitpos */
1246          complain_overflow_dont, /* complain_on_overflow */
1247          bfd_elf_generic_reloc, /* special_function */
1248          "R_PPC64_TLS",         /* name */
1249          FALSE,                 /* partial_inplace */
1250          0,                     /* src_mask */
1251          0,                     /* dst_mask */
1252          FALSE),                /* pcrel_offset */
1253
1254   HOWTO (R_PPC64_TLSGD,
1255          0,                     /* rightshift */
1256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          32,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_dont, /* complain_on_overflow */
1261          bfd_elf_generic_reloc, /* special_function */
1262          "R_PPC64_TLSGD",       /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0,                     /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   HOWTO (R_PPC64_TLSLD,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLSLD",       /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   /* Computes the load module index of the load module that contains the
1283      definition of its TLS sym.  */
1284   HOWTO (R_PPC64_DTPMOD64,
1285          0,                     /* rightshift */
1286          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1287          64,                    /* bitsize */
1288          FALSE,                 /* pc_relative */
1289          0,                     /* bitpos */
1290          complain_overflow_dont, /* complain_on_overflow */
1291          ppc64_elf_unhandled_reloc, /* special_function */
1292          "R_PPC64_DTPMOD64",    /* name */
1293          FALSE,                 /* partial_inplace */
1294          0,                     /* src_mask */
1295          ONES (64),             /* dst_mask */
1296          FALSE),                /* pcrel_offset */
1297
1298   /* Computes a dtv-relative displacement, the difference between the value
1299      of sym+add and the base address of the thread-local storage block that
1300      contains the definition of sym, minus 0x8000.  */
1301   HOWTO (R_PPC64_DTPREL64,
1302          0,                     /* rightshift */
1303          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          64,                    /* 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_DTPREL64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* A 16 bit dtprel reloc.  */
1316   HOWTO (R_PPC64_DTPREL16,
1317          0,                     /* rightshift */
1318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1319          16,                    /* bitsize */
1320          FALSE,                 /* pc_relative */
1321          0,                     /* bitpos */
1322          complain_overflow_signed, /* complain_on_overflow */
1323          ppc64_elf_unhandled_reloc, /* special_function */
1324          "R_PPC64_DTPREL16",    /* name */
1325          FALSE,                 /* partial_inplace */
1326          0,                     /* src_mask */
1327          0xffff,                /* dst_mask */
1328          FALSE),                /* pcrel_offset */
1329
1330   /* Like DTPREL16, but no overflow.  */
1331   HOWTO (R_PPC64_DTPREL16_LO,
1332          0,                     /* 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_LO", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0xffff,                /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1346   HOWTO (R_PPC64_DTPREL16_HI,
1347          16,                    /* 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_HI", /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1361   HOWTO (R_PPC64_DTPREL16_HA,
1362          16,                    /* 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_HA", /* name */
1370          FALSE,                 /* partial_inplace */
1371          0,                     /* src_mask */
1372          0xffff,                /* dst_mask */
1373          FALSE),                /* pcrel_offset */
1374
1375   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1376   HOWTO (R_PPC64_DTPREL16_HIGHER,
1377          32,                    /* 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_HIGHER", /* name */
1385          FALSE,                 /* partial_inplace */
1386          0,                     /* src_mask */
1387          0xffff,                /* dst_mask */
1388          FALSE),                /* pcrel_offset */
1389
1390   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1391   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392          32,                    /* 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_HIGHERA", /* name */
1400          FALSE,                 /* partial_inplace */
1401          0,                     /* src_mask */
1402          0xffff,                /* dst_mask */
1403          FALSE),                /* pcrel_offset */
1404
1405   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1406   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407          48,                    /* rightshift */
1408          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1409          16,                    /* bitsize */
1410          FALSE,                 /* pc_relative */
1411          0,                     /* bitpos */
1412          complain_overflow_dont, /* complain_on_overflow */
1413          ppc64_elf_unhandled_reloc, /* special_function */
1414          "R_PPC64_DTPREL16_HIGHEST", /* name */
1415          FALSE,                 /* partial_inplace */
1416          0,                     /* src_mask */
1417          0xffff,                /* dst_mask */
1418          FALSE),                /* pcrel_offset */
1419
1420   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1421   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422          48,                    /* 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_HIGHESTA", /* name */
1430          FALSE,                 /* partial_inplace */
1431          0,                     /* src_mask */
1432          0xffff,                /* dst_mask */
1433          FALSE),                /* pcrel_offset */
1434
1435   /* Like DTPREL16, but for insns with a DS field.  */
1436   HOWTO (R_PPC64_DTPREL16_DS,
1437          0,                     /* rightshift */
1438          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1439          16,                    /* bitsize */
1440          FALSE,                 /* pc_relative */
1441          0,                     /* bitpos */
1442          complain_overflow_signed, /* complain_on_overflow */
1443          ppc64_elf_unhandled_reloc, /* special_function */
1444          "R_PPC64_DTPREL16_DS", /* name */
1445          FALSE,                 /* partial_inplace */
1446          0,                     /* src_mask */
1447          0xfffc,                /* dst_mask */
1448          FALSE),                /* pcrel_offset */
1449
1450   /* Like DTPREL16_DS, but no overflow.  */
1451   HOWTO (R_PPC64_DTPREL16_LO_DS,
1452          0,                     /* rightshift */
1453          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1454          16,                    /* bitsize */
1455          FALSE,                 /* pc_relative */
1456          0,                     /* bitpos */
1457          complain_overflow_dont, /* complain_on_overflow */
1458          ppc64_elf_unhandled_reloc, /* special_function */
1459          "R_PPC64_DTPREL16_LO_DS", /* name */
1460          FALSE,                 /* partial_inplace */
1461          0,                     /* src_mask */
1462          0xfffc,                /* dst_mask */
1463          FALSE),                /* pcrel_offset */
1464
1465   /* Computes a tp-relative displacement, the difference between the value of
1466      sym+add and the value of the thread pointer (r13).  */
1467   HOWTO (R_PPC64_TPREL64,
1468          0,                     /* rightshift */
1469          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          64,                    /* 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_TPREL64",     /* name */
1476          FALSE,                 /* partial_inplace */
1477          0,                     /* src_mask */
1478          ONES (64),             /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   /* A 16 bit tprel reloc.  */
1482   HOWTO (R_PPC64_TPREL16,
1483          0,                     /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_signed, /* complain_on_overflow */
1489          ppc64_elf_unhandled_reloc, /* special_function */
1490          "R_PPC64_TPREL16",     /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Like TPREL16, but no overflow.  */
1497   HOWTO (R_PPC64_TPREL16_LO,
1498          0,                     /* 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_LO",  /* name */
1506          FALSE,                 /* partial_inplace */
1507          0,                     /* src_mask */
1508          0xffff,                /* dst_mask */
1509          FALSE),                /* pcrel_offset */
1510
1511   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1512   HOWTO (R_PPC64_TPREL16_HI,
1513          16,                    /* 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_HI",  /* name */
1521          FALSE,                 /* partial_inplace */
1522          0,                     /* src_mask */
1523          0xffff,                /* dst_mask */
1524          FALSE),                /* pcrel_offset */
1525
1526   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1527   HOWTO (R_PPC64_TPREL16_HA,
1528          16,                    /* 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_HA",  /* name */
1536          FALSE,                 /* partial_inplace */
1537          0,                     /* src_mask */
1538          0xffff,                /* dst_mask */
1539          FALSE),                /* pcrel_offset */
1540
1541   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1542   HOWTO (R_PPC64_TPREL16_HIGHER,
1543          32,                    /* 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_HIGHER",      /* name */
1551          FALSE,                 /* partial_inplace */
1552          0,                     /* src_mask */
1553          0xffff,                /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1557   HOWTO (R_PPC64_TPREL16_HIGHERA,
1558          32,                    /* 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_HIGHERA", /* name */
1566          FALSE,                 /* partial_inplace */
1567          0,                     /* src_mask */
1568          0xffff,                /* dst_mask */
1569          FALSE),                /* pcrel_offset */
1570
1571   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1572   HOWTO (R_PPC64_TPREL16_HIGHEST,
1573          48,                    /* rightshift */
1574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1575          16,                    /* bitsize */
1576          FALSE,                 /* pc_relative */
1577          0,                     /* bitpos */
1578          complain_overflow_dont, /* complain_on_overflow */
1579          ppc64_elf_unhandled_reloc, /* special_function */
1580          "R_PPC64_TPREL16_HIGHEST", /* name */
1581          FALSE,                 /* partial_inplace */
1582          0,                     /* src_mask */
1583          0xffff,                /* dst_mask */
1584          FALSE),                /* pcrel_offset */
1585
1586   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1587   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588          48,                    /* 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_HIGHESTA", /* name */
1596          FALSE,                 /* partial_inplace */
1597          0,                     /* src_mask */
1598          0xffff,                /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600
1601   /* Like TPREL16, but for insns with a DS field.  */
1602   HOWTO (R_PPC64_TPREL16_DS,
1603          0,                     /* rightshift */
1604          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          16,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_signed, /* complain_on_overflow */
1609          ppc64_elf_unhandled_reloc, /* special_function */
1610          "R_PPC64_TPREL16_DS",  /* name */
1611          FALSE,                 /* partial_inplace */
1612          0,                     /* src_mask */
1613          0xfffc,                /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   /* Like TPREL16_DS, but no overflow.  */
1617   HOWTO (R_PPC64_TPREL16_LO_DS,
1618          0,                     /* rightshift */
1619          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1620          16,                    /* bitsize */
1621          FALSE,                 /* pc_relative */
1622          0,                     /* bitpos */
1623          complain_overflow_dont, /* complain_on_overflow */
1624          ppc64_elf_unhandled_reloc, /* special_function */
1625          "R_PPC64_TPREL16_LO_DS", /* name */
1626          FALSE,                 /* partial_inplace */
1627          0,                     /* src_mask */
1628          0xfffc,                /* dst_mask */
1629          FALSE),                /* pcrel_offset */
1630
1631   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633      to the first entry relative to the TOC base (r2).  */
1634   HOWTO (R_PPC64_GOT_TLSGD16,
1635          0,                     /* rightshift */
1636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1637          16,                    /* bitsize */
1638          FALSE,                 /* pc_relative */
1639          0,                     /* bitpos */
1640          complain_overflow_signed, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_GOT_TLSGD16", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xffff,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Like GOT_TLSGD16, but no overflow.  */
1649   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650          0,                     /* 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_LO", /* name */
1658          FALSE,                 /* partial_inplace */
1659          0,                     /* src_mask */
1660          0xffff,                /* dst_mask */
1661          FALSE),                /* pcrel_offset */
1662
1663   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1664   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665          16,                    /* rightshift */
1666          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1667          16,                    /* bitsize */
1668          FALSE,                 /* pc_relative */
1669          0,                     /* bitpos */
1670          complain_overflow_dont, /* complain_on_overflow */
1671          ppc64_elf_unhandled_reloc, /* special_function */
1672          "R_PPC64_GOT_TLSGD16_HI", /* name */
1673          FALSE,                 /* partial_inplace */
1674          0,                     /* src_mask */
1675          0xffff,                /* dst_mask */
1676          FALSE),                /* pcrel_offset */
1677
1678   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1679   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680          16,                    /* rightshift */
1681          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1682          16,                    /* bitsize */
1683          FALSE,                 /* pc_relative */
1684          0,                     /* bitpos */
1685          complain_overflow_dont, /* complain_on_overflow */
1686          ppc64_elf_unhandled_reloc, /* special_function */
1687          "R_PPC64_GOT_TLSGD16_HA", /* name */
1688          FALSE,                 /* partial_inplace */
1689          0,                     /* src_mask */
1690          0xffff,                /* dst_mask */
1691          FALSE),                /* pcrel_offset */
1692
1693   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694      with values (sym+add)@dtpmod and zero, and computes the offset to the
1695      first entry relative to the TOC base (r2).  */
1696   HOWTO (R_PPC64_GOT_TLSLD16,
1697          0,                     /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_signed, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSLD16", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Like GOT_TLSLD16, but no overflow.  */
1711   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712          0,                     /* 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_LO", /* name */
1720          FALSE,                 /* partial_inplace */
1721          0,                     /* src_mask */
1722          0xffff,                /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1726   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727          16,                    /* rightshift */
1728          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1729          16,                    /* bitsize */
1730          FALSE,                 /* pc_relative */
1731          0,                     /* bitpos */
1732          complain_overflow_dont, /* complain_on_overflow */
1733          ppc64_elf_unhandled_reloc, /* special_function */
1734          "R_PPC64_GOT_TLSLD16_HI", /* name */
1735          FALSE,                 /* partial_inplace */
1736          0,                     /* src_mask */
1737          0xffff,                /* dst_mask */
1738          FALSE),                /* pcrel_offset */
1739
1740   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1741   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742          16,                    /* rightshift */
1743          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1744          16,                    /* bitsize */
1745          FALSE,                 /* pc_relative */
1746          0,                     /* bitpos */
1747          complain_overflow_dont, /* complain_on_overflow */
1748          ppc64_elf_unhandled_reloc, /* special_function */
1749          "R_PPC64_GOT_TLSLD16_HA", /* name */
1750          FALSE,                 /* partial_inplace */
1751          0,                     /* src_mask */
1752          0xffff,                /* dst_mask */
1753          FALSE),                /* pcrel_offset */
1754
1755   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756      the offset to the entry relative to the TOC base (r2).  */
1757   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758          0,                     /* rightshift */
1759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1760          16,                    /* bitsize */
1761          FALSE,                 /* pc_relative */
1762          0,                     /* bitpos */
1763          complain_overflow_signed, /* complain_on_overflow */
1764          ppc64_elf_unhandled_reloc, /* special_function */
1765          "R_PPC64_GOT_DTPREL16_DS", /* name */
1766          FALSE,                 /* partial_inplace */
1767          0,                     /* src_mask */
1768          0xfffc,                /* dst_mask */
1769          FALSE),                /* pcrel_offset */
1770
1771   /* Like GOT_DTPREL16_DS, but no overflow.  */
1772   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773          0,                     /* 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_LO_DS", /* name */
1781          FALSE,                 /* partial_inplace */
1782          0,                     /* src_mask */
1783          0xfffc,                /* dst_mask */
1784          FALSE),                /* pcrel_offset */
1785
1786   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1787   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788          16,                    /* rightshift */
1789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1790          16,                    /* bitsize */
1791          FALSE,                 /* pc_relative */
1792          0,                     /* bitpos */
1793          complain_overflow_dont, /* complain_on_overflow */
1794          ppc64_elf_unhandled_reloc, /* special_function */
1795          "R_PPC64_GOT_DTPREL16_HI", /* name */
1796          FALSE,                 /* partial_inplace */
1797          0,                     /* src_mask */
1798          0xffff,                /* dst_mask */
1799          FALSE),                /* pcrel_offset */
1800
1801   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1802   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803          16,                    /* rightshift */
1804          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1805          16,                    /* bitsize */
1806          FALSE,                 /* pc_relative */
1807          0,                     /* bitpos */
1808          complain_overflow_dont, /* complain_on_overflow */
1809          ppc64_elf_unhandled_reloc, /* special_function */
1810          "R_PPC64_GOT_DTPREL16_HA", /* name */
1811          FALSE,                 /* partial_inplace */
1812          0,                     /* src_mask */
1813          0xffff,                /* dst_mask */
1814          FALSE),                /* pcrel_offset */
1815
1816   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817      offset to the entry relative to the TOC base (r2).  */
1818   HOWTO (R_PPC64_GOT_TPREL16_DS,
1819          0,                     /* rightshift */
1820          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1821          16,                    /* bitsize */
1822          FALSE,                 /* pc_relative */
1823          0,                     /* bitpos */
1824          complain_overflow_signed, /* complain_on_overflow */
1825          ppc64_elf_unhandled_reloc, /* special_function */
1826          "R_PPC64_GOT_TPREL16_DS", /* name */
1827          FALSE,                 /* partial_inplace */
1828          0,                     /* src_mask */
1829          0xfffc,                /* dst_mask */
1830          FALSE),                /* pcrel_offset */
1831
1832   /* Like GOT_TPREL16_DS, but no overflow.  */
1833   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834          0,                     /* 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_LO_DS", /* name */
1842          FALSE,                 /* partial_inplace */
1843          0,                     /* src_mask */
1844          0xfffc,                /* dst_mask */
1845          FALSE),                /* pcrel_offset */
1846
1847   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1848   HOWTO (R_PPC64_GOT_TPREL16_HI,
1849          16,                    /* rightshift */
1850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1851          16,                    /* bitsize */
1852          FALSE,                 /* pc_relative */
1853          0,                     /* bitpos */
1854          complain_overflow_dont, /* complain_on_overflow */
1855          ppc64_elf_unhandled_reloc, /* special_function */
1856          "R_PPC64_GOT_TPREL16_HI", /* name */
1857          FALSE,                 /* partial_inplace */
1858          0,                     /* src_mask */
1859          0xffff,                /* dst_mask */
1860          FALSE),                /* pcrel_offset */
1861
1862   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1863   HOWTO (R_PPC64_GOT_TPREL16_HA,
1864          16,                    /* rightshift */
1865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1866          16,                    /* bitsize */
1867          FALSE,                 /* pc_relative */
1868          0,                     /* bitpos */
1869          complain_overflow_dont, /* complain_on_overflow */
1870          ppc64_elf_unhandled_reloc, /* special_function */
1871          "R_PPC64_GOT_TPREL16_HA", /* name */
1872          FALSE,                 /* partial_inplace */
1873          0,                     /* src_mask */
1874          0xffff,                /* dst_mask */
1875          FALSE),                /* pcrel_offset */
1876
1877   HOWTO (R_PPC64_JMP_IREL,      /* type */
1878          0,                     /* rightshift */
1879          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880          0,                     /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_dont, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_JMP_IREL",    /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0,                     /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   HOWTO (R_PPC64_IRELATIVE,     /* type */
1892          0,                     /* rightshift */
1893          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1894          64,                    /* bitsize */
1895          FALSE,                 /* pc_relative */
1896          0,                     /* bitpos */
1897          complain_overflow_dont, /* complain_on_overflow */
1898          bfd_elf_generic_reloc, /* special_function */
1899          "R_PPC64_IRELATIVE",   /* name */
1900          FALSE,                 /* partial_inplace */
1901          0,                     /* src_mask */
1902          ONES (64),             /* dst_mask */
1903          FALSE),                /* pcrel_offset */
1904
1905   /* A 16 bit relative relocation.  */
1906   HOWTO (R_PPC64_REL16,         /* type */
1907          0,                     /* rightshift */
1908          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1909          16,                    /* bitsize */
1910          TRUE,                  /* pc_relative */
1911          0,                     /* bitpos */
1912          complain_overflow_bitfield, /* complain_on_overflow */
1913          bfd_elf_generic_reloc, /* special_function */
1914          "R_PPC64_REL16",       /* name */
1915          FALSE,                 /* partial_inplace */
1916          0,                     /* src_mask */
1917          0xffff,                /* dst_mask */
1918          TRUE),                 /* pcrel_offset */
1919
1920   /* A 16 bit relative relocation without overflow.  */
1921   HOWTO (R_PPC64_REL16_LO,      /* type */
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          TRUE,                  /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_dont,/* complain_on_overflow */
1928          bfd_elf_generic_reloc, /* special_function */
1929          "R_PPC64_REL16_LO",    /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xffff,                /* dst_mask */
1933          TRUE),                 /* pcrel_offset */
1934
1935   /* The high order 16 bits of a relative address.  */
1936   HOWTO (R_PPC64_REL16_HI,      /* type */
1937          16,                    /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          TRUE,                  /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          bfd_elf_generic_reloc, /* special_function */
1944          "R_PPC64_REL16_HI",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xffff,                /* dst_mask */
1948          TRUE),                 /* pcrel_offset */
1949
1950   /* The high order 16 bits of a relative address, plus 1 if the contents of
1951      the low 16 bits, treated as a signed number, is negative.  */
1952   HOWTO (R_PPC64_REL16_HA,      /* type */
1953          16,                    /* rightshift */
1954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1955          16,                    /* bitsize */
1956          TRUE,                  /* pc_relative */
1957          0,                     /* bitpos */
1958          complain_overflow_dont, /* complain_on_overflow */
1959          ppc64_elf_ha_reloc,    /* special_function */
1960          "R_PPC64_REL16_HA",    /* name */
1961          FALSE,                 /* partial_inplace */
1962          0,                     /* src_mask */
1963          0xffff,                /* dst_mask */
1964          TRUE),                 /* pcrel_offset */
1965
1966   /* GNU extension to record C++ vtable hierarchy.  */
1967   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1968          0,                     /* rightshift */
1969          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1970          0,                     /* bitsize */
1971          FALSE,                 /* pc_relative */
1972          0,                     /* bitpos */
1973          complain_overflow_dont, /* complain_on_overflow */
1974          NULL,                  /* special_function */
1975          "R_PPC64_GNU_VTINHERIT", /* name */
1976          FALSE,                 /* partial_inplace */
1977          0,                     /* src_mask */
1978          0,                     /* dst_mask */
1979          FALSE),                /* pcrel_offset */
1980
1981   /* GNU extension to record C++ vtable member usage.  */
1982   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1983          0,                     /* rightshift */
1984          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1985          0,                     /* bitsize */
1986          FALSE,                 /* pc_relative */
1987          0,                     /* bitpos */
1988          complain_overflow_dont, /* complain_on_overflow */
1989          NULL,                  /* special_function */
1990          "R_PPC64_GNU_VTENTRY", /* name */
1991          FALSE,                 /* partial_inplace */
1992          0,                     /* src_mask */
1993          0,                     /* dst_mask */
1994          FALSE),                /* pcrel_offset */
1995 };
1996
1997 \f
1998 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1999    be done.  */
2000
2001 static void
2002 ppc_howto_init (void)
2003 {
2004   unsigned int i, type;
2005
2006   for (i = 0;
2007        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2008        i++)
2009     {
2010       type = ppc64_elf_howto_raw[i].type;
2011       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2012                           / sizeof (ppc64_elf_howto_table[0])));
2013       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2014     }
2015 }
2016
2017 static reloc_howto_type *
2018 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2019                              bfd_reloc_code_real_type code)
2020 {
2021   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2022
2023   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2024     /* Initialize howto table if needed.  */
2025     ppc_howto_init ();
2026
2027   switch (code)
2028     {
2029     default:
2030       return NULL;
2031
2032     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2033       break;
2034     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2035       break;
2036     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2037       break;
2038     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2039       break;
2040     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2041       break;
2042     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2043       break;
2044     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2045       break;
2046     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2047       break;
2048     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2049       break;
2050     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2051       break;
2052     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2053       break;
2054     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2055       break;
2056     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2057       break;
2058     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2059       break;
2060     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2061       break;
2062     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2063       break;
2064     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2065       break;
2066     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2067       break;
2068     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2069       break;
2070     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2071       break;
2072     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2073       break;
2074     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2075       break;
2076     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2077       break;
2078     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2079       break;
2080     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2081       break;
2082     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2083       break;
2084     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2085       break;
2086     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2087       break;
2088     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2089       break;
2090     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2091       break;
2092     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2093       break;
2094     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2095       break;
2096     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2097       break;
2098     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2099       break;
2100     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2101       break;
2102     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2103       break;
2104     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2105       break;
2106     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2107       break;
2108     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2109       break;
2110     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2111       break;
2112     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2113       break;
2114     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2115       break;
2116     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2117       break;
2118     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2119       break;
2120     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2121       break;
2122     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2123       break;
2124     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2125       break;
2126     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2127       break;
2128     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2129       break;
2130     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2131       break;
2132     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2133       break;
2134     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2135       break;
2136     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2137       break;
2138     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2139       break;
2140     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2141       break;
2142     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2143       break;
2144     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2145       break;
2146     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2147       break;
2148     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2149       break;
2150     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2151       break;
2152     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2153       break;
2154     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2155       break;
2156     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2157       break;
2158     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2159       break;
2160     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2161       break;
2162     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2163       break;
2164     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2165       break;
2166     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2167       break;
2168     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2169       break;
2170     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2171       break;
2172     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2173       break;
2174     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2175       break;
2176     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2177       break;
2178     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2179       break;
2180     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2181       break;
2182     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2183       break;
2184     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2185       break;
2186     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2187       break;
2188     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2189       break;
2190     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2191       break;
2192     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2193       break;
2194     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2195       break;
2196     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2197       break;
2198     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2199       break;
2200     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2201       break;
2202     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2203       break;
2204     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2205       break;
2206     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2207       break;
2208     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2209       break;
2210     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2211       break;
2212     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2213       break;
2214     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2215       break;
2216     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2217       break;
2218     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2219       break;
2220     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2221       break;
2222     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2223       break;
2224     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2225       break;
2226     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2227       break;
2228     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2229       break;
2230     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2231       break;
2232     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2233       break;
2234     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2235       break;
2236     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2237       break;
2238     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2241       break;
2242     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2243       break;
2244     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2245       break;
2246     }
2247
2248   return ppc64_elf_howto_table[r];
2249 };
2250
2251 static reloc_howto_type *
2252 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2253                              const char *r_name)
2254 {
2255   unsigned int i;
2256
2257   for (i = 0;
2258        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2259        i++)
2260     if (ppc64_elf_howto_raw[i].name != NULL
2261         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2262       return &ppc64_elf_howto_raw[i];
2263
2264   return NULL;
2265 }
2266
2267 /* Set the howto pointer for a PowerPC ELF reloc.  */
2268
2269 static void
2270 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2271                          Elf_Internal_Rela *dst)
2272 {
2273   unsigned int type;
2274
2275   /* Initialize howto table if needed.  */
2276   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2277     ppc_howto_init ();
2278
2279   type = ELF64_R_TYPE (dst->r_info);
2280   if (type >= (sizeof (ppc64_elf_howto_table)
2281                / sizeof (ppc64_elf_howto_table[0])))
2282     {
2283       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2284                              abfd, (int) type);
2285       type = R_PPC64_NONE;
2286     }
2287   cache_ptr->howto = ppc64_elf_howto_table[type];
2288 }
2289
2290 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2291
2292 static bfd_reloc_status_type
2293 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2294                     void *data, asection *input_section,
2295                     bfd *output_bfd, char **error_message)
2296 {
2297   /* If this is a relocatable link (output_bfd test tells us), just
2298      call the generic function.  Any adjustment will be done at final
2299      link time.  */
2300   if (output_bfd != NULL)
2301     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2302                                   input_section, output_bfd, error_message);
2303
2304   /* Adjust the addend for sign extension of the low 16 bits.
2305      We won't actually be using the low 16 bits, so trashing them
2306      doesn't matter.  */
2307   reloc_entry->addend += 0x8000;
2308   return bfd_reloc_continue;
2309 }
2310
2311 static bfd_reloc_status_type
2312 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2313                         void *data, asection *input_section,
2314                         bfd *output_bfd, char **error_message)
2315 {
2316   if (output_bfd != NULL)
2317     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2318                                   input_section, output_bfd, error_message);
2319
2320   if (strcmp (symbol->section->name, ".opd") == 0
2321       && (symbol->section->owner->flags & DYNAMIC) == 0)
2322     {
2323       bfd_vma dest = opd_entry_value (symbol->section,
2324                                       symbol->value + reloc_entry->addend,
2325                                       NULL, NULL);
2326       if (dest != (bfd_vma) -1)
2327         reloc_entry->addend = dest - (symbol->value
2328                                       + symbol->section->output_section->vma
2329                                       + symbol->section->output_offset);
2330     }
2331   return bfd_reloc_continue;
2332 }
2333
2334 static bfd_reloc_status_type
2335 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2336                          void *data, asection *input_section,
2337                          bfd *output_bfd, char **error_message)
2338 {
2339   long insn;
2340   enum elf_ppc64_reloc_type r_type;
2341   bfd_size_type octets;
2342   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2343   bfd_boolean is_power4 = FALSE;
2344
2345   /* If this is a relocatable link (output_bfd test tells us), just
2346      call the generic function.  Any adjustment will be done at final
2347      link time.  */
2348   if (output_bfd != NULL)
2349     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2350                                   input_section, output_bfd, error_message);
2351
2352   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2353   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2354   insn &= ~(0x01 << 21);
2355   r_type = reloc_entry->howto->type;
2356   if (r_type == R_PPC64_ADDR14_BRTAKEN
2357       || r_type == R_PPC64_REL14_BRTAKEN)
2358     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2359
2360   if (is_power4)
2361     {
2362       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2363          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2364          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2365       if ((insn & (0x14 << 21)) == (0x04 << 21))
2366         insn |= 0x02 << 21;
2367       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2368         insn |= 0x08 << 21;
2369       else
2370         goto out;
2371     }
2372   else
2373     {
2374       bfd_vma target = 0;
2375       bfd_vma from;
2376
2377       if (!bfd_is_com_section (symbol->section))
2378         target = symbol->value;
2379       target += symbol->section->output_section->vma;
2380       target += symbol->section->output_offset;
2381       target += reloc_entry->addend;
2382
2383       from = (reloc_entry->address
2384               + input_section->output_offset
2385               + input_section->output_section->vma);
2386
2387       /* Invert 'y' bit if not the default.  */
2388       if ((bfd_signed_vma) (target - from) < 0)
2389         insn ^= 0x01 << 21;
2390     }
2391   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2392  out:
2393   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2394                                  input_section, output_bfd, error_message);
2395 }
2396
2397 static bfd_reloc_status_type
2398 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2399                          void *data, asection *input_section,
2400                          bfd *output_bfd, char **error_message)
2401 {
2402   /* If this is a relocatable link (output_bfd test tells us), just
2403      call the generic function.  Any adjustment will be done at final
2404      link time.  */
2405   if (output_bfd != NULL)
2406     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2407                                   input_section, output_bfd, error_message);
2408
2409   /* Subtract the symbol section base address.  */
2410   reloc_entry->addend -= symbol->section->output_section->vma;
2411   return bfd_reloc_continue;
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416                             void *data, asection *input_section,
2417                             bfd *output_bfd, char **error_message)
2418 {
2419   /* If this is a relocatable link (output_bfd test tells us), just
2420      call the generic function.  Any adjustment will be done at final
2421      link time.  */
2422   if (output_bfd != NULL)
2423     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424                                   input_section, output_bfd, error_message);
2425
2426   /* Subtract the symbol section base address.  */
2427   reloc_entry->addend -= symbol->section->output_section->vma;
2428
2429   /* Adjust the addend for sign extension of the low 16 bits.  */
2430   reloc_entry->addend += 0x8000;
2431   return bfd_reloc_continue;
2432 }
2433
2434 static bfd_reloc_status_type
2435 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2436                      void *data, asection *input_section,
2437                      bfd *output_bfd, char **error_message)
2438 {
2439   bfd_vma TOCstart;
2440
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2449   if (TOCstart == 0)
2450     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2451
2452   /* Subtract the TOC base address.  */
2453   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2454   return bfd_reloc_continue;
2455 }
2456
2457 static bfd_reloc_status_type
2458 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2459                         void *data, asection *input_section,
2460                         bfd *output_bfd, char **error_message)
2461 {
2462   bfd_vma TOCstart;
2463
2464   /* If this is a relocatable link (output_bfd test tells us), just
2465      call the generic function.  Any adjustment will be done at final
2466      link time.  */
2467   if (output_bfd != NULL)
2468     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2469                                   input_section, output_bfd, error_message);
2470
2471   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2472   if (TOCstart == 0)
2473     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2474
2475   /* Subtract the TOC base address.  */
2476   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2477
2478   /* Adjust the addend for sign extension of the low 16 bits.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                        void *data, asection *input_section,
2486                        bfd *output_bfd, char **error_message)
2487 {
2488   bfd_vma TOCstart;
2489   bfd_size_type octets;
2490
2491   /* If this is a relocatable link (output_bfd test tells us), just
2492      call the generic function.  Any adjustment will be done at final
2493      link time.  */
2494   if (output_bfd != NULL)
2495     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496                                   input_section, output_bfd, error_message);
2497
2498   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2499   if (TOCstart == 0)
2500     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2501
2502   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2503   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2504   return bfd_reloc_ok;
2505 }
2506
2507 static bfd_reloc_status_type
2508 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2509                            void *data, asection *input_section,
2510                            bfd *output_bfd, char **error_message)
2511 {
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   if (error_message != NULL)
2520     {
2521       static char buf[60];
2522       sprintf (buf, "generic linker can't handle %s",
2523                reloc_entry->howto->name);
2524       *error_message = buf;
2525     }
2526   return bfd_reloc_dangerous;
2527 }
2528
2529 /* Track GOT entries needed for a given symbol.  We might need more
2530    than one got entry per symbol.  */
2531 struct got_entry
2532 {
2533   struct got_entry *next;
2534
2535   /* The symbol addend that we'll be placing in the GOT.  */
2536   bfd_vma addend;
2537
2538   /* Unlike other ELF targets, we use separate GOT entries for the same
2539      symbol referenced from different input files.  This is to support
2540      automatic multiple TOC/GOT sections, where the TOC base can vary
2541      from one input file to another.  After partitioning into TOC groups
2542      we merge entries within the group.
2543
2544      Point to the BFD owning this GOT entry.  */
2545   bfd *owner;
2546
2547   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2548      TLS_TPREL or TLS_DTPREL for tls entries.  */
2549   unsigned char tls_type;
2550
2551   /* Non-zero if got.ent points to real entry.  */
2552   unsigned char is_indirect;
2553
2554   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2555   union
2556     {
2557       bfd_signed_vma refcount;
2558       bfd_vma offset;
2559       struct got_entry *ent;
2560     } got;
2561 };
2562
2563 /* The same for PLT.  */
2564 struct plt_entry
2565 {
2566   struct plt_entry *next;
2567
2568   bfd_vma addend;
2569
2570   union
2571     {
2572       bfd_signed_vma refcount;
2573       bfd_vma offset;
2574     } plt;
2575 };
2576
2577 struct ppc64_elf_obj_tdata
2578 {
2579   struct elf_obj_tdata elf;
2580
2581   /* Shortcuts to dynamic linker sections.  */
2582   asection *got;
2583   asection *relgot;
2584
2585   /* Used during garbage collection.  We attach global symbols defined
2586      on removed .opd entries to this section so that the sym is removed.  */
2587   asection *deleted_section;
2588
2589   /* TLS local dynamic got entry handling.  Support for multiple GOT
2590      sections means we potentially need one of these for each input bfd.  */
2591   struct got_entry tlsld_got;
2592
2593   /* A copy of relocs before they are modified for --emit-relocs.  */
2594   Elf_Internal_Rela *opd_relocs;
2595
2596   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2597      the reloc to be in the range -32768 to 32767.  */
2598   unsigned int has_small_toc_reloc;
2599 };
2600
2601 #define ppc64_elf_tdata(bfd) \
2602   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2603
2604 #define ppc64_tlsld_got(bfd) \
2605   (&ppc64_elf_tdata (bfd)->tlsld_got)
2606
2607 #define is_ppc64_elf(bfd) \
2608   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2609    && elf_object_id (bfd) == PPC64_ELF_DATA)
2610
2611 /* Override the generic function because we store some extras.  */
2612
2613 static bfd_boolean
2614 ppc64_elf_mkobject (bfd *abfd)
2615 {
2616   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2617                                   PPC64_ELF_DATA);
2618 }
2619
2620 /* Fix bad default arch selected for a 64 bit input bfd when the
2621    default is 32 bit.  */
2622
2623 static bfd_boolean
2624 ppc64_elf_object_p (bfd *abfd)
2625 {
2626   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2627     {
2628       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2629
2630       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2631         {
2632           /* Relies on arch after 32 bit default being 64 bit default.  */
2633           abfd->arch_info = abfd->arch_info->next;
2634           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2635         }
2636     }
2637   return TRUE;
2638 }
2639
2640 /* Support for core dump NOTE sections.  */
2641
2642 static bfd_boolean
2643 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2644 {
2645   size_t offset, size;
2646
2647   if (note->descsz != 504)
2648     return FALSE;
2649
2650   /* pr_cursig */
2651   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2652
2653   /* pr_pid */
2654   elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2655
2656   /* pr_reg */
2657   offset = 112;
2658   size = 384;
2659
2660   /* Make a ".reg/999" section.  */
2661   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2662                                           size, note->descpos + offset);
2663 }
2664
2665 static bfd_boolean
2666 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2667 {
2668   if (note->descsz != 136)
2669     return FALSE;
2670
2671   elf_tdata (abfd)->core_program
2672     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2673   elf_tdata (abfd)->core_command
2674     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2675
2676   return TRUE;
2677 }
2678
2679 static char *
2680 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2681                            ...)
2682 {
2683   switch (note_type)
2684     {
2685     default:
2686       return NULL;
2687
2688     case NT_PRPSINFO:
2689       {
2690         char data[136];
2691         va_list ap;
2692
2693         va_start (ap, note_type);
2694         memset (data, 0, 40);
2695         strncpy (data + 40, va_arg (ap, const char *), 16);
2696         strncpy (data + 56, va_arg (ap, const char *), 80);
2697         va_end (ap);
2698         return elfcore_write_note (abfd, buf, bufsiz,
2699                                    "CORE", note_type, data, sizeof (data));
2700       }
2701
2702     case NT_PRSTATUS:
2703       {
2704         char data[504];
2705         va_list ap;
2706         long pid;
2707         int cursig;
2708         const void *greg;
2709
2710         va_start (ap, note_type);
2711         memset (data, 0, 112);
2712         pid = va_arg (ap, long);
2713         bfd_put_32 (abfd, pid, data + 32);
2714         cursig = va_arg (ap, int);
2715         bfd_put_16 (abfd, cursig, data + 12);
2716         greg = va_arg (ap, const void *);
2717         memcpy (data + 112, greg, 384);
2718         memset (data + 496, 0, 8);
2719         va_end (ap);
2720         return elfcore_write_note (abfd, buf, bufsiz,
2721                                    "CORE", note_type, data, sizeof (data));
2722       }
2723     }
2724 }
2725
2726 /* Merge backend specific data from an object file to the output
2727    object file when linking.  */
2728
2729 static bfd_boolean
2730 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2731 {
2732   /* Check if we have the same endianess.  */
2733   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2734       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2735       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2736     {
2737       const char *msg;
2738
2739       if (bfd_big_endian (ibfd))
2740         msg = _("%B: compiled for a big endian system "
2741                 "and target is little endian");
2742       else
2743         msg = _("%B: compiled for a little endian system "
2744                 "and target is big endian");
2745
2746       (*_bfd_error_handler) (msg, ibfd);
2747
2748       bfd_set_error (bfd_error_wrong_format);
2749       return FALSE;
2750     }
2751
2752   return TRUE;
2753 }
2754
2755 /* Add extra PPC sections.  */
2756
2757 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2758 {
2759   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2760   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2761   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2762   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2763   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2764   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2765   { NULL,                     0,  0, 0,            0 }
2766 };
2767
2768 enum _ppc64_sec_type {
2769   sec_normal = 0,
2770   sec_opd = 1,
2771   sec_toc = 2
2772 };
2773
2774 struct _ppc64_elf_section_data
2775 {
2776   struct bfd_elf_section_data elf;
2777
2778   union
2779   {
2780     /* An array with one entry for each opd function descriptor.  */
2781     struct _opd_sec_data
2782     {
2783       /* Points to the function code section for local opd entries.  */
2784       asection **func_sec;
2785
2786       /* After editing .opd, adjust references to opd local syms.  */
2787       long *adjust;
2788     } opd;
2789
2790     /* An array for toc sections, indexed by offset/8.  */
2791     struct _toc_sec_data
2792     {
2793       /* Specifies the relocation symbol index used at a given toc offset.  */
2794       unsigned *symndx;
2795
2796       /* And the relocation addend.  */
2797       bfd_vma *add;
2798     } toc;
2799   } u;
2800
2801   enum _ppc64_sec_type sec_type:2;
2802
2803   /* Flag set when small branches are detected.  Used to
2804      select suitable defaults for the stub group size.  */
2805   unsigned int has_14bit_branch:1;
2806 };
2807
2808 #define ppc64_elf_section_data(sec) \
2809   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2810
2811 static bfd_boolean
2812 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2813 {
2814   if (!sec->used_by_bfd)
2815     {
2816       struct _ppc64_elf_section_data *sdata;
2817       bfd_size_type amt = sizeof (*sdata);
2818
2819       sdata = bfd_zalloc (abfd, amt);
2820       if (sdata == NULL)
2821         return FALSE;
2822       sec->used_by_bfd = sdata;
2823     }
2824
2825   return _bfd_elf_new_section_hook (abfd, sec);
2826 }
2827
2828 static struct _opd_sec_data *
2829 get_opd_info (asection * sec)
2830 {
2831   if (sec != NULL
2832       && ppc64_elf_section_data (sec) != NULL
2833       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2834     return &ppc64_elf_section_data (sec)->u.opd;
2835   return NULL;
2836 }
2837 \f
2838 /* Parameters for the qsort hook.  */
2839 static bfd_boolean synthetic_relocatable;
2840
2841 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2842
2843 static int
2844 compare_symbols (const void *ap, const void *bp)
2845 {
2846   const asymbol *a = * (const asymbol **) ap;
2847   const asymbol *b = * (const asymbol **) bp;
2848
2849   /* Section symbols first.  */
2850   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2851     return -1;
2852   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2853     return 1;
2854
2855   /* then .opd symbols.  */
2856   if (strcmp (a->section->name, ".opd") == 0
2857       && strcmp (b->section->name, ".opd") != 0)
2858     return -1;
2859   if (strcmp (a->section->name, ".opd") != 0
2860       && strcmp (b->section->name, ".opd") == 0)
2861     return 1;
2862
2863   /* then other code symbols.  */
2864   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2865       == (SEC_CODE | SEC_ALLOC)
2866       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867          != (SEC_CODE | SEC_ALLOC))
2868     return -1;
2869
2870   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2871       != (SEC_CODE | SEC_ALLOC)
2872       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2873          == (SEC_CODE | SEC_ALLOC))
2874     return 1;
2875
2876   if (synthetic_relocatable)
2877     {
2878       if (a->section->id < b->section->id)
2879         return -1;
2880
2881       if (a->section->id > b->section->id)
2882         return 1;
2883     }
2884
2885   if (a->value + a->section->vma < b->value + b->section->vma)
2886     return -1;
2887
2888   if (a->value + a->section->vma > b->value + b->section->vma)
2889     return 1;
2890
2891   /* For syms with the same value, prefer strong dynamic global function
2892      syms over other syms.  */
2893   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2894     return -1;
2895
2896   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2897     return 1;
2898
2899   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2900     return -1;
2901
2902   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2903     return 1;
2904
2905   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2906     return -1;
2907
2908   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2909     return 1;
2910
2911   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2912     return -1;
2913
2914   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2915     return 1;
2916
2917   return 0;
2918 }
2919
2920 /* Search SYMS for a symbol of the given VALUE.  */
2921
2922 static asymbol *
2923 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2924 {
2925   long mid;
2926
2927   if (id == -1)
2928     {
2929       while (lo < hi)
2930         {
2931           mid = (lo + hi) >> 1;
2932           if (syms[mid]->value + syms[mid]->section->vma < value)
2933             lo = mid + 1;
2934           else if (syms[mid]->value + syms[mid]->section->vma > value)
2935             hi = mid;
2936           else
2937             return syms[mid];
2938         }
2939     }
2940   else
2941     {
2942       while (lo < hi)
2943         {
2944           mid = (lo + hi) >> 1;
2945           if (syms[mid]->section->id < id)
2946             lo = mid + 1;
2947           else if (syms[mid]->section->id > id)
2948             hi = mid;
2949           else if (syms[mid]->value < value)
2950             lo = mid + 1;
2951           else if (syms[mid]->value > value)
2952             hi = mid;
2953           else
2954             return syms[mid];
2955         }
2956     }
2957   return NULL;
2958 }
2959
2960 static bfd_boolean
2961 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2962 {
2963   bfd_vma vma = *(bfd_vma *) ptr;
2964   return ((section->flags & SEC_ALLOC) != 0
2965           && section->vma <= vma
2966           && vma < section->vma + section->size);
2967 }
2968
2969 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2970    entry syms.  Also generate @plt symbols for the glink branch table.  */
2971
2972 static long
2973 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2974                                 long static_count, asymbol **static_syms,
2975                                 long dyn_count, asymbol **dyn_syms,
2976                                 asymbol **ret)
2977 {
2978   asymbol *s;
2979   long i;
2980   long count;
2981   char *names;
2982   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2983   asection *opd;
2984   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2985   asymbol **syms;
2986
2987   *ret = NULL;
2988
2989   opd = bfd_get_section_by_name (abfd, ".opd");
2990   if (opd == NULL)
2991     return 0;
2992
2993   symcount = static_count;
2994   if (!relocatable)
2995     symcount += dyn_count;
2996   if (symcount == 0)
2997     return 0;
2998
2999   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3000   if (syms == NULL)
3001     return -1;
3002
3003   if (!relocatable && static_count != 0 && dyn_count != 0)
3004     {
3005       /* Use both symbol tables.  */
3006       memcpy (syms, static_syms, static_count * sizeof (*syms));
3007       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3008     }
3009   else if (!relocatable && static_count == 0)
3010     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3011   else
3012     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3013
3014   synthetic_relocatable = relocatable;
3015   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3016
3017   if (!relocatable && symcount > 1)
3018     {
3019       long j;
3020       /* Trim duplicate syms, since we may have merged the normal and
3021          dynamic symbols.  Actually, we only care about syms that have
3022          different values, so trim any with the same value.  */
3023       for (i = 1, j = 1; i < symcount; ++i)
3024         if (syms[i - 1]->value + syms[i - 1]->section->vma
3025             != syms[i]->value + syms[i]->section->vma)
3026           syms[j++] = syms[i];
3027       symcount = j;
3028     }
3029
3030   i = 0;
3031   if (strcmp (syms[i]->section->name, ".opd") == 0)
3032     ++i;
3033   codesecsym = i;
3034
3035   for (; i < symcount; ++i)
3036     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3037          != (SEC_CODE | SEC_ALLOC))
3038         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3039       break;
3040   codesecsymend = i;
3041
3042   for (; i < symcount; ++i)
3043     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3044       break;
3045   secsymend = i;
3046
3047   for (; i < symcount; ++i)
3048     if (strcmp (syms[i]->section->name, ".opd") != 0)
3049       break;
3050   opdsymend = i;
3051
3052   for (; i < symcount; ++i)
3053     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3054         != (SEC_CODE | SEC_ALLOC))
3055       break;
3056   symcount = i;
3057
3058   count = 0;
3059
3060   if (relocatable)
3061     {
3062       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3063       arelent *r;
3064       size_t size;
3065       long relcount;
3066
3067       if (opdsymend == secsymend)
3068         goto done;
3069
3070       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3071       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3072       if (relcount == 0)
3073         goto done;
3074
3075       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3076         {
3077           count = -1;
3078           goto done;
3079         }
3080
3081       size = 0;
3082       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3083         {
3084           asymbol *sym;
3085
3086           while (r < opd->relocation + relcount
3087                  && r->address < syms[i]->value + opd->vma)
3088             ++r;
3089
3090           if (r == opd->relocation + relcount)
3091             break;
3092
3093           if (r->address != syms[i]->value + opd->vma)
3094             continue;
3095
3096           if (r->howto->type != R_PPC64_ADDR64)
3097             continue;
3098
3099           sym = *r->sym_ptr_ptr;
3100           if (!sym_exists_at (syms, opdsymend, symcount,
3101                               sym->section->id, sym->value + r->addend))
3102             {
3103               ++count;
3104               size += sizeof (asymbol);
3105               size += strlen (syms[i]->name) + 2;
3106             }
3107         }
3108
3109       s = *ret = bfd_malloc (size);
3110       if (s == NULL)
3111         {
3112           count = -1;
3113           goto done;
3114         }
3115
3116       names = (char *) (s + count);
3117
3118       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3119         {
3120           asymbol *sym;
3121
3122           while (r < opd->relocation + relcount
3123                  && r->address < syms[i]->value + opd->vma)
3124             ++r;
3125
3126           if (r == opd->relocation + relcount)
3127             break;
3128
3129           if (r->address != syms[i]->value + opd->vma)
3130             continue;
3131
3132           if (r->howto->type != R_PPC64_ADDR64)
3133             continue;
3134
3135           sym = *r->sym_ptr_ptr;
3136           if (!sym_exists_at (syms, opdsymend, symcount,
3137                               sym->section->id, sym->value + r->addend))
3138             {
3139               size_t len;
3140
3141               *s = *syms[i];
3142               s->flags |= BSF_SYNTHETIC;
3143               s->section = sym->section;
3144               s->value = sym->value + r->addend;
3145               s->name = names;
3146               *names++ = '.';
3147               len = strlen (syms[i]->name);
3148               memcpy (names, syms[i]->name, len + 1);
3149               names += len + 1;
3150               /* Have udata.p point back to the original symbol this
3151                  synthetic symbol was derived from.  */
3152               s->udata.p = syms[i];
3153               s++;
3154             }
3155         }
3156     }
3157   else
3158     {
3159       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3160       bfd_byte *contents;
3161       size_t size;
3162       long plt_count = 0;
3163       bfd_vma glink_vma = 0, resolv_vma = 0;
3164       asection *dynamic, *glink = NULL, *relplt = NULL;
3165       arelent *p;
3166
3167       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3168         {
3169           if (contents)
3170             {
3171             free_contents_and_exit:
3172               free (contents);
3173             }
3174           count = -1;
3175           goto done;
3176         }
3177
3178       size = 0;
3179       for (i = secsymend; i < opdsymend; ++i)
3180         {
3181           bfd_vma ent;
3182
3183           /* Ignore bogus symbols.  */
3184           if (syms[i]->value > opd->size - 8)
3185             continue;
3186
3187           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3188           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3189             {
3190               ++count;
3191               size += sizeof (asymbol);
3192               size += strlen (syms[i]->name) + 2;
3193             }
3194         }
3195
3196       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3197       if (dyn_count != 0
3198           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3199         {
3200           bfd_byte *dynbuf, *extdyn, *extdynend;
3201           size_t extdynsize;
3202           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3203
3204           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3205             goto free_contents_and_exit;
3206
3207           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3208           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3209
3210           extdyn = dynbuf;
3211           extdynend = extdyn + dynamic->size;
3212           for (; extdyn < extdynend; extdyn += extdynsize)
3213             {
3214               Elf_Internal_Dyn dyn;
3215               (*swap_dyn_in) (abfd, extdyn, &dyn);
3216
3217               if (dyn.d_tag == DT_NULL)
3218                 break;
3219
3220               if (dyn.d_tag == DT_PPC64_GLINK)
3221                 {
3222                   /* The first glink stub starts at offset 32; see comment in
3223                      ppc64_elf_finish_dynamic_sections. */
3224                   glink_vma = dyn.d_un.d_val + 32;
3225                   /* The .glink section usually does not survive the final
3226                      link; search for the section (usually .text) where the
3227                      glink stubs now reside.  */
3228                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3229                                                 &glink_vma);
3230                   break;
3231                 }
3232             }
3233
3234           free (dynbuf);
3235         }
3236
3237       if (glink != NULL)
3238         {
3239           /* Determine __glink trampoline by reading the relative branch
3240              from the first glink stub.  */
3241           bfd_byte buf[4];
3242           if (bfd_get_section_contents (abfd, glink, buf,
3243                                         glink_vma + 4 - glink->vma, 4))
3244             {
3245               unsigned int insn = bfd_get_32 (abfd, buf);
3246               insn ^= B_DOT;
3247               if ((insn & ~0x3fffffc) == 0)
3248                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3249             }
3250
3251           if (resolv_vma)
3252             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3253
3254           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3255           if (relplt != NULL)
3256             {
3257               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3258               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3259                 goto free_contents_and_exit;
3260
3261               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3262               size += plt_count * sizeof (asymbol);
3263
3264               p = relplt->relocation;
3265               for (i = 0; i < plt_count; i++, p++)
3266                 {
3267                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3268                   if (p->addend != 0)
3269                     size += sizeof ("+0x") - 1 + 16;
3270                 }
3271             }
3272         }
3273
3274       s = *ret = bfd_malloc (size);
3275       if (s == NULL)
3276         goto free_contents_and_exit;
3277
3278       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3279
3280       for (i = secsymend; i < opdsymend; ++i)
3281         {
3282           bfd_vma ent;
3283
3284           if (syms[i]->value > opd->size - 8)
3285             continue;
3286
3287           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3288           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3289             {
3290               long lo, hi;
3291               size_t len;
3292               asection *sec = abfd->sections;
3293
3294               *s = *syms[i];
3295               lo = codesecsym;
3296               hi = codesecsymend;
3297               while (lo < hi)
3298                 {
3299                   long mid = (lo + hi) >> 1;
3300                   if (syms[mid]->section->vma < ent)
3301                     lo = mid + 1;
3302                   else if (syms[mid]->section->vma > ent)
3303                     hi = mid;
3304                   else
3305                     {
3306                       sec = syms[mid]->section;
3307                       break;
3308                     }
3309                 }
3310
3311               if (lo >= hi && lo > codesecsym)
3312                 sec = syms[lo - 1]->section;
3313
3314               for (; sec != NULL; sec = sec->next)
3315                 {
3316                   if (sec->vma > ent)
3317                     break;
3318                   if ((sec->flags & SEC_ALLOC) == 0
3319                       || (sec->flags & SEC_LOAD) == 0)
3320                     break;
3321                   if ((sec->flags & SEC_CODE) != 0)
3322                     s->section = sec;
3323                 }
3324               s->flags |= BSF_SYNTHETIC;
3325               s->value = ent - s->section->vma;
3326               s->name = names;
3327               *names++ = '.';
3328               len = strlen (syms[i]->name);
3329               memcpy (names, syms[i]->name, len + 1);
3330               names += len + 1;
3331               /* Have udata.p point back to the original symbol this
3332                  synthetic symbol was derived from.  */
3333               s->udata.p = syms[i];
3334               s++;
3335             }
3336         }
3337       free (contents);
3338
3339       if (glink != NULL && relplt != NULL)
3340         {
3341           if (resolv_vma)
3342             {
3343               /* Add a symbol for the main glink trampoline.  */
3344               memset (s, 0, sizeof *s);
3345               s->the_bfd = abfd;
3346               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3347               s->section = glink;
3348               s->value = resolv_vma - glink->vma;
3349               s->name = names;
3350               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3351               names += sizeof ("__glink_PLTresolve");
3352               s++;
3353               count++;
3354             }
3355
3356           /* FIXME: It would be very much nicer to put sym@plt on the
3357              stub rather than on the glink branch table entry.  The
3358              objdump disassembler would then use a sensible symbol
3359              name on plt calls.  The difficulty in doing so is
3360              a) finding the stubs, and,
3361              b) matching stubs against plt entries, and,
3362              c) there can be multiple stubs for a given plt entry.
3363
3364              Solving (a) could be done by code scanning, but older
3365              ppc64 binaries used different stubs to current code.
3366              (b) is the tricky one since you need to known the toc
3367              pointer for at least one function that uses a pic stub to
3368              be able to calculate the plt address referenced.
3369              (c) means gdb would need to set multiple breakpoints (or
3370              find the glink branch itself) when setting breakpoints
3371              for pending shared library loads.  */
3372           p = relplt->relocation;
3373           for (i = 0; i < plt_count; i++, p++)
3374             {
3375               size_t len;
3376
3377               *s = **p->sym_ptr_ptr;
3378               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3379                  we are defining a symbol, ensure one of them is set.  */
3380               if ((s->flags & BSF_LOCAL) == 0)
3381                 s->flags |= BSF_GLOBAL;
3382               s->flags |= BSF_SYNTHETIC;
3383               s->section = glink;
3384               s->value = glink_vma - glink->vma;
3385               s->name = names;
3386               s->udata.p = NULL;
3387               len = strlen ((*p->sym_ptr_ptr)->name);
3388               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3389               names += len;
3390               if (p->addend != 0)
3391                 {
3392                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3393                   names += sizeof ("+0x") - 1;
3394                   bfd_sprintf_vma (abfd, names, p->addend);
3395                   names += strlen (names);
3396                 }
3397               memcpy (names, "@plt", sizeof ("@plt"));
3398               names += sizeof ("@plt");
3399               s++;
3400               glink_vma += 8;
3401               if (i >= 0x8000)
3402                 glink_vma += 4;
3403             }
3404           count += plt_count;
3405         }
3406     }
3407
3408  done:
3409   free (syms);
3410   return count;
3411 }
3412 \f
3413 /* The following functions are specific to the ELF linker, while
3414    functions above are used generally.  Those named ppc64_elf_* are
3415    called by the main ELF linker code.  They appear in this file more
3416    or less in the order in which they are called.  eg.
3417    ppc64_elf_check_relocs is called early in the link process,
3418    ppc64_elf_finish_dynamic_sections is one of the last functions
3419    called.
3420
3421    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3422    functions have both a function code symbol and a function descriptor
3423    symbol.  A call to foo in a relocatable object file looks like:
3424
3425    .            .text
3426    .    x:
3427    .            bl      .foo
3428    .            nop
3429
3430    The function definition in another object file might be:
3431
3432    .            .section .opd
3433    .    foo:    .quad   .foo
3434    .            .quad   .TOC.@tocbase
3435    .            .quad   0
3436    .
3437    .            .text
3438    .    .foo:   blr
3439
3440    When the linker resolves the call during a static link, the branch
3441    unsurprisingly just goes to .foo and the .opd information is unused.
3442    If the function definition is in a shared library, things are a little
3443    different:  The call goes via a plt call stub, the opd information gets
3444    copied to the plt, and the linker patches the nop.
3445
3446    .    x:
3447    .            bl      .foo_stub
3448    .            ld      2,40(1)
3449    .
3450    .
3451    .    .foo_stub:
3452    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3453    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3454    .            std     2,40(1)                 # this is the general idea
3455    .            ld      11,0(12)
3456    .            ld      2,8(12)
3457    .            mtctr   11
3458    .            ld      11,16(12)
3459    .            bctr
3460    .
3461    .            .section .plt
3462    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3463
3464    The "reloc ()" notation is supposed to indicate that the linker emits
3465    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3466    copying.
3467
3468    What are the difficulties here?  Well, firstly, the relocations
3469    examined by the linker in check_relocs are against the function code
3470    sym .foo, while the dynamic relocation in the plt is emitted against
3471    the function descriptor symbol, foo.  Somewhere along the line, we need
3472    to carefully copy dynamic link information from one symbol to the other.
3473    Secondly, the generic part of the elf linker will make .foo a dynamic
3474    symbol as is normal for most other backends.  We need foo dynamic
3475    instead, at least for an application final link.  However, when
3476    creating a shared library containing foo, we need to have both symbols
3477    dynamic so that references to .foo are satisfied during the early
3478    stages of linking.  Otherwise the linker might decide to pull in a
3479    definition from some other object, eg. a static library.
3480
3481    Update: As of August 2004, we support a new convention.  Function
3482    calls may use the function descriptor symbol, ie. "bl foo".  This
3483    behaves exactly as "bl .foo".  */
3484
3485 /* The linker needs to keep track of the number of relocs that it
3486    decides to copy as dynamic relocs in check_relocs for each symbol.
3487    This is so that it can later discard them if they are found to be
3488    unnecessary.  We store the information in a field extending the
3489    regular ELF linker hash table.  */
3490
3491 struct ppc_dyn_relocs
3492 {
3493   struct ppc_dyn_relocs *next;
3494
3495   /* The input section of the reloc.  */
3496   asection *sec;
3497
3498   /* Total number of relocs copied for the input section.  */
3499   bfd_size_type count;
3500
3501   /* Number of pc-relative relocs copied for the input section.  */
3502   bfd_size_type pc_count;
3503 };
3504
3505 /* Of those relocs that might be copied as dynamic relocs, this function
3506    selects those that must be copied when linking a shared library,
3507    even when the symbol is local.  */
3508
3509 static int
3510 must_be_dyn_reloc (struct bfd_link_info *info,
3511                    enum elf_ppc64_reloc_type r_type)
3512 {
3513   switch (r_type)
3514     {
3515     default:
3516       return 1;
3517
3518     case R_PPC64_REL32:
3519     case R_PPC64_REL64:
3520     case R_PPC64_REL30:
3521       return 0;
3522
3523     case R_PPC64_TPREL16:
3524     case R_PPC64_TPREL16_LO:
3525     case R_PPC64_TPREL16_HI:
3526     case R_PPC64_TPREL16_HA:
3527     case R_PPC64_TPREL16_DS:
3528     case R_PPC64_TPREL16_LO_DS:
3529     case R_PPC64_TPREL16_HIGHER:
3530     case R_PPC64_TPREL16_HIGHERA:
3531     case R_PPC64_TPREL16_HIGHEST:
3532     case R_PPC64_TPREL16_HIGHESTA:
3533     case R_PPC64_TPREL64:
3534       return !info->executable;
3535     }
3536 }
3537
3538 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3539    copying dynamic variables from a shared lib into an app's dynbss
3540    section, and instead use a dynamic relocation to point into the
3541    shared lib.  With code that gcc generates, it's vital that this be
3542    enabled;  In the PowerPC64 ABI, the address of a function is actually
3543    the address of a function descriptor, which resides in the .opd
3544    section.  gcc uses the descriptor directly rather than going via the
3545    GOT as some other ABI's do, which means that initialized function
3546    pointers must reference the descriptor.  Thus, a function pointer
3547    initialized to the address of a function in a shared library will
3548    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3549    redefines the function descriptor symbol to point to the copy.  This
3550    presents a problem as a plt entry for that function is also
3551    initialized from the function descriptor symbol and the copy reloc
3552    may not be initialized first.  */
3553 #define ELIMINATE_COPY_RELOCS 1
3554
3555 /* Section name for stubs is the associated section name plus this
3556    string.  */
3557 #define STUB_SUFFIX ".stub"
3558
3559 /* Linker stubs.
3560    ppc_stub_long_branch:
3561    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3562    destination, but a 24 bit branch in a stub section will reach.
3563    .    b       dest
3564
3565    ppc_stub_plt_branch:
3566    Similar to the above, but a 24 bit branch in the stub section won't
3567    reach its destination.
3568    .    addis   %r12,%r2,xxx@toc@ha
3569    .    ld      %r11,xxx@toc@l(%r12)
3570    .    mtctr   %r11
3571    .    bctr
3572
3573    ppc_stub_plt_call:
3574    Used to call a function in a shared library.  If it so happens that
3575    the plt entry referenced crosses a 64k boundary, then an extra
3576    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3577    .    addis   %r12,%r2,xxx@toc@ha
3578    .    std     %r2,40(%r1)
3579    .    ld      %r11,xxx+0@toc@l(%r12)
3580    .    mtctr   %r11
3581    .    ld      %r2,xxx+8@toc@l(%r12)
3582    .    ld      %r11,xxx+16@toc@l(%r12)
3583    .    bctr
3584
3585    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3586    code to adjust the value and save r2 to support multiple toc sections.
3587    A ppc_stub_long_branch with an r2 offset looks like:
3588    .    std     %r2,40(%r1)
3589    .    addis   %r2,%r2,off@ha
3590    .    addi    %r2,%r2,off@l
3591    .    b       dest
3592
3593    A ppc_stub_plt_branch with an r2 offset looks like:
3594    .    std     %r2,40(%r1)
3595    .    addis   %r12,%r2,xxx@toc@ha
3596    .    ld      %r11,xxx@toc@l(%r12)
3597    .    addis   %r2,%r2,off@ha
3598    .    addi    %r2,%r2,off@l
3599    .    mtctr   %r11
3600    .    bctr
3601
3602    In cases where the "addis" instruction would add zero, the "addis" is
3603    omitted and following instructions modified slightly in some cases.
3604 */
3605
3606 enum ppc_stub_type {
3607   ppc_stub_none,
3608   ppc_stub_long_branch,
3609   ppc_stub_long_branch_r2off,
3610   ppc_stub_plt_branch,
3611   ppc_stub_plt_branch_r2off,
3612   ppc_stub_plt_call
3613 };
3614
3615 struct ppc_stub_hash_entry {
3616
3617   /* Base hash table entry structure.  */
3618   struct bfd_hash_entry root;
3619
3620   enum ppc_stub_type stub_type;
3621
3622   /* The stub section.  */
3623   asection *stub_sec;
3624
3625   /* Offset within stub_sec of the beginning of this stub.  */
3626   bfd_vma stub_offset;
3627
3628   /* Given the symbol's value and its section we can determine its final
3629      value when building the stubs (so the stub knows where to jump.  */
3630   bfd_vma target_value;
3631   asection *target_section;
3632
3633   /* The symbol table entry, if any, that this was derived from.  */
3634   struct ppc_link_hash_entry *h;
3635   struct plt_entry *plt_ent;
3636
3637   /* And the reloc addend that this was derived from.  */
3638   bfd_vma addend;
3639
3640   /* Where this stub is being called from, or, in the case of combined
3641      stub sections, the first input section in the group.  */
3642   asection *id_sec;
3643 };
3644
3645 struct ppc_branch_hash_entry {
3646
3647   /* Base hash table entry structure.  */
3648   struct bfd_hash_entry root;
3649
3650   /* Offset within branch lookup table.  */
3651   unsigned int offset;
3652
3653   /* Generation marker.  */
3654   unsigned int iter;
3655 };
3656
3657 struct ppc_link_hash_entry
3658 {
3659   struct elf_link_hash_entry elf;
3660
3661   union {
3662     /* A pointer to the most recently used stub hash entry against this
3663        symbol.  */
3664     struct ppc_stub_hash_entry *stub_cache;
3665
3666     /* A pointer to the next symbol starting with a '.'  */
3667     struct ppc_link_hash_entry *next_dot_sym;
3668   } u;
3669
3670   /* Track dynamic relocs copied for this symbol.  */
3671   struct ppc_dyn_relocs *dyn_relocs;
3672
3673   /* Link between function code and descriptor symbols.  */
3674   struct ppc_link_hash_entry *oh;
3675
3676   /* Flag function code and descriptor symbols.  */
3677   unsigned int is_func:1;
3678   unsigned int is_func_descriptor:1;
3679   unsigned int fake:1;
3680
3681   /* Whether global opd/toc sym has been adjusted or not.
3682      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3683      should be set for all globals defined in any opd/toc section.  */
3684   unsigned int adjust_done:1;
3685
3686   /* Set if we twiddled this symbol to weak at some stage.  */
3687   unsigned int was_undefined:1;
3688
3689   /* Contexts in which symbol is used in the GOT (or TOC).
3690      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3691      corresponding relocs are encountered during check_relocs.
3692      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3693      indicate the corresponding GOT entry type is not needed.
3694      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3695      a TPREL one.  We use a separate flag rather than setting TPREL
3696      just for convenience in distinguishing the two cases.  */
3697 #define TLS_GD           1      /* GD reloc. */
3698 #define TLS_LD           2      /* LD reloc. */
3699 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3700 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3701 #define TLS_TLS         16      /* Any TLS reloc.  */
3702 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3703 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3704 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3705   unsigned char tls_mask;
3706 };
3707
3708 /* ppc64 ELF linker hash table.  */
3709
3710 struct ppc_link_hash_table
3711 {
3712   struct elf_link_hash_table elf;
3713
3714   /* The stub hash table.  */
3715   struct bfd_hash_table stub_hash_table;
3716
3717   /* Another hash table for plt_branch stubs.  */
3718   struct bfd_hash_table branch_hash_table;
3719
3720   /* Linker stub bfd.  */
3721   bfd *stub_bfd;
3722
3723   /* Linker call-backs.  */
3724   asection * (*add_stub_section) (const char *, asection *);
3725   void (*layout_sections_again) (void);
3726
3727   /* Array to keep track of which stub sections have been created, and
3728      information on stub grouping.  */
3729   struct map_stub {
3730     /* This is the section to which stubs in the group will be attached.  */
3731     asection *link_sec;
3732     /* The stub section.  */
3733     asection *stub_sec;
3734     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3735     bfd_vma toc_off;
3736   } *stub_group;
3737
3738   /* Temp used when calculating TOC pointers.  */
3739   bfd_vma toc_curr;
3740   bfd *toc_bfd;
3741   asection *toc_first_sec;
3742
3743   /* Highest input section id.  */
3744   int top_id;
3745
3746   /* Highest output section index.  */
3747   int top_index;
3748
3749   /* Used when adding symbols.  */
3750   struct ppc_link_hash_entry *dot_syms;
3751
3752   /* List of input sections for each output section.  */
3753   asection **input_list;
3754
3755   /* Short-cuts to get to dynamic linker sections.  */
3756   asection *got;
3757   asection *plt;
3758   asection *relplt;
3759   asection *iplt;
3760   asection *reliplt;
3761   asection *dynbss;
3762   asection *relbss;
3763   asection *glink;
3764   asection *sfpr;
3765   asection *brlt;
3766   asection *relbrlt;
3767
3768   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3769   struct ppc_link_hash_entry *tls_get_addr;
3770   struct ppc_link_hash_entry *tls_get_addr_fd;
3771
3772   /* The size of reliplt used by got entry relocs.  */
3773   bfd_size_type got_reli_size;
3774
3775   /* Statistics.  */
3776   unsigned long stub_count[ppc_stub_plt_call];
3777
3778   /* Number of stubs against global syms.  */
3779   unsigned long stub_globals;
3780
3781   /* Set if we should emit symbols for stubs.  */
3782   unsigned int emit_stub_syms:1;
3783
3784   /* Set if __tls_get_addr optimization should not be done.  */
3785   unsigned int no_tls_get_addr_opt:1;
3786
3787   /* Support for multiple toc sections.  */
3788   unsigned int do_multi_toc:1;
3789   unsigned int multi_toc_needed:1;
3790   unsigned int second_toc_pass:1;
3791   unsigned int do_toc_opt:1;
3792
3793   /* Set on error.  */
3794   unsigned int stub_error:1;
3795
3796   /* Temp used by ppc64_elf_process_dot_syms.  */
3797   unsigned int twiddled_syms:1;
3798
3799   /* Incremented every time we size stubs.  */
3800   unsigned int stub_iteration;
3801
3802   /* Small local sym cache.  */
3803   struct sym_cache sym_cache;
3804 };
3805
3806 /* Rename some of the generic section flags to better document how they
3807    are used here.  */
3808
3809 /* Nonzero if this section has TLS related relocations.  */
3810 #define has_tls_reloc sec_flg0
3811
3812 /* Nonzero if this section has a call to __tls_get_addr.  */
3813 #define has_tls_get_addr_call sec_flg1
3814
3815 /* Nonzero if this section has any toc or got relocs.  */
3816 #define has_toc_reloc sec_flg2
3817
3818 /* Nonzero if this section has a call to another section that uses
3819    the toc or got.  */
3820 #define makes_toc_func_call sec_flg3
3821
3822 /* Recursion protection when determining above flag.  */
3823 #define call_check_in_progress sec_flg4
3824 #define call_check_done sec_flg5
3825
3826 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3827
3828 #define ppc_hash_table(p) \
3829   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3830   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3831
3832 #define ppc_stub_hash_lookup(table, string, create, copy) \
3833   ((struct ppc_stub_hash_entry *) \
3834    bfd_hash_lookup ((table), (string), (create), (copy)))
3835
3836 #define ppc_branch_hash_lookup(table, string, create, copy) \
3837   ((struct ppc_branch_hash_entry *) \
3838    bfd_hash_lookup ((table), (string), (create), (copy)))
3839
3840 /* Create an entry in the stub hash table.  */
3841
3842 static struct bfd_hash_entry *
3843 stub_hash_newfunc (struct bfd_hash_entry *entry,
3844                    struct bfd_hash_table *table,
3845                    const char *string)
3846 {
3847   /* Allocate the structure if it has not already been allocated by a
3848      subclass.  */
3849   if (entry == NULL)
3850     {
3851       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3852       if (entry == NULL)
3853         return entry;
3854     }
3855
3856   /* Call the allocation method of the superclass.  */
3857   entry = bfd_hash_newfunc (entry, table, string);
3858   if (entry != NULL)
3859     {
3860       struct ppc_stub_hash_entry *eh;
3861
3862       /* Initialize the local fields.  */
3863       eh = (struct ppc_stub_hash_entry *) entry;
3864       eh->stub_type = ppc_stub_none;
3865       eh->stub_sec = NULL;
3866       eh->stub_offset = 0;
3867       eh->target_value = 0;
3868       eh->target_section = NULL;
3869       eh->h = NULL;
3870       eh->id_sec = NULL;
3871     }
3872
3873   return entry;
3874 }
3875
3876 /* Create an entry in the branch hash table.  */
3877
3878 static struct bfd_hash_entry *
3879 branch_hash_newfunc (struct bfd_hash_entry *entry,
3880                      struct bfd_hash_table *table,
3881                      const char *string)
3882 {
3883   /* Allocate the structure if it has not already been allocated by a
3884      subclass.  */
3885   if (entry == NULL)
3886     {
3887       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3888       if (entry == NULL)
3889         return entry;
3890     }
3891
3892   /* Call the allocation method of the superclass.  */
3893   entry = bfd_hash_newfunc (entry, table, string);
3894   if (entry != NULL)
3895     {
3896       struct ppc_branch_hash_entry *eh;
3897
3898       /* Initialize the local fields.  */
3899       eh = (struct ppc_branch_hash_entry *) entry;
3900       eh->offset = 0;
3901       eh->iter = 0;
3902     }
3903
3904   return entry;
3905 }
3906
3907 /* Create an entry in a ppc64 ELF linker hash table.  */
3908
3909 static struct bfd_hash_entry *
3910 link_hash_newfunc (struct bfd_hash_entry *entry,
3911                    struct bfd_hash_table *table,
3912                    const char *string)
3913 {
3914   /* Allocate the structure if it has not already been allocated by a
3915      subclass.  */
3916   if (entry == NULL)
3917     {
3918       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3919       if (entry == NULL)
3920         return entry;
3921     }
3922
3923   /* Call the allocation method of the superclass.  */
3924   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3925   if (entry != NULL)
3926     {
3927       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3928
3929       memset (&eh->u.stub_cache, 0,
3930               (sizeof (struct ppc_link_hash_entry)
3931                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3932
3933       /* When making function calls, old ABI code references function entry
3934          points (dot symbols), while new ABI code references the function
3935          descriptor symbol.  We need to make any combination of reference and
3936          definition work together, without breaking archive linking.
3937
3938          For a defined function "foo" and an undefined call to "bar":
3939          An old object defines "foo" and ".foo", references ".bar" (possibly
3940          "bar" too).
3941          A new object defines "foo" and references "bar".
3942
3943          A new object thus has no problem with its undefined symbols being
3944          satisfied by definitions in an old object.  On the other hand, the
3945          old object won't have ".bar" satisfied by a new object.
3946
3947          Keep a list of newly added dot-symbols.  */
3948
3949       if (string[0] == '.')
3950         {
3951           struct ppc_link_hash_table *htab;
3952
3953           htab = (struct ppc_link_hash_table *) table;
3954           eh->u.next_dot_sym = htab->dot_syms;
3955           htab->dot_syms = eh;
3956         }
3957     }
3958
3959   return entry;
3960 }
3961
3962 /* Create a ppc64 ELF linker hash table.  */
3963
3964 static struct bfd_link_hash_table *
3965 ppc64_elf_link_hash_table_create (bfd *abfd)
3966 {
3967   struct ppc_link_hash_table *htab;
3968   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3969
3970   htab = bfd_zmalloc (amt);
3971   if (htab == NULL)
3972     return NULL;
3973
3974   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3975                                       sizeof (struct ppc_link_hash_entry),
3976                                       PPC64_ELF_DATA))
3977     {
3978       free (htab);
3979       return NULL;
3980     }
3981
3982   /* Init the stub hash table too.  */
3983   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3984                             sizeof (struct ppc_stub_hash_entry)))
3985     return NULL;
3986
3987   /* And the branch hash table.  */
3988   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3989                             sizeof (struct ppc_branch_hash_entry)))
3990     return NULL;
3991
3992   /* Initializing two fields of the union is just cosmetic.  We really
3993      only care about glist, but when compiled on a 32-bit host the
3994      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3995      debugger inspection of these fields look nicer.  */
3996   htab->elf.init_got_refcount.refcount = 0;
3997   htab->elf.init_got_refcount.glist = NULL;
3998   htab->elf.init_plt_refcount.refcount = 0;
3999   htab->elf.init_plt_refcount.glist = NULL;
4000   htab->elf.init_got_offset.offset = 0;
4001   htab->elf.init_got_offset.glist = NULL;
4002   htab->elf.init_plt_offset.offset = 0;
4003   htab->elf.init_plt_offset.glist = NULL;
4004
4005   return &htab->elf.root;
4006 }
4007
4008 /* Free the derived linker hash table.  */
4009
4010 static void
4011 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4012 {
4013   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
4014
4015   bfd_hash_table_free (&ret->stub_hash_table);
4016   bfd_hash_table_free (&ret->branch_hash_table);
4017   _bfd_generic_link_hash_table_free (hash);
4018 }
4019
4020 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4021
4022 void
4023 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4024 {
4025   struct ppc_link_hash_table *htab;
4026
4027   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4028
4029 /* Always hook our dynamic sections into the first bfd, which is the
4030    linker created stub bfd.  This ensures that the GOT header is at
4031    the start of the output TOC section.  */
4032   htab = ppc_hash_table (info);
4033   if (htab == NULL)
4034     return;
4035   htab->stub_bfd = abfd;
4036   htab->elf.dynobj = abfd;
4037 }
4038
4039 /* Build a name for an entry in the stub hash table.  */
4040
4041 static char *
4042 ppc_stub_name (const asection *input_section,
4043                const asection *sym_sec,
4044                const struct ppc_link_hash_entry *h,
4045                const Elf_Internal_Rela *rel)
4046 {
4047   char *stub_name;
4048   bfd_size_type len;
4049
4050   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4051      offsets from a sym as a branch target?  In fact, we could
4052      probably assume the addend is always zero.  */
4053   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4054
4055   if (h)
4056     {
4057       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4058       stub_name = bfd_malloc (len);
4059       if (stub_name == NULL)
4060         return stub_name;
4061
4062       sprintf (stub_name, "%08x.%s+%x",
4063                input_section->id & 0xffffffff,
4064                h->elf.root.root.string,
4065                (int) rel->r_addend & 0xffffffff);
4066     }
4067   else
4068     {
4069       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4070       stub_name = bfd_malloc (len);
4071       if (stub_name == NULL)
4072         return stub_name;
4073
4074       sprintf (stub_name, "%08x.%x:%x+%x",
4075                input_section->id & 0xffffffff,
4076                sym_sec->id & 0xffffffff,
4077                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4078                (int) rel->r_addend & 0xffffffff);
4079     }
4080   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4081     stub_name[len - 2] = 0;
4082   return stub_name;
4083 }
4084
4085 /* Look up an entry in the stub hash.  Stub entries are cached because
4086    creating the stub name takes a bit of time.  */
4087
4088 static struct ppc_stub_hash_entry *
4089 ppc_get_stub_entry (const asection *input_section,
4090                     const asection *sym_sec,
4091                     struct ppc_link_hash_entry *h,
4092                     const Elf_Internal_Rela *rel,
4093                     struct ppc_link_hash_table *htab)
4094 {
4095   struct ppc_stub_hash_entry *stub_entry;
4096   const asection *id_sec;
4097
4098   /* If this input section is part of a group of sections sharing one
4099      stub section, then use the id of the first section in the group.
4100      Stub names need to include a section id, as there may well be
4101      more than one stub used to reach say, printf, and we need to
4102      distinguish between them.  */
4103   id_sec = htab->stub_group[input_section->id].link_sec;
4104
4105   if (h != NULL && h->u.stub_cache != NULL
4106       && h->u.stub_cache->h == h
4107       && h->u.stub_cache->id_sec == id_sec)
4108     {
4109       stub_entry = h->u.stub_cache;
4110     }
4111   else
4112     {
4113       char *stub_name;
4114
4115       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4116       if (stub_name == NULL)
4117         return NULL;
4118
4119       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4120                                          stub_name, FALSE, FALSE);
4121       if (h != NULL)
4122         h->u.stub_cache = stub_entry;
4123
4124       free (stub_name);
4125     }
4126
4127   return stub_entry;
4128 }
4129
4130 /* Add a new stub entry to the stub hash.  Not all fields of the new
4131    stub entry are initialised.  */
4132
4133 static struct ppc_stub_hash_entry *
4134 ppc_add_stub (const char *stub_name,
4135               asection *section,
4136               struct ppc_link_hash_table *htab)
4137 {
4138   asection *link_sec;
4139   asection *stub_sec;
4140   struct ppc_stub_hash_entry *stub_entry;
4141
4142   link_sec = htab->stub_group[section->id].link_sec;
4143   stub_sec = htab->stub_group[section->id].stub_sec;
4144   if (stub_sec == NULL)
4145     {
4146       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4147       if (stub_sec == NULL)
4148         {
4149           size_t namelen;
4150           bfd_size_type len;
4151           char *s_name;
4152
4153           namelen = strlen (link_sec->name);
4154           len = namelen + sizeof (STUB_SUFFIX);
4155           s_name = bfd_alloc (htab->stub_bfd, len);
4156           if (s_name == NULL)
4157             return NULL;
4158
4159           memcpy (s_name, link_sec->name, namelen);
4160           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4161           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4162           if (stub_sec == NULL)
4163             return NULL;
4164           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4165         }
4166       htab->stub_group[section->id].stub_sec = stub_sec;
4167     }
4168
4169   /* Enter this entry into the linker stub hash table.  */
4170   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4171                                      TRUE, FALSE);
4172   if (stub_entry == NULL)
4173     {
4174       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4175                              section->owner, stub_name);
4176       return NULL;
4177     }
4178
4179   stub_entry->stub_sec = stub_sec;
4180   stub_entry->stub_offset = 0;
4181   stub_entry->id_sec = link_sec;
4182   return stub_entry;
4183 }
4184
4185 /* Create sections for linker generated code.  */
4186
4187 static bfd_boolean
4188 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4189 {
4190   struct ppc_link_hash_table *htab;
4191   flagword flags;
4192
4193   htab = ppc_hash_table (info);
4194   if (htab == NULL)
4195     return FALSE;
4196
4197   /* Create .sfpr for code to save and restore fp regs.  */
4198   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4199            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4200   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4201                                                    flags);
4202   if (htab->sfpr == NULL
4203       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4204     return FALSE;
4205
4206   /* Create .glink for lazy dynamic linking support.  */
4207   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4208                                                     flags);
4209   if (htab->glink == NULL
4210       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4211     return FALSE;
4212
4213   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4214   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4215   if (htab->iplt == NULL
4216       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4217     return FALSE;
4218
4219   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4220            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4221   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4222                                                       ".rela.iplt",
4223                                                       flags);
4224   if (htab->reliplt == NULL
4225       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4226     return FALSE;
4227
4228   /* Create branch lookup table for plt_branch stubs.  */
4229   flags = (SEC_ALLOC | SEC_LOAD
4230            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4231   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4232                                                    flags);
4233   if (htab->brlt == NULL
4234       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4235     return FALSE;
4236
4237   if (!info->shared)
4238     return TRUE;
4239
4240   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4241            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4242   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4243                                                       ".rela.branch_lt",
4244                                                       flags);
4245   if (htab->relbrlt == NULL
4246       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4247     return FALSE;
4248
4249   return TRUE;
4250 }
4251
4252 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4253    not already done.  */
4254
4255 static bfd_boolean
4256 create_got_section (bfd *abfd, struct bfd_link_info *info)
4257 {
4258   asection *got, *relgot;
4259   flagword flags;
4260   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4261
4262   if (!is_ppc64_elf (abfd))
4263     return FALSE;
4264   if (htab == NULL)
4265     return FALSE;
4266
4267   if (!htab->got)
4268     {
4269       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4270         return FALSE;
4271
4272       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4273       if (!htab->got)
4274         abort ();
4275     }
4276
4277   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4278            | SEC_LINKER_CREATED);
4279
4280   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4281   if (!got
4282       || !bfd_set_section_alignment (abfd, got, 3))
4283     return FALSE;
4284
4285   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4286                                                flags | SEC_READONLY);
4287   if (!relgot
4288       || ! bfd_set_section_alignment (abfd, relgot, 3))
4289     return FALSE;
4290
4291   ppc64_elf_tdata (abfd)->got = got;
4292   ppc64_elf_tdata (abfd)->relgot = relgot;
4293   return TRUE;
4294 }
4295
4296 /* Create the dynamic sections, and set up shortcuts.  */
4297
4298 static bfd_boolean
4299 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4300 {
4301   struct ppc_link_hash_table *htab;
4302
4303   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4304     return FALSE;
4305
4306   htab = ppc_hash_table (info);
4307   if (htab == NULL)
4308     return FALSE;
4309
4310   if (!htab->got)
4311     htab->got = bfd_get_section_by_name (dynobj, ".got");
4312   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4313   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4314   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4315   if (!info->shared)
4316     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4317
4318   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4319       || (!info->shared && !htab->relbss))
4320     abort ();
4321
4322   return TRUE;
4323 }
4324
4325 /* Follow indirect and warning symbol links.  */
4326
4327 static inline struct bfd_link_hash_entry *
4328 follow_link (struct bfd_link_hash_entry *h)
4329 {
4330   while (h->type == bfd_link_hash_indirect
4331          || h->type == bfd_link_hash_warning)
4332     h = h->u.i.link;
4333   return h;
4334 }
4335
4336 static inline struct elf_link_hash_entry *
4337 elf_follow_link (struct elf_link_hash_entry *h)
4338 {
4339   return (struct elf_link_hash_entry *) follow_link (&h->root);
4340 }
4341
4342 static inline struct ppc_link_hash_entry *
4343 ppc_follow_link (struct ppc_link_hash_entry *h)
4344 {
4345   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4346 }
4347
4348 /* Merge PLT info on FROM with that on TO.  */
4349
4350 static void
4351 move_plt_plist (struct ppc_link_hash_entry *from,
4352                 struct ppc_link_hash_entry *to)
4353 {
4354   if (from->elf.plt.plist != NULL)
4355     {
4356       if (to->elf.plt.plist != NULL)
4357         {
4358           struct plt_entry **entp;
4359           struct plt_entry *ent;
4360
4361           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4362             {
4363               struct plt_entry *dent;
4364
4365               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4366                 if (dent->addend == ent->addend)
4367                   {
4368                     dent->plt.refcount += ent->plt.refcount;
4369                     *entp = ent->next;
4370                     break;
4371                   }
4372               if (dent == NULL)
4373                 entp = &ent->next;
4374             }
4375           *entp = to->elf.plt.plist;
4376         }
4377
4378       to->elf.plt.plist = from->elf.plt.plist;
4379       from->elf.plt.plist = NULL;
4380     }
4381 }
4382
4383 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4384
4385 static void
4386 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4387                                 struct elf_link_hash_entry *dir,
4388                                 struct elf_link_hash_entry *ind)
4389 {
4390   struct ppc_link_hash_entry *edir, *eind;
4391
4392   edir = (struct ppc_link_hash_entry *) dir;
4393   eind = (struct ppc_link_hash_entry *) ind;
4394
4395   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4396   if (eind->dyn_relocs != NULL)
4397     {
4398       if (edir->dyn_relocs != NULL)
4399         {
4400           struct ppc_dyn_relocs **pp;
4401           struct ppc_dyn_relocs *p;
4402
4403           /* Add reloc counts against the indirect sym to the direct sym
4404              list.  Merge any entries against the same section.  */
4405           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4406             {
4407               struct ppc_dyn_relocs *q;
4408
4409               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4410                 if (q->sec == p->sec)
4411                   {
4412                     q->pc_count += p->pc_count;
4413                     q->count += p->count;
4414                     *pp = p->next;
4415                     break;
4416                   }
4417               if (q == NULL)
4418                 pp = &p->next;
4419             }
4420           *pp = edir->dyn_relocs;
4421         }
4422
4423       edir->dyn_relocs = eind->dyn_relocs;
4424       eind->dyn_relocs = NULL;
4425     }
4426
4427   edir->is_func |= eind->is_func;
4428   edir->is_func_descriptor |= eind->is_func_descriptor;
4429   edir->tls_mask |= eind->tls_mask;
4430   if (eind->oh != NULL)
4431     edir->oh = ppc_follow_link (eind->oh);
4432
4433   /* If called to transfer flags for a weakdef during processing
4434      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4435      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4436   if (!(ELIMINATE_COPY_RELOCS
4437         && eind->elf.root.type != bfd_link_hash_indirect
4438         && edir->elf.dynamic_adjusted))
4439     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4440
4441   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4442   edir->elf.ref_regular |= eind->elf.ref_regular;
4443   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4444   edir->elf.needs_plt |= eind->elf.needs_plt;
4445
4446   /* If we were called to copy over info for a weak sym, that's all.  */
4447   if (eind->elf.root.type != bfd_link_hash_indirect)
4448     return;
4449
4450   /* Copy over got entries that we may have already seen to the
4451      symbol which just became indirect.  */
4452   if (eind->elf.got.glist != NULL)
4453     {
4454       if (edir->elf.got.glist != NULL)
4455         {
4456           struct got_entry **entp;
4457           struct got_entry *ent;
4458
4459           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4460             {
4461               struct got_entry *dent;
4462
4463               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4464                 if (dent->addend == ent->addend
4465                     && dent->owner == ent->owner
4466                     && dent->tls_type == ent->tls_type)
4467                   {
4468                     dent->got.refcount += ent->got.refcount;
4469                     *entp = ent->next;
4470                     break;
4471                   }
4472               if (dent == NULL)
4473                 entp = &ent->next;
4474             }
4475           *entp = edir->elf.got.glist;
4476         }
4477
4478       edir->elf.got.glist = eind->elf.got.glist;
4479       eind->elf.got.glist = NULL;
4480     }
4481
4482   /* And plt entries.  */
4483   move_plt_plist (eind, edir);
4484
4485   if (eind->elf.dynindx != -1)
4486     {
4487       if (edir->elf.dynindx != -1)
4488         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4489                                 edir->elf.dynstr_index);
4490       edir->elf.dynindx = eind->elf.dynindx;
4491       edir->elf.dynstr_index = eind->elf.dynstr_index;
4492       eind->elf.dynindx = -1;
4493       eind->elf.dynstr_index = 0;
4494     }
4495 }
4496
4497 /* Find the function descriptor hash entry from the given function code
4498    hash entry FH.  Link the entries via their OH fields.  */
4499
4500 static struct ppc_link_hash_entry *
4501 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4502 {
4503   struct ppc_link_hash_entry *fdh = fh->oh;
4504
4505   if (fdh == NULL)
4506     {
4507       const char *fd_name = fh->elf.root.root.string + 1;
4508
4509       fdh = (struct ppc_link_hash_entry *)
4510         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4511       if (fdh == NULL)
4512         return fdh;
4513
4514       fdh->is_func_descriptor = 1;
4515       fdh->oh = fh;
4516       fh->is_func = 1;
4517       fh->oh = fdh;
4518     }
4519
4520   return ppc_follow_link (fdh);
4521 }
4522
4523 /* Make a fake function descriptor sym for the code sym FH.  */
4524
4525 static struct ppc_link_hash_entry *
4526 make_fdh (struct bfd_link_info *info,
4527           struct ppc_link_hash_entry *fh)
4528 {
4529   bfd *abfd;
4530   asymbol *newsym;
4531   struct bfd_link_hash_entry *bh;
4532   struct ppc_link_hash_entry *fdh;
4533
4534   abfd = fh->elf.root.u.undef.abfd;
4535   newsym = bfd_make_empty_symbol (abfd);
4536   newsym->name = fh->elf.root.root.string + 1;
4537   newsym->section = bfd_und_section_ptr;
4538   newsym->value = 0;
4539   newsym->flags = BSF_WEAK;
4540
4541   bh = NULL;
4542   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4543                                          newsym->flags, newsym->section,
4544                                          newsym->value, NULL, FALSE, FALSE,
4545                                          &bh))
4546     return NULL;
4547
4548   fdh = (struct ppc_link_hash_entry *) bh;
4549   fdh->elf.non_elf = 0;
4550   fdh->fake = 1;
4551   fdh->is_func_descriptor = 1;
4552   fdh->oh = fh;
4553   fh->is_func = 1;
4554   fh->oh = fdh;
4555   return fdh;
4556 }
4557
4558 /* Fix function descriptor symbols defined in .opd sections to be
4559    function type.  */
4560
4561 static bfd_boolean
4562 ppc64_elf_add_symbol_hook (bfd *ibfd,
4563                            struct bfd_link_info *info,
4564                            Elf_Internal_Sym *isym,
4565                            const char **name ATTRIBUTE_UNUSED,
4566                            flagword *flags ATTRIBUTE_UNUSED,
4567                            asection **sec,
4568                            bfd_vma *value ATTRIBUTE_UNUSED)
4569 {
4570   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4571     {
4572       if ((ibfd->flags & DYNAMIC) == 0)
4573         elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4574     }
4575   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4576     ;
4577   else if (*sec != NULL
4578            && strcmp ((*sec)->name, ".opd") == 0)
4579     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4580
4581   return TRUE;
4582 }
4583
4584 /* This function makes an old ABI object reference to ".bar" cause the
4585    inclusion of a new ABI object archive that defines "bar".
4586    NAME is a symbol defined in an archive.  Return a symbol in the hash
4587    table that might be satisfied by the archive symbols.  */
4588
4589 static struct elf_link_hash_entry *
4590 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4591                                  struct bfd_link_info *info,
4592                                  const char *name)
4593 {
4594   struct elf_link_hash_entry *h;
4595   char *dot_name;
4596   size_t len;
4597
4598   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4599   if (h != NULL
4600       /* Don't return this sym if it is a fake function descriptor
4601          created by add_symbol_adjust.  */
4602       && !(h->root.type == bfd_link_hash_undefweak
4603            && ((struct ppc_link_hash_entry *) h)->fake))
4604     return h;
4605
4606   if (name[0] == '.')
4607     return h;
4608
4609   len = strlen (name);
4610   dot_name = bfd_alloc (abfd, len + 2);
4611   if (dot_name == NULL)
4612     return (struct elf_link_hash_entry *) 0 - 1;
4613   dot_name[0] = '.';
4614   memcpy (dot_name + 1, name, len + 1);
4615   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4616   bfd_release (abfd, dot_name);
4617   return h;
4618 }
4619
4620 /* This function satisfies all old ABI object references to ".bar" if a
4621    new ABI object defines "bar".  Well, at least, undefined dot symbols
4622    are made weak.  This stops later archive searches from including an
4623    object if we already have a function descriptor definition.  It also
4624    prevents the linker complaining about undefined symbols.
4625    We also check and correct mismatched symbol visibility here.  The
4626    most restrictive visibility of the function descriptor and the
4627    function entry symbol is used.  */
4628
4629 static bfd_boolean
4630 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4631 {
4632   struct ppc_link_hash_table *htab;
4633   struct ppc_link_hash_entry *fdh;
4634
4635   if (eh->elf.root.type == bfd_link_hash_indirect)
4636     return TRUE;
4637
4638   if (eh->elf.root.type == bfd_link_hash_warning)
4639     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4640
4641   if (eh->elf.root.root.string[0] != '.')
4642     abort ();
4643
4644   htab = ppc_hash_table (info);
4645   if (htab == NULL)
4646     return FALSE;
4647
4648   fdh = lookup_fdh (eh, htab);
4649   if (fdh == NULL)
4650     {
4651       if (!info->relocatable
4652           && (eh->elf.root.type == bfd_link_hash_undefined
4653               || eh->elf.root.type == bfd_link_hash_undefweak)
4654           && eh->elf.ref_regular)
4655         {
4656           /* Make an undefweak function descriptor sym, which is enough to
4657              pull in an --as-needed shared lib, but won't cause link
4658              errors.  Archives are handled elsewhere.  */
4659           fdh = make_fdh (info, eh);
4660           if (fdh == NULL)
4661             return FALSE;
4662           fdh->elf.ref_regular = 1;
4663         }
4664     }
4665   else
4666     {
4667       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4668       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4669       if (entry_vis < descr_vis)
4670         fdh->elf.other += entry_vis - descr_vis;
4671       else if (entry_vis > descr_vis)
4672         eh->elf.other += descr_vis - entry_vis;
4673
4674       if ((fdh->elf.root.type == bfd_link_hash_defined
4675            || fdh->elf.root.type == bfd_link_hash_defweak)
4676           && eh->elf.root.type == bfd_link_hash_undefined)
4677         {
4678           eh->elf.root.type = bfd_link_hash_undefweak;
4679           eh->was_undefined = 1;
4680           htab->twiddled_syms = 1;
4681         }
4682     }
4683
4684   return TRUE;
4685 }
4686
4687 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4688
4689 static bfd_boolean
4690 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4691 {
4692   struct ppc_link_hash_table *htab;
4693   struct ppc_link_hash_entry **p, *eh;
4694
4695   if (!is_ppc64_elf (info->output_bfd))
4696     return TRUE;
4697   htab = ppc_hash_table (info);
4698   if (htab == NULL)
4699     return FALSE;
4700
4701   if (is_ppc64_elf (ibfd))
4702     {
4703       p = &htab->dot_syms;
4704       while ((eh = *p) != NULL)
4705         {
4706           *p = NULL;
4707           if (!add_symbol_adjust (eh, info))
4708             return FALSE;
4709           p = &eh->u.next_dot_sym;
4710         }
4711     }
4712
4713   /* Clear the list for non-ppc64 input files.  */
4714   p = &htab->dot_syms;
4715   while ((eh = *p) != NULL)
4716     {
4717       *p = NULL;
4718       p = &eh->u.next_dot_sym;
4719     }
4720
4721   /* We need to fix the undefs list for any syms we have twiddled to
4722      undef_weak.  */
4723   if (htab->twiddled_syms)
4724     {
4725       bfd_link_repair_undef_list (&htab->elf.root);
4726       htab->twiddled_syms = 0;
4727     }
4728   return TRUE;
4729 }
4730
4731 /* Undo hash table changes when an --as-needed input file is determined
4732    not to be needed.  */
4733
4734 static bfd_boolean
4735 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4736                              struct bfd_link_info *info)
4737 {
4738   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4739
4740   if (htab == NULL)
4741     return FALSE;
4742
4743   htab->dot_syms = NULL;
4744   return TRUE;
4745 }
4746
4747 static struct plt_entry **
4748 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4749                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4750 {
4751   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4752   struct plt_entry **local_plt;
4753   unsigned char *local_got_tls_masks;
4754
4755   if (local_got_ents == NULL)
4756     {
4757       bfd_size_type size = symtab_hdr->sh_info;
4758
4759       size *= (sizeof (*local_got_ents)
4760                + sizeof (*local_plt)
4761                + sizeof (*local_got_tls_masks));
4762       local_got_ents = bfd_zalloc (abfd, size);
4763       if (local_got_ents == NULL)
4764         return NULL;
4765       elf_local_got_ents (abfd) = local_got_ents;
4766     }
4767
4768   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4769     {
4770       struct got_entry *ent;
4771
4772       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4773         if (ent->addend == r_addend
4774             && ent->owner == abfd
4775             && ent->tls_type == tls_type)
4776           break;
4777       if (ent == NULL)
4778         {
4779           bfd_size_type amt = sizeof (*ent);
4780           ent = bfd_alloc (abfd, amt);
4781           if (ent == NULL)
4782             return FALSE;
4783           ent->next = local_got_ents[r_symndx];
4784           ent->addend = r_addend;
4785           ent->owner = abfd;
4786           ent->tls_type = tls_type;
4787           ent->is_indirect = FALSE;
4788           ent->got.refcount = 0;
4789           local_got_ents[r_symndx] = ent;
4790         }
4791       ent->got.refcount += 1;
4792     }
4793
4794   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4795   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4796   local_got_tls_masks[r_symndx] |= tls_type;
4797
4798   return local_plt + r_symndx;
4799 }
4800
4801 static bfd_boolean
4802 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4803 {
4804   struct plt_entry *ent;
4805
4806   for (ent = *plist; ent != NULL; ent = ent->next)
4807     if (ent->addend == addend)
4808       break;
4809   if (ent == NULL)
4810     {
4811       bfd_size_type amt = sizeof (*ent);
4812       ent = bfd_alloc (abfd, amt);
4813       if (ent == NULL)
4814         return FALSE;
4815       ent->next = *plist;
4816       ent->addend = addend;
4817       ent->plt.refcount = 0;
4818       *plist = ent;
4819     }
4820   ent->plt.refcount += 1;
4821   return TRUE;
4822 }
4823
4824 static bfd_boolean
4825 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4826 {
4827   return (r_type == R_PPC64_REL24
4828           || r_type == R_PPC64_REL14
4829           || r_type == R_PPC64_REL14_BRTAKEN
4830           || r_type == R_PPC64_REL14_BRNTAKEN
4831           || r_type == R_PPC64_ADDR24
4832           || r_type == R_PPC64_ADDR14
4833           || r_type == R_PPC64_ADDR14_BRTAKEN
4834           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4835 }
4836
4837 /* Look through the relocs for a section during the first phase, and
4838    calculate needed space in the global offset table, procedure
4839    linkage table, and dynamic reloc sections.  */
4840
4841 static bfd_boolean
4842 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4843                         asection *sec, const Elf_Internal_Rela *relocs)
4844 {
4845   struct ppc_link_hash_table *htab;
4846   Elf_Internal_Shdr *symtab_hdr;
4847   struct elf_link_hash_entry **sym_hashes;
4848   const Elf_Internal_Rela *rel;
4849   const Elf_Internal_Rela *rel_end;
4850   asection *sreloc;
4851   asection **opd_sym_map;
4852   struct elf_link_hash_entry *tga, *dottga;
4853
4854   if (info->relocatable)
4855     return TRUE;
4856
4857   /* Don't do anything special with non-loaded, non-alloced sections.
4858      In particular, any relocs in such sections should not affect GOT
4859      and PLT reference counting (ie. we don't allow them to create GOT
4860      or PLT entries), there's no possibility or desire to optimize TLS
4861      relocs, and there's not much point in propagating relocs to shared
4862      libs that the dynamic linker won't relocate.  */
4863   if ((sec->flags & SEC_ALLOC) == 0)
4864     return TRUE;
4865
4866   BFD_ASSERT (is_ppc64_elf (abfd));
4867
4868   htab = ppc_hash_table (info);
4869   if (htab == NULL)
4870     return FALSE;
4871
4872   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4873                               FALSE, FALSE, TRUE);
4874   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4875                                  FALSE, FALSE, TRUE);
4876   symtab_hdr = &elf_symtab_hdr (abfd);
4877   sym_hashes = elf_sym_hashes (abfd);
4878   sreloc = NULL;
4879   opd_sym_map = NULL;
4880   if (strcmp (sec->name, ".opd") == 0)
4881     {
4882       /* Garbage collection needs some extra help with .opd sections.
4883          We don't want to necessarily keep everything referenced by
4884          relocs in .opd, as that would keep all functions.  Instead,
4885          if we reference an .opd symbol (a function descriptor), we
4886          want to keep the function code symbol's section.  This is
4887          easy for global symbols, but for local syms we need to keep
4888          information about the associated function section.  */
4889       bfd_size_type amt;
4890
4891       amt = sec->size * sizeof (*opd_sym_map) / 8;
4892       opd_sym_map = bfd_zalloc (abfd, amt);
4893       if (opd_sym_map == NULL)
4894         return FALSE;
4895       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4896       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4897       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4898     }
4899
4900   if (htab->sfpr == NULL
4901       && !create_linkage_sections (htab->elf.dynobj, info))
4902     return FALSE;
4903
4904   rel_end = relocs + sec->reloc_count;
4905   for (rel = relocs; rel < rel_end; rel++)
4906     {
4907       unsigned long r_symndx;
4908       struct elf_link_hash_entry *h;
4909       enum elf_ppc64_reloc_type r_type;
4910       int tls_type;
4911       struct _ppc64_elf_section_data *ppc64_sec;
4912       struct plt_entry **ifunc;
4913
4914       r_symndx = ELF64_R_SYM (rel->r_info);
4915       if (r_symndx < symtab_hdr->sh_info)
4916         h = NULL;
4917       else
4918         {
4919           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4920           h = elf_follow_link (h);
4921         }
4922
4923       tls_type = 0;
4924       ifunc = NULL;
4925       if (h != NULL)
4926         {
4927           if (h->type == STT_GNU_IFUNC)
4928             {
4929               h->needs_plt = 1;
4930               ifunc = &h->plt.plist;
4931             }
4932         }
4933       else
4934         {
4935           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4936                                                           abfd, r_symndx);
4937           if (isym == NULL)
4938             return FALSE;
4939
4940           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4941             {
4942               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4943                                              rel->r_addend, PLT_IFUNC);
4944               if (ifunc == NULL)
4945                 return FALSE;
4946             }
4947         }
4948       r_type = ELF64_R_TYPE (rel->r_info);
4949       if (is_branch_reloc (r_type))
4950         {
4951           if (h != NULL && (h == tga || h == dottga))
4952             {
4953               if (rel != relocs
4954                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4955                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4956                 /* We have a new-style __tls_get_addr call with a marker
4957                    reloc.  */
4958                 ;
4959               else
4960                 /* Mark this section as having an old-style call.  */
4961                 sec->has_tls_get_addr_call = 1;
4962             }
4963
4964           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4965           if (ifunc != NULL
4966               && !update_plt_info (abfd, ifunc, rel->r_addend))
4967             return FALSE;
4968         }
4969
4970       switch (r_type)
4971         {
4972         case R_PPC64_TLSGD:
4973         case R_PPC64_TLSLD:
4974           /* These special tls relocs tie a call to __tls_get_addr with
4975              its parameter symbol.  */
4976           break;
4977
4978         case R_PPC64_GOT_TLSLD16:
4979         case R_PPC64_GOT_TLSLD16_LO:
4980         case R_PPC64_GOT_TLSLD16_HI:
4981         case R_PPC64_GOT_TLSLD16_HA:
4982           tls_type = TLS_TLS | TLS_LD;
4983           goto dogottls;
4984
4985         case R_PPC64_GOT_TLSGD16:
4986         case R_PPC64_GOT_TLSGD16_LO:
4987         case R_PPC64_GOT_TLSGD16_HI:
4988         case R_PPC64_GOT_TLSGD16_HA:
4989           tls_type = TLS_TLS | TLS_GD;
4990           goto dogottls;
4991
4992         case R_PPC64_GOT_TPREL16_DS:
4993         case R_PPC64_GOT_TPREL16_LO_DS:
4994         case R_PPC64_GOT_TPREL16_HI:
4995         case R_PPC64_GOT_TPREL16_HA:
4996           if (!info->executable)
4997             info->flags |= DF_STATIC_TLS;
4998           tls_type = TLS_TLS | TLS_TPREL;
4999           goto dogottls;
5000
5001         case R_PPC64_GOT_DTPREL16_DS:
5002         case R_PPC64_GOT_DTPREL16_LO_DS:
5003         case R_PPC64_GOT_DTPREL16_HI:
5004         case R_PPC64_GOT_DTPREL16_HA:
5005           tls_type = TLS_TLS | TLS_DTPREL;
5006         dogottls:
5007           sec->has_tls_reloc = 1;
5008           /* Fall thru */
5009
5010         case R_PPC64_GOT16:
5011         case R_PPC64_GOT16_DS:
5012         case R_PPC64_GOT16_HA:
5013         case R_PPC64_GOT16_HI:
5014         case R_PPC64_GOT16_LO:
5015         case R_PPC64_GOT16_LO_DS:
5016           /* This symbol requires a global offset table entry.  */
5017           sec->has_toc_reloc = 1;
5018           if (r_type == R_PPC64_GOT_TLSLD16
5019               || r_type == R_PPC64_GOT_TLSGD16
5020               || r_type == R_PPC64_GOT_TPREL16_DS
5021               || r_type == R_PPC64_GOT_DTPREL16_DS
5022               || r_type == R_PPC64_GOT16
5023               || r_type == R_PPC64_GOT16_DS)
5024             {
5025               htab->do_multi_toc = 1;
5026               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5027             }
5028
5029           if (ppc64_elf_tdata (abfd)->got == NULL
5030               && !create_got_section (abfd, info))
5031             return FALSE;
5032
5033           if (h != NULL)
5034             {
5035               struct ppc_link_hash_entry *eh;
5036               struct got_entry *ent;
5037
5038               eh = (struct ppc_link_hash_entry *) h;
5039               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5040                 if (ent->addend == rel->r_addend
5041                     && ent->owner == abfd
5042                     && ent->tls_type == tls_type)
5043                   break;
5044               if (ent == NULL)
5045                 {
5046                   bfd_size_type amt = sizeof (*ent);
5047                   ent = bfd_alloc (abfd, amt);
5048                   if (ent == NULL)
5049                     return FALSE;
5050                   ent->next = eh->elf.got.glist;
5051                   ent->addend = rel->r_addend;
5052                   ent->owner = abfd;
5053                   ent->tls_type = tls_type;
5054                   ent->is_indirect = FALSE;
5055                   ent->got.refcount = 0;
5056                   eh->elf.got.glist = ent;
5057                 }
5058               ent->got.refcount += 1;
5059               eh->tls_mask |= tls_type;
5060             }
5061           else
5062             /* This is a global offset table entry for a local symbol.  */
5063             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5064                                         rel->r_addend, tls_type))
5065               return FALSE;
5066           break;
5067
5068         case R_PPC64_PLT16_HA:
5069         case R_PPC64_PLT16_HI:
5070         case R_PPC64_PLT16_LO:
5071         case R_PPC64_PLT32:
5072         case R_PPC64_PLT64:
5073           /* This symbol requires a procedure linkage table entry.  We
5074              actually build the entry in adjust_dynamic_symbol,
5075              because this might be a case of linking PIC code without
5076              linking in any dynamic objects, in which case we don't
5077              need to generate a procedure linkage table after all.  */
5078           if (h == NULL)
5079             {
5080               /* It does not make sense to have a procedure linkage
5081                  table entry for a local symbol.  */
5082               bfd_set_error (bfd_error_bad_value);
5083               return FALSE;
5084             }
5085           else
5086             {
5087               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5088                 return FALSE;
5089               h->needs_plt = 1;
5090               if (h->root.root.string[0] == '.'
5091                   && h->root.root.string[1] != '\0')
5092                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5093             }
5094           break;
5095
5096           /* The following relocations don't need to propagate the
5097              relocation if linking a shared object since they are
5098              section relative.  */
5099         case R_PPC64_SECTOFF:
5100         case R_PPC64_SECTOFF_LO:
5101         case R_PPC64_SECTOFF_HI:
5102         case R_PPC64_SECTOFF_HA:
5103         case R_PPC64_SECTOFF_DS:
5104         case R_PPC64_SECTOFF_LO_DS:
5105         case R_PPC64_DTPREL16:
5106         case R_PPC64_DTPREL16_LO:
5107         case R_PPC64_DTPREL16_HI:
5108         case R_PPC64_DTPREL16_HA:
5109         case R_PPC64_DTPREL16_DS:
5110         case R_PPC64_DTPREL16_LO_DS:
5111         case R_PPC64_DTPREL16_HIGHER:
5112         case R_PPC64_DTPREL16_HIGHERA:
5113         case R_PPC64_DTPREL16_HIGHEST:
5114         case R_PPC64_DTPREL16_HIGHESTA:
5115           break;
5116
5117           /* Nor do these.  */
5118         case R_PPC64_REL16:
5119         case R_PPC64_REL16_LO:
5120         case R_PPC64_REL16_HI:
5121         case R_PPC64_REL16_HA:
5122           break;
5123
5124         case R_PPC64_TOC16:
5125         case R_PPC64_TOC16_DS:
5126           htab->do_multi_toc = 1;
5127           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5128         case R_PPC64_TOC16_LO:
5129         case R_PPC64_TOC16_HI:
5130         case R_PPC64_TOC16_HA:
5131         case R_PPC64_TOC16_LO_DS:
5132           sec->has_toc_reloc = 1;
5133           break;
5134
5135           /* This relocation describes the C++ object vtable hierarchy.
5136              Reconstruct it for later use during GC.  */
5137         case R_PPC64_GNU_VTINHERIT:
5138           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5139             return FALSE;
5140           break;
5141
5142           /* This relocation describes which C++ vtable entries are actually
5143              used.  Record for later use during GC.  */
5144         case R_PPC64_GNU_VTENTRY:
5145           BFD_ASSERT (h != NULL);
5146           if (h != NULL
5147               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5148             return FALSE;
5149           break;
5150
5151         case R_PPC64_REL14:
5152         case R_PPC64_REL14_BRTAKEN:
5153         case R_PPC64_REL14_BRNTAKEN:
5154           {
5155             asection *dest = NULL;
5156
5157             /* Heuristic: If jumping outside our section, chances are
5158                we are going to need a stub.  */
5159             if (h != NULL)
5160               {
5161                 /* If the sym is weak it may be overridden later, so
5162                    don't assume we know where a weak sym lives.  */
5163                 if (h->root.type == bfd_link_hash_defined)
5164                   dest = h->root.u.def.section;
5165               }
5166             else
5167               {
5168                 Elf_Internal_Sym *isym;
5169
5170                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5171                                               abfd, r_symndx);
5172                 if (isym == NULL)
5173                   return FALSE;
5174
5175                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5176               }
5177
5178             if (dest != sec)
5179               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5180           }
5181           /* Fall through.  */
5182
5183         case R_PPC64_REL24:
5184           if (h != NULL && ifunc == NULL)
5185             {
5186               /* We may need a .plt entry if the function this reloc
5187                  refers to is in a shared lib.  */
5188               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5189                 return FALSE;
5190               h->needs_plt = 1;
5191               if (h->root.root.string[0] == '.'
5192                   && h->root.root.string[1] != '\0')
5193                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5194               if (h == tga || h == dottga)
5195                 sec->has_tls_reloc = 1;
5196             }
5197           break;
5198
5199         case R_PPC64_TPREL64:
5200           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5201           if (!info->executable)
5202             info->flags |= DF_STATIC_TLS;
5203           goto dotlstoc;
5204
5205         case R_PPC64_DTPMOD64:
5206           if (rel + 1 < rel_end
5207               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5208               && rel[1].r_offset == rel->r_offset + 8)
5209             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5210           else
5211             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5212           goto dotlstoc;
5213
5214         case R_PPC64_DTPREL64:
5215           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5216           if (rel != relocs
5217               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5218               && rel[-1].r_offset == rel->r_offset - 8)
5219             /* This is the second reloc of a dtpmod, dtprel pair.
5220                Don't mark with TLS_DTPREL.  */
5221             goto dodyn;
5222
5223         dotlstoc:
5224           sec->has_tls_reloc = 1;
5225           if (h != NULL)
5226             {
5227               struct ppc_link_hash_entry *eh;
5228               eh = (struct ppc_link_hash_entry *) h;
5229               eh->tls_mask |= tls_type;
5230             }
5231           else
5232             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5233                                         rel->r_addend, tls_type))
5234               return FALSE;
5235
5236           ppc64_sec = ppc64_elf_section_data (sec);
5237           if (ppc64_sec->sec_type != sec_toc)
5238             {
5239               bfd_size_type amt;
5240
5241               /* One extra to simplify get_tls_mask.  */
5242               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5243               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5244               if (ppc64_sec->u.toc.symndx == NULL)
5245                 return FALSE;
5246               amt = sec->size * sizeof (bfd_vma) / 8;
5247               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5248               if (ppc64_sec->u.toc.add == NULL)
5249                 return FALSE;
5250               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5251               ppc64_sec->sec_type = sec_toc;
5252             }
5253           BFD_ASSERT (rel->r_offset % 8 == 0);
5254           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5255           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5256
5257           /* Mark the second slot of a GD or LD entry.
5258              -1 to indicate GD and -2 to indicate LD.  */
5259           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5260             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5261           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5262             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5263           goto dodyn;
5264
5265         case R_PPC64_TPREL16:
5266         case R_PPC64_TPREL16_LO:
5267         case R_PPC64_TPREL16_HI:
5268         case R_PPC64_TPREL16_HA:
5269         case R_PPC64_TPREL16_DS:
5270         case R_PPC64_TPREL16_LO_DS:
5271         case R_PPC64_TPREL16_HIGHER:
5272         case R_PPC64_TPREL16_HIGHERA:
5273         case R_PPC64_TPREL16_HIGHEST:
5274         case R_PPC64_TPREL16_HIGHESTA:
5275           if (info->shared)
5276             {
5277               if (!info->executable)
5278                 info->flags |= DF_STATIC_TLS;
5279               goto dodyn;
5280             }
5281           break;
5282
5283         case R_PPC64_ADDR64:
5284           if (opd_sym_map != NULL
5285               && rel + 1 < rel_end
5286               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5287             {
5288               if (h != NULL)
5289                 {
5290                   if (h->root.root.string[0] == '.'
5291                       && h->root.root.string[1] != 0
5292                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5293                     ;
5294                   else
5295                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5296                 }
5297               else
5298                 {
5299                   asection *s;
5300                   Elf_Internal_Sym *isym;
5301
5302                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5303                                                 abfd, r_symndx);
5304                   if (isym == NULL)
5305                     return FALSE;
5306
5307                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5308                   if (s != NULL && s != sec)
5309                     opd_sym_map[rel->r_offset / 8] = s;
5310                 }
5311             }
5312           /* Fall through.  */
5313
5314         case R_PPC64_REL30:
5315         case R_PPC64_REL32:
5316         case R_PPC64_REL64:
5317         case R_PPC64_ADDR14:
5318         case R_PPC64_ADDR14_BRNTAKEN:
5319         case R_PPC64_ADDR14_BRTAKEN:
5320         case R_PPC64_ADDR16:
5321         case R_PPC64_ADDR16_DS:
5322         case R_PPC64_ADDR16_HA:
5323         case R_PPC64_ADDR16_HI:
5324         case R_PPC64_ADDR16_HIGHER:
5325         case R_PPC64_ADDR16_HIGHERA:
5326         case R_PPC64_ADDR16_HIGHEST:
5327         case R_PPC64_ADDR16_HIGHESTA:
5328         case R_PPC64_ADDR16_LO:
5329         case R_PPC64_ADDR16_LO_DS:
5330         case R_PPC64_ADDR24:
5331         case R_PPC64_ADDR32:
5332         case R_PPC64_UADDR16:
5333         case R_PPC64_UADDR32:
5334         case R_PPC64_UADDR64:
5335         case R_PPC64_TOC:
5336           if (h != NULL && !info->shared)
5337             /* We may need a copy reloc.  */
5338             h->non_got_ref = 1;
5339
5340           /* Don't propagate .opd relocs.  */
5341           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5342             break;
5343
5344           /* If we are creating a shared library, and this is a reloc
5345              against a global symbol, or a non PC relative reloc
5346              against a local symbol, then we need to copy the reloc
5347              into the shared library.  However, if we are linking with
5348              -Bsymbolic, we do not need to copy a reloc against a
5349              global symbol which is defined in an object we are
5350              including in the link (i.e., DEF_REGULAR is set).  At
5351              this point we have not seen all the input files, so it is
5352              possible that DEF_REGULAR is not set now but will be set
5353              later (it is never cleared).  In case of a weak definition,
5354              DEF_REGULAR may be cleared later by a strong definition in
5355              a shared library.  We account for that possibility below by
5356              storing information in the dyn_relocs field of the hash
5357              table entry.  A similar situation occurs when creating
5358              shared libraries and symbol visibility changes render the
5359              symbol local.
5360
5361              If on the other hand, we are creating an executable, we
5362              may need to keep relocations for symbols satisfied by a
5363              dynamic library if we manage to avoid copy relocs for the
5364              symbol.  */
5365         dodyn:
5366           if ((info->shared
5367                && (must_be_dyn_reloc (info, r_type)
5368                    || (h != NULL
5369                        && (! info->symbolic
5370                            || h->root.type == bfd_link_hash_defweak
5371                            || !h->def_regular))))
5372               || (ELIMINATE_COPY_RELOCS
5373                   && !info->shared
5374                   && h != NULL
5375                   && (h->root.type == bfd_link_hash_defweak
5376                       || !h->def_regular))
5377               || (!info->shared
5378                   && ifunc != NULL))
5379             {
5380               struct ppc_dyn_relocs *p;
5381               struct ppc_dyn_relocs **head;
5382
5383               /* We must copy these reloc types into the output file.
5384                  Create a reloc section in dynobj and make room for
5385                  this reloc.  */
5386               if (sreloc == NULL)
5387                 {
5388                   sreloc = _bfd_elf_make_dynamic_reloc_section
5389                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5390
5391                   if (sreloc == NULL)
5392                     return FALSE;
5393                 }
5394
5395               /* If this is a global symbol, we count the number of
5396                  relocations we need for this symbol.  */
5397               if (h != NULL)
5398                 {
5399                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5400                 }
5401               else
5402                 {
5403                   /* Track dynamic relocs needed for local syms too.
5404                      We really need local syms available to do this
5405                      easily.  Oh well.  */
5406                   asection *s;
5407                   void *vpp;
5408                   Elf_Internal_Sym *isym;
5409
5410                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5411                                                 abfd, r_symndx);
5412                   if (isym == NULL)
5413                     return FALSE;
5414
5415                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5416                   if (s == NULL)
5417                     s = sec;
5418
5419                   vpp = &elf_section_data (s)->local_dynrel;
5420                   head = (struct ppc_dyn_relocs **) vpp;
5421                 }
5422
5423               p = *head;
5424               if (p == NULL || p->sec != sec)
5425                 {
5426                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5427                   if (p == NULL)
5428                     return FALSE;
5429                   p->next = *head;
5430                   *head = p;
5431                   p->sec = sec;
5432                   p->count = 0;
5433                   p->pc_count = 0;
5434                 }
5435
5436               p->count += 1;
5437               if (!must_be_dyn_reloc (info, r_type))
5438                 p->pc_count += 1;
5439             }
5440           break;
5441
5442         default:
5443           break;
5444         }
5445     }
5446
5447   return TRUE;
5448 }
5449
5450 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5451    of the code entry point, and its section.  */
5452
5453 static bfd_vma
5454 opd_entry_value (asection *opd_sec,
5455                  bfd_vma offset,
5456                  asection **code_sec,
5457                  bfd_vma *code_off)
5458 {
5459   bfd *opd_bfd = opd_sec->owner;
5460   Elf_Internal_Rela *relocs;
5461   Elf_Internal_Rela *lo, *hi, *look;
5462   bfd_vma val;
5463
5464   /* No relocs implies we are linking a --just-symbols object.  */
5465   if (opd_sec->reloc_count == 0)
5466     {
5467       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5468         return (bfd_vma) -1;
5469
5470       if (code_sec != NULL)
5471         {
5472           asection *sec, *likely = NULL;
5473           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5474             if (sec->vma <= val
5475                 && (sec->flags & SEC_LOAD) != 0
5476                 && (sec->flags & SEC_ALLOC) != 0)
5477               likely = sec;
5478           if (likely != NULL)
5479             {
5480               *code_sec = likely;
5481               if (code_off != NULL)
5482                 *code_off = val - likely->vma;
5483             }
5484         }
5485       return val;
5486     }
5487
5488   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5489
5490   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5491   if (relocs == NULL)
5492     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5493
5494   /* Go find the opd reloc at the sym address.  */
5495   lo = relocs;
5496   BFD_ASSERT (lo != NULL);
5497   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5498   val = (bfd_vma) -1;
5499   while (lo < hi)
5500     {
5501       look = lo + (hi - lo) / 2;
5502       if (look->r_offset < offset)
5503         lo = look + 1;
5504       else if (look->r_offset > offset)
5505         hi = look;
5506       else
5507         {
5508           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5509
5510           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5511               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5512             {
5513               unsigned long symndx = ELF64_R_SYM (look->r_info);
5514               asection *sec;
5515
5516               if (symndx < symtab_hdr->sh_info)
5517                 {
5518                   Elf_Internal_Sym *sym;
5519
5520                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5521                   if (sym == NULL)
5522                     {
5523                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5524                                                   symtab_hdr->sh_info,
5525                                                   0, NULL, NULL, NULL);
5526                       if (sym == NULL)
5527                         break;
5528                       symtab_hdr->contents = (bfd_byte *) sym;
5529                     }
5530
5531                   sym += symndx;
5532                   val = sym->st_value;
5533                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5534                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5535                 }
5536               else
5537                 {
5538                   struct elf_link_hash_entry **sym_hashes;
5539                   struct elf_link_hash_entry *rh;
5540
5541                   sym_hashes = elf_sym_hashes (opd_bfd);
5542                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5543                   rh = elf_follow_link (rh);
5544                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5545                               || rh->root.type == bfd_link_hash_defweak);
5546                   val = rh->root.u.def.value;
5547                   sec = rh->root.u.def.section;
5548                 }
5549               val += look->r_addend;
5550               if (code_off != NULL)
5551                 *code_off = val;
5552               if (code_sec != NULL)
5553                 *code_sec = sec;
5554               if (sec != NULL && sec->output_section != NULL)
5555                 val += sec->output_section->vma + sec->output_offset;
5556             }
5557           break;
5558         }
5559     }
5560
5561   return val;
5562 }
5563
5564 /* Return true if symbol is defined in a regular object file.  */
5565
5566 static bfd_boolean
5567 is_static_defined (struct elf_link_hash_entry *h)
5568 {
5569   return ((h->root.type == bfd_link_hash_defined
5570            || h->root.type == bfd_link_hash_defweak)
5571           && h->root.u.def.section != NULL
5572           && h->root.u.def.section->output_section != NULL);
5573 }
5574
5575 /* If FDH is a function descriptor symbol, return the associated code
5576    entry symbol if it is defined.  Return NULL otherwise.  */
5577
5578 static struct ppc_link_hash_entry *
5579 defined_code_entry (struct ppc_link_hash_entry *fdh)
5580 {
5581   if (fdh->is_func_descriptor)
5582     {
5583       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5584       if (fh->elf.root.type == bfd_link_hash_defined
5585           || fh->elf.root.type == bfd_link_hash_defweak)
5586         return fh;
5587     }
5588   return NULL;
5589 }
5590
5591 /* If FH is a function code entry symbol, return the associated
5592    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5593
5594 static struct ppc_link_hash_entry *
5595 defined_func_desc (struct ppc_link_hash_entry *fh)
5596 {
5597   if (fh->oh != NULL
5598       && fh->oh->is_func_descriptor)
5599     {
5600       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5601       if (fdh->elf.root.type == bfd_link_hash_defined
5602           || fdh->elf.root.type == bfd_link_hash_defweak)
5603         return fdh;
5604     }
5605   return NULL;
5606 }
5607
5608 /* Mark all our entry sym sections, both opd and code section.  */
5609
5610 static void
5611 ppc64_elf_gc_keep (struct bfd_link_info *info)
5612 {
5613   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5614   struct bfd_sym_chain *sym;
5615
5616   if (htab == NULL)
5617     return;
5618
5619   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5620     {
5621       struct ppc_link_hash_entry *eh, *fh;
5622       asection *sec;
5623
5624       eh = (struct ppc_link_hash_entry *)
5625         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5626       if (eh == NULL)
5627         continue;
5628       if (eh->elf.root.type != bfd_link_hash_defined
5629           && eh->elf.root.type != bfd_link_hash_defweak)
5630         continue;
5631
5632       fh = defined_code_entry (eh);
5633       if (fh != NULL)
5634         {
5635           sec = fh->elf.root.u.def.section;
5636           sec->flags |= SEC_KEEP;
5637         }
5638       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5639                && opd_entry_value (eh->elf.root.u.def.section,
5640                                    eh->elf.root.u.def.value,
5641                                    &sec, NULL) != (bfd_vma) -1)
5642         sec->flags |= SEC_KEEP;
5643
5644       sec = eh->elf.root.u.def.section;
5645       sec->flags |= SEC_KEEP;
5646     }
5647 }
5648
5649 /* Mark sections containing dynamically referenced symbols.  When
5650    building shared libraries, we must assume that any visible symbol is
5651    referenced.  */
5652
5653 static bfd_boolean
5654 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5655 {
5656   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5657   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5658   struct ppc_link_hash_entry *fdh;
5659
5660   if (eh->elf.root.type == bfd_link_hash_warning)
5661     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5662
5663   /* Dynamic linking info is on the func descriptor sym.  */
5664   fdh = defined_func_desc (eh);
5665   if (fdh != NULL)
5666     eh = fdh;
5667
5668   if ((eh->elf.root.type == bfd_link_hash_defined
5669        || eh->elf.root.type == bfd_link_hash_defweak)
5670       && (eh->elf.ref_dynamic
5671           || (!info->executable
5672               && eh->elf.def_regular
5673               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5674               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5675     {
5676       asection *code_sec;
5677       struct ppc_link_hash_entry *fh;
5678
5679       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5680
5681       /* Function descriptor syms cause the associated
5682          function code sym section to be marked.  */
5683       fh = defined_code_entry (eh);
5684       if (fh != NULL)
5685         {
5686           code_sec = fh->elf.root.u.def.section;
5687           code_sec->flags |= SEC_KEEP;
5688         }
5689       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5690                && opd_entry_value (eh->elf.root.u.def.section,
5691                                    eh->elf.root.u.def.value,
5692                                    &code_sec, NULL) != (bfd_vma) -1)
5693         code_sec->flags |= SEC_KEEP;
5694     }
5695
5696   return TRUE;
5697 }
5698
5699 /* Return the section that should be marked against GC for a given
5700    relocation.  */
5701
5702 static asection *
5703 ppc64_elf_gc_mark_hook (asection *sec,
5704                         struct bfd_link_info *info,
5705                         Elf_Internal_Rela *rel,
5706                         struct elf_link_hash_entry *h,
5707                         Elf_Internal_Sym *sym)
5708 {
5709   asection *rsec;
5710
5711   /* Syms return NULL if we're marking .opd, so we avoid marking all
5712      function sections, as all functions are referenced in .opd.  */
5713   rsec = NULL;
5714   if (get_opd_info (sec) != NULL)
5715     return rsec;
5716
5717   if (h != NULL)
5718     {
5719       enum elf_ppc64_reloc_type r_type;
5720       struct ppc_link_hash_entry *eh, *fh, *fdh;
5721
5722       r_type = ELF64_R_TYPE (rel->r_info);
5723       switch (r_type)
5724         {
5725         case R_PPC64_GNU_VTINHERIT:
5726         case R_PPC64_GNU_VTENTRY:
5727           break;
5728
5729         default:
5730           switch (h->root.type)
5731             {
5732             case bfd_link_hash_defined:
5733             case bfd_link_hash_defweak:
5734               eh = (struct ppc_link_hash_entry *) h;
5735               fdh = defined_func_desc (eh);
5736               if (fdh != NULL)
5737                 eh = fdh;
5738
5739               /* Function descriptor syms cause the associated
5740                  function code sym section to be marked.  */
5741               fh = defined_code_entry (eh);
5742               if (fh != NULL)
5743                 {
5744                   /* They also mark their opd section.  */
5745                   eh->elf.root.u.def.section->gc_mark = 1;
5746
5747                   rsec = fh->elf.root.u.def.section;
5748                 }
5749               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5750                        && opd_entry_value (eh->elf.root.u.def.section,
5751                                            eh->elf.root.u.def.value,
5752                                            &rsec, NULL) != (bfd_vma) -1)
5753                 eh->elf.root.u.def.section->gc_mark = 1;
5754               else
5755                 rsec = h->root.u.def.section;
5756               break;
5757
5758             case bfd_link_hash_common:
5759               rsec = h->root.u.c.p->section;
5760               break;
5761
5762             default:
5763               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5764             }
5765         }
5766     }
5767   else
5768     {
5769       struct _opd_sec_data *opd;
5770
5771       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5772       opd = get_opd_info (rsec);
5773       if (opd != NULL && opd->func_sec != NULL)
5774         {
5775           rsec->gc_mark = 1;
5776
5777           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5778         }
5779     }
5780
5781   return rsec;
5782 }
5783
5784 /* Update the .got, .plt. and dynamic reloc reference counts for the
5785    section being removed.  */
5786
5787 static bfd_boolean
5788 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5789                          asection *sec, const Elf_Internal_Rela *relocs)
5790 {
5791   struct ppc_link_hash_table *htab;
5792   Elf_Internal_Shdr *symtab_hdr;
5793   struct elf_link_hash_entry **sym_hashes;
5794   struct got_entry **local_got_ents;
5795   const Elf_Internal_Rela *rel, *relend;
5796
5797   if (info->relocatable)
5798     return TRUE;
5799
5800   if ((sec->flags & SEC_ALLOC) == 0)
5801     return TRUE;
5802
5803   elf_section_data (sec)->local_dynrel = NULL;
5804
5805   htab = ppc_hash_table (info);
5806   if (htab == NULL)
5807     return FALSE;
5808
5809   symtab_hdr = &elf_symtab_hdr (abfd);
5810   sym_hashes = elf_sym_hashes (abfd);
5811   local_got_ents = elf_local_got_ents (abfd);
5812
5813   relend = relocs + sec->reloc_count;
5814   for (rel = relocs; rel < relend; rel++)
5815     {
5816       unsigned long r_symndx;
5817       enum elf_ppc64_reloc_type r_type;
5818       struct elf_link_hash_entry *h = NULL;
5819       unsigned char tls_type = 0;
5820
5821       r_symndx = ELF64_R_SYM (rel->r_info);
5822       r_type = ELF64_R_TYPE (rel->r_info);
5823       if (r_symndx >= symtab_hdr->sh_info)
5824         {
5825           struct ppc_link_hash_entry *eh;
5826           struct ppc_dyn_relocs **pp;
5827           struct ppc_dyn_relocs *p;
5828
5829           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5830           h = elf_follow_link (h);
5831           eh = (struct ppc_link_hash_entry *) h;
5832
5833           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5834             if (p->sec == sec)
5835               {
5836                 /* Everything must go for SEC.  */
5837                 *pp = p->next;
5838                 break;
5839               }
5840         }
5841
5842       if (is_branch_reloc (r_type))
5843         {
5844           struct plt_entry **ifunc = NULL;
5845           if (h != NULL)
5846             {
5847               if (h->type == STT_GNU_IFUNC)
5848                 ifunc = &h->plt.plist;
5849             }
5850           else if (local_got_ents != NULL)
5851             {
5852               struct plt_entry **local_plt = (struct plt_entry **)
5853                 (local_got_ents + symtab_hdr->sh_info);
5854               unsigned char *local_got_tls_masks = (unsigned char *)
5855                 (local_plt + symtab_hdr->sh_info);
5856               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5857                 ifunc = local_plt + r_symndx;
5858             }
5859           if (ifunc != NULL)
5860             {
5861               struct plt_entry *ent;
5862
5863               for (ent = *ifunc; ent != NULL; ent = ent->next)
5864                 if (ent->addend == rel->r_addend)
5865                   break;
5866               if (ent == NULL)
5867                 abort ();
5868               if (ent->plt.refcount > 0)
5869                 ent->plt.refcount -= 1;
5870               continue;
5871             }
5872         }
5873
5874       switch (r_type)
5875         {
5876         case R_PPC64_GOT_TLSLD16:
5877         case R_PPC64_GOT_TLSLD16_LO:
5878         case R_PPC64_GOT_TLSLD16_HI:
5879         case R_PPC64_GOT_TLSLD16_HA:
5880           tls_type = TLS_TLS | TLS_LD;
5881           goto dogot;
5882
5883         case R_PPC64_GOT_TLSGD16:
5884         case R_PPC64_GOT_TLSGD16_LO:
5885         case R_PPC64_GOT_TLSGD16_HI:
5886         case R_PPC64_GOT_TLSGD16_HA:
5887           tls_type = TLS_TLS | TLS_GD;
5888           goto dogot;
5889
5890         case R_PPC64_GOT_TPREL16_DS:
5891         case R_PPC64_GOT_TPREL16_LO_DS:
5892         case R_PPC64_GOT_TPREL16_HI:
5893         case R_PPC64_GOT_TPREL16_HA:
5894           tls_type = TLS_TLS | TLS_TPREL;
5895           goto dogot;
5896
5897         case R_PPC64_GOT_DTPREL16_DS:
5898         case R_PPC64_GOT_DTPREL16_LO_DS:
5899         case R_PPC64_GOT_DTPREL16_HI:
5900         case R_PPC64_GOT_DTPREL16_HA:
5901           tls_type = TLS_TLS | TLS_DTPREL;
5902           goto dogot;
5903
5904         case R_PPC64_GOT16:
5905         case R_PPC64_GOT16_DS:
5906         case R_PPC64_GOT16_HA:
5907         case R_PPC64_GOT16_HI:
5908         case R_PPC64_GOT16_LO:
5909         case R_PPC64_GOT16_LO_DS:
5910         dogot:
5911           {
5912             struct got_entry *ent;
5913
5914             if (h != NULL)
5915               ent = h->got.glist;
5916             else
5917               ent = local_got_ents[r_symndx];
5918
5919             for (; ent != NULL; ent = ent->next)
5920               if (ent->addend == rel->r_addend
5921                   && ent->owner == abfd
5922                   && ent->tls_type == tls_type)
5923                 break;
5924             if (ent == NULL)
5925               abort ();
5926             if (ent->got.refcount > 0)
5927               ent->got.refcount -= 1;
5928           }
5929           break;
5930
5931         case R_PPC64_PLT16_HA:
5932         case R_PPC64_PLT16_HI:
5933         case R_PPC64_PLT16_LO:
5934         case R_PPC64_PLT32:
5935         case R_PPC64_PLT64:
5936         case R_PPC64_REL14:
5937         case R_PPC64_REL14_BRNTAKEN:
5938         case R_PPC64_REL14_BRTAKEN:
5939         case R_PPC64_REL24:
5940           if (h != NULL)
5941             {
5942               struct plt_entry *ent;
5943
5944               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5945                 if (ent->addend == rel->r_addend)
5946                   break;
5947               if (ent != NULL && ent->plt.refcount > 0)
5948                 ent->plt.refcount -= 1;
5949             }
5950           break;
5951
5952         default:
5953           break;
5954         }
5955     }
5956   return TRUE;
5957 }
5958
5959 /* The maximum size of .sfpr.  */
5960 #define SFPR_MAX (218*4)
5961
5962 struct sfpr_def_parms
5963 {
5964   const char name[12];
5965   unsigned char lo, hi;
5966   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5967   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5968 };
5969
5970 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5971
5972 static bfd_boolean
5973 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5974 {
5975   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5976   unsigned int i;
5977   size_t len = strlen (parm->name);
5978   bfd_boolean writing = FALSE;
5979   char sym[16];
5980
5981   if (htab == NULL)
5982     return FALSE;
5983
5984   memcpy (sym, parm->name, len);
5985   sym[len + 2] = 0;
5986
5987   for (i = parm->lo; i <= parm->hi; i++)
5988     {
5989       struct elf_link_hash_entry *h;
5990
5991       sym[len + 0] = i / 10 + '0';
5992       sym[len + 1] = i % 10 + '0';
5993       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5994       if (h != NULL
5995           && !h->def_regular)
5996         {
5997           h->root.type = bfd_link_hash_defined;
5998           h->root.u.def.section = htab->sfpr;
5999           h->root.u.def.value = htab->sfpr->size;
6000           h->type = STT_FUNC;
6001           h->def_regular = 1;
6002           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6003           writing = TRUE;
6004           if (htab->sfpr->contents == NULL)
6005             {
6006               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6007               if (htab->sfpr->contents == NULL)
6008                 return FALSE;
6009             }
6010         }
6011       if (writing)
6012         {
6013           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6014           if (i != parm->hi)
6015             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6016           else
6017             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6018           htab->sfpr->size = p - htab->sfpr->contents;
6019         }
6020     }
6021
6022   return TRUE;
6023 }
6024
6025 static bfd_byte *
6026 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6027 {
6028   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6029   return p + 4;
6030 }
6031
6032 static bfd_byte *
6033 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6034 {
6035   p = savegpr0 (abfd, p, r);
6036   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6037   p = p + 4;
6038   bfd_put_32 (abfd, BLR, p);
6039   return p + 4;
6040 }
6041
6042 static bfd_byte *
6043 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6044 {
6045   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6046   return p + 4;
6047 }
6048
6049 static bfd_byte *
6050 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6051 {
6052   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6053   p = p + 4;
6054   p = restgpr0 (abfd, p, r);
6055   bfd_put_32 (abfd, MTLR_R0, p);
6056   p = p + 4;
6057   if (r == 29)
6058     {
6059       p = restgpr0 (abfd, p, 30);
6060       p = restgpr0 (abfd, p, 31);
6061     }
6062   bfd_put_32 (abfd, BLR, p);
6063   return p + 4;
6064 }
6065
6066 static bfd_byte *
6067 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6068 {
6069   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6070   return p + 4;
6071 }
6072
6073 static bfd_byte *
6074 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6075 {
6076   p = savegpr1 (abfd, p, r);
6077   bfd_put_32 (abfd, BLR, p);
6078   return p + 4;
6079 }
6080
6081 static bfd_byte *
6082 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6083 {
6084   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6085   return p + 4;
6086 }
6087
6088 static bfd_byte *
6089 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6090 {
6091   p = restgpr1 (abfd, p, r);
6092   bfd_put_32 (abfd, BLR, p);
6093   return p + 4;
6094 }
6095
6096 static bfd_byte *
6097 savefpr (bfd *abfd, bfd_byte *p, int r)
6098 {
6099   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6100   return p + 4;
6101 }
6102
6103 static bfd_byte *
6104 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6105 {
6106   p = savefpr (abfd, p, r);
6107   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6108   p = p + 4;
6109   bfd_put_32 (abfd, BLR, p);
6110   return p + 4;
6111 }
6112
6113 static bfd_byte *
6114 restfpr (bfd *abfd, bfd_byte *p, int r)
6115 {
6116   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6117   return p + 4;
6118 }
6119
6120 static bfd_byte *
6121 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6122 {
6123   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6124   p = p + 4;
6125   p = restfpr (abfd, p, r);
6126   bfd_put_32 (abfd, MTLR_R0, p);
6127   p = p + 4;
6128   if (r == 29)
6129     {
6130       p = restfpr (abfd, p, 30);
6131       p = restfpr (abfd, p, 31);
6132     }
6133   bfd_put_32 (abfd, BLR, p);
6134   return p + 4;
6135 }
6136
6137 static bfd_byte *
6138 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6139 {
6140   p = savefpr (abfd, p, r);
6141   bfd_put_32 (abfd, BLR, p);
6142   return p + 4;
6143 }
6144
6145 static bfd_byte *
6146 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6147 {
6148   p = restfpr (abfd, p, r);
6149   bfd_put_32 (abfd, BLR, p);
6150   return p + 4;
6151 }
6152
6153 static bfd_byte *
6154 savevr (bfd *abfd, bfd_byte *p, int r)
6155 {
6156   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6157   p = p + 4;
6158   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6159   return p + 4;
6160 }
6161
6162 static bfd_byte *
6163 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6164 {
6165   p = savevr (abfd, p, r);
6166   bfd_put_32 (abfd, BLR, p);
6167   return p + 4;
6168 }
6169
6170 static bfd_byte *
6171 restvr (bfd *abfd, bfd_byte *p, int r)
6172 {
6173   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6174   p = p + 4;
6175   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6176   return p + 4;
6177 }
6178
6179 static bfd_byte *
6180 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6181 {
6182   p = restvr (abfd, p, r);
6183   bfd_put_32 (abfd, BLR, p);
6184   return p + 4;
6185 }
6186
6187 /* Called via elf_link_hash_traverse to transfer dynamic linking
6188    information on function code symbol entries to their corresponding
6189    function descriptor symbol entries.  */
6190
6191 static bfd_boolean
6192 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6193 {
6194   struct bfd_link_info *info;
6195   struct ppc_link_hash_table *htab;
6196   struct plt_entry *ent;
6197   struct ppc_link_hash_entry *fh;
6198   struct ppc_link_hash_entry *fdh;
6199   bfd_boolean force_local;
6200
6201   fh = (struct ppc_link_hash_entry *) h;
6202   if (fh->elf.root.type == bfd_link_hash_indirect)
6203     return TRUE;
6204
6205   if (fh->elf.root.type == bfd_link_hash_warning)
6206     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6207
6208   info = inf;
6209   htab = ppc_hash_table (info);
6210   if (htab == NULL)
6211     return FALSE;
6212
6213   /* Resolve undefined references to dot-symbols as the value
6214      in the function descriptor, if we have one in a regular object.
6215      This is to satisfy cases like ".quad .foo".  Calls to functions
6216      in dynamic objects are handled elsewhere.  */
6217   if (fh->elf.root.type == bfd_link_hash_undefweak
6218       && fh->was_undefined
6219       && (fdh = defined_func_desc (fh)) != NULL
6220       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6221       && opd_entry_value (fdh->elf.root.u.def.section,
6222                           fdh->elf.root.u.def.value,
6223                           &fh->elf.root.u.def.section,
6224                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6225     {
6226       fh->elf.root.type = fdh->elf.root.type;
6227       fh->elf.forced_local = 1;
6228       fh->elf.def_regular = fdh->elf.def_regular;
6229       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6230     }
6231
6232   /* If this is a function code symbol, transfer dynamic linking
6233      information to the function descriptor symbol.  */
6234   if (!fh->is_func)
6235     return TRUE;
6236
6237   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6238     if (ent->plt.refcount > 0)
6239       break;
6240   if (ent == NULL
6241       || fh->elf.root.root.string[0] != '.'
6242       || fh->elf.root.root.string[1] == '\0')
6243     return TRUE;
6244
6245   /* Find the corresponding function descriptor symbol.  Create it
6246      as undefined if necessary.  */
6247
6248   fdh = lookup_fdh (fh, htab);
6249   if (fdh == NULL
6250       && !info->executable
6251       && (fh->elf.root.type == bfd_link_hash_undefined
6252           || fh->elf.root.type == bfd_link_hash_undefweak))
6253     {
6254       fdh = make_fdh (info, fh);
6255       if (fdh == NULL)
6256         return FALSE;
6257     }
6258
6259   /* Fake function descriptors are made undefweak.  If the function
6260      code symbol is strong undefined, make the fake sym the same.
6261      If the function code symbol is defined, then force the fake
6262      descriptor local;  We can't support overriding of symbols in a
6263      shared library on a fake descriptor.  */
6264
6265   if (fdh != NULL
6266       && fdh->fake
6267       && fdh->elf.root.type == bfd_link_hash_undefweak)
6268     {
6269       if (fh->elf.root.type == bfd_link_hash_undefined)
6270         {
6271           fdh->elf.root.type = bfd_link_hash_undefined;
6272           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6273         }
6274       else if (fh->elf.root.type == bfd_link_hash_defined
6275                || fh->elf.root.type == bfd_link_hash_defweak)
6276         {
6277           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6278         }
6279     }
6280
6281   if (fdh != NULL
6282       && !fdh->elf.forced_local
6283       && (!info->executable
6284           || fdh->elf.def_dynamic
6285           || fdh->elf.ref_dynamic
6286           || (fdh->elf.root.type == bfd_link_hash_undefweak
6287               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6288     {
6289       if (fdh->elf.dynindx == -1)
6290         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6291           return FALSE;
6292       fdh->elf.ref_regular |= fh->elf.ref_regular;
6293       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6294       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6295       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6296       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6297         {
6298           move_plt_plist (fh, fdh);
6299           fdh->elf.needs_plt = 1;
6300         }
6301       fdh->is_func_descriptor = 1;
6302       fdh->oh = fh;
6303       fh->oh = fdh;
6304     }
6305
6306   /* Now that the info is on the function descriptor, clear the
6307      function code sym info.  Any function code syms for which we
6308      don't have a definition in a regular file, we force local.
6309      This prevents a shared library from exporting syms that have
6310      been imported from another library.  Function code syms that
6311      are really in the library we must leave global to prevent the
6312      linker dragging in a definition from a static library.  */
6313   force_local = (!fh->elf.def_regular
6314                  || fdh == NULL
6315                  || !fdh->elf.def_regular
6316                  || fdh->elf.forced_local);
6317   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6318
6319   return TRUE;
6320 }
6321
6322 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6323    this hook to a) provide some gcc support functions, and b) transfer
6324    dynamic linking information gathered so far on function code symbol
6325    entries, to their corresponding function descriptor symbol entries.  */
6326
6327 static bfd_boolean
6328 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6329                             struct bfd_link_info *info)
6330 {
6331   struct ppc_link_hash_table *htab;
6332   unsigned int i;
6333   const struct sfpr_def_parms funcs[] =
6334     {
6335       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6336       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6337       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6338       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6339       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6340       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6341       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6342       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6343       { "._savef", 14, 31, savefpr, savefpr1_tail },
6344       { "._restf", 14, 31, restfpr, restfpr1_tail },
6345       { "_savevr_", 20, 31, savevr, savevr_tail },
6346       { "_restvr_", 20, 31, restvr, restvr_tail }
6347     };
6348
6349   htab = ppc_hash_table (info);
6350   if (htab == NULL)
6351     return FALSE;
6352
6353   if (htab->sfpr == NULL)
6354     /* We don't have any relocs.  */
6355     return TRUE;
6356
6357   /* Provide any missing _save* and _rest* functions.  */
6358   htab->sfpr->size = 0;
6359   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6360     if (!sfpr_define (info, &funcs[i]))
6361       return FALSE;
6362
6363   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6364
6365   if (htab->sfpr->size == 0)
6366     htab->sfpr->flags |= SEC_EXCLUDE;
6367
6368   return TRUE;
6369 }
6370
6371 /* Adjust a symbol defined by a dynamic object and referenced by a
6372    regular object.  The current definition is in some section of the
6373    dynamic object, but we're not including those sections.  We have to
6374    change the definition to something the rest of the link can
6375    understand.  */
6376
6377 static bfd_boolean
6378 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6379                                  struct elf_link_hash_entry *h)
6380 {
6381   struct ppc_link_hash_table *htab;
6382   asection *s;
6383
6384   htab = ppc_hash_table (info);
6385   if (htab == NULL)
6386     return FALSE;
6387
6388   /* Deal with function syms.  */
6389   if (h->type == STT_FUNC
6390       || h->type == STT_GNU_IFUNC
6391       || h->needs_plt)
6392     {
6393       /* Clear procedure linkage table information for any symbol that
6394          won't need a .plt entry.  */
6395       struct plt_entry *ent;
6396       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6397         if (ent->plt.refcount > 0)
6398           break;
6399       if (ent == NULL
6400           || (h->type != STT_GNU_IFUNC
6401               && (SYMBOL_CALLS_LOCAL (info, h)
6402                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6403                       && h->root.type == bfd_link_hash_undefweak))))
6404         {
6405           h->plt.plist = NULL;
6406           h->needs_plt = 0;
6407         }
6408     }
6409   else
6410     h->plt.plist = NULL;
6411
6412   /* If this is a weak symbol, and there is a real definition, the
6413      processor independent code will have arranged for us to see the
6414      real definition first, and we can just use the same value.  */
6415   if (h->u.weakdef != NULL)
6416     {
6417       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6418                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6419       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6420       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6421       if (ELIMINATE_COPY_RELOCS)
6422         h->non_got_ref = h->u.weakdef->non_got_ref;
6423       return TRUE;
6424     }
6425
6426   /* If we are creating a shared library, we must presume that the
6427      only references to the symbol are via the global offset table.
6428      For such cases we need not do anything here; the relocations will
6429      be handled correctly by relocate_section.  */
6430   if (info->shared)
6431     return TRUE;
6432
6433   /* If there are no references to this symbol that do not use the
6434      GOT, we don't need to generate a copy reloc.  */
6435   if (!h->non_got_ref)
6436     return TRUE;
6437
6438   /* Don't generate a copy reloc for symbols defined in the executable.  */
6439   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6440     return TRUE;
6441
6442   if (ELIMINATE_COPY_RELOCS)
6443     {
6444       struct ppc_link_hash_entry * eh;
6445       struct ppc_dyn_relocs *p;
6446
6447       eh = (struct ppc_link_hash_entry *) h;
6448       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6449         {
6450           s = p->sec->output_section;
6451           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6452             break;
6453         }
6454
6455       /* If we didn't find any dynamic relocs in read-only sections, then
6456          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6457       if (p == NULL)
6458         {
6459           h->non_got_ref = 0;
6460           return TRUE;
6461         }
6462     }
6463
6464   if (h->plt.plist != NULL)
6465     {
6466       /* We should never get here, but unfortunately there are versions
6467          of gcc out there that improperly (for this ABI) put initialized
6468          function pointers, vtable refs and suchlike in read-only
6469          sections.  Allow them to proceed, but warn that this might
6470          break at runtime.  */
6471       (*_bfd_error_handler)
6472         (_("copy reloc against `%s' requires lazy plt linking; "
6473            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6474          h->root.root.string);
6475     }
6476
6477   /* This is a reference to a symbol defined by a dynamic object which
6478      is not a function.  */
6479
6480   if (h->size == 0)
6481     {
6482       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6483                              h->root.root.string);
6484       return TRUE;
6485     }
6486
6487   /* We must allocate the symbol in our .dynbss section, which will
6488      become part of the .bss section of the executable.  There will be
6489      an entry for this symbol in the .dynsym section.  The dynamic
6490      object will contain position independent code, so all references
6491      from the dynamic object to this symbol will go through the global
6492      offset table.  The dynamic linker will use the .dynsym entry to
6493      determine the address it must put in the global offset table, so
6494      both the dynamic object and the regular object will refer to the
6495      same memory location for the variable.  */
6496
6497   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6498      to copy the initial value out of the dynamic object and into the
6499      runtime process image.  We need to remember the offset into the
6500      .rela.bss section we are going to use.  */
6501   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6502     {
6503       htab->relbss->size += sizeof (Elf64_External_Rela);
6504       h->needs_copy = 1;
6505     }
6506
6507   s = htab->dynbss;
6508
6509   return _bfd_elf_adjust_dynamic_copy (h, s);
6510 }
6511
6512 /* If given a function descriptor symbol, hide both the function code
6513    sym and the descriptor.  */
6514 static void
6515 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6516                        struct elf_link_hash_entry *h,
6517                        bfd_boolean force_local)
6518 {
6519   struct ppc_link_hash_entry *eh;
6520   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6521
6522   eh = (struct ppc_link_hash_entry *) h;
6523   if (eh->is_func_descriptor)
6524     {
6525       struct ppc_link_hash_entry *fh = eh->oh;
6526
6527       if (fh == NULL)
6528         {
6529           const char *p, *q;
6530           struct ppc_link_hash_table *htab;
6531           char save;
6532
6533           /* We aren't supposed to use alloca in BFD because on
6534              systems which do not have alloca the version in libiberty
6535              calls xmalloc, which might cause the program to crash
6536              when it runs out of memory.  This function doesn't have a
6537              return status, so there's no way to gracefully return an
6538              error.  So cheat.  We know that string[-1] can be safely
6539              accessed;  It's either a string in an ELF string table,
6540              or allocated in an objalloc structure.  */
6541
6542           p = eh->elf.root.root.string - 1;
6543           save = *p;
6544           *(char *) p = '.';
6545           htab = ppc_hash_table (info);
6546           if (htab == NULL)
6547             return;
6548
6549           fh = (struct ppc_link_hash_entry *)
6550             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6551           *(char *) p = save;
6552
6553           /* Unfortunately, if it so happens that the string we were
6554              looking for was allocated immediately before this string,
6555              then we overwrote the string terminator.  That's the only
6556              reason the lookup should fail.  */
6557           if (fh == NULL)
6558             {
6559               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6560               while (q >= eh->elf.root.root.string && *q == *p)
6561                 --q, --p;
6562               if (q < eh->elf.root.root.string && *p == '.')
6563                 fh = (struct ppc_link_hash_entry *)
6564                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6565             }
6566           if (fh != NULL)
6567             {
6568               eh->oh = fh;
6569               fh->oh = eh;
6570             }
6571         }
6572       if (fh != NULL)
6573         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6574     }
6575 }
6576
6577 static bfd_boolean
6578 get_sym_h (struct elf_link_hash_entry **hp,
6579            Elf_Internal_Sym **symp,
6580            asection **symsecp,
6581            unsigned char **tls_maskp,
6582            Elf_Internal_Sym **locsymsp,
6583            unsigned long r_symndx,
6584            bfd *ibfd)
6585 {
6586   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6587
6588   if (r_symndx >= symtab_hdr->sh_info)
6589     {
6590       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6591       struct elf_link_hash_entry *h;
6592
6593       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6594       h = elf_follow_link (h);
6595
6596       if (hp != NULL)
6597         *hp = h;
6598
6599       if (symp != NULL)
6600         *symp = NULL;
6601
6602       if (symsecp != NULL)
6603         {
6604           asection *symsec = NULL;
6605           if (h->root.type == bfd_link_hash_defined
6606               || h->root.type == bfd_link_hash_defweak)
6607             symsec = h->root.u.def.section;
6608           *symsecp = symsec;
6609         }
6610
6611       if (tls_maskp != NULL)
6612         {
6613           struct ppc_link_hash_entry *eh;
6614
6615           eh = (struct ppc_link_hash_entry *) h;
6616           *tls_maskp = &eh->tls_mask;
6617         }
6618     }
6619   else
6620     {
6621       Elf_Internal_Sym *sym;
6622       Elf_Internal_Sym *locsyms = *locsymsp;
6623
6624       if (locsyms == NULL)
6625         {
6626           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6627           if (locsyms == NULL)
6628             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6629                                             symtab_hdr->sh_info,
6630                                             0, NULL, NULL, NULL);
6631           if (locsyms == NULL)
6632             return FALSE;
6633           *locsymsp = locsyms;
6634         }
6635       sym = locsyms + r_symndx;
6636
6637       if (hp != NULL)
6638         *hp = NULL;
6639
6640       if (symp != NULL)
6641         *symp = sym;
6642
6643       if (symsecp != NULL)
6644         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6645
6646       if (tls_maskp != NULL)
6647         {
6648           struct got_entry **lgot_ents;
6649           unsigned char *tls_mask;
6650
6651           tls_mask = NULL;
6652           lgot_ents = elf_local_got_ents (ibfd);
6653           if (lgot_ents != NULL)
6654             {
6655               struct plt_entry **local_plt = (struct plt_entry **)
6656                 (lgot_ents + symtab_hdr->sh_info);
6657               unsigned char *lgot_masks = (unsigned char *)
6658                 (local_plt + symtab_hdr->sh_info);
6659               tls_mask = &lgot_masks[r_symndx];
6660             }
6661           *tls_maskp = tls_mask;
6662         }
6663     }
6664   return TRUE;
6665 }
6666
6667 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6668    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6669    type suitable for optimization, and 1 otherwise.  */
6670
6671 static int
6672 get_tls_mask (unsigned char **tls_maskp,
6673               unsigned long *toc_symndx,
6674               bfd_vma *toc_addend,
6675               Elf_Internal_Sym **locsymsp,
6676               const Elf_Internal_Rela *rel,
6677               bfd *ibfd)
6678 {
6679   unsigned long r_symndx;
6680   int next_r;
6681   struct elf_link_hash_entry *h;
6682   Elf_Internal_Sym *sym;
6683   asection *sec;
6684   bfd_vma off;
6685
6686   r_symndx = ELF64_R_SYM (rel->r_info);
6687   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6688     return 0;
6689
6690   if ((*tls_maskp != NULL && **tls_maskp != 0)
6691       || sec == NULL
6692       || ppc64_elf_section_data (sec) == NULL
6693       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6694     return 1;
6695
6696   /* Look inside a TOC section too.  */
6697   if (h != NULL)
6698     {
6699       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6700       off = h->root.u.def.value;
6701     }
6702   else
6703     off = sym->st_value;
6704   off += rel->r_addend;
6705   BFD_ASSERT (off % 8 == 0);
6706   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6707   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6708   if (toc_symndx != NULL)
6709     *toc_symndx = r_symndx;
6710   if (toc_addend != NULL)
6711     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6712   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6713     return 0;
6714   if ((h == NULL || is_static_defined (h))
6715       && (next_r == -1 || next_r == -2))
6716     return 1 - next_r;
6717   return 1;
6718 }
6719
6720 /* Adjust all global syms defined in opd sections.  In gcc generated
6721    code for the old ABI, these will already have been done.  */
6722
6723 static bfd_boolean
6724 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6725 {
6726   struct ppc_link_hash_entry *eh;
6727   asection *sym_sec;
6728   struct _opd_sec_data *opd;
6729
6730   if (h->root.type == bfd_link_hash_indirect)
6731     return TRUE;
6732
6733   if (h->root.type == bfd_link_hash_warning)
6734     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6735
6736   if (h->root.type != bfd_link_hash_defined
6737       && h->root.type != bfd_link_hash_defweak)
6738     return TRUE;
6739
6740   eh = (struct ppc_link_hash_entry *) h;
6741   if (eh->adjust_done)
6742     return TRUE;
6743
6744   sym_sec = eh->elf.root.u.def.section;
6745   opd = get_opd_info (sym_sec);
6746   if (opd != NULL && opd->adjust != NULL)
6747     {
6748       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6749       if (adjust == -1)
6750         {
6751           /* This entry has been deleted.  */
6752           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6753           if (dsec == NULL)
6754             {
6755               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6756                 if (elf_discarded_section (dsec))
6757                   {
6758                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6759                     break;
6760                   }
6761             }
6762           eh->elf.root.u.def.value = 0;
6763           eh->elf.root.u.def.section = dsec;
6764         }
6765       else
6766         eh->elf.root.u.def.value += adjust;
6767       eh->adjust_done = 1;
6768     }
6769   return TRUE;
6770 }
6771
6772 /* Handles decrementing dynamic reloc counts for the reloc specified by
6773    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6774    have already been determined.  */
6775
6776 static bfd_boolean
6777 dec_dynrel_count (bfd_vma r_info,
6778                   asection *sec,
6779                   struct bfd_link_info *info,
6780                   Elf_Internal_Sym **local_syms,
6781                   struct elf_link_hash_entry *h,
6782                   asection *sym_sec)
6783 {
6784   enum elf_ppc64_reloc_type r_type;
6785   struct ppc_dyn_relocs *p;
6786   struct ppc_dyn_relocs **pp;
6787
6788   /* Can this reloc be dynamic?  This switch, and later tests here
6789      should be kept in sync with the code in check_relocs.  */
6790   r_type = ELF64_R_TYPE (r_info);
6791   switch (r_type)
6792     {
6793     default:
6794       return TRUE;
6795
6796     case R_PPC64_TPREL16:
6797     case R_PPC64_TPREL16_LO:
6798     case R_PPC64_TPREL16_HI:
6799     case R_PPC64_TPREL16_HA:
6800     case R_PPC64_TPREL16_DS:
6801     case R_PPC64_TPREL16_LO_DS:
6802     case R_PPC64_TPREL16_HIGHER:
6803     case R_PPC64_TPREL16_HIGHERA:
6804     case R_PPC64_TPREL16_HIGHEST:
6805     case R_PPC64_TPREL16_HIGHESTA:
6806       if (!info->shared)
6807         return TRUE;
6808
6809     case R_PPC64_TPREL64:
6810     case R_PPC64_DTPMOD64:
6811     case R_PPC64_DTPREL64:
6812     case R_PPC64_ADDR64:
6813     case R_PPC64_REL30:
6814     case R_PPC64_REL32:
6815     case R_PPC64_REL64:
6816     case R_PPC64_ADDR14:
6817     case R_PPC64_ADDR14_BRNTAKEN:
6818     case R_PPC64_ADDR14_BRTAKEN:
6819     case R_PPC64_ADDR16:
6820     case R_PPC64_ADDR16_DS:
6821     case R_PPC64_ADDR16_HA:
6822     case R_PPC64_ADDR16_HI:
6823     case R_PPC64_ADDR16_HIGHER:
6824     case R_PPC64_ADDR16_HIGHERA:
6825     case R_PPC64_ADDR16_HIGHEST:
6826     case R_PPC64_ADDR16_HIGHESTA:
6827     case R_PPC64_ADDR16_LO:
6828     case R_PPC64_ADDR16_LO_DS:
6829     case R_PPC64_ADDR24:
6830     case R_PPC64_ADDR32:
6831     case R_PPC64_UADDR16:
6832     case R_PPC64_UADDR32:
6833     case R_PPC64_UADDR64:
6834     case R_PPC64_TOC:
6835       break;
6836     }
6837
6838   if (local_syms != NULL)
6839     {
6840       unsigned long r_symndx;
6841       Elf_Internal_Sym *sym;
6842       bfd *ibfd = sec->owner;
6843
6844       r_symndx = ELF64_R_SYM (r_info);
6845       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6846         return FALSE;
6847     }
6848
6849   if ((info->shared
6850        && (must_be_dyn_reloc (info, r_type)
6851            || (h != NULL
6852                && (!info->symbolic
6853                    || h->root.type == bfd_link_hash_defweak
6854                    || !h->def_regular))))
6855       || (ELIMINATE_COPY_RELOCS
6856           && !info->shared
6857           && h != NULL
6858           && (h->root.type == bfd_link_hash_defweak
6859               || !h->def_regular)))
6860     ;
6861   else
6862     return TRUE;
6863
6864   if (h != NULL)
6865     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6866   else
6867     {
6868       if (sym_sec != NULL)
6869         {
6870           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6871           pp = (struct ppc_dyn_relocs **) vpp;
6872         }
6873       else
6874         {
6875           void *vpp = &elf_section_data (sec)->local_dynrel;
6876           pp = (struct ppc_dyn_relocs **) vpp;
6877         }
6878
6879       /* elf_gc_sweep may have already removed all dyn relocs associated
6880          with local syms for a given section.  Don't report a dynreloc
6881          miscount.  */
6882       if (*pp == NULL)
6883         return TRUE;
6884     }
6885
6886   while ((p = *pp) != NULL)
6887     {
6888       if (p->sec == sec)
6889         {
6890           if (!must_be_dyn_reloc (info, r_type))
6891             p->pc_count -= 1;
6892           p->count -= 1;
6893           if (p->count == 0)
6894             *pp = p->next;
6895           return TRUE;
6896         }
6897       pp = &p->next;
6898     }
6899
6900   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6901                            sec->owner, sec);
6902   bfd_set_error (bfd_error_bad_value);
6903   return FALSE;
6904 }
6905
6906 /* Remove unused Official Procedure Descriptor entries.  Currently we
6907    only remove those associated with functions in discarded link-once
6908    sections, or weakly defined functions that have been overridden.  It
6909    would be possible to remove many more entries for statically linked
6910    applications.  */
6911
6912 bfd_boolean
6913 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
6914 {
6915   bfd *ibfd;
6916   bfd_boolean some_edited = FALSE;
6917   asection *need_pad = NULL;
6918
6919   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6920     {
6921       asection *sec;
6922       Elf_Internal_Rela *relstart, *rel, *relend;
6923       Elf_Internal_Shdr *symtab_hdr;
6924       Elf_Internal_Sym *local_syms;
6925       bfd_vma offset;
6926       struct _opd_sec_data *opd;
6927       bfd_boolean need_edit, add_aux_fields;
6928       bfd_size_type cnt_16b = 0;
6929
6930       if (!is_ppc64_elf (ibfd))
6931         continue;
6932
6933       sec = bfd_get_section_by_name (ibfd, ".opd");
6934       if (sec == NULL || sec->size == 0)
6935         continue;
6936
6937       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6938         continue;
6939
6940       if (sec->output_section == bfd_abs_section_ptr)
6941         continue;
6942
6943       /* Look through the section relocs.  */
6944       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6945         continue;
6946
6947       local_syms = NULL;
6948       symtab_hdr = &elf_symtab_hdr (ibfd);
6949
6950       /* Read the relocations.  */
6951       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6952                                             info->keep_memory);
6953       if (relstart == NULL)
6954         return FALSE;
6955
6956       /* First run through the relocs to check they are sane, and to
6957          determine whether we need to edit this opd section.  */
6958       need_edit = FALSE;
6959       need_pad = sec;
6960       offset = 0;
6961       relend = relstart + sec->reloc_count;
6962       for (rel = relstart; rel < relend; )
6963         {
6964           enum elf_ppc64_reloc_type r_type;
6965           unsigned long r_symndx;
6966           asection *sym_sec;
6967           struct elf_link_hash_entry *h;
6968           Elf_Internal_Sym *sym;
6969
6970           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6971              only interested in the reloc pointing to a function entry
6972              point.  */
6973           if (rel->r_offset != offset
6974               || rel + 1 >= relend
6975               || (rel + 1)->r_offset != offset + 8)
6976             {
6977               /* If someone messes with .opd alignment then after a
6978                  "ld -r" we might have padding in the middle of .opd.
6979                  Also, there's nothing to prevent someone putting
6980                  something silly in .opd with the assembler.  No .opd
6981                  optimization for them!  */
6982             broken_opd:
6983               (*_bfd_error_handler)
6984                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6985               need_edit = FALSE;
6986               break;
6987             }
6988
6989           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6990               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6991             {
6992               (*_bfd_error_handler)
6993                 (_("%B: unexpected reloc type %u in .opd section"),
6994                  ibfd, r_type);
6995               need_edit = FALSE;
6996               break;
6997             }
6998
6999           r_symndx = ELF64_R_SYM (rel->r_info);
7000           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7001                           r_symndx, ibfd))
7002             goto error_ret;
7003
7004           if (sym_sec == NULL || sym_sec->owner == NULL)
7005             {
7006               const char *sym_name;
7007               if (h != NULL)
7008                 sym_name = h->root.root.string;
7009               else
7010                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7011                                              sym_sec);
7012
7013               (*_bfd_error_handler)
7014                 (_("%B: undefined sym `%s' in .opd section"),
7015                  ibfd, sym_name);
7016               need_edit = FALSE;
7017               break;
7018             }
7019
7020           /* opd entries are always for functions defined in the
7021              current input bfd.  If the symbol isn't defined in the
7022              input bfd, then we won't be using the function in this
7023              bfd;  It must be defined in a linkonce section in another
7024              bfd, or is weak.  It's also possible that we are
7025              discarding the function due to a linker script /DISCARD/,
7026              which we test for via the output_section.  */
7027           if (sym_sec->owner != ibfd
7028               || sym_sec->output_section == bfd_abs_section_ptr)
7029             need_edit = TRUE;
7030
7031           rel += 2;
7032           if (rel == relend
7033               || (rel + 1 == relend && rel->r_offset == offset + 16))
7034             {
7035               if (sec->size == offset + 24)
7036                 {
7037                   need_pad = NULL;
7038                   break;
7039                 }
7040               if (rel == relend && sec->size == offset + 16)
7041                 {
7042                   cnt_16b++;
7043                   break;
7044                 }
7045               goto broken_opd;
7046             }
7047
7048           if (rel->r_offset == offset + 24)
7049             offset += 24;
7050           else if (rel->r_offset != offset + 16)
7051             goto broken_opd;
7052           else if (rel + 1 < relend
7053                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7054                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7055             {
7056               offset += 16;
7057               cnt_16b++;
7058             }
7059           else if (rel + 2 < relend
7060                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7061                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7062             {
7063               offset += 24;
7064               rel += 1;
7065             }
7066           else
7067             goto broken_opd;
7068         }
7069
7070       add_aux_fields = non_overlapping && cnt_16b > 0;
7071
7072       if (need_edit || add_aux_fields)
7073         {
7074           Elf_Internal_Rela *write_rel;
7075           bfd_byte *rptr, *wptr;
7076           bfd_byte *new_contents;
7077           bfd_boolean skip;
7078           long opd_ent_size;
7079           bfd_size_type amt;
7080
7081           new_contents = NULL;
7082           amt = sec->size * sizeof (long) / 8;
7083           opd = &ppc64_elf_section_data (sec)->u.opd;
7084           opd->adjust = bfd_zalloc (sec->owner, amt);
7085           if (opd->adjust == NULL)
7086             return FALSE;
7087           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7088
7089           /* This seems a waste of time as input .opd sections are all
7090              zeros as generated by gcc, but I suppose there's no reason
7091              this will always be so.  We might start putting something in
7092              the third word of .opd entries.  */
7093           if ((sec->flags & SEC_IN_MEMORY) == 0)
7094             {
7095               bfd_byte *loc;
7096               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7097                 {
7098                   if (loc != NULL)
7099                     free (loc);
7100                 error_ret:
7101                   if (local_syms != NULL
7102                       && symtab_hdr->contents != (unsigned char *) local_syms)
7103                     free (local_syms);
7104                   if (elf_section_data (sec)->relocs != relstart)
7105                     free (relstart);
7106                   return FALSE;
7107                 }
7108               sec->contents = loc;
7109               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7110             }
7111
7112           elf_section_data (sec)->relocs = relstart;
7113
7114           new_contents = sec->contents;
7115           if (add_aux_fields)
7116             {
7117               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7118               if (new_contents == NULL)
7119                 return FALSE;
7120               need_pad = FALSE;
7121             }
7122           wptr = new_contents;
7123           rptr = sec->contents;
7124
7125           write_rel = relstart;
7126           skip = FALSE;
7127           offset = 0;
7128           opd_ent_size = 0;
7129           for (rel = relstart; rel < relend; rel++)
7130             {
7131               unsigned long r_symndx;
7132               asection *sym_sec;
7133               struct elf_link_hash_entry *h;
7134               Elf_Internal_Sym *sym;
7135
7136               r_symndx = ELF64_R_SYM (rel->r_info);
7137               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7138                               r_symndx, ibfd))
7139                 goto error_ret;
7140
7141               if (rel->r_offset == offset)
7142                 {
7143                   struct ppc_link_hash_entry *fdh = NULL;
7144
7145                   /* See if the .opd entry is full 24 byte or
7146                      16 byte (with fd_aux entry overlapped with next
7147                      fd_func).  */
7148                   opd_ent_size = 24;
7149                   if ((rel + 2 == relend && sec->size == offset + 16)
7150                       || (rel + 3 < relend
7151                           && rel[2].r_offset == offset + 16
7152                           && rel[3].r_offset == offset + 24
7153                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7154                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7155                     opd_ent_size = 16;
7156
7157                   if (h != NULL
7158                       && h->root.root.string[0] == '.')
7159                     {
7160                       struct ppc_link_hash_table *htab;
7161
7162                       htab = ppc_hash_table (info);
7163                       if (htab != NULL)
7164                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7165                                           htab);
7166                       if (fdh != NULL
7167                           && fdh->elf.root.type != bfd_link_hash_defined
7168                           && fdh->elf.root.type != bfd_link_hash_defweak)
7169                         fdh = NULL;
7170                     }
7171
7172                   skip = (sym_sec->owner != ibfd
7173                           || sym_sec->output_section == bfd_abs_section_ptr);
7174                   if (skip)
7175                     {
7176                       if (fdh != NULL && sym_sec->owner == ibfd)
7177                         {
7178                           /* Arrange for the function descriptor sym
7179                              to be dropped.  */
7180                           fdh->elf.root.u.def.value = 0;
7181                           fdh->elf.root.u.def.section = sym_sec;
7182                         }
7183                       opd->adjust[rel->r_offset / 8] = -1;
7184                     }
7185                   else
7186                     {
7187                       /* We'll be keeping this opd entry.  */
7188
7189                       if (fdh != NULL)
7190                         {
7191                           /* Redefine the function descriptor symbol to
7192                              this location in the opd section.  It is
7193                              necessary to update the value here rather
7194                              than using an array of adjustments as we do
7195                              for local symbols, because various places
7196                              in the generic ELF code use the value
7197                              stored in u.def.value.  */
7198                           fdh->elf.root.u.def.value = wptr - new_contents;
7199                           fdh->adjust_done = 1;
7200                         }
7201
7202                       /* Local syms are a bit tricky.  We could
7203                          tweak them as they can be cached, but
7204                          we'd need to look through the local syms
7205                          for the function descriptor sym which we
7206                          don't have at the moment.  So keep an
7207                          array of adjustments.  */
7208                       opd->adjust[rel->r_offset / 8]
7209                         = (wptr - new_contents) - (rptr - sec->contents);
7210
7211                       if (wptr != rptr)
7212                         memcpy (wptr, rptr, opd_ent_size);
7213                       wptr += opd_ent_size;
7214                       if (add_aux_fields && opd_ent_size == 16)
7215                         {
7216                           memset (wptr, '\0', 8);
7217                           wptr += 8;
7218                         }
7219                     }
7220                   rptr += opd_ent_size;
7221                   offset += opd_ent_size;
7222                 }
7223
7224               if (skip)
7225                 {
7226                   if (!NO_OPD_RELOCS
7227                       && !info->relocatable
7228                       && !dec_dynrel_count (rel->r_info, sec, info,
7229                                             NULL, h, sym_sec))
7230                     goto error_ret;
7231                 }
7232               else
7233                 {
7234                   /* We need to adjust any reloc offsets to point to the
7235                      new opd entries.  While we're at it, we may as well
7236                      remove redundant relocs.  */
7237                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7238                   if (write_rel != rel)
7239                     memcpy (write_rel, rel, sizeof (*rel));
7240                   ++write_rel;
7241                 }
7242             }
7243
7244           sec->size = wptr - new_contents;
7245           sec->reloc_count = write_rel - relstart;
7246           if (add_aux_fields)
7247             {
7248               free (sec->contents);
7249               sec->contents = new_contents;
7250             }
7251
7252           /* Fudge the header size too, as this is used later in
7253              elf_bfd_final_link if we are emitting relocs.  */
7254           elf_section_data (sec)->rel_hdr.sh_size
7255             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7256           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7257           some_edited = TRUE;
7258         }
7259       else if (elf_section_data (sec)->relocs != relstart)
7260         free (relstart);
7261
7262       if (local_syms != NULL
7263           && symtab_hdr->contents != (unsigned char *) local_syms)
7264         {
7265           if (!info->keep_memory)
7266             free (local_syms);
7267           else
7268             symtab_hdr->contents = (unsigned char *) local_syms;
7269         }
7270     }
7271
7272   if (some_edited)
7273     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7274
7275   /* If we are doing a final link and the last .opd entry is just 16 byte
7276      long, add a 8 byte padding after it.  */
7277   if (need_pad != NULL && !info->relocatable)
7278     {
7279       bfd_byte *p;
7280
7281       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7282         {
7283           BFD_ASSERT (need_pad->size > 0);
7284
7285           p = bfd_malloc (need_pad->size + 8);
7286           if (p == NULL)
7287             return FALSE;
7288
7289           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7290                                           p, 0, need_pad->size))
7291             return FALSE;
7292
7293           need_pad->contents = p;
7294           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7295         }
7296       else
7297         {
7298           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7299           if (p == NULL)
7300             return FALSE;
7301
7302           need_pad->contents = p;
7303         }
7304
7305       memset (need_pad->contents + need_pad->size, 0, 8);
7306       need_pad->size += 8;
7307     }
7308
7309   return TRUE;
7310 }
7311
7312 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7313
7314 asection *
7315 ppc64_elf_tls_setup (struct bfd_link_info *info,
7316                      int no_tls_get_addr_opt,
7317                      int *no_multi_toc)
7318 {
7319   struct ppc_link_hash_table *htab;
7320
7321   htab = ppc_hash_table (info);
7322   if (htab == NULL)
7323     return NULL;
7324
7325   if (*no_multi_toc)
7326     htab->do_multi_toc = 0;
7327   else if (!htab->do_multi_toc)
7328     *no_multi_toc = 1;
7329
7330   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7331                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7332                                               FALSE, FALSE, TRUE));
7333   /* Move dynamic linking info to the function descriptor sym.  */
7334   if (htab->tls_get_addr != NULL)
7335     func_desc_adjust (&htab->tls_get_addr->elf, info);
7336   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7337                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7338                                                  FALSE, FALSE, TRUE));
7339   if (!no_tls_get_addr_opt)
7340     {
7341       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7342
7343       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7344                                   FALSE, FALSE, TRUE);
7345       if (opt != NULL)
7346         func_desc_adjust (opt, info);
7347       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7348                                      FALSE, FALSE, TRUE);
7349       if (opt_fd != NULL
7350           && (opt_fd->root.type == bfd_link_hash_defined
7351               || opt_fd->root.type == bfd_link_hash_defweak))
7352         {
7353           /* If glibc supports an optimized __tls_get_addr call stub,
7354              signalled by the presence of __tls_get_addr_opt, and we'll
7355              be calling __tls_get_addr via a plt call stub, then
7356              make __tls_get_addr point to __tls_get_addr_opt.  */
7357           tga_fd = &htab->tls_get_addr_fd->elf;
7358           if (htab->elf.dynamic_sections_created
7359               && tga_fd != NULL
7360               && (tga_fd->type == STT_FUNC
7361                   || tga_fd->needs_plt)
7362               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7363                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7364                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7365             {
7366               struct plt_entry *ent;
7367
7368               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7369                 if (ent->plt.refcount > 0)
7370                   break;
7371               if (ent != NULL)
7372                 {
7373                   tga_fd->root.type = bfd_link_hash_indirect;
7374                   tga_fd->root.u.i.link = &opt_fd->root;
7375                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7376                   if (opt_fd->dynindx != -1)
7377                     {
7378                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7379                       opt_fd->dynindx = -1;
7380                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7381                                               opt_fd->dynstr_index);
7382                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7383                         return NULL;
7384                     }
7385                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7386                   tga = &htab->tls_get_addr->elf;
7387                   if (opt != NULL && tga != NULL)
7388                     {
7389                       tga->root.type = bfd_link_hash_indirect;
7390                       tga->root.u.i.link = &opt->root;
7391                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7392                       _bfd_elf_link_hash_hide_symbol (info, opt,
7393                                                       tga->forced_local);
7394                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7395                     }
7396                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7397                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7398                   if (htab->tls_get_addr != NULL)
7399                     {
7400                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7401                       htab->tls_get_addr->is_func = 1;
7402                     }
7403                 }
7404             }
7405         }
7406       else
7407         no_tls_get_addr_opt = TRUE;
7408     }
7409   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7410   return _bfd_elf_tls_setup (info->output_bfd, info);
7411 }
7412
7413 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7414    HASH1 or HASH2.  */
7415
7416 static bfd_boolean
7417 branch_reloc_hash_match (const bfd *ibfd,
7418                          const Elf_Internal_Rela *rel,
7419                          const struct ppc_link_hash_entry *hash1,
7420                          const struct ppc_link_hash_entry *hash2)
7421 {
7422   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7423   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7424   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7425
7426   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7427     {
7428       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7429       struct elf_link_hash_entry *h;
7430
7431       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7432       h = elf_follow_link (h);
7433       if (h == &hash1->elf || h == &hash2->elf)
7434         return TRUE;
7435     }
7436   return FALSE;
7437 }
7438
7439 /* Run through all the TLS relocs looking for optimization
7440    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7441    a preliminary section layout so that we know the TLS segment
7442    offsets.  We can't optimize earlier because some optimizations need
7443    to know the tp offset, and we need to optimize before allocating
7444    dynamic relocations.  */
7445
7446 bfd_boolean
7447 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7448 {
7449   bfd *ibfd;
7450   asection *sec;
7451   struct ppc_link_hash_table *htab;
7452   int pass;
7453
7454   if (info->relocatable || !info->executable)
7455     return TRUE;
7456
7457   htab = ppc_hash_table (info);
7458   if (htab == NULL)
7459     return FALSE;
7460
7461   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7462     {
7463       Elf_Internal_Sym *locsyms = NULL;
7464       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7465       unsigned char *toc_ref = NULL;
7466
7467       /* Look at all the sections for this file.  Make two passes over
7468          the relocs.  On the first pass, mark toc entries involved
7469          with tls relocs, and check that tls relocs involved in
7470          setting up a tls_get_addr call are indeed followed by such a
7471          call.  If they are not, exclude them from the optimizations
7472          done on the second pass.  */
7473       for (pass = 0; pass < 2; ++pass)
7474         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7475           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7476             {
7477               Elf_Internal_Rela *relstart, *rel, *relend;
7478
7479               /* Read the relocations.  */
7480               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7481                                                     info->keep_memory);
7482               if (relstart == NULL)
7483                 return FALSE;
7484
7485               relend = relstart + sec->reloc_count;
7486               for (rel = relstart; rel < relend; rel++)
7487                 {
7488                   enum elf_ppc64_reloc_type r_type;
7489                   unsigned long r_symndx;
7490                   struct elf_link_hash_entry *h;
7491                   Elf_Internal_Sym *sym;
7492                   asection *sym_sec;
7493                   unsigned char *tls_mask;
7494                   unsigned char tls_set, tls_clear, tls_type = 0;
7495                   bfd_vma value;
7496                   bfd_boolean ok_tprel, is_local;
7497                   long toc_ref_index = 0;
7498                   int expecting_tls_get_addr = 0;
7499
7500                   r_symndx = ELF64_R_SYM (rel->r_info);
7501                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7502                                   r_symndx, ibfd))
7503                     {
7504                     err_free_rel:
7505                       if (elf_section_data (sec)->relocs != relstart)
7506                         free (relstart);
7507                       if (toc_ref != NULL)
7508                         free (toc_ref);
7509                       if (locsyms != NULL
7510                           && (elf_symtab_hdr (ibfd).contents
7511                               != (unsigned char *) locsyms))
7512                         free (locsyms);
7513                       return FALSE;
7514                     }
7515
7516                   if (h != NULL)
7517                     {
7518                       if (h->root.type == bfd_link_hash_defined
7519                           || h->root.type == bfd_link_hash_defweak)
7520                         value = h->root.u.def.value;
7521                       else if (h->root.type == bfd_link_hash_undefweak)
7522                         value = 0;
7523                       else
7524                         continue;
7525                     }
7526                   else
7527                     /* Symbols referenced by TLS relocs must be of type
7528                        STT_TLS.  So no need for .opd local sym adjust.  */
7529                     value = sym->st_value;
7530
7531                   ok_tprel = FALSE;
7532                   is_local = FALSE;
7533                   if (h == NULL
7534                       || !h->def_dynamic)
7535                     {
7536                       is_local = TRUE;
7537                       if (h != NULL
7538                           && h->root.type == bfd_link_hash_undefweak)
7539                         ok_tprel = TRUE;
7540                       else
7541                         {
7542                           value += sym_sec->output_offset;
7543                           value += sym_sec->output_section->vma;
7544                           value -= htab->elf.tls_sec->vma;
7545                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7546                                       < (bfd_vma) 1 << 32);
7547                         }
7548                     }
7549
7550                   r_type = ELF64_R_TYPE (rel->r_info);
7551                   switch (r_type)
7552                     {
7553                     case R_PPC64_GOT_TLSLD16:
7554                     case R_PPC64_GOT_TLSLD16_LO:
7555                       expecting_tls_get_addr = 1;
7556                       /* Fall thru */
7557
7558                     case R_PPC64_GOT_TLSLD16_HI:
7559                     case R_PPC64_GOT_TLSLD16_HA:
7560                       /* These relocs should never be against a symbol
7561                          defined in a shared lib.  Leave them alone if
7562                          that turns out to be the case.  */
7563                       if (!is_local)
7564                         continue;
7565
7566                       /* LD -> LE */
7567                       tls_set = 0;
7568                       tls_clear = TLS_LD;
7569                       tls_type = TLS_TLS | TLS_LD;
7570                       break;
7571
7572                     case R_PPC64_GOT_TLSGD16:
7573                     case R_PPC64_GOT_TLSGD16_LO:
7574                       expecting_tls_get_addr = 1;
7575                       /* Fall thru */
7576
7577                     case R_PPC64_GOT_TLSGD16_HI:
7578                     case R_PPC64_GOT_TLSGD16_HA:
7579                       if (ok_tprel)
7580                         /* GD -> LE */
7581                         tls_set = 0;
7582                       else
7583                         /* GD -> IE */
7584                         tls_set = TLS_TLS | TLS_TPRELGD;
7585                       tls_clear = TLS_GD;
7586                       tls_type = TLS_TLS | TLS_GD;
7587                       break;
7588
7589                     case R_PPC64_GOT_TPREL16_DS:
7590                     case R_PPC64_GOT_TPREL16_LO_DS:
7591                     case R_PPC64_GOT_TPREL16_HI:
7592                     case R_PPC64_GOT_TPREL16_HA:
7593                       if (ok_tprel)
7594                         {
7595                           /* IE -> LE */
7596                           tls_set = 0;
7597                           tls_clear = TLS_TPREL;
7598                           tls_type = TLS_TLS | TLS_TPREL;
7599                           break;
7600                         }
7601                       continue;
7602
7603                     case R_PPC64_TOC16:
7604                     case R_PPC64_TOC16_LO:
7605                     case R_PPC64_TLS:
7606                     case R_PPC64_TLSGD:
7607                     case R_PPC64_TLSLD:
7608                       if (sym_sec == NULL || sym_sec != toc)
7609                         continue;
7610
7611                       /* Mark this toc entry as referenced by a TLS
7612                          code sequence.  We can do that now in the
7613                          case of R_PPC64_TLS, and after checking for
7614                          tls_get_addr for the TOC16 relocs.  */
7615                       if (toc_ref == NULL)
7616                         {
7617                           toc_ref = bfd_zmalloc (toc->size / 8);
7618                           if (toc_ref == NULL)
7619                             goto err_free_rel;
7620                         }
7621                       if (h != NULL)
7622                         value = h->root.u.def.value;
7623                       else
7624                         value = sym->st_value;
7625                       value += rel->r_addend;
7626                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7627                       toc_ref_index = value / 8;
7628                       if (r_type == R_PPC64_TLS
7629                           || r_type == R_PPC64_TLSGD
7630                           || r_type == R_PPC64_TLSLD)
7631                         {
7632                           toc_ref[toc_ref_index] = 1;
7633                           continue;
7634                         }
7635
7636                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7637                         continue;
7638
7639                       tls_set = 0;
7640                       tls_clear = 0;
7641                       expecting_tls_get_addr = 2;
7642                       break;
7643
7644                     case R_PPC64_TPREL64:
7645                       if (pass == 0
7646                           || sec != toc
7647                           || toc_ref == NULL
7648                           || !toc_ref[rel->r_offset / 8])
7649                         continue;
7650                       if (ok_tprel)
7651                         {
7652                           /* IE -> LE */
7653                           tls_set = TLS_EXPLICIT;
7654                           tls_clear = TLS_TPREL;
7655                           break;
7656                         }
7657                       continue;
7658
7659                     case R_PPC64_DTPMOD64:
7660                       if (pass == 0
7661                           || sec != toc
7662                           || toc_ref == NULL
7663                           || !toc_ref[rel->r_offset / 8])
7664                         continue;
7665                       if (rel + 1 < relend
7666                           && (rel[1].r_info
7667                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7668                           && rel[1].r_offset == rel->r_offset + 8)
7669                         {
7670                           if (ok_tprel)
7671                             /* GD -> LE */
7672                             tls_set = TLS_EXPLICIT | TLS_GD;
7673                           else
7674                             /* GD -> IE */
7675                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7676                           tls_clear = TLS_GD;
7677                         }
7678                       else
7679                         {
7680                           if (!is_local)
7681                             continue;
7682
7683                           /* LD -> LE */
7684                           tls_set = TLS_EXPLICIT;
7685                           tls_clear = TLS_LD;
7686                         }
7687                       break;
7688
7689                     default:
7690                       continue;
7691                     }
7692
7693                   if (pass == 0)
7694                     {
7695                       if (!expecting_tls_get_addr
7696                           || !sec->has_tls_get_addr_call)
7697                         continue;
7698
7699                       if (rel + 1 < relend
7700                           && branch_reloc_hash_match (ibfd, rel + 1,
7701                                                       htab->tls_get_addr,
7702                                                       htab->tls_get_addr_fd))
7703                         {
7704                           if (expecting_tls_get_addr == 2)
7705                             {
7706                               /* Check for toc tls entries.  */
7707                               unsigned char *toc_tls;
7708                               int retval;
7709
7710                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7711                                                      &locsyms,
7712                                                      rel, ibfd);
7713                               if (retval == 0)
7714                                 goto err_free_rel;
7715                               if (retval > 1 && toc_tls != NULL)
7716                                 toc_ref[toc_ref_index] = 1;
7717                             }
7718                           continue;
7719                         }
7720
7721                       if (expecting_tls_get_addr != 1)
7722                         continue;
7723
7724                       /* Uh oh, we didn't find the expected call.  We
7725                          could just mark this symbol to exclude it
7726                          from tls optimization but it's safer to skip
7727                          the entire section.  */
7728                       sec->has_tls_reloc = 0;
7729                       break;
7730                     }
7731
7732                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7733                     {
7734                       struct plt_entry *ent;
7735                       for (ent = htab->tls_get_addr->elf.plt.plist;
7736                            ent != NULL;
7737                            ent = ent->next)
7738                         if (ent->addend == 0)
7739                           {
7740                             if (ent->plt.refcount > 0)
7741                               {
7742                                 ent->plt.refcount -= 1;
7743                                 expecting_tls_get_addr = 0;
7744                               }
7745                             break;
7746                           }
7747                     }
7748
7749                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7750                     {
7751                       struct plt_entry *ent;
7752                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7753                            ent != NULL;
7754                            ent = ent->next)
7755                         if (ent->addend == 0)
7756                           {
7757                             if (ent->plt.refcount > 0)
7758                               ent->plt.refcount -= 1;
7759                             break;
7760                           }
7761                     }
7762
7763                   if (tls_clear == 0)
7764                     continue;
7765
7766                   if ((tls_set & TLS_EXPLICIT) == 0)
7767                     {
7768                       struct got_entry *ent;
7769
7770                       /* Adjust got entry for this reloc.  */
7771                       if (h != NULL)
7772                         ent = h->got.glist;
7773                       else
7774                         ent = elf_local_got_ents (ibfd)[r_symndx];
7775
7776                       for (; ent != NULL; ent = ent->next)
7777                         if (ent->addend == rel->r_addend
7778                             && ent->owner == ibfd
7779                             && ent->tls_type == tls_type)
7780                           break;
7781                       if (ent == NULL)
7782                         abort ();
7783
7784                       if (tls_set == 0)
7785                         {
7786                           /* We managed to get rid of a got entry.  */
7787                           if (ent->got.refcount > 0)
7788                             ent->got.refcount -= 1;
7789                         }
7790                     }
7791                   else
7792                     {
7793                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7794                          we'll lose one or two dyn relocs.  */
7795                       if (!dec_dynrel_count (rel->r_info, sec, info,
7796                                              NULL, h, sym_sec))
7797                         return FALSE;
7798
7799                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7800                         {
7801                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7802                                                  NULL, h, sym_sec))
7803                             return FALSE;
7804                         }
7805                     }
7806
7807                   *tls_mask |= tls_set;
7808                   *tls_mask &= ~tls_clear;
7809                 }
7810
7811               if (elf_section_data (sec)->relocs != relstart)
7812                 free (relstart);
7813             }
7814
7815       if (toc_ref != NULL)
7816         free (toc_ref);
7817
7818       if (locsyms != NULL
7819           && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7820         {
7821           if (!info->keep_memory)
7822             free (locsyms);
7823           else
7824             elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7825         }
7826     }
7827   return TRUE;
7828 }
7829
7830 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7831    the values of any global symbols in a toc section that has been
7832    edited.  Globals in toc sections should be a rarity, so this function
7833    sets a flag if any are found in toc sections other than the one just
7834    edited, so that futher hash table traversals can be avoided.  */
7835
7836 struct adjust_toc_info
7837 {
7838   asection *toc;
7839   unsigned long *skip;
7840   bfd_boolean global_toc_syms;
7841 };
7842
7843 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7844
7845 static bfd_boolean
7846 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7847 {
7848   struct ppc_link_hash_entry *eh;
7849   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7850   unsigned long i;
7851
7852   if (h->root.type == bfd_link_hash_indirect)
7853     return TRUE;
7854
7855   if (h->root.type == bfd_link_hash_warning)
7856     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7857
7858   if (h->root.type != bfd_link_hash_defined
7859       && h->root.type != bfd_link_hash_defweak)
7860     return TRUE;
7861
7862   eh = (struct ppc_link_hash_entry *) h;
7863   if (eh->adjust_done)
7864     return TRUE;
7865
7866   if (eh->elf.root.u.def.section == toc_inf->toc)
7867     {
7868       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
7869         i = toc_inf->toc->rawsize >> 3;
7870       else
7871         i = eh->elf.root.u.def.value >> 3;
7872
7873       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
7874         {
7875           (*_bfd_error_handler)
7876             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
7877           do
7878             ++i;
7879           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
7880           eh->elf.root.u.def.value = (bfd_vma) i << 3;
7881         }
7882
7883       eh->elf.root.u.def.value -= toc_inf->skip[i];
7884       eh->adjust_done = 1;
7885     }
7886   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7887     toc_inf->global_toc_syms = TRUE;
7888
7889   return TRUE;
7890 }
7891
7892 /* Examine all relocs referencing .toc sections in order to remove
7893    unused .toc entries.  */
7894
7895 bfd_boolean
7896 ppc64_elf_edit_toc (struct bfd_link_info *info)
7897 {
7898   bfd *ibfd;
7899   struct adjust_toc_info toc_inf;
7900   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7901
7902   htab->do_toc_opt = 1;
7903   toc_inf.global_toc_syms = TRUE;
7904   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7905     {
7906       asection *toc, *sec;
7907       Elf_Internal_Shdr *symtab_hdr;
7908       Elf_Internal_Sym *local_syms;
7909       Elf_Internal_Rela *relstart, *rel;
7910       unsigned long *skip, *drop;
7911       unsigned char *used;
7912       unsigned char *keep, last, some_unused;
7913
7914       if (!is_ppc64_elf (ibfd))
7915         continue;
7916
7917       toc = bfd_get_section_by_name (ibfd, ".toc");
7918       if (toc == NULL
7919           || toc->size == 0
7920           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7921           || elf_discarded_section (toc))
7922         continue;
7923
7924       local_syms = NULL;
7925       symtab_hdr = &elf_symtab_hdr (ibfd);
7926
7927       /* Look at sections dropped from the final link.  */
7928       skip = NULL;
7929       relstart = NULL;
7930       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7931         {
7932           if (sec->reloc_count == 0
7933               || !elf_discarded_section (sec)
7934               || get_opd_info (sec)
7935               || (sec->flags & SEC_ALLOC) == 0
7936               || (sec->flags & SEC_DEBUGGING) != 0)
7937             continue;
7938
7939           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7940           if (relstart == NULL)
7941             goto error_ret;
7942
7943           /* Run through the relocs to see which toc entries might be
7944              unused.  */
7945           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7946             {
7947               enum elf_ppc64_reloc_type r_type;
7948               unsigned long r_symndx;
7949               asection *sym_sec;
7950               struct elf_link_hash_entry *h;
7951               Elf_Internal_Sym *sym;
7952               bfd_vma val;
7953
7954               r_type = ELF64_R_TYPE (rel->r_info);
7955               switch (r_type)
7956                 {
7957                 default:
7958                   continue;
7959
7960                 case R_PPC64_TOC16:
7961                 case R_PPC64_TOC16_LO:
7962                 case R_PPC64_TOC16_HI:
7963                 case R_PPC64_TOC16_HA:
7964                 case R_PPC64_TOC16_DS:
7965                 case R_PPC64_TOC16_LO_DS:
7966                   break;
7967                 }
7968
7969               r_symndx = ELF64_R_SYM (rel->r_info);
7970               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7971                               r_symndx, ibfd))
7972                 goto error_ret;
7973
7974               if (sym_sec != toc)
7975                 continue;
7976
7977               if (h != NULL)
7978                 val = h->root.u.def.value;
7979               else
7980                 val = sym->st_value;
7981               val += rel->r_addend;
7982
7983               if (val >= toc->size)
7984                 continue;
7985
7986               /* Anything in the toc ought to be aligned to 8 bytes.
7987                  If not, don't mark as unused.  */
7988               if (val & 7)
7989                 continue;
7990
7991               if (skip == NULL)
7992                 {
7993                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
7994                   if (skip == NULL)
7995                     goto error_ret;
7996                 }
7997
7998               skip[val >> 3] = ref_from_discarded;
7999             }
8000
8001           if (elf_section_data (sec)->relocs != relstart)
8002             free (relstart);
8003         }
8004
8005       /* For largetoc loads of address constants, we can convert
8006          .  addis rx,2,addr@got@ha
8007          .  ld ry,addr@got@l(rx)
8008          to
8009          .  addis rx,2,addr@toc@ha
8010          .  addi ry,rx,addr@toc@l
8011          when addr is within 2G of the toc pointer.  This then means
8012          that the word storing "addr" in the toc is no longer needed.  */
8013
8014       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8015           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8016           && toc->reloc_count != 0)
8017         {
8018           /* Read toc relocs.  */
8019           relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8020                                                 info->keep_memory);
8021           if (relstart == NULL)
8022             goto error_ret;
8023
8024           for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8025             {
8026               enum elf_ppc64_reloc_type r_type;
8027               unsigned long r_symndx;
8028               asection *sym_sec;
8029               struct elf_link_hash_entry *h;
8030               Elf_Internal_Sym *sym;
8031               bfd_vma val, addr;
8032
8033               r_type = ELF64_R_TYPE (rel->r_info);
8034               if (r_type != R_PPC64_ADDR64)
8035                 continue;
8036
8037               r_symndx = ELF64_R_SYM (rel->r_info);
8038               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8039                               r_symndx, ibfd))
8040                 goto error_ret;
8041
8042               if (!SYMBOL_CALLS_LOCAL (info, h))
8043                 continue;
8044
8045               if (h != NULL)
8046                 {
8047                   if (h->type == STT_GNU_IFUNC)
8048                     continue;
8049                   val = h->root.u.def.value;
8050                 }
8051               else
8052                 {
8053                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8054                     continue;
8055                   val = sym->st_value;
8056                 }
8057               val += rel->r_addend;
8058               val += sym_sec->output_section->vma + sym_sec->output_offset;
8059
8060               /* We don't yet know the exact toc pointer value, but we
8061                  know it will be somewhere in the toc section.  Don't
8062                  optimize if the difference from any possible toc
8063                  pointer is outside [ff..f80008000, 7fff7fff].  */
8064               addr = toc->output_section->vma + TOC_BASE_OFF;
8065               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8066                 continue;
8067
8068               addr = toc->output_section->vma + toc->output_section->rawsize;
8069               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8070                 continue;
8071
8072               if (skip == NULL)
8073                 {
8074                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8075                   if (skip == NULL)
8076                     goto error_ret;
8077                 }
8078
8079               skip[rel->r_offset >> 3]
8080                 |= can_optimize | ((rel - relstart) << 2);
8081             }
8082
8083           if (elf_section_data (toc)->relocs != relstart)
8084             free (relstart);
8085         }
8086
8087       if (skip == NULL)
8088         continue;
8089
8090       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8091       if (used == NULL)
8092         {
8093         error_ret:
8094           if (local_syms != NULL
8095               && symtab_hdr->contents != (unsigned char *) local_syms)
8096             free (local_syms);
8097           if (sec != NULL
8098               && relstart != NULL
8099               && elf_section_data (sec)->relocs != relstart)
8100             free (relstart);
8101           if (skip != NULL)
8102             free (skip);
8103           return FALSE;
8104         }
8105
8106       /* Now check all kept sections that might reference the toc.
8107          Check the toc itself last.  */
8108       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8109                   : ibfd->sections);
8110            sec != NULL;
8111            sec = (sec == toc ? NULL
8112                   : sec->next == NULL ? toc
8113                   : sec->next == toc && toc->next ? toc->next
8114                   : sec->next))
8115         {
8116           int repeat;
8117
8118           if (sec->reloc_count == 0
8119               || elf_discarded_section (sec)
8120               || get_opd_info (sec)
8121               || (sec->flags & SEC_ALLOC) == 0
8122               || (sec->flags & SEC_DEBUGGING) != 0)
8123             continue;
8124
8125           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8126                                                 info->keep_memory);
8127           if (relstart == NULL)
8128             goto error_ret;
8129
8130           /* Mark toc entries referenced as used.  */
8131           repeat = 0;
8132           do
8133             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8134               {
8135                 enum elf_ppc64_reloc_type r_type;
8136                 unsigned long r_symndx;
8137                 asection *sym_sec;
8138                 struct elf_link_hash_entry *h;
8139                 Elf_Internal_Sym *sym;
8140                 bfd_vma val;
8141
8142                 r_type = ELF64_R_TYPE (rel->r_info);
8143                 switch (r_type)
8144                   {
8145                   case R_PPC64_TOC16:
8146                   case R_PPC64_TOC16_LO:
8147                   case R_PPC64_TOC16_HI:
8148                   case R_PPC64_TOC16_HA:
8149                   case R_PPC64_TOC16_DS:
8150                   case R_PPC64_TOC16_LO_DS:
8151                     /* In case we're taking addresses of toc entries.  */
8152                   case R_PPC64_ADDR64:
8153                     break;
8154
8155                   default:
8156                     continue;
8157                   }
8158
8159                 r_symndx = ELF64_R_SYM (rel->r_info);
8160                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8161                                 r_symndx, ibfd))
8162                   {
8163                     free (used);
8164                     goto error_ret;
8165                   }
8166
8167                 if (sym_sec != toc)
8168                   continue;
8169
8170                 if (h != NULL)
8171                   val = h->root.u.def.value;
8172                 else
8173                   val = sym->st_value;
8174                 val += rel->r_addend;
8175
8176                 if (val >= toc->size)
8177                   continue;
8178
8179                 if ((skip[val >> 3] & can_optimize) != 0)
8180                   {
8181                     bfd_vma off;
8182                     unsigned char opc;
8183
8184                     switch (r_type)
8185                       {
8186                       case R_PPC64_TOC16_HA:
8187                         break;
8188
8189                       case R_PPC64_TOC16_LO_DS:
8190                         off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8191                         if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8192                           return FALSE;
8193                         if ((opc & (0x3f << 2)) == (58u << 2))
8194                           break;
8195                         /* Fall thru */
8196
8197                       default:
8198                         /* Wrong sort of reloc, or not a ld.  We may
8199                            as well clear ref_from_discarded too.  */
8200                         skip[val >> 3] = 0;
8201                       }
8202                   }
8203
8204                 /* For the toc section, we only mark as used if
8205                    this entry itself isn't unused.  */
8206                 if (sec == toc
8207                     && !used[val >> 3]
8208                     && (used[rel->r_offset >> 3]
8209                         || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8210                   /* Do all the relocs again, to catch reference
8211                      chains.  */
8212                   repeat = 1;
8213
8214                 used[val >> 3] = 1;
8215               }
8216           while (repeat);
8217
8218           if (elf_section_data (sec)->relocs != relstart)
8219             free (relstart);
8220         }
8221
8222       /* Merge the used and skip arrays.  Assume that TOC
8223          doublewords not appearing as either used or unused belong
8224          to to an entry more than one doubleword in size.  */
8225       for (drop = skip, keep = used, last = 0, some_unused = 0;
8226            drop < skip + (toc->size + 7) / 8;
8227            ++drop, ++keep)
8228         {
8229           if (*keep)
8230             {
8231               *drop &= ~ref_from_discarded;
8232               if ((*drop & can_optimize) != 0)
8233                 some_unused = 1;
8234               last = 0;
8235             }
8236           else if (*drop)
8237             {
8238               some_unused = 1;
8239               last = ref_from_discarded;
8240             }
8241           else
8242             *drop = last;
8243         }
8244
8245       free (used);
8246
8247       if (some_unused)
8248         {
8249           bfd_byte *contents, *src;
8250           unsigned long off;
8251           Elf_Internal_Sym *sym;
8252           bfd_boolean local_toc_syms = FALSE;
8253
8254           /* Shuffle the toc contents, and at the same time convert the
8255              skip array from booleans into offsets.  */
8256           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8257             goto error_ret;
8258
8259           elf_section_data (toc)->this_hdr.contents = contents;
8260
8261           for (src = contents, off = 0, drop = skip;
8262                src < contents + toc->size;
8263                src += 8, ++drop)
8264             {
8265               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8266                 off += 8;
8267               else if (off != 0)
8268                 {
8269                   *drop = off;
8270                   memcpy (src - off, src, 8);
8271                 }
8272             }
8273           *drop = off;
8274           toc->rawsize = toc->size;
8275           toc->size = src - contents - off;
8276
8277           /* Adjust addends for relocs against the toc section sym,
8278              and optimize any accesses we can.  */
8279           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8280             {
8281               if (sec->reloc_count == 0
8282                   || elf_discarded_section (sec))
8283                 continue;
8284
8285               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8286                                                     info->keep_memory);
8287               if (relstart == NULL)
8288                 goto error_ret;
8289
8290               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8291                 {
8292                   enum elf_ppc64_reloc_type r_type;
8293                   unsigned long r_symndx;
8294                   asection *sym_sec;
8295                   struct elf_link_hash_entry *h;
8296                   bfd_vma val;
8297
8298                   r_type = ELF64_R_TYPE (rel->r_info);
8299                   switch (r_type)
8300                     {
8301                     default:
8302                       continue;
8303
8304                     case R_PPC64_TOC16:
8305                     case R_PPC64_TOC16_LO:
8306                     case R_PPC64_TOC16_HI:
8307                     case R_PPC64_TOC16_HA:
8308                     case R_PPC64_TOC16_DS:
8309                     case R_PPC64_TOC16_LO_DS:
8310                     case R_PPC64_ADDR64:
8311                       break;
8312                     }
8313
8314                   r_symndx = ELF64_R_SYM (rel->r_info);
8315                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8316                                   r_symndx, ibfd))
8317                     goto error_ret;
8318
8319                   if (sym_sec != toc)
8320                     continue;
8321
8322                   if (h != NULL)
8323                     val = h->root.u.def.value;
8324                   else
8325                     {
8326                       val = sym->st_value;
8327                       if (val != 0)
8328                         local_toc_syms = TRUE;
8329                     }
8330
8331                   val += rel->r_addend;
8332
8333                   if (val > toc->rawsize)
8334                     val = toc->rawsize;
8335                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8336                     continue;
8337                   else if ((skip[val >> 3] & can_optimize) != 0)
8338                     {
8339                       Elf_Internal_Rela *tocrel
8340                         = elf_section_data (toc)->relocs + (skip[val >> 3] >> 2);
8341                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8342
8343                       switch (r_type)
8344                         {
8345                         case R_PPC64_TOC16_HA:
8346                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8347                           break;
8348
8349                         case R_PPC64_TOC16_LO_DS:
8350                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8351                           break;
8352
8353                         default:
8354                           abort ();
8355                         }
8356                       rel->r_addend = tocrel->r_addend;
8357                       elf_section_data (sec)->relocs = relstart;
8358                       continue;
8359                     }
8360
8361                   if (h != NULL || sym->st_value != 0)
8362                     continue;
8363
8364                   rel->r_addend -= skip[val >> 3];
8365                   elf_section_data (sec)->relocs = relstart;
8366                 }
8367
8368               if (elf_section_data (sec)->relocs != relstart)
8369                 free (relstart);
8370             }
8371
8372           /* We shouldn't have local or global symbols defined in the TOC,
8373              but handle them anyway.  */
8374           for (sym = local_syms;
8375                sym < local_syms + symtab_hdr->sh_info;
8376                ++sym)
8377             if (sym->st_value != 0
8378                 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8379               {
8380                 unsigned long i;
8381
8382                 if (sym->st_value > toc->rawsize)
8383                   i = toc->rawsize >> 3;
8384                 else
8385                   i = sym->st_value >> 3;
8386
8387                 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8388                   {
8389                     if (local_toc_syms)
8390                       (*_bfd_error_handler)
8391                         (_("%s defined on removed toc entry"),
8392                          bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8393                     do
8394                       ++i;
8395                     while ((skip[i] & (ref_from_discarded | can_optimize)));
8396                     sym->st_value = (bfd_vma) i << 3;
8397                   }
8398
8399                 sym->st_value -= skip[i];
8400                 symtab_hdr->contents = (unsigned char *) local_syms;
8401               }
8402
8403           /* Adjust any global syms defined in this toc input section.  */
8404           if (toc_inf.global_toc_syms)
8405             {
8406               toc_inf.toc = toc;
8407               toc_inf.skip = skip;
8408               toc_inf.global_toc_syms = FALSE;
8409               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8410                                       &toc_inf);
8411             }
8412
8413           if (toc->reloc_count != 0)
8414             {
8415               Elf_Internal_Rela *wrel;
8416               bfd_size_type sz;
8417
8418               /* Read toc relocs.  */
8419               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8420                                                     TRUE);
8421               if (relstart == NULL)
8422                 goto error_ret;
8423
8424               /* Remove unused toc relocs, and adjust those we keep.  */
8425               wrel = relstart;
8426               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8427                 if ((skip[rel->r_offset >> 3]
8428                      & (ref_from_discarded | can_optimize)) == 0)
8429                   {
8430                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8431                     wrel->r_info = rel->r_info;
8432                     wrel->r_addend = rel->r_addend;
8433                     ++wrel;
8434                   }
8435                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8436                                             &local_syms, NULL, NULL))
8437                   goto error_ret;
8438
8439               toc->reloc_count = wrel - relstart;
8440               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
8441               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
8442               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
8443             }
8444         }
8445
8446       if (local_syms != NULL
8447           && symtab_hdr->contents != (unsigned char *) local_syms)
8448         {
8449           if (!info->keep_memory)
8450             free (local_syms);
8451           else
8452             symtab_hdr->contents = (unsigned char *) local_syms;
8453         }
8454       free (skip);
8455     }
8456
8457   return TRUE;
8458 }
8459
8460 /* Return true iff input section I references the TOC using
8461    instructions limited to +/-32k offsets.  */
8462
8463 bfd_boolean
8464 ppc64_elf_has_small_toc_reloc (asection *i)
8465 {
8466   return (is_ppc64_elf (i->owner)
8467           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8468 }
8469
8470 /* Allocate space for one GOT entry.  */
8471
8472 static void
8473 allocate_got (struct elf_link_hash_entry *h,
8474               struct bfd_link_info *info,
8475               struct got_entry *gent)
8476 {
8477   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8478   bfd_boolean dyn;
8479   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8480   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8481                  ? 16 : 8);
8482   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8483                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8484   asection *got = ppc64_elf_tdata (gent->owner)->got;
8485
8486   gent->got.offset = got->size;
8487   got->size += entsize;
8488
8489   dyn = htab->elf.dynamic_sections_created;
8490   if ((info->shared
8491        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8492             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8493                 || h->root.type != bfd_link_hash_undefweak))
8494     {
8495       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8496       relgot->size += rentsize;
8497     }
8498   else if (h->type == STT_GNU_IFUNC)
8499     {
8500       asection *relgot = htab->reliplt;
8501       relgot->size += rentsize;
8502       htab->got_reli_size += rentsize;
8503     }
8504 }
8505
8506 /* This function merges got entries in the same toc group.  */
8507
8508 static void
8509 merge_got_entries (struct got_entry **pent)
8510 {
8511   struct got_entry *ent, *ent2;
8512
8513   for (ent = *pent; ent != NULL; ent = ent->next)
8514     if (!ent->is_indirect)
8515       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8516         if (!ent2->is_indirect
8517             && ent2->addend == ent->addend
8518             && ent2->tls_type == ent->tls_type
8519             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8520           {
8521             ent2->is_indirect = TRUE;
8522             ent2->got.ent = ent;
8523           }
8524 }
8525
8526 /* Allocate space in .plt, .got and associated reloc sections for
8527    dynamic relocs.  */
8528
8529 static bfd_boolean
8530 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8531 {
8532   struct bfd_link_info *info;
8533   struct ppc_link_hash_table *htab;
8534   asection *s;
8535   struct ppc_link_hash_entry *eh;
8536   struct ppc_dyn_relocs *p;
8537   struct got_entry **pgent, *gent;
8538
8539   if (h->root.type == bfd_link_hash_indirect)
8540     return TRUE;
8541
8542   if (h->root.type == bfd_link_hash_warning)
8543     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8544
8545   info = (struct bfd_link_info *) inf;
8546   htab = ppc_hash_table (info);
8547   if (htab == NULL)
8548     return FALSE;
8549
8550   if ((htab->elf.dynamic_sections_created
8551        && h->dynindx != -1
8552        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8553       || h->type == STT_GNU_IFUNC)
8554     {
8555       struct plt_entry *pent;
8556       bfd_boolean doneone = FALSE;
8557       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8558         if (pent->plt.refcount > 0)
8559           {
8560             if (!htab->elf.dynamic_sections_created
8561                 || h->dynindx == -1)
8562               {
8563                 s = htab->iplt;
8564                 pent->plt.offset = s->size;
8565                 s->size += PLT_ENTRY_SIZE;
8566                 s = htab->reliplt;
8567               }
8568             else
8569               {
8570                 /* If this is the first .plt entry, make room for the special
8571                    first entry.  */
8572                 s = htab->plt;
8573                 if (s->size == 0)
8574                   s->size += PLT_INITIAL_ENTRY_SIZE;
8575
8576                 pent->plt.offset = s->size;
8577
8578                 /* Make room for this entry.  */
8579                 s->size += PLT_ENTRY_SIZE;
8580
8581                 /* Make room for the .glink code.  */
8582                 s = htab->glink;
8583                 if (s->size == 0)
8584                   s->size += GLINK_CALL_STUB_SIZE;
8585                 /* We need bigger stubs past index 32767.  */
8586                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8587                   s->size += 4;
8588                 s->size += 2*4;
8589
8590                 /* We also need to make an entry in the .rela.plt section.  */
8591                 s = htab->relplt;
8592               }
8593             s->size += sizeof (Elf64_External_Rela);
8594             doneone = TRUE;
8595           }
8596         else
8597           pent->plt.offset = (bfd_vma) -1;
8598       if (!doneone)
8599         {
8600           h->plt.plist = NULL;
8601           h->needs_plt = 0;
8602         }
8603     }
8604   else
8605     {
8606       h->plt.plist = NULL;
8607       h->needs_plt = 0;
8608     }
8609
8610   eh = (struct ppc_link_hash_entry *) h;
8611   /* Run through the TLS GD got entries first if we're changing them
8612      to TPREL.  */
8613   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8614     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8615       if (gent->got.refcount > 0
8616           && (gent->tls_type & TLS_GD) != 0)
8617         {
8618           /* This was a GD entry that has been converted to TPREL.  If
8619              there happens to be a TPREL entry we can use that one.  */
8620           struct got_entry *ent;
8621           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8622             if (ent->got.refcount > 0
8623                 && (ent->tls_type & TLS_TPREL) != 0
8624                 && ent->addend == gent->addend
8625                 && ent->owner == gent->owner)
8626               {
8627                 gent->got.refcount = 0;
8628                 break;
8629               }
8630
8631           /* If not, then we'll be using our own TPREL entry.  */
8632           if (gent->got.refcount != 0)
8633             gent->tls_type = TLS_TLS | TLS_TPREL;
8634         }
8635
8636   /* Remove any list entry that won't generate a word in the GOT before
8637      we call merge_got_entries.  Otherwise we risk merging to empty
8638      entries.  */
8639   pgent = &h->got.glist;
8640   while ((gent = *pgent) != NULL)
8641     if (gent->got.refcount > 0)
8642       {
8643         if ((gent->tls_type & TLS_LD) != 0
8644             && !h->def_dynamic)
8645           {
8646             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8647             *pgent = gent->next;
8648           }
8649         else
8650           pgent = &gent->next;
8651       }
8652     else
8653       *pgent = gent->next;
8654
8655   if (!htab->do_multi_toc)
8656     merge_got_entries (&h->got.glist);
8657
8658   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8659     if (!gent->is_indirect)
8660       {
8661         /* Make sure this symbol is output as a dynamic symbol.
8662            Undefined weak syms won't yet be marked as dynamic,
8663            nor will all TLS symbols.  */
8664         if (h->dynindx == -1
8665             && !h->forced_local
8666             && h->type != STT_GNU_IFUNC
8667             && htab->elf.dynamic_sections_created)
8668           {
8669             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8670               return FALSE;
8671           }
8672
8673         if (!is_ppc64_elf (gent->owner))
8674           abort ();
8675
8676         allocate_got (h, info, gent);
8677       }
8678
8679   if (eh->dyn_relocs == NULL
8680       || (!htab->elf.dynamic_sections_created
8681           && h->type != STT_GNU_IFUNC))
8682     return TRUE;
8683
8684   /* In the shared -Bsymbolic case, discard space allocated for
8685      dynamic pc-relative relocs against symbols which turn out to be
8686      defined in regular objects.  For the normal shared case, discard
8687      space for relocs that have become local due to symbol visibility
8688      changes.  */
8689
8690   if (info->shared)
8691     {
8692       /* Relocs that use pc_count are those that appear on a call insn,
8693          or certain REL relocs (see must_be_dyn_reloc) that can be
8694          generated via assembly.  We want calls to protected symbols to
8695          resolve directly to the function rather than going via the plt.
8696          If people want function pointer comparisons to work as expected
8697          then they should avoid writing weird assembly.  */
8698       if (SYMBOL_CALLS_LOCAL (info, h))
8699         {
8700           struct ppc_dyn_relocs **pp;
8701
8702           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8703             {
8704               p->count -= p->pc_count;
8705               p->pc_count = 0;
8706               if (p->count == 0)
8707                 *pp = p->next;
8708               else
8709                 pp = &p->next;
8710             }
8711         }
8712
8713       /* Also discard relocs on undefined weak syms with non-default
8714          visibility.  */
8715       if (eh->dyn_relocs != NULL
8716           && h->root.type == bfd_link_hash_undefweak)
8717         {
8718           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8719             eh->dyn_relocs = NULL;
8720
8721           /* Make sure this symbol is output as a dynamic symbol.
8722              Undefined weak syms won't yet be marked as dynamic.  */
8723           else if (h->dynindx == -1
8724                    && !h->forced_local)
8725             {
8726               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8727                 return FALSE;
8728             }
8729         }
8730     }
8731   else if (h->type == STT_GNU_IFUNC)
8732     {
8733       if (!h->non_got_ref)
8734         eh->dyn_relocs = NULL;
8735     }
8736   else if (ELIMINATE_COPY_RELOCS)
8737     {
8738       /* For the non-shared case, discard space for relocs against
8739          symbols which turn out to need copy relocs or are not
8740          dynamic.  */
8741
8742       if (!h->non_got_ref
8743           && !h->def_regular)
8744         {
8745           /* Make sure this symbol is output as a dynamic symbol.
8746              Undefined weak syms won't yet be marked as dynamic.  */
8747           if (h->dynindx == -1
8748               && !h->forced_local)
8749             {
8750               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8751                 return FALSE;
8752             }
8753
8754           /* If that succeeded, we know we'll be keeping all the
8755              relocs.  */
8756           if (h->dynindx != -1)
8757             goto keep;
8758         }
8759
8760       eh->dyn_relocs = NULL;
8761
8762     keep: ;
8763     }
8764
8765   /* Finally, allocate space.  */
8766   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8767     {
8768       asection *sreloc = elf_section_data (p->sec)->sreloc;
8769       if (!htab->elf.dynamic_sections_created)
8770         sreloc = htab->reliplt;
8771       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8772     }
8773
8774   return TRUE;
8775 }
8776
8777 /* Find any dynamic relocs that apply to read-only sections.  */
8778
8779 static bfd_boolean
8780 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8781 {
8782   struct ppc_link_hash_entry *eh;
8783   struct ppc_dyn_relocs *p;
8784
8785   if (h->root.type == bfd_link_hash_warning)
8786     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8787
8788   eh = (struct ppc_link_hash_entry *) h;
8789   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8790     {
8791       asection *s = p->sec->output_section;
8792
8793       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8794         {
8795           struct bfd_link_info *info = inf;
8796
8797           info->flags |= DF_TEXTREL;
8798
8799           /* Not an error, just cut short the traversal.  */
8800           return FALSE;
8801         }
8802     }
8803   return TRUE;
8804 }
8805
8806 /* Set the sizes of the dynamic sections.  */
8807
8808 static bfd_boolean
8809 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8810                                  struct bfd_link_info *info)
8811 {
8812   struct ppc_link_hash_table *htab;
8813   bfd *dynobj;
8814   asection *s;
8815   bfd_boolean relocs;
8816   bfd *ibfd;
8817   struct got_entry *first_tlsld;
8818
8819   htab = ppc_hash_table (info);
8820   if (htab == NULL)
8821     return FALSE;
8822
8823   dynobj = htab->elf.dynobj;
8824   if (dynobj == NULL)
8825     abort ();
8826
8827   if (htab->elf.dynamic_sections_created)
8828     {
8829       /* Set the contents of the .interp section to the interpreter.  */
8830       if (info->executable)
8831         {
8832           s = bfd_get_section_by_name (dynobj, ".interp");
8833           if (s == NULL)
8834             abort ();
8835           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8836           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8837         }
8838     }
8839
8840   /* Set up .got offsets for local syms, and space for local dynamic
8841      relocs.  */
8842   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8843     {
8844       struct got_entry **lgot_ents;
8845       struct got_entry **end_lgot_ents;
8846       struct plt_entry **local_plt;
8847       struct plt_entry **end_local_plt;
8848       unsigned char *lgot_masks;
8849       bfd_size_type locsymcount;
8850       Elf_Internal_Shdr *symtab_hdr;
8851       asection *srel;
8852
8853       if (!is_ppc64_elf (ibfd))
8854         continue;
8855
8856       for (s = ibfd->sections; s != NULL; s = s->next)
8857         {
8858           struct ppc_dyn_relocs *p;
8859
8860           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8861             {
8862               if (!bfd_is_abs_section (p->sec)
8863                   && bfd_is_abs_section (p->sec->output_section))
8864                 {
8865                   /* Input section has been discarded, either because
8866                      it is a copy of a linkonce section or due to
8867                      linker script /DISCARD/, so we'll be discarding
8868                      the relocs too.  */
8869                 }
8870               else if (p->count != 0)
8871                 {
8872                   srel = elf_section_data (p->sec)->sreloc;
8873                   if (!htab->elf.dynamic_sections_created)
8874                     srel = htab->reliplt;
8875                   srel->size += p->count * sizeof (Elf64_External_Rela);
8876                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8877                     info->flags |= DF_TEXTREL;
8878                 }
8879             }
8880         }
8881
8882       lgot_ents = elf_local_got_ents (ibfd);
8883       if (!lgot_ents)
8884         continue;
8885
8886       symtab_hdr = &elf_symtab_hdr (ibfd);
8887       locsymcount = symtab_hdr->sh_info;
8888       end_lgot_ents = lgot_ents + locsymcount;
8889       local_plt = (struct plt_entry **) end_lgot_ents;
8890       end_local_plt = local_plt + locsymcount;
8891       lgot_masks = (unsigned char *) end_local_plt;
8892       s = ppc64_elf_tdata (ibfd)->got;
8893       srel = ppc64_elf_tdata (ibfd)->relgot;
8894       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8895         {
8896           struct got_entry **pent, *ent;
8897
8898           pent = lgot_ents;
8899           while ((ent = *pent) != NULL)
8900             if (ent->got.refcount > 0)
8901               {
8902                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8903                   {
8904                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
8905                     *pent = ent->next;
8906                   }
8907                 else
8908                   {
8909                     unsigned int num = 1;
8910                     ent->got.offset = s->size;
8911                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8912                       num = 2;
8913                     s->size += num * 8;
8914                     if (info->shared)
8915                       srel->size += num * sizeof (Elf64_External_Rela);
8916                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8917                       {
8918                         htab->reliplt->size
8919                           += num * sizeof (Elf64_External_Rela);
8920                         htab->got_reli_size
8921                           += num * sizeof (Elf64_External_Rela);
8922                       }
8923                     pent = &ent->next;
8924                   }
8925               }
8926             else
8927               *pent = ent->next;
8928         }
8929
8930       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8931       for (; local_plt < end_local_plt; ++local_plt)
8932         {
8933           struct plt_entry *ent;
8934
8935           for (ent = *local_plt; ent != NULL; ent = ent->next)
8936             if (ent->plt.refcount > 0)
8937               {
8938                 s = htab->iplt;
8939                 ent->plt.offset = s->size;
8940                 s->size += PLT_ENTRY_SIZE;
8941
8942                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8943               }
8944             else
8945               ent->plt.offset = (bfd_vma) -1;
8946         }
8947     }
8948
8949   /* Allocate global sym .plt and .got entries, and space for global
8950      sym dynamic relocs.  */
8951   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8952
8953   first_tlsld = NULL;
8954   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8955     {
8956       struct got_entry *ent;
8957
8958       if (!is_ppc64_elf (ibfd))
8959         continue;
8960
8961       ent = ppc64_tlsld_got (ibfd);
8962       if (ent->got.refcount > 0)
8963         {
8964           if (!htab->do_multi_toc && first_tlsld != NULL)
8965             {
8966               ent->is_indirect = TRUE;
8967               ent->got.ent = first_tlsld;
8968             }
8969           else
8970             {
8971               if (first_tlsld == NULL)
8972                 first_tlsld = ent;
8973               s = ppc64_elf_tdata (ibfd)->got;
8974               ent->got.offset = s->size;
8975               ent->owner = ibfd;
8976               s->size += 16;
8977               if (info->shared)
8978                 {
8979                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8980                   srel->size += sizeof (Elf64_External_Rela);
8981                 }
8982             }
8983         }
8984       else
8985         ent->got.offset = (bfd_vma) -1;
8986     }
8987
8988   /* We now have determined the sizes of the various dynamic sections.
8989      Allocate memory for them.  */
8990   relocs = FALSE;
8991   for (s = dynobj->sections; s != NULL; s = s->next)
8992     {
8993       if ((s->flags & SEC_LINKER_CREATED) == 0)
8994         continue;
8995
8996       if (s == htab->brlt || s == htab->relbrlt)
8997         /* These haven't been allocated yet;  don't strip.  */
8998         continue;
8999       else if (s == htab->got
9000                || s == htab->plt
9001                || s == htab->iplt
9002                || s == htab->glink
9003                || s == htab->dynbss)
9004         {
9005           /* Strip this section if we don't need it; see the
9006              comment below.  */
9007         }
9008       else if (CONST_STRNEQ (s->name, ".rela"))
9009         {
9010           if (s->size != 0)
9011             {
9012               if (s != htab->relplt)
9013                 relocs = TRUE;
9014
9015               /* We use the reloc_count field as a counter if we need
9016                  to copy relocs into the output file.  */
9017               s->reloc_count = 0;
9018             }
9019         }
9020       else
9021         {
9022           /* It's not one of our sections, so don't allocate space.  */
9023           continue;
9024         }
9025
9026       if (s->size == 0)
9027         {
9028           /* If we don't need this section, strip it from the
9029              output file.  This is mostly to handle .rela.bss and
9030              .rela.plt.  We must create both sections in
9031              create_dynamic_sections, because they must be created
9032              before the linker maps input sections to output
9033              sections.  The linker does that before
9034              adjust_dynamic_symbol is called, and it is that
9035              function which decides whether anything needs to go
9036              into these sections.  */
9037           s->flags |= SEC_EXCLUDE;
9038           continue;
9039         }
9040
9041       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9042         continue;
9043
9044       /* Allocate memory for the section contents.  We use bfd_zalloc
9045          here in case unused entries are not reclaimed before the
9046          section's contents are written out.  This should not happen,
9047          but this way if it does we get a R_PPC64_NONE reloc in .rela
9048          sections instead of garbage.
9049          We also rely on the section contents being zero when writing
9050          the GOT.  */
9051       s->contents = bfd_zalloc (dynobj, s->size);
9052       if (s->contents == NULL)
9053         return FALSE;
9054     }
9055
9056   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9057     {
9058       if (!is_ppc64_elf (ibfd))
9059         continue;
9060
9061       s = ppc64_elf_tdata (ibfd)->got;
9062       if (s != NULL && s != htab->got)
9063         {
9064           if (s->size == 0)
9065             s->flags |= SEC_EXCLUDE;
9066           else
9067             {
9068               s->contents = bfd_zalloc (ibfd, s->size);
9069               if (s->contents == NULL)
9070                 return FALSE;
9071             }
9072         }
9073       s = ppc64_elf_tdata (ibfd)->relgot;
9074       if (s != NULL)
9075         {
9076           if (s->size == 0)
9077             s->flags |= SEC_EXCLUDE;
9078           else
9079             {
9080               s->contents = bfd_zalloc (ibfd, s->size);
9081               if (s->contents == NULL)
9082                 return FALSE;
9083               relocs = TRUE;
9084               s->reloc_count = 0;
9085             }
9086         }
9087     }
9088
9089   if (htab->elf.dynamic_sections_created)
9090     {
9091       /* Add some entries to the .dynamic section.  We fill in the
9092          values later, in ppc64_elf_finish_dynamic_sections, but we
9093          must add the entries now so that we get the correct size for
9094          the .dynamic section.  The DT_DEBUG entry is filled in by the
9095          dynamic linker and used by the debugger.  */
9096 #define add_dynamic_entry(TAG, VAL) \
9097   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9098
9099       if (info->executable)
9100         {
9101           if (!add_dynamic_entry (DT_DEBUG, 0))
9102             return FALSE;
9103         }
9104
9105       if (htab->plt != NULL && htab->plt->size != 0)
9106         {
9107           if (!add_dynamic_entry (DT_PLTGOT, 0)
9108               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9109               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9110               || !add_dynamic_entry (DT_JMPREL, 0)
9111               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9112             return FALSE;
9113         }
9114
9115       if (NO_OPD_RELOCS)
9116         {
9117           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9118               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9119             return FALSE;
9120         }
9121
9122       if (!htab->no_tls_get_addr_opt
9123           && htab->tls_get_addr_fd != NULL
9124           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9125           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9126         return FALSE;
9127
9128       if (relocs)
9129         {
9130           if (!add_dynamic_entry (DT_RELA, 0)
9131               || !add_dynamic_entry (DT_RELASZ, 0)
9132               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9133             return FALSE;
9134
9135           /* If any dynamic relocs apply to a read-only section,
9136              then we need a DT_TEXTREL entry.  */
9137           if ((info->flags & DF_TEXTREL) == 0)
9138             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9139
9140           if ((info->flags & DF_TEXTREL) != 0)
9141             {
9142               if (!add_dynamic_entry (DT_TEXTREL, 0))
9143                 return FALSE;
9144             }
9145         }
9146     }
9147 #undef add_dynamic_entry
9148
9149   return TRUE;
9150 }
9151
9152 /* Determine the type of stub needed, if any, for a call.  */
9153
9154 static inline enum ppc_stub_type
9155 ppc_type_of_stub (asection *input_sec,
9156                   const Elf_Internal_Rela *rel,
9157                   struct ppc_link_hash_entry **hash,
9158                   struct plt_entry **plt_ent,
9159                   bfd_vma destination)
9160 {
9161   struct ppc_link_hash_entry *h = *hash;
9162   bfd_vma location;
9163   bfd_vma branch_offset;
9164   bfd_vma max_branch_offset;
9165   enum elf_ppc64_reloc_type r_type;
9166
9167   if (h != NULL)
9168     {
9169       struct plt_entry *ent;
9170       struct ppc_link_hash_entry *fdh = h;
9171       if (h->oh != NULL
9172           && h->oh->is_func_descriptor)
9173         {
9174           fdh = ppc_follow_link (h->oh);
9175           *hash = fdh;
9176         }
9177
9178       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9179         if (ent->addend == rel->r_addend
9180             && ent->plt.offset != (bfd_vma) -1)
9181           {
9182             *plt_ent = ent;
9183             return ppc_stub_plt_call;
9184           }
9185
9186       /* Here, we know we don't have a plt entry.  If we don't have a
9187          either a defined function descriptor or a defined entry symbol
9188          in a regular object file, then it is pointless trying to make
9189          any other type of stub.  */
9190       if (!is_static_defined (&fdh->elf)
9191           && !is_static_defined (&h->elf))
9192         return ppc_stub_none;
9193     }
9194   else if (elf_local_got_ents (input_sec->owner) != NULL)
9195     {
9196       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9197       struct plt_entry **local_plt = (struct plt_entry **)
9198         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9199       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9200
9201       if (local_plt[r_symndx] != NULL)
9202         {
9203           struct plt_entry *ent;
9204
9205           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9206             if (ent->addend == rel->r_addend
9207                 && ent->plt.offset != (bfd_vma) -1)
9208               {
9209                 *plt_ent = ent;
9210                 return ppc_stub_plt_call;
9211               }
9212         }
9213     }
9214
9215   /* Determine where the call point is.  */
9216   location = (input_sec->output_offset
9217               + input_sec->output_section->vma
9218               + rel->r_offset);
9219
9220   branch_offset = destination - location;
9221   r_type = ELF64_R_TYPE (rel->r_info);
9222
9223   /* Determine if a long branch stub is needed.  */
9224   max_branch_offset = 1 << 25;
9225   if (r_type != R_PPC64_REL24)
9226     max_branch_offset = 1 << 15;
9227
9228   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9229     /* We need a stub.  Figure out whether a long_branch or plt_branch
9230        is needed later.  */
9231     return ppc_stub_long_branch;
9232
9233   return ppc_stub_none;
9234 }
9235
9236 /* Build a .plt call stub.  */
9237
9238 static inline bfd_byte *
9239 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
9240 {
9241 #define PPC_LO(v) ((v) & 0xffff)
9242 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9243 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9244
9245   if (PPC_HA (offset) != 0)
9246     {
9247       if (r != NULL)
9248         {
9249           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9250           r[1].r_offset = r[0].r_offset + 8;
9251           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9252           r[1].r_addend = r[0].r_addend;
9253           if (PPC_HA (offset + 16) != PPC_HA (offset))
9254             {
9255               r[2].r_offset = r[1].r_offset + 4;
9256               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9257               r[2].r_addend = r[0].r_addend;
9258             }
9259           else
9260             {
9261               r[2].r_offset = r[1].r_offset + 8;
9262               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9263               r[2].r_addend = r[0].r_addend + 8;
9264               r[3].r_offset = r[2].r_offset + 4;
9265               r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9266               r[3].r_addend = r[0].r_addend + 16;
9267             }
9268         }
9269       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9270       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9271       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9272       if (PPC_HA (offset + 16) != PPC_HA (offset))
9273         {
9274           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9275           offset = 0;
9276         }
9277       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9278       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9279       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9280       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9281     }
9282   else
9283     {
9284       if (r != NULL)
9285         {
9286           r[0].r_offset += 4;
9287           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9288           if (PPC_HA (offset + 16) != PPC_HA (offset))
9289             {
9290               r[1].r_offset = r[0].r_offset + 4;
9291               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9292               r[1].r_addend = r[0].r_addend;
9293             }
9294           else
9295             {
9296               r[1].r_offset = r[0].r_offset + 8;
9297               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9298               r[1].r_addend = r[0].r_addend + 16;
9299               r[2].r_offset = r[1].r_offset + 4;
9300               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9301               r[2].r_addend = r[0].r_addend + 8;
9302             }
9303         }
9304       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9305       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9306       if (PPC_HA (offset + 16) != PPC_HA (offset))
9307         {
9308           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9309           offset = 0;
9310         }
9311       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9312       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
9313       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9314       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9315     }
9316   return p;
9317 }
9318
9319 /* Build a special .plt call stub for __tls_get_addr.  */
9320
9321 #define LD_R11_0R3      0xe9630000
9322 #define LD_R12_0R3      0xe9830000
9323 #define MR_R0_R3        0x7c601b78
9324 #define CMPDI_R11_0     0x2c2b0000
9325 #define ADD_R3_R12_R13  0x7c6c6a14
9326 #define BEQLR           0x4d820020
9327 #define MR_R3_R0        0x7c030378
9328 #define MFLR_R11        0x7d6802a6
9329 #define STD_R11_0R1     0xf9610000
9330 #define BCTRL           0x4e800421
9331 #define LD_R11_0R1      0xe9610000
9332 #define LD_R2_0R1       0xe8410000
9333 #define MTLR_R11        0x7d6803a6
9334
9335 static inline bfd_byte *
9336 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9337                          Elf_Internal_Rela *r)
9338 {
9339   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9340   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9341   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9342   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9343   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9344   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9345   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9346   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9347   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9348
9349   if (r != NULL)
9350     r[0].r_offset += 9 * 4;
9351   p = build_plt_stub (obfd, p, offset, r);
9352   bfd_put_32 (obfd, BCTRL, p - 4);
9353
9354   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9355   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9356   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9357   bfd_put_32 (obfd, BLR, p),                    p += 4;
9358
9359   return p;
9360 }
9361
9362 static Elf_Internal_Rela *
9363 get_relocs (asection *sec, int count)
9364 {
9365   Elf_Internal_Rela *relocs;
9366   struct bfd_elf_section_data *elfsec_data;
9367
9368   elfsec_data = elf_section_data (sec);
9369   relocs = elfsec_data->relocs;
9370   if (relocs == NULL)
9371     {
9372       bfd_size_type relsize;
9373       relsize = sec->reloc_count * sizeof (*relocs);
9374       relocs = bfd_alloc (sec->owner, relsize);
9375       if (relocs == NULL)
9376         return NULL;
9377       elfsec_data->relocs = relocs;
9378       elfsec_data->rel_hdr.sh_size = (sec->reloc_count
9379                                       * sizeof (Elf64_External_Rela));
9380       elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
9381       sec->reloc_count = 0;
9382     }
9383   relocs += sec->reloc_count;
9384   sec->reloc_count += count;
9385   return relocs;
9386 }
9387
9388 static bfd_boolean
9389 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9390 {
9391   struct ppc_stub_hash_entry *stub_entry;
9392   struct ppc_branch_hash_entry *br_entry;
9393   struct bfd_link_info *info;
9394   struct ppc_link_hash_table *htab;
9395   bfd_byte *loc;
9396   bfd_byte *p;
9397   bfd_vma dest, off;
9398   int size;
9399   Elf_Internal_Rela *r;
9400   asection *plt;
9401
9402   /* Massage our args to the form they really have.  */
9403   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9404   info = in_arg;
9405
9406   htab = ppc_hash_table (info);
9407   if (htab == NULL)
9408     return FALSE;
9409
9410   /* Make a note of the offset within the stubs for this entry.  */
9411   stub_entry->stub_offset = stub_entry->stub_sec->size;
9412   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9413
9414   htab->stub_count[stub_entry->stub_type - 1] += 1;
9415   switch (stub_entry->stub_type)
9416     {
9417     case ppc_stub_long_branch:
9418     case ppc_stub_long_branch_r2off:
9419       /* Branches are relative.  This is where we are going to.  */
9420       off = dest = (stub_entry->target_value
9421                     + stub_entry->target_section->output_offset
9422                     + stub_entry->target_section->output_section->vma);
9423
9424       /* And this is where we are coming from.  */
9425       off -= (stub_entry->stub_offset
9426               + stub_entry->stub_sec->output_offset
9427               + stub_entry->stub_sec->output_section->vma);
9428
9429       size = 4;
9430       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9431         {
9432           bfd_vma r2off;
9433
9434           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9435                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9436           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9437           loc += 4;
9438           size = 12;
9439           if (PPC_HA (r2off) != 0)
9440             {
9441               size = 16;
9442               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9443               loc += 4;
9444             }
9445           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9446           loc += 4;
9447           off -= size - 4;
9448         }
9449       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9450
9451       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9452         {
9453           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9454                                  stub_entry->root.string);
9455           htab->stub_error = TRUE;
9456           return FALSE;
9457         }
9458
9459       if (info->emitrelocations)
9460         {
9461           r = get_relocs (stub_entry->stub_sec, 1);
9462           if (r == NULL)
9463             return FALSE;
9464           r->r_offset = loc - stub_entry->stub_sec->contents;
9465           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9466           r->r_addend = dest;
9467           if (stub_entry->h != NULL)
9468             {
9469               struct elf_link_hash_entry **hashes;
9470               unsigned long symndx;
9471               struct ppc_link_hash_entry *h;
9472
9473               hashes = elf_sym_hashes (htab->stub_bfd);
9474               if (hashes == NULL)
9475                 {
9476                   bfd_size_type hsize;
9477
9478                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9479                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9480                   if (hashes == NULL)
9481                     return FALSE;
9482                   elf_sym_hashes (htab->stub_bfd) = hashes;
9483                   htab->stub_globals = 1;
9484                 }
9485               symndx = htab->stub_globals++;
9486               h = stub_entry->h;
9487               hashes[symndx] = &h->elf;
9488               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9489               if (h->oh != NULL && h->oh->is_func)
9490                 h = ppc_follow_link (h->oh);
9491               if (h->elf.root.u.def.section != stub_entry->target_section)
9492                 /* H is an opd symbol.  The addend must be zero.  */
9493                 r->r_addend = 0;
9494               else
9495                 {
9496                   off = (h->elf.root.u.def.value
9497                          + h->elf.root.u.def.section->output_offset
9498                          + h->elf.root.u.def.section->output_section->vma);
9499                   r->r_addend -= off;
9500                 }
9501             }
9502         }
9503       break;
9504
9505     case ppc_stub_plt_branch:
9506     case ppc_stub_plt_branch_r2off:
9507       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9508                                          stub_entry->root.string + 9,
9509                                          FALSE, FALSE);
9510       if (br_entry == NULL)
9511         {
9512           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9513                                  stub_entry->root.string);
9514           htab->stub_error = TRUE;
9515           return FALSE;
9516         }
9517
9518       dest = (stub_entry->target_value
9519               + stub_entry->target_section->output_offset
9520               + stub_entry->target_section->output_section->vma);
9521
9522       bfd_put_64 (htab->brlt->owner, dest,
9523                   htab->brlt->contents + br_entry->offset);
9524
9525       if (br_entry->iter == htab->stub_iteration)
9526         {
9527           br_entry->iter = 0;
9528
9529           if (htab->relbrlt != NULL)
9530             {
9531               /* Create a reloc for the branch lookup table entry.  */
9532               Elf_Internal_Rela rela;
9533               bfd_byte *rl;
9534
9535               rela.r_offset = (br_entry->offset
9536                                + htab->brlt->output_offset
9537                                + htab->brlt->output_section->vma);
9538               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9539               rela.r_addend = dest;
9540
9541               rl = htab->relbrlt->contents;
9542               rl += (htab->relbrlt->reloc_count++
9543                      * sizeof (Elf64_External_Rela));
9544               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9545             }
9546           else if (info->emitrelocations)
9547             {
9548               r = get_relocs (htab->brlt, 1);
9549               if (r == NULL)
9550                 return FALSE;
9551               /* brlt, being SEC_LINKER_CREATED does not go through the
9552                  normal reloc processing.  Symbols and offsets are not
9553                  translated from input file to output file form, so
9554                  set up the offset per the output file.  */
9555               r->r_offset = (br_entry->offset
9556                              + htab->brlt->output_offset
9557                              + htab->brlt->output_section->vma);
9558               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9559               r->r_addend = dest;
9560             }
9561         }
9562
9563       dest = (br_entry->offset
9564               + htab->brlt->output_offset
9565               + htab->brlt->output_section->vma);
9566
9567       off = (dest
9568              - elf_gp (htab->brlt->output_section->owner)
9569              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9570
9571       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9572         {
9573           (*_bfd_error_handler)
9574             (_("linkage table error against `%s'"),
9575              stub_entry->root.string);
9576           bfd_set_error (bfd_error_bad_value);
9577           htab->stub_error = TRUE;
9578           return FALSE;
9579         }
9580
9581       if (info->emitrelocations)
9582         {
9583           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9584           if (r == NULL)
9585             return FALSE;
9586           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9587           if (bfd_big_endian (info->output_bfd))
9588             r[0].r_offset += 2;
9589           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9590             r[0].r_offset += 4;
9591           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9592           r[0].r_addend = dest;
9593           if (PPC_HA (off) != 0)
9594             {
9595               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9596               r[1].r_offset = r[0].r_offset + 4;
9597               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9598               r[1].r_addend = r[0].r_addend;
9599             }
9600         }
9601
9602       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9603         {
9604           if (PPC_HA (off) != 0)
9605             {
9606               size = 16;
9607               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9608               loc += 4;
9609               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9610             }
9611           else
9612             {
9613               size = 12;
9614               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9615             }
9616         }
9617       else
9618         {
9619           bfd_vma r2off;
9620
9621           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9622                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9623           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9624           loc += 4;
9625           size = 20;
9626           if (PPC_HA (off) != 0)
9627             {
9628               size += 4;
9629               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9630               loc += 4;
9631               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9632               loc += 4;
9633             }
9634           else
9635             {
9636               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9637               loc += 4;
9638             }
9639
9640           if (PPC_HA (r2off) != 0)
9641             {
9642               size += 4;
9643               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9644               loc += 4;
9645             }
9646           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9647         }
9648       loc += 4;
9649       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9650       loc += 4;
9651       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9652       break;
9653
9654     case ppc_stub_plt_call:
9655       if (stub_entry->h != NULL
9656           && stub_entry->h->is_func_descriptor
9657           && stub_entry->h->oh != NULL)
9658         {
9659           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9660
9661           /* If the old-ABI "dot-symbol" is undefined make it weak so
9662              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9663              FIXME: We used to define the symbol on one of the call
9664              stubs instead, which is why we test symbol section id
9665              against htab->top_id in various places.  Likely all
9666              these checks could now disappear.  */
9667           if (fh->elf.root.type == bfd_link_hash_undefined)
9668             fh->elf.root.type = bfd_link_hash_undefweak;
9669         }
9670
9671       /* Now build the stub.  */
9672       dest = stub_entry->plt_ent->plt.offset & ~1;
9673       if (dest >= (bfd_vma) -2)
9674         abort ();
9675
9676       plt = htab->plt;
9677       if (!htab->elf.dynamic_sections_created
9678           || stub_entry->h == NULL
9679           || stub_entry->h->elf.dynindx == -1)
9680         plt = htab->iplt;
9681
9682       dest += plt->output_offset + plt->output_section->vma;
9683
9684       if (stub_entry->h == NULL
9685           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9686         {
9687           Elf_Internal_Rela rela;
9688           bfd_byte *rl;
9689
9690           rela.r_offset = dest;
9691           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9692           rela.r_addend = (stub_entry->target_value
9693                            + stub_entry->target_section->output_offset
9694                            + stub_entry->target_section->output_section->vma);
9695
9696           rl = (htab->reliplt->contents
9697                 + (htab->reliplt->reloc_count++
9698                    * sizeof (Elf64_External_Rela)));
9699           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9700           stub_entry->plt_ent->plt.offset |= 1;
9701         }
9702
9703       off = (dest
9704              - elf_gp (plt->output_section->owner)
9705              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9706
9707       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9708         {
9709           (*_bfd_error_handler)
9710             (_("linkage table error against `%s'"),
9711              stub_entry->h != NULL
9712              ? stub_entry->h->elf.root.root.string
9713              : "<local sym>");
9714           bfd_set_error (bfd_error_bad_value);
9715           htab->stub_error = TRUE;
9716           return FALSE;
9717         }
9718
9719       r = NULL;
9720       if (info->emitrelocations)
9721         {
9722           r = get_relocs (stub_entry->stub_sec,
9723                           (2 + (PPC_HA (off) != 0)
9724                            + (PPC_HA (off + 16) == PPC_HA (off))));
9725           if (r == NULL)
9726             return FALSE;
9727           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9728           if (bfd_big_endian (info->output_bfd))
9729             r[0].r_offset += 2;
9730           r[0].r_addend = dest;
9731         }
9732       if (stub_entry->h != NULL
9733           && (stub_entry->h == htab->tls_get_addr_fd
9734               || stub_entry->h == htab->tls_get_addr)
9735           && !htab->no_tls_get_addr_opt)
9736         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9737       else
9738         p = build_plt_stub (htab->stub_bfd, loc, off, r);
9739       size = p - loc;
9740       break;
9741
9742     default:
9743       BFD_FAIL ();
9744       return FALSE;
9745     }
9746
9747   stub_entry->stub_sec->size += size;
9748
9749   if (htab->emit_stub_syms)
9750     {
9751       struct elf_link_hash_entry *h;
9752       size_t len1, len2;
9753       char *name;
9754       const char *const stub_str[] = { "long_branch",
9755                                        "long_branch_r2off",
9756                                        "plt_branch",
9757                                        "plt_branch_r2off",
9758                                        "plt_call" };
9759
9760       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9761       len2 = strlen (stub_entry->root.string);
9762       name = bfd_malloc (len1 + len2 + 2);
9763       if (name == NULL)
9764         return FALSE;
9765       memcpy (name, stub_entry->root.string, 9);
9766       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9767       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9768       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9769       if (h == NULL)
9770         return FALSE;
9771       if (h->root.type == bfd_link_hash_new)
9772         {
9773           h->root.type = bfd_link_hash_defined;
9774           h->root.u.def.section = stub_entry->stub_sec;
9775           h->root.u.def.value = stub_entry->stub_offset;
9776           h->ref_regular = 1;
9777           h->def_regular = 1;
9778           h->ref_regular_nonweak = 1;
9779           h->forced_local = 1;
9780           h->non_elf = 0;
9781         }
9782     }
9783
9784   return TRUE;
9785 }
9786
9787 /* As above, but don't actually build the stub.  Just bump offset so
9788    we know stub section sizes, and select plt_branch stubs where
9789    long_branch stubs won't do.  */
9790
9791 static bfd_boolean
9792 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9793 {
9794   struct ppc_stub_hash_entry *stub_entry;
9795   struct bfd_link_info *info;
9796   struct ppc_link_hash_table *htab;
9797   bfd_vma off;
9798   int size;
9799
9800   /* Massage our args to the form they really have.  */
9801   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9802   info = in_arg;
9803
9804   htab = ppc_hash_table (info);
9805   if (htab == NULL)
9806     return FALSE;
9807
9808   if (stub_entry->stub_type == ppc_stub_plt_call)
9809     {
9810       asection *plt;
9811       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9812       if (off >= (bfd_vma) -2)
9813         abort ();
9814       plt = htab->plt;
9815       if (!htab->elf.dynamic_sections_created
9816           || stub_entry->h == NULL
9817           || stub_entry->h->elf.dynindx == -1)
9818         plt = htab->iplt;
9819       off += (plt->output_offset
9820               + plt->output_section->vma
9821               - elf_gp (plt->output_section->owner)
9822               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9823
9824       size = PLT_CALL_STUB_SIZE;
9825       if (PPC_HA (off) == 0)
9826         size -= 4;
9827       if (PPC_HA (off + 16) != PPC_HA (off))
9828         size += 4;
9829       if (stub_entry->h != NULL
9830           && (stub_entry->h == htab->tls_get_addr_fd
9831               || stub_entry->h == htab->tls_get_addr)
9832           && !htab->no_tls_get_addr_opt)
9833         size += 13 * 4;
9834       if (info->emitrelocations)
9835         {
9836           stub_entry->stub_sec->reloc_count
9837             += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9838           stub_entry->stub_sec->flags |= SEC_RELOC;
9839         }
9840     }
9841   else
9842     {
9843       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9844          variants.  */
9845       bfd_vma r2off = 0;
9846
9847       off = (stub_entry->target_value
9848              + stub_entry->target_section->output_offset
9849              + stub_entry->target_section->output_section->vma);
9850       off -= (stub_entry->stub_sec->size
9851               + stub_entry->stub_sec->output_offset
9852               + stub_entry->stub_sec->output_section->vma);
9853
9854       /* Reset the stub type from the plt variant in case we now
9855          can reach with a shorter stub.  */
9856       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9857         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9858
9859       size = 4;
9860       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9861         {
9862           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9863                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9864           size = 12;
9865           if (PPC_HA (r2off) != 0)
9866             size = 16;
9867           off -= size - 4;
9868         }
9869
9870       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9871       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9872         {
9873           struct ppc_branch_hash_entry *br_entry;
9874
9875           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9876                                              stub_entry->root.string + 9,
9877                                              TRUE, FALSE);
9878           if (br_entry == NULL)
9879             {
9880               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9881                                      stub_entry->root.string);
9882               htab->stub_error = TRUE;
9883               return FALSE;
9884             }
9885
9886           if (br_entry->iter != htab->stub_iteration)
9887             {
9888               br_entry->iter = htab->stub_iteration;
9889               br_entry->offset = htab->brlt->size;
9890               htab->brlt->size += 8;
9891
9892               if (htab->relbrlt != NULL)
9893                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9894               else if (info->emitrelocations)
9895                 {
9896                   htab->brlt->reloc_count += 1;
9897                   htab->brlt->flags |= SEC_RELOC;
9898                 }
9899             }
9900
9901           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9902           off = (br_entry->offset
9903                  + htab->brlt->output_offset
9904                  + htab->brlt->output_section->vma
9905                  - elf_gp (htab->brlt->output_section->owner)
9906                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
9907
9908           if (info->emitrelocations)
9909             {
9910               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9911               stub_entry->stub_sec->flags |= SEC_RELOC;
9912             }
9913
9914           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9915             {
9916               size = 12;
9917               if (PPC_HA (off) != 0)
9918                 size = 16;
9919             }
9920           else
9921             {
9922               size = 20;
9923               if (PPC_HA (off) != 0)
9924                 size += 4;
9925
9926               if (PPC_HA (r2off) != 0)
9927                 size += 4;
9928             }
9929         }
9930       else if (info->emitrelocations)
9931         {
9932           stub_entry->stub_sec->reloc_count += 1;
9933           stub_entry->stub_sec->flags |= SEC_RELOC;
9934         }
9935     }
9936
9937   stub_entry->stub_sec->size += size;
9938   return TRUE;
9939 }
9940
9941 /* Set up various things so that we can make a list of input sections
9942    for each output section included in the link.  Returns -1 on error,
9943    0 when no stubs will be needed, and 1 on success.  */
9944
9945 int
9946 ppc64_elf_setup_section_lists
9947   (struct bfd_link_info *info,
9948    asection *(*add_stub_section) (const char *, asection *),
9949    void (*layout_sections_again) (void))
9950 {
9951   bfd *input_bfd;
9952   int top_id, top_index, id;
9953   asection *section;
9954   asection **input_list;
9955   bfd_size_type amt;
9956   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9957
9958   if (htab == NULL)
9959     return -1;
9960   /* Stash our params away.  */
9961   htab->add_stub_section = add_stub_section;
9962   htab->layout_sections_again = layout_sections_again;
9963
9964   if (htab->brlt == NULL)
9965     return 0;
9966
9967   /* Find the top input section id.  */
9968   for (input_bfd = info->input_bfds, top_id = 3;
9969        input_bfd != NULL;
9970        input_bfd = input_bfd->link_next)
9971     {
9972       for (section = input_bfd->sections;
9973            section != NULL;
9974            section = section->next)
9975         {
9976           if (top_id < section->id)
9977             top_id = section->id;
9978         }
9979     }
9980
9981   htab->top_id = top_id;
9982   amt = sizeof (struct map_stub) * (top_id + 1);
9983   htab->stub_group = bfd_zmalloc (amt);
9984   if (htab->stub_group == NULL)
9985     return -1;
9986
9987   /* Set toc_off for com, und, abs and ind sections.  */
9988   for (id = 0; id < 3; id++)
9989     htab->stub_group[id].toc_off = TOC_BASE_OFF;
9990
9991   /* We can't use output_bfd->section_count here to find the top output
9992      section index as some sections may have been removed, and
9993      strip_excluded_output_sections doesn't renumber the indices.  */
9994   for (section = info->output_bfd->sections, top_index = 0;
9995        section != NULL;
9996        section = section->next)
9997     {
9998       if (top_index < section->index)
9999         top_index = section->index;
10000     }
10001
10002   htab->top_index = top_index;
10003   amt = sizeof (asection *) * (top_index + 1);
10004   input_list = bfd_zmalloc (amt);
10005   htab->input_list = input_list;
10006   if (input_list == NULL)
10007     return -1;
10008
10009   return 1;
10010 }
10011
10012 /* Set up for first pass at multitoc partitioning.  */
10013
10014 void
10015 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10016 {
10017   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10018
10019   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10020   htab->toc_curr = elf_gp (info->output_bfd);
10021   htab->toc_bfd = NULL;
10022   htab->toc_first_sec = NULL;
10023 }
10024
10025 /* The linker repeatedly calls this function for each TOC input section
10026    and linker generated GOT section.  Group input bfds such that the toc
10027    within a group is less than 64k in size.  */
10028
10029 bfd_boolean
10030 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10031 {
10032   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10033   bfd_vma addr, off, limit;
10034
10035   if (htab == NULL)
10036     return FALSE;
10037
10038   if (!htab->second_toc_pass)
10039     {
10040       /* Keep track of the first .toc or .got section for this input bfd.  */
10041       if (htab->toc_bfd != isec->owner)
10042         {
10043           htab->toc_bfd = isec->owner;
10044           htab->toc_first_sec = isec;
10045         }
10046
10047       addr = isec->output_offset + isec->output_section->vma;
10048       off = addr - htab->toc_curr;
10049       limit = 0x80008000;
10050       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10051         limit = 0x10000;
10052       if (off + isec->size > limit)
10053         {
10054           addr = (htab->toc_first_sec->output_offset
10055                   + htab->toc_first_sec->output_section->vma);
10056           htab->toc_curr = addr;
10057         }
10058
10059       /* toc_curr is the base address of this toc group.  Set elf_gp
10060          for the input section to be the offset relative to the
10061          output toc base plus 0x8000.  Making the input elf_gp an
10062          offset allows us to move the toc as a whole without
10063          recalculating input elf_gp.  */
10064       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10065       off += TOC_BASE_OFF;
10066
10067       /* Die if someone uses a linker script that doesn't keep input
10068          file .toc and .got together.  */
10069       if (elf_gp (isec->owner) != 0
10070           && elf_gp (isec->owner) != off)
10071         return FALSE;
10072
10073       elf_gp (isec->owner) = off;
10074       return TRUE;
10075     }
10076
10077   /* During the second pass toc_first_sec points to the start of
10078      a toc group, and toc_curr is used to track the old elf_gp.
10079      We use toc_bfd to ensure we only look at each bfd once.  */
10080   if (htab->toc_bfd == isec->owner)
10081     return TRUE;
10082   htab->toc_bfd = isec->owner;
10083
10084   if (htab->toc_first_sec == NULL
10085       || htab->toc_curr != elf_gp (isec->owner))
10086     {
10087       htab->toc_curr = elf_gp (isec->owner);
10088       htab->toc_first_sec = isec;
10089     }
10090   addr = (htab->toc_first_sec->output_offset
10091           + htab->toc_first_sec->output_section->vma);
10092   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10093   elf_gp (isec->owner) = off;
10094
10095   return TRUE;
10096 }
10097
10098 /* Called via elf_link_hash_traverse to merge GOT entries for global
10099    symbol H.  */
10100
10101 static bfd_boolean
10102 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10103 {
10104   if (h->root.type == bfd_link_hash_indirect)
10105     return TRUE;
10106
10107   if (h->root.type == bfd_link_hash_warning)
10108     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10109
10110   merge_got_entries (&h->got.glist);
10111
10112   return TRUE;
10113 }
10114
10115 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10116    symbol H.  */
10117
10118 static bfd_boolean
10119 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10120 {
10121   struct got_entry *gent;
10122
10123   if (h->root.type == bfd_link_hash_indirect)
10124     return TRUE;
10125
10126   if (h->root.type == bfd_link_hash_warning)
10127     h = (struct elf_link_hash_entry *) h->root.u.i.link;
10128
10129   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10130     if (!gent->is_indirect)
10131       allocate_got (h, (struct bfd_link_info *) inf, gent);
10132   return TRUE;
10133 }
10134
10135 /* Called on the first multitoc pass after the last call to
10136    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10137    entries.  */
10138
10139 bfd_boolean
10140 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10141 {
10142   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10143   struct bfd *ibfd, *ibfd2;
10144   bfd_boolean done_something;
10145
10146   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10147
10148   if (!htab->do_multi_toc)
10149     return FALSE;
10150
10151   /* Merge global sym got entries within a toc group.  */
10152   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10153
10154   /* And tlsld_got.  */
10155   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10156     {
10157       struct got_entry *ent, *ent2;
10158
10159       if (!is_ppc64_elf (ibfd))
10160         continue;
10161
10162       ent = ppc64_tlsld_got (ibfd);
10163       if (!ent->is_indirect
10164           && ent->got.offset != (bfd_vma) -1)
10165         {
10166           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10167             {
10168               if (!is_ppc64_elf (ibfd2))
10169                 continue;
10170
10171               ent2 = ppc64_tlsld_got (ibfd2);
10172               if (!ent2->is_indirect
10173                   && ent2->got.offset != (bfd_vma) -1
10174                   && elf_gp (ibfd2) == elf_gp (ibfd))
10175                 {
10176                   ent2->is_indirect = TRUE;
10177                   ent2->got.ent = ent;
10178                 }
10179             }
10180         }
10181     }
10182
10183   /* Zap sizes of got sections.  */
10184   htab->reliplt->rawsize = htab->reliplt->size;
10185   htab->reliplt->size -= htab->got_reli_size;
10186   htab->got_reli_size = 0;
10187
10188   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10189     {
10190       asection *got, *relgot;
10191
10192       if (!is_ppc64_elf (ibfd))
10193         continue;
10194
10195       got = ppc64_elf_tdata (ibfd)->got;
10196       if (got != NULL)
10197         {
10198           got->rawsize = got->size;
10199           got->size = 0;
10200           relgot = ppc64_elf_tdata (ibfd)->relgot;
10201           relgot->rawsize = relgot->size;
10202           relgot->size = 0;
10203         }
10204     }
10205
10206   /* Now reallocate the got, local syms first.  We don't need to
10207      allocate section contents again since we never increase size.  */
10208   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10209     {
10210       struct got_entry **lgot_ents;
10211       struct got_entry **end_lgot_ents;
10212       struct plt_entry **local_plt;
10213       struct plt_entry **end_local_plt;
10214       unsigned char *lgot_masks;
10215       bfd_size_type locsymcount;
10216       Elf_Internal_Shdr *symtab_hdr;
10217       asection *s, *srel;
10218
10219       if (!is_ppc64_elf (ibfd))
10220         continue;
10221
10222       lgot_ents = elf_local_got_ents (ibfd);
10223       if (!lgot_ents)
10224         continue;
10225
10226       symtab_hdr = &elf_symtab_hdr (ibfd);
10227       locsymcount = symtab_hdr->sh_info;
10228       end_lgot_ents = lgot_ents + locsymcount;
10229       local_plt = (struct plt_entry **) end_lgot_ents;
10230       end_local_plt = local_plt + locsymcount;
10231       lgot_masks = (unsigned char *) end_local_plt;
10232       s = ppc64_elf_tdata (ibfd)->got;
10233       srel = ppc64_elf_tdata (ibfd)->relgot;
10234       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10235         {
10236           struct got_entry *ent;
10237
10238           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10239             {
10240               unsigned int num = 1;
10241               ent->got.offset = s->size;
10242               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10243                 num = 2;
10244               s->size += num * 8;
10245               if (info->shared)
10246                 srel->size += num * sizeof (Elf64_External_Rela);
10247               else if ((*lgot_masks & PLT_IFUNC) != 0)
10248                 {
10249                   htab->reliplt->size
10250                     += num * sizeof (Elf64_External_Rela);
10251                   htab->got_reli_size
10252                     += num * sizeof (Elf64_External_Rela);
10253                 }
10254             }
10255         }
10256     }
10257
10258   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10259
10260   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10261     {
10262       struct got_entry *ent;
10263
10264       if (!is_ppc64_elf (ibfd))
10265         continue;
10266
10267       ent = ppc64_tlsld_got (ibfd);
10268       if (!ent->is_indirect
10269           && ent->got.offset != (bfd_vma) -1)
10270         {
10271           asection *s = ppc64_elf_tdata (ibfd)->got;
10272           ent->got.offset = s->size;
10273           s->size += 16;
10274           if (info->shared)
10275             {
10276               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10277               srel->size += sizeof (Elf64_External_Rela);
10278             }
10279         }
10280     }
10281
10282   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10283   if (!done_something)
10284     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10285       {
10286         asection *got;
10287
10288         if (!is_ppc64_elf (ibfd))
10289           continue;
10290
10291         got = ppc64_elf_tdata (ibfd)->got;
10292         if (got != NULL)
10293           {
10294             done_something = got->rawsize != got->size;
10295             if (done_something)
10296               break;
10297           }
10298       }
10299
10300   if (done_something)
10301     (*htab->layout_sections_again) ();
10302
10303   /* Set up for second pass over toc sections to recalculate elf_gp
10304      on input sections.  */
10305   htab->toc_bfd = NULL;
10306   htab->toc_first_sec = NULL;
10307   htab->second_toc_pass = TRUE;
10308   return done_something;
10309 }
10310
10311 /* Called after second pass of multitoc partitioning.  */
10312
10313 void
10314 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10315 {
10316   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10317
10318   /* After the second pass, toc_curr tracks the TOC offset used
10319      for code sections below in ppc64_elf_next_input_section.  */
10320   htab->toc_curr = TOC_BASE_OFF;
10321 }
10322
10323 /* No toc references were found in ISEC.  If the code in ISEC makes no
10324    calls, then there's no need to use toc adjusting stubs when branching
10325    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10326    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10327    needed, and 2 if a cyclical call-graph was found but no other reason
10328    for a stub was detected.  If called from the top level, a return of
10329    2 means the same as a return of 0.  */
10330
10331 static int
10332 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10333 {
10334   int ret;
10335
10336   /* Mark this section as checked.  */
10337   isec->call_check_done = 1;
10338
10339   /* We know none of our code bearing sections will need toc stubs.  */
10340   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10341     return 0;
10342
10343   if (isec->size == 0)
10344     return 0;
10345
10346   if (isec->output_section == NULL)
10347     return 0;
10348
10349   ret = 0;
10350   if (isec->reloc_count != 0)
10351     {
10352       Elf_Internal_Rela *relstart, *rel;
10353       Elf_Internal_Sym *local_syms;
10354       struct ppc_link_hash_table *htab;
10355
10356       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10357                                             info->keep_memory);
10358       if (relstart == NULL)
10359         return -1;
10360
10361       /* Look for branches to outside of this section.  */
10362       local_syms = NULL;
10363       htab = ppc_hash_table (info);
10364       if (htab == NULL)
10365         return -1;
10366
10367       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10368         {
10369           enum elf_ppc64_reloc_type r_type;
10370           unsigned long r_symndx;
10371           struct elf_link_hash_entry *h;
10372           struct ppc_link_hash_entry *eh;
10373           Elf_Internal_Sym *sym;
10374           asection *sym_sec;
10375           struct _opd_sec_data *opd;
10376           bfd_vma sym_value;
10377           bfd_vma dest;
10378
10379           r_type = ELF64_R_TYPE (rel->r_info);
10380           if (r_type != R_PPC64_REL24
10381               && r_type != R_PPC64_REL14
10382               && r_type != R_PPC64_REL14_BRTAKEN
10383               && r_type != R_PPC64_REL14_BRNTAKEN)
10384             continue;
10385
10386           r_symndx = ELF64_R_SYM (rel->r_info);
10387           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10388                           isec->owner))
10389             {
10390               ret = -1;
10391               break;
10392             }
10393
10394           /* Calls to dynamic lib functions go through a plt call stub
10395              that uses r2.  */
10396           eh = (struct ppc_link_hash_entry *) h;
10397           if (eh != NULL
10398               && (eh->elf.plt.plist != NULL
10399                   || (eh->oh != NULL
10400                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10401             {
10402               ret = 1;
10403               break;
10404             }
10405
10406           if (sym_sec == NULL)
10407             /* Ignore other undefined symbols.  */
10408             continue;
10409
10410           /* Assume branches to other sections not included in the
10411              link need stubs too, to cover -R and absolute syms.  */
10412           if (sym_sec->output_section == NULL)
10413             {
10414               ret = 1;
10415               break;
10416             }
10417
10418           if (h == NULL)
10419             sym_value = sym->st_value;
10420           else
10421             {
10422               if (h->root.type != bfd_link_hash_defined
10423                   && h->root.type != bfd_link_hash_defweak)
10424                 abort ();
10425               sym_value = h->root.u.def.value;
10426             }
10427           sym_value += rel->r_addend;
10428
10429           /* If this branch reloc uses an opd sym, find the code section.  */
10430           opd = get_opd_info (sym_sec);
10431           if (opd != NULL)
10432             {
10433               if (h == NULL && opd->adjust != NULL)
10434                 {
10435                   long adjust;
10436
10437                   adjust = opd->adjust[sym->st_value / 8];
10438                   if (adjust == -1)
10439                     /* Assume deleted functions won't ever be called.  */
10440                     continue;
10441                   sym_value += adjust;
10442                 }
10443
10444               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10445               if (dest == (bfd_vma) -1)
10446                 continue;
10447             }
10448           else
10449             dest = (sym_value
10450                     + sym_sec->output_offset
10451                     + sym_sec->output_section->vma);
10452
10453           /* Ignore branch to self.  */
10454           if (sym_sec == isec)
10455             continue;
10456
10457           /* If the called function uses the toc, we need a stub.  */
10458           if (sym_sec->has_toc_reloc
10459               || sym_sec->makes_toc_func_call)
10460             {
10461               ret = 1;
10462               break;
10463             }
10464
10465           /* Assume any branch that needs a long branch stub might in fact
10466              need a plt_branch stub.  A plt_branch stub uses r2.  */
10467           else if (dest - (isec->output_offset
10468                            + isec->output_section->vma
10469                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10470             {
10471               ret = 1;
10472               break;
10473             }
10474
10475           /* If calling back to a section in the process of being
10476              tested, we can't say for sure that no toc adjusting stubs
10477              are needed, so don't return zero.  */
10478           else if (sym_sec->call_check_in_progress)
10479             ret = 2;
10480
10481           /* Branches to another section that itself doesn't have any TOC
10482              references are OK.  Recursively call ourselves to check.  */
10483           else if (!sym_sec->call_check_done)
10484             {
10485               int recur;
10486
10487               /* Mark current section as indeterminate, so that other
10488                  sections that call back to current won't be marked as
10489                  known.  */
10490               isec->call_check_in_progress = 1;
10491               recur = toc_adjusting_stub_needed (info, sym_sec);
10492               isec->call_check_in_progress = 0;
10493
10494               if (recur != 0)
10495                 {
10496                   ret = recur;
10497                   if (recur != 2)
10498                     break;
10499                 }
10500             }
10501         }
10502
10503       if (local_syms != NULL
10504           && (elf_symtab_hdr (isec->owner).contents
10505               != (unsigned char *) local_syms))
10506         free (local_syms);
10507       if (elf_section_data (isec)->relocs != relstart)
10508         free (relstart);
10509     }
10510
10511   if ((ret & 1) == 0
10512       && isec->map_head.s != NULL
10513       && (strcmp (isec->output_section->name, ".init") == 0
10514           || strcmp (isec->output_section->name, ".fini") == 0))
10515     {
10516       if (isec->map_head.s->has_toc_reloc
10517           || isec->map_head.s->makes_toc_func_call)
10518         ret = 1;
10519       else if (!isec->map_head.s->call_check_done)
10520         {
10521           int recur;
10522           isec->call_check_in_progress = 1;
10523           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10524           isec->call_check_in_progress = 0;
10525           if (recur != 0)
10526             ret = recur;
10527         }
10528     }
10529
10530   if (ret == 1)
10531     isec->makes_toc_func_call = 1;
10532
10533   return ret;
10534 }
10535
10536 /* The linker repeatedly calls this function for each input section,
10537    in the order that input sections are linked into output sections.
10538    Build lists of input sections to determine groupings between which
10539    we may insert linker stubs.  */
10540
10541 bfd_boolean
10542 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10543 {
10544   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10545
10546   if (htab == NULL)
10547     return FALSE;
10548
10549   if ((isec->output_section->flags & SEC_CODE) != 0
10550       && isec->output_section->index <= htab->top_index)
10551     {
10552       asection **list = htab->input_list + isec->output_section->index;
10553       /* Steal the link_sec pointer for our list.  */
10554 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10555       /* This happens to make the list in reverse order,
10556          which is what we want.  */
10557       PREV_SEC (isec) = *list;
10558       *list = isec;
10559     }
10560
10561   if (htab->multi_toc_needed)
10562     {
10563       /* If a code section has a function that uses the TOC then we need
10564          to use the right TOC (obviously).  Also, make sure that .opd gets
10565          the correct TOC value for R_PPC64_TOC relocs that don't have or
10566          can't find their function symbol (shouldn't ever happen now).
10567          Also specially treat .fixup for the linux kernel.  .fixup
10568          contains branches, but only back to the function that hit an
10569          exception.  */
10570       if (isec->has_toc_reloc
10571           || (isec->flags & SEC_CODE) == 0
10572           || strcmp (isec->name, ".fixup") == 0)
10573         {
10574           if (elf_gp (isec->owner) != 0)
10575             htab->toc_curr = elf_gp (isec->owner);
10576         }
10577       else if (!isec->call_check_done
10578                && toc_adjusting_stub_needed (info, isec) < 0)
10579         return FALSE;
10580     }
10581
10582   /* Functions that don't use the TOC can belong in any TOC group.
10583      Use the last TOC base.  This happens to make _init and _fini
10584      pasting work, because the fragments generally don't use the TOC.  */
10585   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10586   return TRUE;
10587 }
10588
10589 /* Check that all .init and .fini sections use the same toc, if they
10590    have toc relocs.  */
10591
10592 static bfd_boolean
10593 check_pasted_section (struct bfd_link_info *info, const char *name)
10594 {
10595   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10596
10597   if (o != NULL)
10598     {
10599       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10600       bfd_vma toc_off = 0;
10601       asection *i;
10602
10603       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10604         if (i->has_toc_reloc)
10605           {
10606             if (toc_off == 0)
10607               toc_off = htab->stub_group[i->id].toc_off;
10608             else if (toc_off != htab->stub_group[i->id].toc_off)
10609               return FALSE;
10610           }
10611       /* Make sure the whole pasted function uses the same toc offset.  */
10612       if (toc_off != 0)
10613         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10614           htab->stub_group[i->id].toc_off = toc_off;
10615     }
10616   return TRUE;
10617 }
10618
10619 bfd_boolean
10620 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10621 {
10622   return (check_pasted_section (info, ".init")
10623           & check_pasted_section (info, ".fini"));
10624 }
10625
10626 /* See whether we can group stub sections together.  Grouping stub
10627    sections may result in fewer stubs.  More importantly, we need to
10628    put all .init* and .fini* stubs at the beginning of the .init or
10629    .fini output sections respectively, because glibc splits the
10630    _init and _fini functions into multiple parts.  Putting a stub in
10631    the middle of a function is not a good idea.  */
10632
10633 static void
10634 group_sections (struct ppc_link_hash_table *htab,
10635                 bfd_size_type stub_group_size,
10636                 bfd_boolean stubs_always_before_branch)
10637 {
10638   asection **list;
10639   bfd_size_type stub14_group_size;
10640   bfd_boolean suppress_size_errors;
10641
10642   suppress_size_errors = FALSE;
10643   stub14_group_size = stub_group_size;
10644   if (stub_group_size == 1)
10645     {
10646       /* Default values.  */
10647       if (stubs_always_before_branch)
10648         {
10649           stub_group_size = 0x1e00000;
10650           stub14_group_size = 0x7800;
10651         }
10652       else
10653         {
10654           stub_group_size = 0x1c00000;
10655           stub14_group_size = 0x7000;
10656         }
10657       suppress_size_errors = TRUE;
10658     }
10659
10660   list = htab->input_list + htab->top_index;
10661   do
10662     {
10663       asection *tail = *list;
10664       while (tail != NULL)
10665         {
10666           asection *curr;
10667           asection *prev;
10668           bfd_size_type total;
10669           bfd_boolean big_sec;
10670           bfd_vma curr_toc;
10671
10672           curr = tail;
10673           total = tail->size;
10674           big_sec = total > (ppc64_elf_section_data (tail) != NULL
10675                              && ppc64_elf_section_data (tail)->has_14bit_branch
10676                              ? stub14_group_size : stub_group_size);
10677           if (big_sec && !suppress_size_errors)
10678             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10679                                      tail->owner, tail);
10680           curr_toc = htab->stub_group[tail->id].toc_off;
10681
10682           while ((prev = PREV_SEC (curr)) != NULL
10683                  && ((total += curr->output_offset - prev->output_offset)
10684                      < (ppc64_elf_section_data (prev) != NULL
10685                         && ppc64_elf_section_data (prev)->has_14bit_branch
10686                         ? stub14_group_size : stub_group_size))
10687                  && htab->stub_group[prev->id].toc_off == curr_toc)
10688             curr = prev;
10689
10690           /* OK, the size from the start of CURR to the end is less
10691              than stub_group_size and thus can be handled by one stub
10692              section.  (or the tail section is itself larger than
10693              stub_group_size, in which case we may be toast.)  We
10694              should really be keeping track of the total size of stubs
10695              added here, as stubs contribute to the final output
10696              section size.  That's a little tricky, and this way will
10697              only break if stubs added make the total size more than
10698              2^25, ie. for the default stub_group_size, if stubs total
10699              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10700           do
10701             {
10702               prev = PREV_SEC (tail);
10703               /* Set up this stub group.  */
10704               htab->stub_group[tail->id].link_sec = curr;
10705             }
10706           while (tail != curr && (tail = prev) != NULL);
10707
10708           /* But wait, there's more!  Input sections up to stub_group_size
10709              bytes before the stub section can be handled by it too.
10710              Don't do this if we have a really large section after the
10711              stubs, as adding more stubs increases the chance that
10712              branches may not reach into the stub section.  */
10713           if (!stubs_always_before_branch && !big_sec)
10714             {
10715               total = 0;
10716               while (prev != NULL
10717                      && ((total += tail->output_offset - prev->output_offset)
10718                          < (ppc64_elf_section_data (prev) != NULL
10719                             && ppc64_elf_section_data (prev)->has_14bit_branch
10720                             ? stub14_group_size : stub_group_size))
10721                      && htab->stub_group[prev->id].toc_off == curr_toc)
10722                 {
10723                   tail = prev;
10724                   prev = PREV_SEC (tail);
10725                   htab->stub_group[tail->id].link_sec = curr;
10726                 }
10727             }
10728           tail = prev;
10729         }
10730     }
10731   while (list-- != htab->input_list);
10732   free (htab->input_list);
10733 #undef PREV_SEC
10734 }
10735
10736 /* Determine and set the size of the stub section for a final link.
10737
10738    The basic idea here is to examine all the relocations looking for
10739    PC-relative calls to a target that is unreachable with a "bl"
10740    instruction.  */
10741
10742 bfd_boolean
10743 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size)
10744 {
10745   bfd_size_type stub_group_size;
10746   bfd_boolean stubs_always_before_branch;
10747   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10748
10749   if (htab == NULL)
10750     return FALSE;
10751
10752   stubs_always_before_branch = group_size < 0;
10753   if (group_size < 0)
10754     stub_group_size = -group_size;
10755   else
10756     stub_group_size = group_size;
10757
10758   group_sections (htab, stub_group_size, stubs_always_before_branch);
10759
10760   while (1)
10761     {
10762       bfd *input_bfd;
10763       unsigned int bfd_indx;
10764       asection *stub_sec;
10765
10766       htab->stub_iteration += 1;
10767
10768       for (input_bfd = info->input_bfds, bfd_indx = 0;
10769            input_bfd != NULL;
10770            input_bfd = input_bfd->link_next, bfd_indx++)
10771         {
10772           Elf_Internal_Shdr *symtab_hdr;
10773           asection *section;
10774           Elf_Internal_Sym *local_syms = NULL;
10775
10776           if (!is_ppc64_elf (input_bfd))
10777             continue;
10778
10779           /* We'll need the symbol table in a second.  */
10780           symtab_hdr = &elf_symtab_hdr (input_bfd);
10781           if (symtab_hdr->sh_info == 0)
10782             continue;
10783
10784           /* Walk over each section attached to the input bfd.  */
10785           for (section = input_bfd->sections;
10786                section != NULL;
10787                section = section->next)
10788             {
10789               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10790
10791               /* If there aren't any relocs, then there's nothing more
10792                  to do.  */
10793               if ((section->flags & SEC_RELOC) == 0
10794                   || (section->flags & SEC_ALLOC) == 0
10795                   || (section->flags & SEC_LOAD) == 0
10796                   || (section->flags & SEC_CODE) == 0
10797                   || section->reloc_count == 0)
10798                 continue;
10799
10800               /* If this section is a link-once section that will be
10801                  discarded, then don't create any stubs.  */
10802               if (section->output_section == NULL
10803                   || section->output_section->owner != info->output_bfd)
10804                 continue;
10805
10806               /* Get the relocs.  */
10807               internal_relocs
10808                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10809                                              info->keep_memory);
10810               if (internal_relocs == NULL)
10811                 goto error_ret_free_local;
10812
10813               /* Now examine each relocation.  */
10814               irela = internal_relocs;
10815               irelaend = irela + section->reloc_count;
10816               for (; irela < irelaend; irela++)
10817                 {
10818                   enum elf_ppc64_reloc_type r_type;
10819                   unsigned int r_indx;
10820                   enum ppc_stub_type stub_type;
10821                   struct ppc_stub_hash_entry *stub_entry;
10822                   asection *sym_sec, *code_sec;
10823                   bfd_vma sym_value, code_value;
10824                   bfd_vma destination;
10825                   bfd_boolean ok_dest;
10826                   struct ppc_link_hash_entry *hash;
10827                   struct ppc_link_hash_entry *fdh;
10828                   struct elf_link_hash_entry *h;
10829                   Elf_Internal_Sym *sym;
10830                   char *stub_name;
10831                   const asection *id_sec;
10832                   struct _opd_sec_data *opd;
10833                   struct plt_entry *plt_ent;
10834
10835                   r_type = ELF64_R_TYPE (irela->r_info);
10836                   r_indx = ELF64_R_SYM (irela->r_info);
10837
10838                   if (r_type >= R_PPC64_max)
10839                     {
10840                       bfd_set_error (bfd_error_bad_value);
10841                       goto error_ret_free_internal;
10842                     }
10843
10844                   /* Only look for stubs on branch instructions.  */
10845                   if (r_type != R_PPC64_REL24
10846                       && r_type != R_PPC64_REL14
10847                       && r_type != R_PPC64_REL14_BRTAKEN
10848                       && r_type != R_PPC64_REL14_BRNTAKEN)
10849                     continue;
10850
10851                   /* Now determine the call target, its name, value,
10852                      section.  */
10853                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
10854                                   r_indx, input_bfd))
10855                     goto error_ret_free_internal;
10856                   hash = (struct ppc_link_hash_entry *) h;
10857
10858                   ok_dest = FALSE;
10859                   fdh = NULL;
10860                   sym_value = 0;
10861                   if (hash == NULL)
10862                     {
10863                       sym_value = sym->st_value;
10864                       ok_dest = TRUE;
10865                     }
10866                   else if (hash->elf.root.type == bfd_link_hash_defined
10867                            || hash->elf.root.type == bfd_link_hash_defweak)
10868                     {
10869                       sym_value = hash->elf.root.u.def.value;
10870                       if (sym_sec->output_section != NULL)
10871                         ok_dest = TRUE;
10872                     }
10873                   else if (hash->elf.root.type == bfd_link_hash_undefweak
10874                            || hash->elf.root.type == bfd_link_hash_undefined)
10875                     {
10876                       /* Recognise an old ABI func code entry sym, and
10877                          use the func descriptor sym instead if it is
10878                          defined.  */
10879                       if (hash->elf.root.root.string[0] == '.'
10880                           && (fdh = lookup_fdh (hash, htab)) != NULL)
10881                         {
10882                           if (fdh->elf.root.type == bfd_link_hash_defined
10883                               || fdh->elf.root.type == bfd_link_hash_defweak)
10884                             {
10885                               sym_sec = fdh->elf.root.u.def.section;
10886                               sym_value = fdh->elf.root.u.def.value;
10887                               if (sym_sec->output_section != NULL)
10888                                 ok_dest = TRUE;
10889                             }
10890                           else
10891                             fdh = NULL;
10892                         }
10893                     }
10894                   else
10895                     {
10896                       bfd_set_error (bfd_error_bad_value);
10897                       goto error_ret_free_internal;
10898                     }
10899
10900                   destination = 0;
10901                   if (ok_dest)
10902                     {
10903                       sym_value += irela->r_addend;
10904                       destination = (sym_value
10905                                      + sym_sec->output_offset
10906                                      + sym_sec->output_section->vma);
10907                     }
10908
10909                   code_sec = sym_sec;
10910                   code_value = sym_value;
10911                   opd = get_opd_info (sym_sec);
10912                   if (opd != NULL)
10913                     {
10914                       bfd_vma dest;
10915
10916                       if (hash == NULL && opd->adjust != NULL)
10917                         {
10918                           long adjust = opd->adjust[sym_value / 8];
10919                           if (adjust == -1)
10920                             continue;
10921                           code_value += adjust;
10922                           sym_value += adjust;
10923                         }
10924                       dest = opd_entry_value (sym_sec, sym_value,
10925                                               &code_sec, &code_value);
10926                       if (dest != (bfd_vma) -1)
10927                         {
10928                           destination = dest;
10929                           if (fdh != NULL)
10930                             {
10931                               /* Fixup old ABI sym to point at code
10932                                  entry.  */
10933                               hash->elf.root.type = bfd_link_hash_defweak;
10934                               hash->elf.root.u.def.section = code_sec;
10935                               hash->elf.root.u.def.value = code_value;
10936                             }
10937                         }
10938                     }
10939
10940                   /* Determine what (if any) linker stub is needed.  */
10941                   plt_ent = NULL;
10942                   stub_type = ppc_type_of_stub (section, irela, &hash,
10943                                                 &plt_ent, destination);
10944
10945                   if (stub_type != ppc_stub_plt_call)
10946                     {
10947                       /* Check whether we need a TOC adjusting stub.
10948                          Since the linker pastes together pieces from
10949                          different object files when creating the
10950                          _init and _fini functions, it may be that a
10951                          call to what looks like a local sym is in
10952                          fact a call needing a TOC adjustment.  */
10953                       if (code_sec != NULL
10954                           && code_sec->output_section != NULL
10955                           && (htab->stub_group[code_sec->id].toc_off
10956                               != htab->stub_group[section->id].toc_off)
10957                           && (code_sec->has_toc_reloc
10958                               || code_sec->makes_toc_func_call))
10959                         stub_type = ppc_stub_long_branch_r2off;
10960                     }
10961
10962                   if (stub_type == ppc_stub_none)
10963                     continue;
10964
10965                   /* __tls_get_addr calls might be eliminated.  */
10966                   if (stub_type != ppc_stub_plt_call
10967                       && hash != NULL
10968                       && (hash == htab->tls_get_addr
10969                           || hash == htab->tls_get_addr_fd)
10970                       && section->has_tls_reloc
10971                       && irela != internal_relocs)
10972                     {
10973                       /* Get tls info.  */
10974                       unsigned char *tls_mask;
10975
10976                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
10977                                          irela - 1, input_bfd))
10978                         goto error_ret_free_internal;
10979                       if (*tls_mask != 0)
10980                         continue;
10981                     }
10982
10983                   /* Support for grouping stub sections.  */
10984                   id_sec = htab->stub_group[section->id].link_sec;
10985
10986                   /* Get the name of this stub.  */
10987                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10988                   if (!stub_name)
10989                     goto error_ret_free_internal;
10990
10991                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10992                                                      stub_name, FALSE, FALSE);
10993                   if (stub_entry != NULL)
10994                     {
10995                       /* The proper stub has already been created.  */
10996                       free (stub_name);
10997                       continue;
10998                     }
10999
11000                   stub_entry = ppc_add_stub (stub_name, section, htab);
11001                   if (stub_entry == NULL)
11002                     {
11003                       free (stub_name);
11004                     error_ret_free_internal:
11005                       if (elf_section_data (section)->relocs == NULL)
11006                         free (internal_relocs);
11007                     error_ret_free_local:
11008                       if (local_syms != NULL
11009                           && (symtab_hdr->contents
11010                               != (unsigned char *) local_syms))
11011                         free (local_syms);
11012                       return FALSE;
11013                     }
11014
11015                   stub_entry->stub_type = stub_type;
11016                   if (stub_type != ppc_stub_plt_call)
11017                     {
11018                       stub_entry->target_value = code_value;
11019                       stub_entry->target_section = code_sec;
11020                     }
11021                   else
11022                     {
11023                       stub_entry->target_value = sym_value;
11024                       stub_entry->target_section = sym_sec;
11025                     }
11026                   stub_entry->h = hash;
11027                   stub_entry->plt_ent = plt_ent;
11028                   stub_entry->addend = irela->r_addend;
11029
11030                   if (stub_entry->h != NULL)
11031                     htab->stub_globals += 1;
11032                 }
11033
11034               /* We're done with the internal relocs, free them.  */
11035               if (elf_section_data (section)->relocs != internal_relocs)
11036                 free (internal_relocs);
11037             }
11038
11039           if (local_syms != NULL
11040               && symtab_hdr->contents != (unsigned char *) local_syms)
11041             {
11042               if (!info->keep_memory)
11043                 free (local_syms);
11044               else
11045                 symtab_hdr->contents = (unsigned char *) local_syms;
11046             }
11047         }
11048
11049       /* We may have added some stubs.  Find out the new size of the
11050          stub sections.  */
11051       for (stub_sec = htab->stub_bfd->sections;
11052            stub_sec != NULL;
11053            stub_sec = stub_sec->next)
11054         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11055           {
11056             stub_sec->rawsize = stub_sec->size;
11057             stub_sec->size = 0;
11058             stub_sec->reloc_count = 0;
11059             stub_sec->flags &= ~SEC_RELOC;
11060           }
11061
11062       htab->brlt->size = 0;
11063       htab->brlt->reloc_count = 0;
11064       htab->brlt->flags &= ~SEC_RELOC;
11065       if (htab->relbrlt != NULL)
11066         htab->relbrlt->size = 0;
11067
11068       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11069
11070       if (info->emitrelocations
11071           && htab->glink != NULL && htab->glink->size != 0)
11072         {
11073           htab->glink->reloc_count = 1;
11074           htab->glink->flags |= SEC_RELOC;
11075         }
11076
11077       for (stub_sec = htab->stub_bfd->sections;
11078            stub_sec != NULL;
11079            stub_sec = stub_sec->next)
11080         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11081             && stub_sec->rawsize != stub_sec->size)
11082           break;
11083
11084       /* Exit from this loop when no stubs have been added, and no stubs
11085          have changed size.  */
11086       if (stub_sec == NULL)
11087         break;
11088
11089       /* Ask the linker to do its stuff.  */
11090       (*htab->layout_sections_again) ();
11091     }
11092
11093   /* It would be nice to strip htab->brlt from the output if the
11094      section is empty, but it's too late.  If we strip sections here,
11095      the dynamic symbol table is corrupted since the section symbol
11096      for the stripped section isn't written.  */
11097
11098   return TRUE;
11099 }
11100
11101 /* Called after we have determined section placement.  If sections
11102    move, we'll be called again.  Provide a value for TOCstart.  */
11103
11104 bfd_vma
11105 ppc64_elf_toc (bfd *obfd)
11106 {
11107   asection *s;
11108   bfd_vma TOCstart;
11109
11110   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11111      order.  The TOC starts where the first of these sections starts.  */
11112   s = bfd_get_section_by_name (obfd, ".got");
11113   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11114     s = bfd_get_section_by_name (obfd, ".toc");
11115   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11116     s = bfd_get_section_by_name (obfd, ".tocbss");
11117   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11118     s = bfd_get_section_by_name (obfd, ".plt");
11119   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11120     {
11121       /* This may happen for
11122          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11123          .toc directive
11124          o  bad linker script
11125          o --gc-sections and empty TOC sections
11126
11127          FIXME: Warn user?  */
11128
11129       /* Look for a likely section.  We probably won't even be
11130          using TOCstart.  */
11131       for (s = obfd->sections; s != NULL; s = s->next)
11132         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11133                          | SEC_EXCLUDE))
11134             == (SEC_ALLOC | SEC_SMALL_DATA))
11135           break;
11136       if (s == NULL)
11137         for (s = obfd->sections; s != NULL; s = s->next)
11138           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11139               == (SEC_ALLOC | SEC_SMALL_DATA))
11140             break;
11141       if (s == NULL)
11142         for (s = obfd->sections; s != NULL; s = s->next)
11143           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11144               == SEC_ALLOC)
11145             break;
11146       if (s == NULL)
11147         for (s = obfd->sections; s != NULL; s = s->next)
11148           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11149             break;
11150     }
11151
11152   TOCstart = 0;
11153   if (s != NULL)
11154     TOCstart = s->output_section->vma + s->output_offset;
11155
11156   return TOCstart;
11157 }
11158
11159 /* Build all the stubs associated with the current output file.
11160    The stubs are kept in a hash table attached to the main linker
11161    hash table.  This function is called via gldelf64ppc_finish.  */
11162
11163 bfd_boolean
11164 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11165                        struct bfd_link_info *info,
11166                        char **stats)
11167 {
11168   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11169   asection *stub_sec;
11170   bfd_byte *p;
11171   int stub_sec_count = 0;
11172
11173   if (htab == NULL)
11174     return FALSE;
11175
11176   htab->emit_stub_syms = emit_stub_syms;
11177
11178   /* Allocate memory to hold the linker stubs.  */
11179   for (stub_sec = htab->stub_bfd->sections;
11180        stub_sec != NULL;
11181        stub_sec = stub_sec->next)
11182     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11183         && stub_sec->size != 0)
11184       {
11185         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11186         if (stub_sec->contents == NULL)
11187           return FALSE;
11188         /* We want to check that built size is the same as calculated
11189            size.  rawsize is a convenient location to use.  */
11190         stub_sec->rawsize = stub_sec->size;
11191         stub_sec->size = 0;
11192       }
11193
11194   if (htab->glink != NULL && htab->glink->size != 0)
11195     {
11196       unsigned int indx;
11197       bfd_vma plt0;
11198
11199       /* Build the .glink plt call stub.  */
11200       if (htab->emit_stub_syms)
11201         {
11202           struct elf_link_hash_entry *h;
11203           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11204                                     TRUE, FALSE, FALSE);
11205           if (h == NULL)
11206             return FALSE;
11207           if (h->root.type == bfd_link_hash_new)
11208             {
11209               h->root.type = bfd_link_hash_defined;
11210               h->root.u.def.section = htab->glink;
11211               h->root.u.def.value = 8;
11212               h->ref_regular = 1;
11213               h->def_regular = 1;
11214               h->ref_regular_nonweak = 1;
11215               h->forced_local = 1;
11216               h->non_elf = 0;
11217             }
11218         }
11219       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11220       if (info->emitrelocations)
11221         {
11222           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11223           if (r == NULL)
11224             return FALSE;
11225           r->r_offset = (htab->glink->output_offset
11226                          + htab->glink->output_section->vma);
11227           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11228           r->r_addend = plt0;
11229         }
11230       p = htab->glink->contents;
11231       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11232       bfd_put_64 (htab->glink->owner, plt0, p);
11233       p += 8;
11234       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11235       p += 4;
11236       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11237       p += 4;
11238       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11239       p += 4;
11240       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11241       p += 4;
11242       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11243       p += 4;
11244       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11245       p += 4;
11246       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11247       p += 4;
11248       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11249       p += 4;
11250       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11251       p += 4;
11252       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11253       p += 4;
11254       bfd_put_32 (htab->glink->owner, BCTR, p);
11255       p += 4;
11256       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11257         {
11258           bfd_put_32 (htab->glink->owner, NOP, p);
11259           p += 4;
11260         }
11261
11262       /* Build the .glink lazy link call stubs.  */
11263       indx = 0;
11264       while (p < htab->glink->contents + htab->glink->size)
11265         {
11266           if (indx < 0x8000)
11267             {
11268               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11269               p += 4;
11270             }
11271           else
11272             {
11273               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11274               p += 4;
11275               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11276               p += 4;
11277             }
11278           bfd_put_32 (htab->glink->owner,
11279                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11280           indx++;
11281           p += 4;
11282         }
11283       htab->glink->rawsize = p - htab->glink->contents;
11284     }
11285
11286   if (htab->brlt->size != 0)
11287     {
11288       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11289                                          htab->brlt->size);
11290       if (htab->brlt->contents == NULL)
11291         return FALSE;
11292     }
11293   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11294     {
11295       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11296                                             htab->relbrlt->size);
11297       if (htab->relbrlt->contents == NULL)
11298         return FALSE;
11299     }
11300
11301   /* Build the stubs as directed by the stub hash table.  */
11302   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11303
11304   if (htab->relbrlt != NULL)
11305     htab->relbrlt->reloc_count = 0;
11306
11307   for (stub_sec = htab->stub_bfd->sections;
11308        stub_sec != NULL;
11309        stub_sec = stub_sec->next)
11310     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11311       {
11312         stub_sec_count += 1;
11313         if (stub_sec->rawsize != stub_sec->size)
11314           break;
11315       }
11316
11317   if (stub_sec != NULL
11318       || htab->glink->rawsize != htab->glink->size)
11319     {
11320       htab->stub_error = TRUE;
11321       (*_bfd_error_handler) (_("stubs don't match calculated size"));
11322     }
11323
11324   if (htab->stub_error)
11325     return FALSE;
11326
11327   if (stats != NULL)
11328     {
11329       *stats = bfd_malloc (500);
11330       if (*stats == NULL)
11331         return FALSE;
11332
11333       sprintf (*stats, _("linker stubs in %u group%s\n"
11334                          "  branch       %lu\n"
11335                          "  toc adjust   %lu\n"
11336                          "  long branch  %lu\n"
11337                          "  long toc adj %lu\n"
11338                          "  plt call     %lu"),
11339                stub_sec_count,
11340                stub_sec_count == 1 ? "" : "s",
11341                htab->stub_count[ppc_stub_long_branch - 1],
11342                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11343                htab->stub_count[ppc_stub_plt_branch - 1],
11344                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11345                htab->stub_count[ppc_stub_plt_call - 1]);
11346     }
11347   return TRUE;
11348 }
11349
11350 /* This function undoes the changes made by add_symbol_adjust.  */
11351
11352 static bfd_boolean
11353 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11354 {
11355   struct ppc_link_hash_entry *eh;
11356
11357   if (h->root.type == bfd_link_hash_indirect)
11358     return TRUE;
11359
11360   if (h->root.type == bfd_link_hash_warning)
11361     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11362
11363   eh = (struct ppc_link_hash_entry *) h;
11364   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11365     return TRUE;
11366
11367   eh->elf.root.type = bfd_link_hash_undefined;
11368   return TRUE;
11369 }
11370
11371 void
11372 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11373 {
11374   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11375
11376   if (htab != NULL)
11377     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11378 }
11379
11380 /* What to do when ld finds relocations against symbols defined in
11381    discarded sections.  */
11382
11383 static unsigned int
11384 ppc64_elf_action_discarded (asection *sec)
11385 {
11386   if (strcmp (".opd", sec->name) == 0)
11387     return 0;
11388
11389   if (strcmp (".toc", sec->name) == 0)
11390     return 0;
11391
11392   if (strcmp (".toc1", sec->name) == 0)
11393     return 0;
11394
11395   return _bfd_elf_default_action_discarded (sec);
11396 }
11397
11398 /* REL points to a low-part reloc on a largetoc instruction sequence.
11399    Find the matching high-part reloc instruction and verify that it
11400    is addis REG,x,imm.  If so, set *REG to x and return a pointer to
11401    the high-part reloc.  */
11402
11403 static const Elf_Internal_Rela *
11404 ha_reloc_match (const Elf_Internal_Rela *relocs,
11405                 const Elf_Internal_Rela *rel,
11406                 unsigned int *reg,
11407                 bfd_boolean match_addend,
11408                 const bfd *input_bfd,
11409                 const bfd_byte *contents)
11410 {
11411   enum elf_ppc64_reloc_type r_type, r_type_ha;
11412   bfd_vma r_info_ha, r_addend;
11413
11414   r_type = ELF64_R_TYPE (rel->r_info);
11415   switch (r_type)
11416     {
11417     case R_PPC64_GOT_TLSLD16_LO:
11418     case R_PPC64_GOT_TLSGD16_LO:
11419     case R_PPC64_GOT_TPREL16_LO_DS:
11420     case R_PPC64_GOT_DTPREL16_LO_DS:
11421     case R_PPC64_GOT16_LO:
11422     case R_PPC64_TOC16_LO:
11423       r_type_ha = r_type + 2;
11424       break;
11425     case R_PPC64_GOT16_LO_DS:
11426       r_type_ha = R_PPC64_GOT16_HA;
11427       break;
11428     case R_PPC64_TOC16_LO_DS:
11429       r_type_ha = R_PPC64_TOC16_HA;
11430       break;
11431     default:
11432       abort ();
11433     }
11434   r_info_ha = ELF64_R_INFO (ELF64_R_SYM (rel->r_info), r_type_ha);
11435   r_addend = rel->r_addend;
11436
11437   while (--rel >= relocs)
11438     if (rel->r_info == r_info_ha
11439         && (!match_addend
11440             || rel->r_addend == r_addend))
11441       {
11442         const bfd_byte *p = contents + (rel->r_offset & ~3);
11443         unsigned int insn = bfd_get_32 (input_bfd, p);
11444         if ((insn & (0x3f << 26)) == (15u << 26) /* addis rt,x,imm */
11445             && (insn & (0x1f << 21)) == (*reg << 21))
11446           {
11447             *reg = (insn >> 16) & 0x1f;
11448             return rel;
11449           }
11450         break;
11451       }
11452   return NULL;
11453 }
11454
11455 /* The RELOCATE_SECTION function is called by the ELF backend linker
11456    to handle the relocations for a section.
11457
11458    The relocs are always passed as Rela structures; if the section
11459    actually uses Rel structures, the r_addend field will always be
11460    zero.
11461
11462    This function is responsible for adjust the section contents as
11463    necessary, and (if using Rela relocs and generating a
11464    relocatable output file) adjusting the reloc addend as
11465    necessary.
11466
11467    This function does not have to worry about setting the reloc
11468    address or the reloc symbol index.
11469
11470    LOCAL_SYMS is a pointer to the swapped in local symbols.
11471
11472    LOCAL_SECTIONS is an array giving the section in the input file
11473    corresponding to the st_shndx field of each local symbol.
11474
11475    The global hash table entry for the global symbols can be found
11476    via elf_sym_hashes (input_bfd).
11477
11478    When generating relocatable output, this function must handle
11479    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11480    going to be the section symbol corresponding to the output
11481    section, which means that the addend must be adjusted
11482    accordingly.  */
11483
11484 static bfd_boolean
11485 ppc64_elf_relocate_section (bfd *output_bfd,
11486                             struct bfd_link_info *info,
11487                             bfd *input_bfd,
11488                             asection *input_section,
11489                             bfd_byte *contents,
11490                             Elf_Internal_Rela *relocs,
11491                             Elf_Internal_Sym *local_syms,
11492                             asection **local_sections)
11493 {
11494   struct ppc_link_hash_table *htab;
11495   Elf_Internal_Shdr *symtab_hdr;
11496   struct elf_link_hash_entry **sym_hashes;
11497   Elf_Internal_Rela *rel;
11498   Elf_Internal_Rela *relend;
11499   Elf_Internal_Rela outrel;
11500   bfd_byte *loc;
11501   struct got_entry **local_got_ents;
11502   unsigned char *ha_opt;
11503   bfd_vma TOCstart;
11504   bfd_boolean no_ha_opt;
11505   bfd_boolean ret = TRUE;
11506   bfd_boolean is_opd;
11507   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11508   bfd_boolean is_power4 = FALSE;
11509   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11510
11511   /* Initialize howto table if needed.  */
11512   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11513     ppc_howto_init ();
11514
11515   htab = ppc_hash_table (info);
11516   if (htab == NULL)
11517     return FALSE;
11518
11519   /* Don't relocate stub sections.  */
11520   if (input_section->owner == htab->stub_bfd)
11521     return TRUE;
11522
11523   BFD_ASSERT (is_ppc64_elf (input_bfd));
11524
11525   local_got_ents = elf_local_got_ents (input_bfd);
11526   TOCstart = elf_gp (output_bfd);
11527   symtab_hdr = &elf_symtab_hdr (input_bfd);
11528   sym_hashes = elf_sym_hashes (input_bfd);
11529   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11530   ha_opt = NULL;
11531   no_ha_opt = FALSE;
11532
11533   rel = relocs;
11534   relend = relocs + input_section->reloc_count;
11535   for (; rel < relend; rel++)
11536     {
11537       enum elf_ppc64_reloc_type r_type;
11538       bfd_vma addend, orig_addend;
11539       bfd_reloc_status_type r;
11540       Elf_Internal_Sym *sym;
11541       asection *sec;
11542       struct elf_link_hash_entry *h_elf;
11543       struct ppc_link_hash_entry *h;
11544       struct ppc_link_hash_entry *fdh;
11545       const char *sym_name;
11546       unsigned long r_symndx, toc_symndx;
11547       bfd_vma toc_addend;
11548       unsigned char tls_mask, tls_gd, tls_type;
11549       unsigned char sym_type;
11550       bfd_vma relocation;
11551       bfd_boolean unresolved_reloc;
11552       bfd_boolean warned;
11553       unsigned int insn;
11554       bfd_vma mask;
11555       struct ppc_stub_hash_entry *stub_entry;
11556       bfd_vma max_br_offset;
11557       bfd_vma from;
11558
11559       r_type = ELF64_R_TYPE (rel->r_info);
11560       r_symndx = ELF64_R_SYM (rel->r_info);
11561
11562       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11563          symbol of the previous ADDR64 reloc.  The symbol gives us the
11564          proper TOC base to use.  */
11565       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11566           && rel != relocs
11567           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11568           && is_opd)
11569         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11570
11571       sym = NULL;
11572       sec = NULL;
11573       h_elf = NULL;
11574       sym_name = NULL;
11575       unresolved_reloc = FALSE;
11576       warned = FALSE;
11577       orig_addend = rel->r_addend;
11578
11579       if (r_symndx < symtab_hdr->sh_info)
11580         {
11581           /* It's a local symbol.  */
11582           struct _opd_sec_data *opd;
11583
11584           sym = local_syms + r_symndx;
11585           sec = local_sections[r_symndx];
11586           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11587           sym_type = ELF64_ST_TYPE (sym->st_info);
11588           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11589           opd = get_opd_info (sec);
11590           if (opd != NULL && opd->adjust != NULL)
11591             {
11592               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11593               if (adjust == -1)
11594                 relocation = 0;
11595               else
11596                 {
11597                   /* If this is a relocation against the opd section sym
11598                      and we have edited .opd, adjust the reloc addend so
11599                      that ld -r and ld --emit-relocs output is correct.
11600                      If it is a reloc against some other .opd symbol,
11601                      then the symbol value will be adjusted later.  */
11602                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11603                     rel->r_addend += adjust;
11604                   else
11605                     relocation += adjust;
11606                 }
11607             }
11608         }
11609       else
11610         {
11611           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11612                                    r_symndx, symtab_hdr, sym_hashes,
11613                                    h_elf, sec, relocation,
11614                                    unresolved_reloc, warned);
11615           sym_name = h_elf->root.root.string;
11616           sym_type = h_elf->type;
11617         }
11618       h = (struct ppc_link_hash_entry *) h_elf;
11619
11620       if (sec != NULL && elf_discarded_section (sec))
11621         {
11622           /* For relocs against symbols from removed linkonce sections,
11623              or sections discarded by a linker script, we just want the
11624              section contents zeroed.  Avoid any special processing.  */
11625           _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
11626                                contents + rel->r_offset);
11627           rel->r_info = 0;
11628           rel->r_addend = 0;
11629           continue;
11630         }
11631
11632       if (info->relocatable)
11633         continue;
11634
11635       /* TLS optimizations.  Replace instruction sequences and relocs
11636          based on information we collected in tls_optimize.  We edit
11637          RELOCS so that --emit-relocs will output something sensible
11638          for the final instruction stream.  */
11639       tls_mask = 0;
11640       tls_gd = 0;
11641       toc_symndx = 0;
11642       if (h != NULL)
11643         tls_mask = h->tls_mask;
11644       else if (local_got_ents != NULL)
11645         {
11646           struct plt_entry **local_plt = (struct plt_entry **)
11647             (local_got_ents + symtab_hdr->sh_info);
11648           unsigned char *lgot_masks = (unsigned char *)
11649             (local_plt + symtab_hdr->sh_info);
11650           tls_mask = lgot_masks[r_symndx];
11651         }
11652       if (tls_mask == 0
11653           && (r_type == R_PPC64_TLS
11654               || r_type == R_PPC64_TLSGD
11655               || r_type == R_PPC64_TLSLD))
11656         {
11657           /* Check for toc tls entries.  */
11658           unsigned char *toc_tls;
11659
11660           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11661                              &local_syms, rel, input_bfd))
11662             return FALSE;
11663
11664           if (toc_tls)
11665             tls_mask = *toc_tls;
11666         }
11667
11668       /* Check that tls relocs are used with tls syms, and non-tls
11669          relocs are used with non-tls syms.  */
11670       if (r_symndx != 0
11671           && r_type != R_PPC64_NONE
11672           && (h == NULL
11673               || h->elf.root.type == bfd_link_hash_defined
11674               || h->elf.root.type == bfd_link_hash_defweak)
11675           && (IS_PPC64_TLS_RELOC (r_type)
11676               != (sym_type == STT_TLS
11677                   || (sym_type == STT_SECTION
11678                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11679         {
11680           if (tls_mask != 0
11681               && (r_type == R_PPC64_TLS
11682                   || r_type == R_PPC64_TLSGD
11683                   || r_type == R_PPC64_TLSLD))
11684             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
11685             ;
11686           else
11687             (*_bfd_error_handler)
11688               (!IS_PPC64_TLS_RELOC (r_type)
11689                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11690                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
11691                input_bfd,
11692                input_section,
11693                (long) rel->r_offset,
11694                ppc64_elf_howto_table[r_type]->name,
11695                sym_name);
11696         }
11697
11698       /* Ensure reloc mapping code below stays sane.  */
11699       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11700           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11701           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
11702           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11703           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11704           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11705           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
11706           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11707           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11708           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11709         abort ();
11710
11711       switch (r_type)
11712         {
11713         default:
11714           break;
11715
11716         case R_PPC64_LO_DS_OPT:
11717           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11718           if ((insn & (0x3f << 26)) != 58u << 26)
11719             abort ();
11720           insn += (14u << 26) - (58u << 26);
11721           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11722           r_type = R_PPC64_TOC16_LO;
11723           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11724           break;
11725
11726         case R_PPC64_TOC16:
11727         case R_PPC64_TOC16_LO:
11728         case R_PPC64_TOC16_DS:
11729         case R_PPC64_TOC16_LO_DS:
11730           {
11731             /* Check for toc tls entries.  */
11732             unsigned char *toc_tls;
11733             int retval;
11734
11735             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11736                                    &local_syms, rel, input_bfd);
11737             if (retval == 0)
11738               return FALSE;
11739
11740             if (toc_tls)
11741               {
11742                 tls_mask = *toc_tls;
11743                 if (r_type == R_PPC64_TOC16_DS
11744                     || r_type == R_PPC64_TOC16_LO_DS)
11745                   {
11746                     if (tls_mask != 0
11747                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
11748                       goto toctprel;
11749                   }
11750                 else
11751                   {
11752                     /* If we found a GD reloc pair, then we might be
11753                        doing a GD->IE transition.  */
11754                     if (retval == 2)
11755                       {
11756                         tls_gd = TLS_TPRELGD;
11757                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11758                           goto tls_ldgd_opt;
11759                       }
11760                     else if (retval == 3)
11761                       {
11762                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11763                           goto tls_ldgd_opt;
11764                       }
11765                   }
11766               }
11767           }
11768           break;
11769
11770         case R_PPC64_GOT_TPREL16_HI:
11771         case R_PPC64_GOT_TPREL16_HA:
11772           if (tls_mask != 0
11773               && (tls_mask & TLS_TPREL) == 0)
11774             {
11775               rel->r_offset -= d_offset;
11776               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11777               r_type = R_PPC64_NONE;
11778               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11779             }
11780           break;
11781
11782         case R_PPC64_GOT_TPREL16_DS:
11783         case R_PPC64_GOT_TPREL16_LO_DS:
11784           if (tls_mask != 0
11785               && (tls_mask & TLS_TPREL) == 0)
11786             {
11787             toctprel:
11788               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11789               insn &= 31 << 21;
11790               insn |= 0x3c0d0000;       /* addis 0,13,0 */
11791               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11792               r_type = R_PPC64_TPREL16_HA;
11793               if (toc_symndx != 0)
11794                 {
11795                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11796                   rel->r_addend = toc_addend;
11797                   /* We changed the symbol.  Start over in order to
11798                      get h, sym, sec etc. right.  */
11799                   rel--;
11800                   continue;
11801                 }
11802               else
11803                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11804             }
11805           break;
11806
11807         case R_PPC64_TLS:
11808           if (tls_mask != 0
11809               && (tls_mask & TLS_TPREL) == 0)
11810             {
11811               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11812               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11813               if (insn == 0)
11814                 abort ();
11815               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11816               /* Was PPC64_TLS which sits on insn boundary, now
11817                  PPC64_TPREL16_LO which is at low-order half-word.  */
11818               rel->r_offset += d_offset;
11819               r_type = R_PPC64_TPREL16_LO;
11820               if (toc_symndx != 0)
11821                 {
11822                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11823                   rel->r_addend = toc_addend;
11824                   /* We changed the symbol.  Start over in order to
11825                      get h, sym, sec etc. right.  */
11826                   rel--;
11827                   continue;
11828                 }
11829               else
11830                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11831             }
11832           break;
11833
11834         case R_PPC64_GOT_TLSGD16_HI:
11835         case R_PPC64_GOT_TLSGD16_HA:
11836           tls_gd = TLS_TPRELGD;
11837           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11838             goto tls_gdld_hi;
11839           break;
11840
11841         case R_PPC64_GOT_TLSLD16_HI:
11842         case R_PPC64_GOT_TLSLD16_HA:
11843           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11844             {
11845             tls_gdld_hi:
11846               if ((tls_mask & tls_gd) != 0)
11847                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11848                           + R_PPC64_GOT_TPREL16_DS);
11849               else
11850                 {
11851                   rel->r_offset -= d_offset;
11852                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11853                   r_type = R_PPC64_NONE;
11854                 }
11855               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11856             }
11857           break;
11858
11859         case R_PPC64_GOT_TLSGD16:
11860         case R_PPC64_GOT_TLSGD16_LO:
11861           tls_gd = TLS_TPRELGD;
11862           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11863             goto tls_ldgd_opt;
11864           break;
11865
11866         case R_PPC64_GOT_TLSLD16:
11867         case R_PPC64_GOT_TLSLD16_LO:
11868           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11869             {
11870               unsigned int insn1, insn2, insn3;
11871               bfd_vma offset;
11872
11873             tls_ldgd_opt:
11874               offset = (bfd_vma) -1;
11875               /* If not using the newer R_PPC64_TLSGD/LD to mark
11876                  __tls_get_addr calls, we must trust that the call
11877                  stays with its arg setup insns, ie. that the next
11878                  reloc is the __tls_get_addr call associated with
11879                  the current reloc.  Edit both insns.  */
11880               if (input_section->has_tls_get_addr_call
11881                   && rel + 1 < relend
11882                   && branch_reloc_hash_match (input_bfd, rel + 1,
11883                                               htab->tls_get_addr,
11884                                               htab->tls_get_addr_fd))
11885                 offset = rel[1].r_offset;
11886               if ((tls_mask & tls_gd) != 0)
11887                 {
11888                   /* IE */
11889                   insn1 = bfd_get_32 (output_bfd,
11890                                       contents + rel->r_offset - d_offset);
11891                   insn1 &= (1 << 26) - (1 << 2);
11892                   insn1 |= 58 << 26;    /* ld */
11893                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11894                   if (offset != (bfd_vma) -1)
11895                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11896                   if ((tls_mask & TLS_EXPLICIT) == 0)
11897                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11898                               + R_PPC64_GOT_TPREL16_DS);
11899                   else
11900                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
11901                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11902                 }
11903               else
11904                 {
11905                   /* LE */
11906                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
11907                   insn2 = 0x38630000;   /* addi 3,3,0 */
11908                   if (tls_gd == 0)
11909                     {
11910                       /* Was an LD reloc.  */
11911                       if (toc_symndx)
11912                         sec = local_sections[toc_symndx];
11913                       for (r_symndx = 0;
11914                            r_symndx < symtab_hdr->sh_info;
11915                            r_symndx++)
11916                         if (local_sections[r_symndx] == sec)
11917                           break;
11918                       if (r_symndx >= symtab_hdr->sh_info)
11919                         r_symndx = 0;
11920                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11921                       if (r_symndx != 0)
11922                         rel->r_addend -= (local_syms[r_symndx].st_value
11923                                           + sec->output_offset
11924                                           + sec->output_section->vma);
11925                     }
11926                   else if (toc_symndx != 0)
11927                     {
11928                       r_symndx = toc_symndx;
11929                       rel->r_addend = toc_addend;
11930                     }
11931                   r_type = R_PPC64_TPREL16_HA;
11932                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11933                   if (offset != (bfd_vma) -1)
11934                     {
11935                       rel[1].r_info = ELF64_R_INFO (r_symndx,
11936                                                     R_PPC64_TPREL16_LO);
11937                       rel[1].r_offset = offset + d_offset;
11938                       rel[1].r_addend = rel->r_addend;
11939                     }
11940                 }
11941               bfd_put_32 (output_bfd, insn1,
11942                           contents + rel->r_offset - d_offset);
11943               if (offset != (bfd_vma) -1)
11944                 {
11945                   insn3 = bfd_get_32 (output_bfd,
11946                                       contents + offset + 4);
11947                   if (insn3 == NOP
11948                       || insn3 == CROR_151515 || insn3 == CROR_313131)
11949                     {
11950                       rel[1].r_offset += 4;
11951                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11952                       insn2 = NOP;
11953                     }
11954                   bfd_put_32 (output_bfd, insn2, contents + offset);
11955                 }
11956               if ((tls_mask & tls_gd) == 0
11957                   && (tls_gd == 0 || toc_symndx != 0))
11958                 {
11959                   /* We changed the symbol.  Start over in order
11960                      to get h, sym, sec etc. right.  */
11961                   rel--;
11962                   continue;
11963                 }
11964             }
11965           break;
11966
11967         case R_PPC64_TLSGD:
11968           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11969             {
11970               unsigned int insn2, insn3;
11971               bfd_vma offset = rel->r_offset;
11972
11973               if ((tls_mask & TLS_TPRELGD) != 0)
11974                 {
11975                   /* IE */
11976                   r_type = R_PPC64_NONE;
11977                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11978                 }
11979               else
11980                 {
11981                   /* LE */
11982                   if (toc_symndx != 0)
11983                     {
11984                       r_symndx = toc_symndx;
11985                       rel->r_addend = toc_addend;
11986                     }
11987                   r_type = R_PPC64_TPREL16_LO;
11988                   rel->r_offset = offset + d_offset;
11989                   insn2 = 0x38630000;   /* addi 3,3,0 */
11990                 }
11991               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11992               /* Zap the reloc on the _tls_get_addr call too.  */
11993               BFD_ASSERT (offset == rel[1].r_offset);
11994               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11995               insn3 = bfd_get_32 (output_bfd,
11996                                   contents + offset + 4);
11997               if (insn3 == NOP
11998                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11999                 {
12000                   rel->r_offset += 4;
12001                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12002                   insn2 = NOP;
12003                 }
12004               bfd_put_32 (output_bfd, insn2, contents + offset);
12005               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12006                 {
12007                   rel--;
12008                   continue;
12009                 }
12010             }
12011           break;
12012
12013         case R_PPC64_TLSLD:
12014           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12015             {
12016               unsigned int insn2, insn3;
12017               bfd_vma offset = rel->r_offset;
12018
12019               if (toc_symndx)
12020                 sec = local_sections[toc_symndx];
12021               for (r_symndx = 0;
12022                    r_symndx < symtab_hdr->sh_info;
12023                    r_symndx++)
12024                 if (local_sections[r_symndx] == sec)
12025                   break;
12026               if (r_symndx >= symtab_hdr->sh_info)
12027                 r_symndx = 0;
12028               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12029               if (r_symndx != 0)
12030                 rel->r_addend -= (local_syms[r_symndx].st_value
12031                                   + sec->output_offset
12032                                   + sec->output_section->vma);
12033
12034               r_type = R_PPC64_TPREL16_LO;
12035               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12036               rel->r_offset = offset + d_offset;
12037               /* Zap the reloc on the _tls_get_addr call too.  */
12038               BFD_ASSERT (offset == rel[1].r_offset);
12039               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12040               insn2 = 0x38630000;       /* addi 3,3,0 */
12041               insn3 = bfd_get_32 (output_bfd,
12042                                   contents + offset + 4);
12043               if (insn3 == NOP
12044                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12045                 {
12046                   rel->r_offset += 4;
12047                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12048                   insn2 = NOP;
12049                 }
12050               bfd_put_32 (output_bfd, insn2, contents + offset);
12051               rel--;
12052               continue;
12053             }
12054           break;
12055
12056         case R_PPC64_DTPMOD64:
12057           if (rel + 1 < relend
12058               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12059               && rel[1].r_offset == rel->r_offset + 8)
12060             {
12061               if ((tls_mask & TLS_GD) == 0)
12062                 {
12063                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12064                   if ((tls_mask & TLS_TPRELGD) != 0)
12065                     r_type = R_PPC64_TPREL64;
12066                   else
12067                     {
12068                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12069                       r_type = R_PPC64_NONE;
12070                     }
12071                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12072                 }
12073             }
12074           else
12075             {
12076               if ((tls_mask & TLS_LD) == 0)
12077                 {
12078                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12079                   r_type = R_PPC64_NONE;
12080                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12081                 }
12082             }
12083           break;
12084
12085         case R_PPC64_TPREL64:
12086           if ((tls_mask & TLS_TPREL) == 0)
12087             {
12088               r_type = R_PPC64_NONE;
12089               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12090             }
12091           break;
12092         }
12093
12094       /* Handle other relocations that tweak non-addend part of insn.  */
12095       insn = 0;
12096       max_br_offset = 1 << 25;
12097       addend = rel->r_addend;
12098       switch (r_type)
12099         {
12100         default:
12101           break;
12102
12103           /* Branch taken prediction relocations.  */
12104         case R_PPC64_ADDR14_BRTAKEN:
12105         case R_PPC64_REL14_BRTAKEN:
12106           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12107           /* Fall thru.  */
12108
12109           /* Branch not taken prediction relocations.  */
12110         case R_PPC64_ADDR14_BRNTAKEN:
12111         case R_PPC64_REL14_BRNTAKEN:
12112           insn |= bfd_get_32 (output_bfd,
12113                               contents + rel->r_offset) & ~(0x01 << 21);
12114           /* Fall thru.  */
12115
12116         case R_PPC64_REL14:
12117           max_br_offset = 1 << 15;
12118           /* Fall thru.  */
12119
12120         case R_PPC64_REL24:
12121           /* Calls to functions with a different TOC, such as calls to
12122              shared objects, need to alter the TOC pointer.  This is
12123              done using a linkage stub.  A REL24 branching to these
12124              linkage stubs needs to be followed by a nop, as the nop
12125              will be replaced with an instruction to restore the TOC
12126              base pointer.  */
12127           fdh = h;
12128           if (h != NULL
12129               && h->oh != NULL
12130               && h->oh->is_func_descriptor)
12131             fdh = ppc_follow_link (h->oh);
12132           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12133           if (stub_entry != NULL
12134               && (stub_entry->stub_type == ppc_stub_plt_call
12135                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12136                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12137             {
12138               bfd_boolean can_plt_call = FALSE;
12139
12140               if (rel->r_offset + 8 <= input_section->size)
12141                 {
12142                   unsigned long nop;
12143                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12144                   if (nop == NOP
12145                       || nop == CROR_151515 || nop == CROR_313131)
12146                     {
12147                       if (h != NULL
12148                           && (h == htab->tls_get_addr_fd
12149                               || h == htab->tls_get_addr)
12150                           && !htab->no_tls_get_addr_opt)
12151                         {
12152                           /* Special stub used, leave nop alone.  */
12153                         }
12154                       else
12155                         bfd_put_32 (input_bfd, LD_R2_40R1,
12156                                     contents + rel->r_offset + 4);
12157                       can_plt_call = TRUE;
12158                     }
12159                 }
12160
12161               if (!can_plt_call)
12162                 {
12163                   if (stub_entry->stub_type == ppc_stub_plt_call)
12164                     {
12165                       /* If this is a plain branch rather than a branch
12166                          and link, don't require a nop.  However, don't
12167                          allow tail calls in a shared library as they
12168                          will result in r2 being corrupted.  */
12169                       unsigned long br;
12170                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12171                       if (info->executable && (br & 1) == 0)
12172                         can_plt_call = TRUE;
12173                       else
12174                         stub_entry = NULL;
12175                     }
12176                   else if (h != NULL
12177                            && strcmp (h->elf.root.root.string,
12178                                       ".__libc_start_main") == 0)
12179                     {
12180                       /* Allow crt1 branch to go via a toc adjusting stub.  */
12181                       can_plt_call = TRUE;
12182                     }
12183                   else
12184                     {
12185                       if (strcmp (input_section->output_section->name,
12186                                   ".init") == 0
12187                           || strcmp (input_section->output_section->name,
12188                                      ".fini") == 0)
12189                         (*_bfd_error_handler)
12190                           (_("%B(%A+0x%lx): automatic multiple TOCs "
12191                              "not supported using your crt files; "
12192                              "recompile with -mminimal-toc or upgrade gcc"),
12193                            input_bfd,
12194                            input_section,
12195                            (long) rel->r_offset);
12196                       else
12197                         (*_bfd_error_handler)
12198                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
12199                              "does not allow automatic multiple TOCs; "
12200                              "recompile with -mminimal-toc or "
12201                              "-fno-optimize-sibling-calls, "
12202                              "or make `%s' extern"),
12203                            input_bfd,
12204                            input_section,
12205                            (long) rel->r_offset,
12206                            sym_name,
12207                            sym_name);
12208                       bfd_set_error (bfd_error_bad_value);
12209                       ret = FALSE;
12210                     }
12211                 }
12212
12213               if (can_plt_call
12214                   && stub_entry->stub_type == ppc_stub_plt_call)
12215                 unresolved_reloc = FALSE;
12216             }
12217
12218           if ((stub_entry == NULL
12219                || stub_entry->stub_type == ppc_stub_long_branch
12220                || stub_entry->stub_type == ppc_stub_plt_branch)
12221               && get_opd_info (sec) != NULL)
12222             {
12223               /* The branch destination is the value of the opd entry. */
12224               bfd_vma off = (relocation + addend
12225                              - sec->output_section->vma
12226                              - sec->output_offset);
12227               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12228               if (dest != (bfd_vma) -1)
12229                 {
12230                   relocation = dest;
12231                   addend = 0;
12232                 }
12233             }
12234
12235           /* If the branch is out of reach we ought to have a long
12236              branch stub.  */
12237           from = (rel->r_offset
12238                   + input_section->output_offset
12239                   + input_section->output_section->vma);
12240
12241           if (stub_entry != NULL
12242               && (stub_entry->stub_type == ppc_stub_long_branch
12243                   || stub_entry->stub_type == ppc_stub_plt_branch)
12244               && (r_type == R_PPC64_ADDR14_BRTAKEN
12245                   || r_type == R_PPC64_ADDR14_BRNTAKEN
12246                   || (relocation + addend - from + max_br_offset
12247                       < 2 * max_br_offset)))
12248             /* Don't use the stub if this branch is in range.  */
12249             stub_entry = NULL;
12250
12251           if (stub_entry != NULL)
12252             {
12253               /* Munge up the value and addend so that we call the stub
12254                  rather than the procedure directly.  */
12255               relocation = (stub_entry->stub_offset
12256                             + stub_entry->stub_sec->output_offset
12257                             + stub_entry->stub_sec->output_section->vma);
12258               addend = 0;
12259             }
12260
12261           if (insn != 0)
12262             {
12263               if (is_power4)
12264                 {
12265                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12266                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12267                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12268                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12269                     insn |= 0x02 << 21;
12270                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12271                     insn |= 0x08 << 21;
12272                   else
12273                     break;
12274                 }
12275               else
12276                 {
12277                   /* Invert 'y' bit if not the default.  */
12278                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12279                     insn ^= 0x01 << 21;
12280                 }
12281
12282               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12283             }
12284
12285           /* NOP out calls to undefined weak functions.
12286              We can thus call a weak function without first
12287              checking whether the function is defined.  */
12288           else if (h != NULL
12289                    && h->elf.root.type == bfd_link_hash_undefweak
12290                    && h->elf.dynindx == -1
12291                    && r_type == R_PPC64_REL24
12292                    && relocation == 0
12293                    && addend == 0)
12294             {
12295               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12296               continue;
12297             }
12298           break;
12299         }
12300
12301       /* Set `addend'.  */
12302       tls_type = 0;
12303       switch (r_type)
12304         {
12305         default:
12306           (*_bfd_error_handler)
12307             (_("%B: unknown relocation type %d for symbol %s"),
12308              input_bfd, (int) r_type, sym_name);
12309
12310           bfd_set_error (bfd_error_bad_value);
12311           ret = FALSE;
12312           continue;
12313
12314         case R_PPC64_NONE:
12315         case R_PPC64_TLS:
12316         case R_PPC64_TLSGD:
12317         case R_PPC64_TLSLD:
12318         case R_PPC64_GNU_VTINHERIT:
12319         case R_PPC64_GNU_VTENTRY:
12320           continue;
12321
12322           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12323              address in the GOT as relocation value instead of the
12324              symbol's value itself.  Also, create a GOT entry for the
12325              symbol and put the symbol value there.  */
12326         case R_PPC64_GOT_TLSGD16:
12327         case R_PPC64_GOT_TLSGD16_LO:
12328         case R_PPC64_GOT_TLSGD16_HI:
12329         case R_PPC64_GOT_TLSGD16_HA:
12330           tls_type = TLS_TLS | TLS_GD;
12331           goto dogot;
12332
12333         case R_PPC64_GOT_TLSLD16:
12334         case R_PPC64_GOT_TLSLD16_LO:
12335         case R_PPC64_GOT_TLSLD16_HI:
12336         case R_PPC64_GOT_TLSLD16_HA:
12337           tls_type = TLS_TLS | TLS_LD;
12338           goto dogot;
12339
12340         case R_PPC64_GOT_TPREL16_DS:
12341         case R_PPC64_GOT_TPREL16_LO_DS:
12342         case R_PPC64_GOT_TPREL16_HI:
12343         case R_PPC64_GOT_TPREL16_HA:
12344           tls_type = TLS_TLS | TLS_TPREL;
12345           goto dogot;
12346
12347         case R_PPC64_GOT_DTPREL16_DS:
12348         case R_PPC64_GOT_DTPREL16_LO_DS:
12349         case R_PPC64_GOT_DTPREL16_HI:
12350         case R_PPC64_GOT_DTPREL16_HA:
12351           tls_type = TLS_TLS | TLS_DTPREL;
12352           goto dogot;
12353
12354         case R_PPC64_GOT16:
12355         case R_PPC64_GOT16_LO:
12356         case R_PPC64_GOT16_HI:
12357         case R_PPC64_GOT16_HA:
12358         case R_PPC64_GOT16_DS:
12359         case R_PPC64_GOT16_LO_DS:
12360         dogot:
12361           {
12362             /* Relocation is to the entry for this symbol in the global
12363                offset table.  */
12364             asection *got;
12365             bfd_vma *offp;
12366             bfd_vma off;
12367             unsigned long indx = 0;
12368             struct got_entry *ent;
12369
12370             if (tls_type == (TLS_TLS | TLS_LD)
12371                 && (h == NULL
12372                     || !h->elf.def_dynamic))
12373               ent = ppc64_tlsld_got (input_bfd);
12374             else
12375               {
12376
12377                 if (h != NULL)
12378                   {
12379                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12380                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12381                                                           &h->elf)
12382                         || (info->shared
12383                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12384                       /* This is actually a static link, or it is a
12385                          -Bsymbolic link and the symbol is defined
12386                          locally, or the symbol was forced to be local
12387                          because of a version file.  */
12388                       ;
12389                     else
12390                       {
12391                         indx = h->elf.dynindx;
12392                         unresolved_reloc = FALSE;
12393                       }
12394                     ent = h->elf.got.glist;
12395                   }
12396                 else
12397                   {
12398                     if (local_got_ents == NULL)
12399                       abort ();
12400                     ent = local_got_ents[r_symndx];
12401                   }
12402
12403                 for (; ent != NULL; ent = ent->next)
12404                   if (ent->addend == orig_addend
12405                       && ent->owner == input_bfd
12406                       && ent->tls_type == tls_type)
12407                     break;
12408               }
12409
12410             if (ent == NULL)
12411               abort ();
12412             if (ent->is_indirect)
12413               ent = ent->got.ent;
12414             offp = &ent->got.offset;
12415             got = ppc64_elf_tdata (ent->owner)->got;
12416             if (got == NULL)
12417               abort ();
12418
12419             /* The offset must always be a multiple of 8.  We use the
12420                least significant bit to record whether we have already
12421                processed this entry.  */
12422             off = *offp;
12423             if ((off & 1) != 0)
12424               off &= ~1;
12425             else
12426               {
12427                 /* Generate relocs for the dynamic linker, except in
12428                    the case of TLSLD where we'll use one entry per
12429                    module.  */
12430                 asection *relgot;
12431                 bfd_boolean ifunc;
12432
12433                 *offp = off | 1;
12434                 relgot = NULL;
12435                 ifunc = (h != NULL
12436                          ? h->elf.type == STT_GNU_IFUNC
12437                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12438                 if ((info->shared || indx != 0)
12439                     && (h == NULL
12440                         || (tls_type == (TLS_TLS | TLS_LD)
12441                             && !h->elf.def_dynamic)
12442                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12443                         || h->elf.root.type != bfd_link_hash_undefweak))
12444                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12445                 else if (ifunc)
12446                   relgot = htab->reliplt;
12447                 if (relgot != NULL)
12448                   {
12449                     outrel.r_offset = (got->output_section->vma
12450                                        + got->output_offset
12451                                        + off);
12452                     outrel.r_addend = addend;
12453                     if (tls_type & (TLS_LD | TLS_GD))
12454                       {
12455                         outrel.r_addend = 0;
12456                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12457                         if (tls_type == (TLS_TLS | TLS_GD))
12458                           {
12459                             loc = relgot->contents;
12460                             loc += (relgot->reloc_count++
12461                                     * sizeof (Elf64_External_Rela));
12462                             bfd_elf64_swap_reloca_out (output_bfd,
12463                                                        &outrel, loc);
12464                             outrel.r_offset += 8;
12465                             outrel.r_addend = addend;
12466                             outrel.r_info
12467                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12468                           }
12469                       }
12470                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12471                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12472                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12473                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12474                     else if (indx != 0)
12475                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12476                     else
12477                       {
12478                         if (ifunc)
12479                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12480                         else
12481                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12482
12483                         /* Write the .got section contents for the sake
12484                            of prelink.  */
12485                         loc = got->contents + off;
12486                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12487                                     loc);
12488                       }
12489
12490                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12491                       {
12492                         outrel.r_addend += relocation;
12493                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12494                           outrel.r_addend -= htab->elf.tls_sec->vma;
12495                       }
12496                     loc = relgot->contents;
12497                     loc += (relgot->reloc_count++
12498                             * sizeof (Elf64_External_Rela));
12499                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12500                   }
12501
12502                 /* Init the .got section contents here if we're not
12503                    emitting a reloc.  */
12504                 else
12505                   {
12506                     relocation += addend;
12507                     if (tls_type == (TLS_TLS | TLS_LD))
12508                       relocation = 1;
12509                     else if (tls_type != 0)
12510                       {
12511                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12512                         if (tls_type == (TLS_TLS | TLS_TPREL))
12513                           relocation += DTP_OFFSET - TP_OFFSET;
12514
12515                         if (tls_type == (TLS_TLS | TLS_GD))
12516                           {
12517                             bfd_put_64 (output_bfd, relocation,
12518                                         got->contents + off + 8);
12519                             relocation = 1;
12520                           }
12521                       }
12522
12523                     bfd_put_64 (output_bfd, relocation,
12524                                 got->contents + off);
12525                   }
12526               }
12527
12528             if (off >= (bfd_vma) -2)
12529               abort ();
12530
12531             relocation = got->output_section->vma + got->output_offset + off;
12532             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12533           }
12534           break;
12535
12536         case R_PPC64_PLT16_HA:
12537         case R_PPC64_PLT16_HI:
12538         case R_PPC64_PLT16_LO:
12539         case R_PPC64_PLT32:
12540         case R_PPC64_PLT64:
12541           /* Relocation is to the entry for this symbol in the
12542              procedure linkage table.  */
12543
12544           /* Resolve a PLT reloc against a local symbol directly,
12545              without using the procedure linkage table.  */
12546           if (h == NULL)
12547             break;
12548
12549           /* It's possible that we didn't make a PLT entry for this
12550              symbol.  This happens when statically linking PIC code,
12551              or when using -Bsymbolic.  Go find a match if there is a
12552              PLT entry.  */
12553           if (htab->plt != NULL)
12554             {
12555               struct plt_entry *ent;
12556               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12557                 if (ent->addend == orig_addend
12558                     && ent->plt.offset != (bfd_vma) -1)
12559                   {
12560                     relocation = (htab->plt->output_section->vma
12561                                   + htab->plt->output_offset
12562                                   + ent->plt.offset);
12563                     unresolved_reloc = FALSE;
12564                   }
12565             }
12566           break;
12567
12568         case R_PPC64_TOC:
12569           /* Relocation value is TOC base.  */
12570           relocation = TOCstart;
12571           if (r_symndx == 0)
12572             relocation += htab->stub_group[input_section->id].toc_off;
12573           else if (unresolved_reloc)
12574             ;
12575           else if (sec != NULL && sec->id <= htab->top_id)
12576             relocation += htab->stub_group[sec->id].toc_off;
12577           else
12578             unresolved_reloc = TRUE;
12579           goto dodyn;
12580
12581           /* TOC16 relocs.  We want the offset relative to the TOC base,
12582              which is the address of the start of the TOC plus 0x8000.
12583              The TOC consists of sections .got, .toc, .tocbss, and .plt,
12584              in this order.  */
12585         case R_PPC64_TOC16:
12586         case R_PPC64_TOC16_LO:
12587         case R_PPC64_TOC16_HI:
12588         case R_PPC64_TOC16_DS:
12589         case R_PPC64_TOC16_LO_DS:
12590         case R_PPC64_TOC16_HA:
12591           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12592           break;
12593
12594           /* Relocate against the beginning of the section.  */
12595         case R_PPC64_SECTOFF:
12596         case R_PPC64_SECTOFF_LO:
12597         case R_PPC64_SECTOFF_HI:
12598         case R_PPC64_SECTOFF_DS:
12599         case R_PPC64_SECTOFF_LO_DS:
12600         case R_PPC64_SECTOFF_HA:
12601           if (sec != NULL)
12602             addend -= sec->output_section->vma;
12603           break;
12604
12605         case R_PPC64_REL16:
12606         case R_PPC64_REL16_LO:
12607         case R_PPC64_REL16_HI:
12608         case R_PPC64_REL16_HA:
12609           break;
12610
12611         case R_PPC64_REL14:
12612         case R_PPC64_REL14_BRNTAKEN:
12613         case R_PPC64_REL14_BRTAKEN:
12614         case R_PPC64_REL24:
12615           break;
12616
12617         case R_PPC64_TPREL16:
12618         case R_PPC64_TPREL16_LO:
12619         case R_PPC64_TPREL16_HI:
12620         case R_PPC64_TPREL16_HA:
12621         case R_PPC64_TPREL16_DS:
12622         case R_PPC64_TPREL16_LO_DS:
12623         case R_PPC64_TPREL16_HIGHER:
12624         case R_PPC64_TPREL16_HIGHERA:
12625         case R_PPC64_TPREL16_HIGHEST:
12626         case R_PPC64_TPREL16_HIGHESTA:
12627           if (h != NULL
12628               && h->elf.root.type == bfd_link_hash_undefweak
12629               && h->elf.dynindx == -1)
12630             {
12631               /* Make this relocation against an undefined weak symbol
12632                  resolve to zero.  This is really just a tweak, since
12633                  code using weak externs ought to check that they are
12634                  defined before using them.  */
12635               bfd_byte *p = contents + rel->r_offset - d_offset;
12636
12637               insn = bfd_get_32 (output_bfd, p);
12638               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12639               if (insn != 0)
12640                 bfd_put_32 (output_bfd, insn, p);
12641               break;
12642             }
12643           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12644           if (info->shared)
12645             /* The TPREL16 relocs shouldn't really be used in shared
12646                libs as they will result in DT_TEXTREL being set, but
12647                support them anyway.  */
12648             goto dodyn;
12649           break;
12650
12651         case R_PPC64_DTPREL16:
12652         case R_PPC64_DTPREL16_LO:
12653         case R_PPC64_DTPREL16_HI:
12654         case R_PPC64_DTPREL16_HA:
12655         case R_PPC64_DTPREL16_DS:
12656         case R_PPC64_DTPREL16_LO_DS:
12657         case R_PPC64_DTPREL16_HIGHER:
12658         case R_PPC64_DTPREL16_HIGHERA:
12659         case R_PPC64_DTPREL16_HIGHEST:
12660         case R_PPC64_DTPREL16_HIGHESTA:
12661           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12662           break;
12663
12664         case R_PPC64_DTPMOD64:
12665           relocation = 1;
12666           addend = 0;
12667           goto dodyn;
12668
12669         case R_PPC64_TPREL64:
12670           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12671           goto dodyn;
12672
12673         case R_PPC64_DTPREL64:
12674           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12675           /* Fall thru */
12676
12677           /* Relocations that may need to be propagated if this is a
12678              dynamic object.  */
12679         case R_PPC64_REL30:
12680         case R_PPC64_REL32:
12681         case R_PPC64_REL64:
12682         case R_PPC64_ADDR14:
12683         case R_PPC64_ADDR14_BRNTAKEN:
12684         case R_PPC64_ADDR14_BRTAKEN:
12685         case R_PPC64_ADDR16:
12686         case R_PPC64_ADDR16_DS:
12687         case R_PPC64_ADDR16_HA:
12688         case R_PPC64_ADDR16_HI:
12689         case R_PPC64_ADDR16_HIGHER:
12690         case R_PPC64_ADDR16_HIGHERA:
12691         case R_PPC64_ADDR16_HIGHEST:
12692         case R_PPC64_ADDR16_HIGHESTA:
12693         case R_PPC64_ADDR16_LO:
12694         case R_PPC64_ADDR16_LO_DS:
12695         case R_PPC64_ADDR24:
12696         case R_PPC64_ADDR32:
12697         case R_PPC64_ADDR64:
12698         case R_PPC64_UADDR16:
12699         case R_PPC64_UADDR32:
12700         case R_PPC64_UADDR64:
12701         dodyn:
12702           if ((input_section->flags & SEC_ALLOC) == 0)
12703             break;
12704
12705           if (NO_OPD_RELOCS && is_opd)
12706             break;
12707
12708           if ((info->shared
12709                && (h == NULL
12710                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12711                    || h->elf.root.type != bfd_link_hash_undefweak)
12712                && (must_be_dyn_reloc (info, r_type)
12713                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12714               || (ELIMINATE_COPY_RELOCS
12715                   && !info->shared
12716                   && h != NULL
12717                   && h->elf.dynindx != -1
12718                   && !h->elf.non_got_ref
12719                   && !h->elf.def_regular)
12720               || (!info->shared
12721                   && (h != NULL
12722                       ? h->elf.type == STT_GNU_IFUNC
12723                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12724             {
12725               bfd_boolean skip, relocate;
12726               asection *sreloc;
12727               bfd_vma out_off;
12728
12729               /* When generating a dynamic object, these relocations
12730                  are copied into the output file to be resolved at run
12731                  time.  */
12732
12733               skip = FALSE;
12734               relocate = FALSE;
12735
12736               out_off = _bfd_elf_section_offset (output_bfd, info,
12737                                                  input_section, rel->r_offset);
12738               if (out_off == (bfd_vma) -1)
12739                 skip = TRUE;
12740               else if (out_off == (bfd_vma) -2)
12741                 skip = TRUE, relocate = TRUE;
12742               out_off += (input_section->output_section->vma
12743                           + input_section->output_offset);
12744               outrel.r_offset = out_off;
12745               outrel.r_addend = rel->r_addend;
12746
12747               /* Optimize unaligned reloc use.  */
12748               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
12749                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
12750                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
12751               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
12752                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
12753                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
12754               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
12755                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
12756                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
12757
12758               if (skip)
12759                 memset (&outrel, 0, sizeof outrel);
12760               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
12761                        && !is_opd
12762                        && r_type != R_PPC64_TOC)
12763                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
12764               else
12765                 {
12766                   /* This symbol is local, or marked to become local,
12767                      or this is an opd section reloc which must point
12768                      at a local function.  */
12769                   outrel.r_addend += relocation;
12770                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12771                     {
12772                       if (is_opd && h != NULL)
12773                         {
12774                           /* Lie about opd entries.  This case occurs
12775                              when building shared libraries and we
12776                              reference a function in another shared
12777                              lib.  The same thing happens for a weak
12778                              definition in an application that's
12779                              overridden by a strong definition in a
12780                              shared lib.  (I believe this is a generic
12781                              bug in binutils handling of weak syms.)
12782                              In these cases we won't use the opd
12783                              entry in this lib.  */
12784                           unresolved_reloc = FALSE;
12785                         }
12786                       if (!is_opd
12787                           && r_type == R_PPC64_ADDR64
12788                           && (h != NULL
12789                               ? h->elf.type == STT_GNU_IFUNC
12790                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12791                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12792                       else
12793                         {
12794                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12795
12796                           /* We need to relocate .opd contents for ld.so.
12797                              Prelink also wants simple and consistent rules
12798                              for relocs.  This make all RELATIVE relocs have
12799                              *r_offset equal to r_addend.  */
12800                           relocate = TRUE;
12801                         }
12802                     }
12803                   else
12804                     {
12805                       long indx = 0;
12806
12807                       if (h != NULL
12808                           ? h->elf.type == STT_GNU_IFUNC
12809                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12810                         {
12811                           (*_bfd_error_handler)
12812                             (_("%B(%A+0x%lx): relocation %s for indirect "
12813                                "function %s unsupported"),
12814                              input_bfd,
12815                              input_section,
12816                              (long) rel->r_offset,
12817                              ppc64_elf_howto_table[r_type]->name,
12818                              sym_name);
12819                           ret = FALSE;
12820                         }
12821                       else if (r_symndx == 0 || bfd_is_abs_section (sec))
12822                         ;
12823                       else if (sec == NULL || sec->owner == NULL)
12824                         {
12825                           bfd_set_error (bfd_error_bad_value);
12826                           return FALSE;
12827                         }
12828                       else
12829                         {
12830                           asection *osec;
12831
12832                           osec = sec->output_section;
12833                           indx = elf_section_data (osec)->dynindx;
12834
12835                           if (indx == 0)
12836                             {
12837                               if ((osec->flags & SEC_READONLY) == 0
12838                                   && htab->elf.data_index_section != NULL)
12839                                 osec = htab->elf.data_index_section;
12840                               else
12841                                 osec = htab->elf.text_index_section;
12842                               indx = elf_section_data (osec)->dynindx;
12843                             }
12844                           BFD_ASSERT (indx != 0);
12845
12846                           /* We are turning this relocation into one
12847                              against a section symbol, so subtract out
12848                              the output section's address but not the
12849                              offset of the input section in the output
12850                              section.  */
12851                           outrel.r_addend -= osec->vma;
12852                         }
12853
12854                       outrel.r_info = ELF64_R_INFO (indx, r_type);
12855                     }
12856                 }
12857
12858               sreloc = elf_section_data (input_section)->sreloc;
12859               if (!htab->elf.dynamic_sections_created)
12860                 sreloc = htab->reliplt;
12861               if (sreloc == NULL)
12862                 abort ();
12863
12864               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
12865                   >= sreloc->size)
12866                 abort ();
12867               loc = sreloc->contents;
12868               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
12869               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12870
12871               /* If this reloc is against an external symbol, it will
12872                  be computed at runtime, so there's no need to do
12873                  anything now.  However, for the sake of prelink ensure
12874                  that the section contents are a known value.  */
12875               if (! relocate)
12876                 {
12877                   unresolved_reloc = FALSE;
12878                   /* The value chosen here is quite arbitrary as ld.so
12879                      ignores section contents except for the special
12880                      case of .opd where the contents might be accessed
12881                      before relocation.  Choose zero, as that won't
12882                      cause reloc overflow.  */
12883                   relocation = 0;
12884                   addend = 0;
12885                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
12886                      to improve backward compatibility with older
12887                      versions of ld.  */
12888                   if (r_type == R_PPC64_ADDR64)
12889                     addend = outrel.r_addend;
12890                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
12891                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
12892                     addend = (input_section->output_section->vma
12893                               + input_section->output_offset
12894                               + rel->r_offset);
12895                 }
12896             }
12897           break;
12898
12899         case R_PPC64_COPY:
12900         case R_PPC64_GLOB_DAT:
12901         case R_PPC64_JMP_SLOT:
12902         case R_PPC64_JMP_IREL:
12903         case R_PPC64_RELATIVE:
12904           /* We shouldn't ever see these dynamic relocs in relocatable
12905              files.  */
12906           /* Fall through.  */
12907
12908         case R_PPC64_PLTGOT16:
12909         case R_PPC64_PLTGOT16_DS:
12910         case R_PPC64_PLTGOT16_HA:
12911         case R_PPC64_PLTGOT16_HI:
12912         case R_PPC64_PLTGOT16_LO:
12913         case R_PPC64_PLTGOT16_LO_DS:
12914         case R_PPC64_PLTREL32:
12915         case R_PPC64_PLTREL64:
12916           /* These ones haven't been implemented yet.  */
12917
12918           (*_bfd_error_handler)
12919             (_("%B: relocation %s is not supported for symbol %s."),
12920              input_bfd,
12921              ppc64_elf_howto_table[r_type]->name, sym_name);
12922
12923           bfd_set_error (bfd_error_invalid_operation);
12924           ret = FALSE;
12925           continue;
12926         }
12927
12928       /* Multi-instruction sequences that access the TOC can be
12929          optimized, eg. addis ra,r2,0; addi rb,ra,x;
12930          to             nop;           addi rb,r2,x;  */
12931       switch (r_type)
12932         {
12933         default:
12934           break;
12935
12936         case R_PPC64_GOT_TLSLD16_HI:
12937         case R_PPC64_GOT_TLSGD16_HI:
12938         case R_PPC64_GOT_TPREL16_HI:
12939         case R_PPC64_GOT_DTPREL16_HI:
12940         case R_PPC64_GOT16_HI:
12941         case R_PPC64_TOC16_HI:
12942           /* These relocs would only be useful if building up an
12943              offset to later add to r2, perhaps in an indexed
12944              addressing mode instruction.  Don't try to optimize.
12945              Unfortunately, the possibility of someone building up an
12946              offset like this or even with the HA relocs, means that
12947              we need to check the high insn when optimizing the low
12948              insn.  */
12949           break;
12950
12951         case R_PPC64_GOT_TLSLD16_HA:
12952         case R_PPC64_GOT_TLSGD16_HA:
12953         case R_PPC64_GOT_TPREL16_HA:
12954         case R_PPC64_GOT_DTPREL16_HA:
12955         case R_PPC64_GOT16_HA:
12956         case R_PPC64_TOC16_HA:
12957           /* nop is done later.  */
12958           break;
12959
12960         case R_PPC64_GOT_TLSLD16_LO:
12961         case R_PPC64_GOT_TLSGD16_LO:
12962         case R_PPC64_GOT_TPREL16_LO_DS:
12963         case R_PPC64_GOT_DTPREL16_LO_DS:
12964         case R_PPC64_GOT16_LO:
12965         case R_PPC64_GOT16_LO_DS:
12966         case R_PPC64_TOC16_LO:
12967         case R_PPC64_TOC16_LO_DS:
12968           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000)
12969             {
12970               bfd_byte *p = contents + (rel->r_offset & ~3);
12971               insn = bfd_get_32 (input_bfd, p);
12972               if ((insn & (0x3f << 26)) == 14u << 26 /* addi */
12973                   || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
12974                   || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
12975                   || (insn & (0x3f << 26)) == 36u << 26 /* stw */
12976                   || (insn & (0x3f << 26)) == 38u << 26 /* stb */
12977                   || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
12978                   || (insn & (0x3f << 26)) == 42u << 26 /* lha */
12979                   || (insn & (0x3f << 26)) == 44u << 26 /* sth */
12980                   || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
12981                   || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
12982                   || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
12983                   || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
12984                   || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
12985                   || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
12986                   || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
12987                       && (insn & 3) != 1)
12988                   || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
12989                       && ((insn & 3) == 0 || (insn & 3) == 3)))
12990                 {
12991                   unsigned int reg = (insn >> 16) & 0x1f;
12992                   const Elf_Internal_Rela *ha;
12993                   bfd_boolean match_addend;
12994
12995                   match_addend = (sym != NULL
12996                                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION);
12997                   ha = ha_reloc_match (relocs, rel, &reg, match_addend,
12998                                        input_bfd, contents);
12999                   if (ha != NULL)
13000                     {
13001                       insn &= ~(0x1f << 16);
13002                       insn |= reg << 16;
13003                       bfd_put_32 (input_bfd, insn, p);
13004                       if (ha_opt == NULL)
13005                         {
13006                           ha_opt = bfd_zmalloc (input_section->reloc_count);
13007                           if (ha_opt == NULL)
13008                             return FALSE;
13009                         }
13010                       ha_opt[ha - relocs] = 1;
13011                     }
13012                   else
13013                     /* If we don't find a matching high part insn,
13014                        something is fishy.  Refuse to nop any high
13015                        part insn in this section.  */
13016                     no_ha_opt = TRUE;
13017                 }
13018             }
13019           break;
13020         }
13021
13022       /* Do any further special processing.  */
13023       switch (r_type)
13024         {
13025         default:
13026           break;
13027
13028         case R_PPC64_ADDR16_HA:
13029         case R_PPC64_REL16_HA:
13030         case R_PPC64_ADDR16_HIGHERA:
13031         case R_PPC64_ADDR16_HIGHESTA:
13032         case R_PPC64_TOC16_HA:
13033         case R_PPC64_SECTOFF_HA:
13034         case R_PPC64_TPREL16_HA:
13035         case R_PPC64_DTPREL16_HA:
13036         case R_PPC64_TPREL16_HIGHER:
13037         case R_PPC64_TPREL16_HIGHERA:
13038         case R_PPC64_TPREL16_HIGHEST:
13039         case R_PPC64_TPREL16_HIGHESTA:
13040         case R_PPC64_DTPREL16_HIGHER:
13041         case R_PPC64_DTPREL16_HIGHERA:
13042         case R_PPC64_DTPREL16_HIGHEST:
13043         case R_PPC64_DTPREL16_HIGHESTA:
13044           /* It's just possible that this symbol is a weak symbol
13045              that's not actually defined anywhere. In that case,
13046              'sec' would be NULL, and we should leave the symbol
13047              alone (it will be set to zero elsewhere in the link).  */
13048           if (sec == NULL)
13049             break;
13050           /* Fall thru */
13051
13052         case R_PPC64_GOT16_HA:
13053         case R_PPC64_PLTGOT16_HA:
13054         case R_PPC64_PLT16_HA:
13055         case R_PPC64_GOT_TLSGD16_HA:
13056         case R_PPC64_GOT_TLSLD16_HA:
13057         case R_PPC64_GOT_TPREL16_HA:
13058         case R_PPC64_GOT_DTPREL16_HA:
13059           /* Add 0x10000 if sign bit in 0:15 is set.
13060              Bits 0:15 are not used.  */
13061           addend += 0x8000;
13062           break;
13063
13064         case R_PPC64_ADDR16_DS:
13065         case R_PPC64_ADDR16_LO_DS:
13066         case R_PPC64_GOT16_DS:
13067         case R_PPC64_GOT16_LO_DS:
13068         case R_PPC64_PLT16_LO_DS:
13069         case R_PPC64_SECTOFF_DS:
13070         case R_PPC64_SECTOFF_LO_DS:
13071         case R_PPC64_TOC16_DS:
13072         case R_PPC64_TOC16_LO_DS:
13073         case R_PPC64_PLTGOT16_DS:
13074         case R_PPC64_PLTGOT16_LO_DS:
13075         case R_PPC64_GOT_TPREL16_DS:
13076         case R_PPC64_GOT_TPREL16_LO_DS:
13077         case R_PPC64_GOT_DTPREL16_DS:
13078         case R_PPC64_GOT_DTPREL16_LO_DS:
13079         case R_PPC64_TPREL16_DS:
13080         case R_PPC64_TPREL16_LO_DS:
13081         case R_PPC64_DTPREL16_DS:
13082         case R_PPC64_DTPREL16_LO_DS:
13083           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13084           mask = 3;
13085           /* If this reloc is against an lq insn, then the value must be
13086              a multiple of 16.  This is somewhat of a hack, but the
13087              "correct" way to do this by defining _DQ forms of all the
13088              _DS relocs bloats all reloc switches in this file.  It
13089              doesn't seem to make much sense to use any of these relocs
13090              in data, so testing the insn should be safe.  */
13091           if ((insn & (0x3f << 26)) == (56u << 26))
13092             mask = 15;
13093           if (((relocation + addend) & mask) != 0)
13094             {
13095               (*_bfd_error_handler)
13096                 (_("%B: error: relocation %s not a multiple of %d"),
13097                  input_bfd,
13098                  ppc64_elf_howto_table[r_type]->name,
13099                  mask + 1);
13100               bfd_set_error (bfd_error_bad_value);
13101               ret = FALSE;
13102               continue;
13103             }
13104           break;
13105         }
13106
13107       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13108          because such sections are not SEC_ALLOC and thus ld.so will
13109          not process them.  */
13110       if (unresolved_reloc
13111           && !((input_section->flags & SEC_DEBUGGING) != 0
13112                && h->elf.def_dynamic))
13113         {
13114           (*_bfd_error_handler)
13115             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
13116              input_bfd,
13117              input_section,
13118              (long) rel->r_offset,
13119              ppc64_elf_howto_table[(int) r_type]->name,
13120              h->elf.root.root.string);
13121           ret = FALSE;
13122         }
13123
13124       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13125                                     input_bfd,
13126                                     input_section,
13127                                     contents,
13128                                     rel->r_offset,
13129                                     relocation,
13130                                     addend);
13131
13132       if (r != bfd_reloc_ok)
13133         {
13134           if (sym_name == NULL)
13135             sym_name = "(null)";
13136           if (r == bfd_reloc_overflow)
13137             {
13138               if (warned)
13139                 continue;
13140               if (h != NULL
13141                   && h->elf.root.type == bfd_link_hash_undefweak
13142                   && ppc64_elf_howto_table[r_type]->pc_relative)
13143                 {
13144                   /* Assume this is a call protected by other code that
13145                      detects the symbol is undefined.  If this is the case,
13146                      we can safely ignore the overflow.  If not, the
13147                      program is hosed anyway, and a little warning isn't
13148                      going to help.  */
13149
13150                   continue;
13151                 }
13152
13153               if (!((*info->callbacks->reloc_overflow)
13154                     (info, (h ? &h->elf.root : NULL), sym_name,
13155                      ppc64_elf_howto_table[r_type]->name,
13156                      orig_addend, input_bfd, input_section, rel->r_offset)))
13157                 return FALSE;
13158             }
13159           else
13160             {
13161               (*_bfd_error_handler)
13162                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
13163                  input_bfd,
13164                  input_section,
13165                  (long) rel->r_offset,
13166                  ppc64_elf_howto_table[r_type]->name,
13167                  sym_name,
13168                  (int) r);
13169               ret = FALSE;
13170             }
13171         }
13172     }
13173
13174   if (ha_opt != NULL)
13175     {
13176       if (!no_ha_opt)
13177         {
13178           unsigned char *opt = ha_opt;
13179           rel = relocs;
13180           relend = relocs + input_section->reloc_count;
13181           for (; rel < relend; opt++, rel++)
13182             if (*opt != 0)
13183               {
13184                 bfd_byte *p = contents + (rel->r_offset & ~3);
13185                 bfd_put_32 (input_bfd, NOP, p);
13186               }
13187         }
13188       free (ha_opt);
13189     }
13190
13191   /* If we're emitting relocations, then shortly after this function
13192      returns, reloc offsets and addends for this section will be
13193      adjusted.  Worse, reloc symbol indices will be for the output
13194      file rather than the input.  Save a copy of the relocs for
13195      opd_entry_value.  */
13196   if (is_opd && (info->emitrelocations || info->relocatable))
13197     {
13198       bfd_size_type amt;
13199       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13200       rel = bfd_alloc (input_bfd, amt);
13201       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13202       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13203       if (rel == NULL)
13204         return FALSE;
13205       memcpy (rel, relocs, amt);
13206     }
13207   return ret;
13208 }
13209
13210 /* Adjust the value of any local symbols in opd sections.  */
13211
13212 static int
13213 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13214                               const char *name ATTRIBUTE_UNUSED,
13215                               Elf_Internal_Sym *elfsym,
13216                               asection *input_sec,
13217                               struct elf_link_hash_entry *h)
13218 {
13219   struct _opd_sec_data *opd;
13220   long adjust;
13221   bfd_vma value;
13222
13223   if (h != NULL)
13224     return 1;
13225
13226   opd = get_opd_info (input_sec);
13227   if (opd == NULL || opd->adjust == NULL)
13228     return 1;
13229
13230   value = elfsym->st_value - input_sec->output_offset;
13231   if (!info->relocatable)
13232     value -= input_sec->output_section->vma;
13233
13234   adjust = opd->adjust[value / 8];
13235   if (adjust == -1)
13236     return 2;
13237
13238   elfsym->st_value += adjust;
13239   return 1;
13240 }
13241
13242 /* Finish up dynamic symbol handling.  We set the contents of various
13243    dynamic sections here.  */
13244
13245 static bfd_boolean
13246 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13247                                  struct bfd_link_info *info,
13248                                  struct elf_link_hash_entry *h,
13249                                  Elf_Internal_Sym *sym)
13250 {
13251   struct ppc_link_hash_table *htab;
13252   struct plt_entry *ent;
13253   Elf_Internal_Rela rela;
13254   bfd_byte *loc;
13255
13256   htab = ppc_hash_table (info);
13257   if (htab == NULL)
13258     return FALSE;
13259
13260   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13261     if (ent->plt.offset != (bfd_vma) -1)
13262       {
13263         /* This symbol has an entry in the procedure linkage
13264            table.  Set it up.  */
13265         if (!htab->elf.dynamic_sections_created
13266             || h->dynindx == -1)
13267           {
13268             BFD_ASSERT (h->type == STT_GNU_IFUNC
13269                         && h->def_regular
13270                         && (h->root.type == bfd_link_hash_defined
13271                             || h->root.type == bfd_link_hash_defweak));
13272             rela.r_offset = (htab->iplt->output_section->vma
13273                              + htab->iplt->output_offset
13274                              + ent->plt.offset);
13275             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13276             rela.r_addend = (h->root.u.def.value
13277                              + h->root.u.def.section->output_offset
13278                              + h->root.u.def.section->output_section->vma
13279                              + ent->addend);
13280             loc = (htab->reliplt->contents
13281                    + (htab->reliplt->reloc_count++
13282                       * sizeof (Elf64_External_Rela)));
13283           }
13284         else
13285           {
13286             rela.r_offset = (htab->plt->output_section->vma
13287                              + htab->plt->output_offset
13288                              + ent->plt.offset);
13289             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13290             rela.r_addend = ent->addend;
13291             loc = (htab->relplt->contents
13292                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13293                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13294           }
13295         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13296       }
13297
13298   if (h->needs_copy)
13299     {
13300       /* This symbol needs a copy reloc.  Set it up.  */
13301
13302       if (h->dynindx == -1
13303           || (h->root.type != bfd_link_hash_defined
13304               && h->root.type != bfd_link_hash_defweak)
13305           || htab->relbss == NULL)
13306         abort ();
13307
13308       rela.r_offset = (h->root.u.def.value
13309                        + h->root.u.def.section->output_section->vma
13310                        + h->root.u.def.section->output_offset);
13311       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13312       rela.r_addend = 0;
13313       loc = htab->relbss->contents;
13314       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13315       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13316     }
13317
13318   /* Mark some specially defined symbols as absolute.  */
13319   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13320     sym->st_shndx = SHN_ABS;
13321
13322   return TRUE;
13323 }
13324
13325 /* Used to decide how to sort relocs in an optimal manner for the
13326    dynamic linker, before writing them out.  */
13327
13328 static enum elf_reloc_type_class
13329 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13330 {
13331   enum elf_ppc64_reloc_type r_type;
13332
13333   r_type = ELF64_R_TYPE (rela->r_info);
13334   switch (r_type)
13335     {
13336     case R_PPC64_RELATIVE:
13337       return reloc_class_relative;
13338     case R_PPC64_JMP_SLOT:
13339       return reloc_class_plt;
13340     case R_PPC64_COPY:
13341       return reloc_class_copy;
13342     default:
13343       return reloc_class_normal;
13344     }
13345 }
13346
13347 /* Finish up the dynamic sections.  */
13348
13349 static bfd_boolean
13350 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13351                                    struct bfd_link_info *info)
13352 {
13353   struct ppc_link_hash_table *htab;
13354   bfd *dynobj;
13355   asection *sdyn;
13356
13357   htab = ppc_hash_table (info);
13358   if (htab == NULL)
13359     return FALSE;
13360
13361   dynobj = htab->elf.dynobj;
13362   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13363
13364   if (htab->elf.dynamic_sections_created)
13365     {
13366       Elf64_External_Dyn *dyncon, *dynconend;
13367
13368       if (sdyn == NULL || htab->got == NULL)
13369         abort ();
13370
13371       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13372       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13373       for (; dyncon < dynconend; dyncon++)
13374         {
13375           Elf_Internal_Dyn dyn;
13376           asection *s;
13377
13378           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13379
13380           switch (dyn.d_tag)
13381             {
13382             default:
13383               continue;
13384
13385             case DT_PPC64_GLINK:
13386               s = htab->glink;
13387               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13388               /* We stupidly defined DT_PPC64_GLINK to be the start
13389                  of glink rather than the first entry point, which is
13390                  what ld.so needs, and now have a bigger stub to
13391                  support automatic multiple TOCs.  */
13392               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13393               break;
13394
13395             case DT_PPC64_OPD:
13396               s = bfd_get_section_by_name (output_bfd, ".opd");
13397               if (s == NULL)
13398                 continue;
13399               dyn.d_un.d_ptr = s->vma;
13400               break;
13401
13402             case DT_PPC64_OPDSZ:
13403               s = bfd_get_section_by_name (output_bfd, ".opd");
13404               if (s == NULL)
13405                 continue;
13406               dyn.d_un.d_val = s->size;
13407               break;
13408
13409             case DT_PLTGOT:
13410               s = htab->plt;
13411               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13412               break;
13413
13414             case DT_JMPREL:
13415               s = htab->relplt;
13416               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13417               break;
13418
13419             case DT_PLTRELSZ:
13420               dyn.d_un.d_val = htab->relplt->size;
13421               break;
13422
13423             case DT_RELASZ:
13424               /* Don't count procedure linkage table relocs in the
13425                  overall reloc count.  */
13426               s = htab->relplt;
13427               if (s == NULL)
13428                 continue;
13429               dyn.d_un.d_val -= s->size;
13430               break;
13431
13432             case DT_RELA:
13433               /* We may not be using the standard ELF linker script.
13434                  If .rela.plt is the first .rela section, we adjust
13435                  DT_RELA to not include it.  */
13436               s = htab->relplt;
13437               if (s == NULL)
13438                 continue;
13439               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13440                 continue;
13441               dyn.d_un.d_ptr += s->size;
13442               break;
13443             }
13444
13445           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13446         }
13447     }
13448
13449   if (htab->got != NULL && htab->got->size != 0)
13450     {
13451       /* Fill in the first entry in the global offset table.
13452          We use it to hold the link-time TOCbase.  */
13453       bfd_put_64 (output_bfd,
13454                   elf_gp (output_bfd) + TOC_BASE_OFF,
13455                   htab->got->contents);
13456
13457       /* Set .got entry size.  */
13458       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13459     }
13460
13461   if (htab->plt != NULL && htab->plt->size != 0)
13462     {
13463       /* Set .plt entry size.  */
13464       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13465         = PLT_ENTRY_SIZE;
13466     }
13467
13468   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13469      brlt ourselves if emitrelocations.  */
13470   if (htab->brlt != NULL
13471       && htab->brlt->reloc_count != 0
13472       && !_bfd_elf_link_output_relocs (output_bfd,
13473                                        htab->brlt,
13474                                        &elf_section_data (htab->brlt)->rel_hdr,
13475                                        elf_section_data (htab->brlt)->relocs,
13476                                        NULL))
13477     return FALSE;
13478
13479   if (htab->glink != NULL
13480       && htab->glink->reloc_count != 0
13481       && !_bfd_elf_link_output_relocs (output_bfd,
13482                                        htab->glink,
13483                                        &elf_section_data (htab->glink)->rel_hdr,
13484                                        elf_section_data (htab->glink)->relocs,
13485                                        NULL))
13486     return FALSE;
13487
13488   /* We need to handle writing out multiple GOT sections ourselves,
13489      since we didn't add them to DYNOBJ.  We know dynobj is the first
13490      bfd.  */
13491   while ((dynobj = dynobj->link_next) != NULL)
13492     {
13493       asection *s;
13494
13495       if (!is_ppc64_elf (dynobj))
13496         continue;
13497
13498       s = ppc64_elf_tdata (dynobj)->got;
13499       if (s != NULL
13500           && s->size != 0
13501           && s->output_section != bfd_abs_section_ptr
13502           && !bfd_set_section_contents (output_bfd, s->output_section,
13503                                         s->contents, s->output_offset,
13504                                         s->size))
13505         return FALSE;
13506       s = ppc64_elf_tdata (dynobj)->relgot;
13507       if (s != NULL
13508           && s->size != 0
13509           && s->output_section != bfd_abs_section_ptr
13510           && !bfd_set_section_contents (output_bfd, s->output_section,
13511                                         s->contents, s->output_offset,
13512                                         s->size))
13513         return FALSE;
13514     }
13515
13516   return TRUE;
13517 }
13518
13519 #include "elf64-target.h"