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