bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *);
  58
  59 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_MACHINE_CODE        EM_PPC64
  65 #define ELF_MAXPAGESIZE         0x10000
  66 #define ELF_COMMONPAGESIZE      0x1000
  67 #define elf_info_to_howto       ppc64_elf_info_to_howto
  68
  69 #define elf_backend_want_got_sym 0
  70 #define elf_backend_want_plt_sym 0
  71 #define elf_backend_plt_alignment 3
  72 #define elf_backend_plt_not_loaded 1
  73 #define elf_backend_got_header_size 8
  74 #define elf_backend_can_gc_sections 1
  75 #define elf_backend_can_refcount 1
  76 #define elf_backend_rela_normal 1
  77 #define elf_backend_default_execstack 0
  78
  79 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  80 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
  82 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  83 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  84 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  85 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  86 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  87
  88 #define elf_backend_object_p                  ppc64_elf_object_p
  89 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  90 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  91 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  92 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  93 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  94 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  95 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  96 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
  97 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  98 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  99 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 100 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 101 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 102 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 103 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 104 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 105 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 106 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 107 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 108 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 109 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 110 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 111 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 112 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 113 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 114 #define elf_backend_special_sections          ppc64_elf_special_sections
 115 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 116
 117 /* The name of the dynamic interpreter.  This is put in the .interp
 118    section.  */
 119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 120
 121 /* The size in bytes of an entry in the procedure linkage table.  */
 122 #define PLT_ENTRY_SIZE 24
 123
 124 /* The initial size of the plt reserved for the dynamic linker.  */
 125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 126
 127 /* TOC base pointers offset from start of TOC.  */
 128 #define TOC_BASE_OFF    0x8000
 129
 130 /* Offset of tp and dtp pointers from start of TLS block.  */
 131 #define TP_OFFSET       0x7000
 132 #define DTP_OFFSET      0x8000
 133
 134 /* .plt call stub instructions.  The normal stub is like this, but
 135    sometimes the .plt entry crosses a 64k boundary and we need to
 136    insert an addi to adjust r12.  */
 137 #define PLT_CALL_STUB_SIZE (7*4)
 138 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 139 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 140 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 141 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 142 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 143                                         /* ld    %r11,xxx+16@l(%r12) */
 144 #define BCTR            0x4e800420      /* bctr                      */
 145
 146
 147 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 148 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 149 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 150 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 151
 152 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 153 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 154
 155 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 156
 157 /* glink call stub instructions.  We enter with the index in R0.  */
 158 #define GLINK_CALL_STUB_SIZE (16*4)
 159                                         /* 0:                           */
 160                                         /*  .quad plt0-1f               */
 161                                         /* __glink:                     */
 162 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 163 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 164                                         /* 1:                           */
 165 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 166 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 167 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 168 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 169                                         /*  ld %11,0(%12)               */
 170                                         /*  ld %2,8(%12)                */
 171                                         /*  mtctr %11                   */
 172                                         /*  ld %11,16(%12)              */
 173                                         /*  bctr                        */
 174
 175 /* Pad with this.  */
 176 #define NOP             0x60000000
 177
 178 /* Some other nops.  */
 179 #define CROR_151515     0x4def7b82
 180 #define CROR_313131     0x4ffffb82
 181
 182 /* .glink entries for the first 32k functions are two instructions.  */
 183 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 184 #define B_DOT           0x48000000      /* b     .              */
 185
 186 /* After that, we need two instructions to load the index, followed by
 187    a branch.  */
 188 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 189 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 190
 191 /* Instructions used by the save and restore reg functions.  */
 192 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 193 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 194 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 195 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 196 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 197 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 198 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 199 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 200 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 201 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 202 #define BLR             0x4e800020      /* blr                  */
 203
 204 /* Since .opd is an array of descriptors and each entry will end up
 205    with identical R_PPC64_RELATIVE relocs, there is really no need to
 206    propagate .opd relocs;  The dynamic linker should be taught to
 207    relocate .opd without reloc entries.  */
 208 #ifndef NO_OPD_RELOCS
 209 #define NO_OPD_RELOCS 0
 210 #endif
 211 \f
 212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 213
 214 /* Relocation HOWTO's.  */
 215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 216
 217 static reloc_howto_type ppc64_elf_howto_raw[] = {
 218   /* This reloc does nothing.  */
 219   HOWTO (R_PPC64_NONE,          /* type */
 220          0,                     /* rightshift */
 221          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          FALSE,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_dont, /* complain_on_overflow */
 226          bfd_elf_generic_reloc, /* special_function */
 227          "R_PPC64_NONE",        /* name */
 228          FALSE,                 /* partial_inplace */
 229          0,                     /* src_mask */
 230          0,                     /* dst_mask */
 231          FALSE),                /* pcrel_offset */
 232
 233   /* A standard 32 bit relocation.  */
 234   HOWTO (R_PPC64_ADDR32,        /* type */
 235          0,                     /* rightshift */
 236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          32,                    /* bitsize */
 238          FALSE,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_bitfield, /* complain_on_overflow */
 241          bfd_elf_generic_reloc, /* special_function */
 242          "R_PPC64_ADDR32",      /* name */
 243          FALSE,                 /* partial_inplace */
 244          0,                     /* src_mask */
 245          0xffffffff,            /* dst_mask */
 246          FALSE),                /* pcrel_offset */
 247
 248   /* An absolute 26 bit branch; the lower two bits must be zero.
 249      FIXME: we don't check that, we just clear them.  */
 250   HOWTO (R_PPC64_ADDR24,        /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          26,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_bitfield, /* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_PPC64_ADDR24",      /* name */
 259          FALSE,                 /* partial_inplace */
 260          0,                     /* src_mask */
 261          0x03fffffc,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   /* A standard 16 bit relocation.  */
 265   HOWTO (R_PPC64_ADDR16,        /* type */
 266          0,                     /* rightshift */
 267          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          16,                    /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_bitfield, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_ADDR16",      /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0xffff,                /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A 16 bit relocation without overflow.  */
 280   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 281          0,                     /* rightshift */
 282          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          16,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_dont,/* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR16_LO",   /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffff,                /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* Bits 16-31 of an address.  */
 295   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 296          16,                    /* rightshift */
 297          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_dont, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC64_ADDR16_HI",   /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0xffff,                /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 310      bits, treated as a signed number, is negative.  */
 311   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 312          16,                    /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_dont, /* complain_on_overflow */
 318          ppc64_elf_ha_reloc,    /* special_function */
 319          "R_PPC64_ADDR16_HA",   /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* An absolute 16 bit branch; the lower two bits must be zero.
 326      FIXME: we don't check that, we just clear them.  */
 327   HOWTO (R_PPC64_ADDR14,        /* type */
 328          0,                     /* rightshift */
 329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 330          16,                    /* bitsize */
 331          FALSE,                 /* pc_relative */
 332          0,                     /* bitpos */
 333          complain_overflow_bitfield, /* complain_on_overflow */
 334          ppc64_elf_branch_reloc, /* special_function */
 335          "R_PPC64_ADDR14",      /* name */
 336          FALSE,                 /* partial_inplace */
 337          0,                     /* src_mask */
 338          0x0000fffc,            /* dst_mask */
 339          FALSE),                /* pcrel_offset */
 340
 341   /* An absolute 16 bit branch, for which bit 10 should be set to
 342      indicate that the branch is expected to be taken.  The lower two
 343      bits must be zero.  */
 344   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          16,                    /* bitsize */
 348          FALSE,                 /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_bitfield, /* complain_on_overflow */
 351          ppc64_elf_brtaken_reloc, /* special_function */
 352          "R_PPC64_ADDR14_BRTAKEN",/* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x0000fffc,            /* dst_mask */
 356          FALSE),                /* pcrel_offset */
 357
 358   /* An absolute 16 bit branch, for which bit 10 should be set to
 359      indicate that the branch is not expected to be taken.  The lower
 360      two bits must be zero.  */
 361   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 362          0,                     /* rightshift */
 363          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_bitfield, /* complain_on_overflow */
 368          ppc64_elf_brtaken_reloc, /* special_function */
 369          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0x0000fffc,            /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* A relative 26 bit branch; the lower two bits must be zero.  */
 376   HOWTO (R_PPC64_REL24,         /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          26,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          ppc64_elf_branch_reloc, /* special_function */
 384          "R_PPC64_REL24",       /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0x03fffffc,            /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch; the lower two bits must be zero.  */
 391   HOWTO (R_PPC64_REL14,         /* type */
 392          0,                     /* rightshift */
 393          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 394          16,                    /* bitsize */
 395          TRUE,                  /* pc_relative */
 396          0,                     /* bitpos */
 397          complain_overflow_signed, /* complain_on_overflow */
 398          ppc64_elf_branch_reloc, /* special_function */
 399          "R_PPC64_REL14",       /* name */
 400          FALSE,                 /* partial_inplace */
 401          0,                     /* src_mask */
 402          0x0000fffc,            /* dst_mask */
 403          TRUE),                 /* pcrel_offset */
 404
 405   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 406      the branch is expected to be taken.  The lower two bits must be
 407      zero.  */
 408   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          ppc64_elf_brtaken_reloc, /* special_function */
 416          "R_PPC64_REL14_BRTAKEN", /* name */
 417          FALSE,                 /* partial_inplace */
 418          0,                     /* src_mask */
 419          0x0000fffc,            /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 423      the branch is not expected to be taken.  The lower two bits must
 424      be zero.  */
 425   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 426          0,                     /* rightshift */
 427          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          TRUE,                  /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_signed, /* complain_on_overflow */
 432          ppc64_elf_brtaken_reloc, /* special_function */
 433          "R_PPC64_REL14_BRNTAKEN",/* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0x0000fffc,            /* dst_mask */
 437          TRUE),                 /* pcrel_offset */
 438
 439   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 440      symbol.  */
 441   HOWTO (R_PPC64_GOT16,         /* type */
 442          0,                     /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_unhandled_reloc, /* special_function */
 449          "R_PPC64_GOT16",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                /* pcrel_offset */
 454
 455   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC64_GOT16_LO,      /* type */
 458          0,                     /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          ppc64_elf_unhandled_reloc, /* special_function */
 465          "R_PPC64_GOT16_LO",    /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 472      the symbol.  */
 473   HOWTO (R_PPC64_GOT16_HI,      /* type */
 474          16,                    /* rightshift */
 475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          16,                    /* bitsize */
 477          FALSE,                 /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_dont,/* complain_on_overflow */
 480          ppc64_elf_unhandled_reloc, /* special_function */
 481          "R_PPC64_GOT16_HI",    /* name */
 482          FALSE,                 /* partial_inplace */
 483          0,                     /* src_mask */
 484          0xffff,                /* dst_mask */
 485          FALSE),                /* pcrel_offset */
 486
 487   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 488      the symbol.  */
 489   HOWTO (R_PPC64_GOT16_HA,      /* type */
 490          16,                    /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_dont,/* complain_on_overflow */
 496          ppc64_elf_unhandled_reloc, /* special_function */
 497          "R_PPC64_GOT16_HA",    /* name */
 498          FALSE,                 /* partial_inplace */
 499          0,                     /* src_mask */
 500          0xffff,                /* dst_mask */
 501          FALSE),                /* pcrel_offset */
 502
 503   /* This is used only by the dynamic linker.  The symbol should exist
 504      both in the object being run and in some shared library.  The
 505      dynamic linker copies the data addressed by the symbol from the
 506      shared library into the object, because the object being
 507      run has to have the data at some particular address.  */
 508   HOWTO (R_PPC64_COPY,          /* type */
 509          0,                     /* rightshift */
 510          0,                     /* this one is variable size */
 511          0,                     /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_COPY",        /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0,                     /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR64, but used when setting global offset table
 523      entries.  */
 524   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 525          0,                     /* rightshift */
 526          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 527          64,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_dont, /* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc,  /* special_function */
 532          "R_PPC64_GLOB_DAT",    /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          ONES (64),             /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Created by the link editor.  Marks a procedure linkage table
 539      entry for a symbol.  */
 540   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 541          0,                     /* rightshift */
 542          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          0,                     /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_JMP_SLOT",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0,                     /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Used only by the dynamic linker.  When the object is run, this
 555      doubleword64 is set to the load address of the object, plus the
 556      addend.  */
 557   HOWTO (R_PPC64_RELATIVE,      /* type */
 558          0,                     /* rightshift */
 559          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 560          64,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_dont, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC64_RELATIVE",    /* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          ONES (64),             /* dst_mask */
 569          FALSE),                /* pcrel_offset */
 570
 571   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 572   HOWTO (R_PPC64_UADDR32,       /* type */
 573          0,                     /* rightshift */
 574          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          32,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_bitfield, /* complain_on_overflow */
 579          bfd_elf_generic_reloc, /* special_function */
 580          "R_PPC64_UADDR32",     /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffffffff,            /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 587   HOWTO (R_PPC64_UADDR16,       /* type */
 588          0,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          16,                    /* bitsize */
 591          FALSE,                 /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_bitfield, /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_PPC64_UADDR16",     /* name */
 596          FALSE,                 /* partial_inplace */
 597          0,                     /* src_mask */
 598          0xffff,                /* dst_mask */
 599          FALSE),                /* pcrel_offset */
 600
 601   /* 32-bit PC relative.  */
 602   HOWTO (R_PPC64_REL32,         /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 609          complain_overflow_signed, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_REL32",       /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          0xffffffff,            /* dst_mask */
 615          TRUE),                 /* pcrel_offset */
 616
 617   /* 32-bit relocation to the symbol's procedure linkage table.  */
 618   HOWTO (R_PPC64_PLT32,         /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          ppc64_elf_unhandled_reloc, /* special_function */
 626          "R_PPC64_PLT32",       /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 633      FIXME: R_PPC64_PLTREL32 not supported.  */
 634   HOWTO (R_PPC64_PLTREL32,      /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          TRUE,                  /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_signed, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_PPC64_PLTREL32",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          TRUE),                 /* pcrel_offset */
 647
 648   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC64_PLT16_LO,      /* type */
 651          0,                     /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          ppc64_elf_unhandled_reloc, /* special_function */
 658          "R_PPC64_PLT16_LO",    /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 665      the symbol.  */
 666   HOWTO (R_PPC64_PLT16_HI,      /* type */
 667          16,                    /* rightshift */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          16,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_dont, /* complain_on_overflow */
 673          ppc64_elf_unhandled_reloc, /* special_function */
 674          "R_PPC64_PLT16_HI",    /* name */
 675          FALSE,                 /* partial_inplace */
 676          0,                     /* src_mask */
 677          0xffff,                /* dst_mask */
 678          FALSE),                /* pcrel_offset */
 679
 680   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 681      the symbol.  */
 682   HOWTO (R_PPC64_PLT16_HA,      /* type */
 683          16,                    /* rightshift */
 684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          16,                    /* bitsize */
 686          FALSE,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_dont, /* complain_on_overflow */
 689          ppc64_elf_unhandled_reloc, /* special_function */
 690          "R_PPC64_PLT16_HA",    /* name */
 691          FALSE,                 /* partial_inplace */
 692          0,                     /* src_mask */
 693          0xffff,                /* dst_mask */
 694          FALSE),                /* pcrel_offset */
 695
 696   /* 16-bit section relative relocation.  */
 697   HOWTO (R_PPC64_SECTOFF,       /* type */
 698          0,                     /* rightshift */
 699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 700          16,                    /* bitsize */
 701          FALSE,                 /* pc_relative */
 702          0,                     /* bitpos */
 703          complain_overflow_bitfield, /* complain_on_overflow */
 704          ppc64_elf_sectoff_reloc, /* special_function */
 705          "R_PPC64_SECTOFF",     /* name */
 706          FALSE,                 /* partial_inplace */
 707          0,                     /* src_mask */
 708          0xffff,                /* dst_mask */
 709          FALSE),                /* pcrel_offset */
 710
 711   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 712   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 713          0,                     /* rightshift */
 714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 715          16,                    /* bitsize */
 716          FALSE,                 /* pc_relative */
 717          0,                     /* bitpos */
 718          complain_overflow_dont, /* complain_on_overflow */
 719          ppc64_elf_sectoff_reloc, /* special_function */
 720          "R_PPC64_SECTOFF_LO",  /* name */
 721          FALSE,                 /* partial_inplace */
 722          0,                     /* src_mask */
 723          0xffff,                /* dst_mask */
 724          FALSE),                /* pcrel_offset */
 725
 726   /* 16-bit upper half section relative relocation.  */
 727   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          ppc64_elf_sectoff_reloc, /* special_function */
 735          "R_PPC64_SECTOFF_HI",  /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit upper half adjusted section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 743          16,                    /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_dont, /* complain_on_overflow */
 749          ppc64_elf_sectoff_ha_reloc, /* special_function */
 750          "R_PPC64_SECTOFF_HA",  /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 757   HOWTO (R_PPC64_REL30,         /* type */
 758          2,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          30,                    /* bitsize */
 761          TRUE,                  /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_PPC64_REL30",       /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xfffffffc,            /* dst_mask */
 769          TRUE),                 /* pcrel_offset */
 770
 771   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 772
 773   /* A standard 64-bit relocation.  */
 774   HOWTO (R_PPC64_ADDR64,        /* type */
 775          0,                     /* rightshift */
 776          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 777          64,                    /* bitsize */
 778          FALSE,                 /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_dont, /* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_PPC64_ADDR64",      /* name */
 783          FALSE,                 /* partial_inplace */
 784          0,                     /* src_mask */
 785          ONES (64),             /* dst_mask */
 786          FALSE),                /* pcrel_offset */
 787
 788   /* The bits 32-47 of an address.  */
 789   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 790          32,                    /* rightshift */
 791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 792          16,                    /* bitsize */
 793          FALSE,                 /* pc_relative */
 794          0,                     /* bitpos */
 795          complain_overflow_dont, /* complain_on_overflow */
 796          bfd_elf_generic_reloc, /* special_function */
 797          "R_PPC64_ADDR16_HIGHER", /* name */
 798          FALSE,                 /* partial_inplace */
 799          0,                     /* src_mask */
 800          0xffff,                /* dst_mask */
 801          FALSE),                /* pcrel_offset */
 802
 803   /* The bits 32-47 of an address, plus 1 if the contents of the low
 804      16 bits, treated as a signed number, is negative.  */
 805   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 806          32,                    /* rightshift */
 807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 808          16,                    /* bitsize */
 809          FALSE,                 /* pc_relative */
 810          0,                     /* bitpos */
 811          complain_overflow_dont, /* complain_on_overflow */
 812          ppc64_elf_ha_reloc,    /* special_function */
 813          "R_PPC64_ADDR16_HIGHERA", /* name */
 814          FALSE,                 /* partial_inplace */
 815          0,                     /* src_mask */
 816          0xffff,                /* dst_mask */
 817          FALSE),                /* pcrel_offset */
 818
 819   /* The bits 48-63 of an address.  */
 820   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 821          48,                    /* rightshift */
 822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 823          16,                    /* bitsize */
 824          FALSE,                 /* pc_relative */
 825          0,                     /* bitpos */
 826          complain_overflow_dont, /* complain_on_overflow */
 827          bfd_elf_generic_reloc, /* special_function */
 828          "R_PPC64_ADDR16_HIGHEST", /* name */
 829          FALSE,                 /* partial_inplace */
 830          0,                     /* src_mask */
 831          0xffff,                /* dst_mask */
 832          FALSE),                /* pcrel_offset */
 833
 834   /* The bits 48-63 of an address, plus 1 if the contents of the low
 835      16 bits, treated as a signed number, is negative.  */
 836   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 837          48,                    /* rightshift */
 838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 839          16,                    /* bitsize */
 840          FALSE,                 /* pc_relative */
 841          0,                     /* bitpos */
 842          complain_overflow_dont, /* complain_on_overflow */
 843          ppc64_elf_ha_reloc,    /* special_function */
 844          "R_PPC64_ADDR16_HIGHESTA", /* name */
 845          FALSE,                 /* partial_inplace */
 846          0,                     /* src_mask */
 847          0xffff,                /* dst_mask */
 848          FALSE),                /* pcrel_offset */
 849
 850   /* Like ADDR64, but may be unaligned.  */
 851   HOWTO (R_PPC64_UADDR64,       /* type */
 852          0,                     /* rightshift */
 853          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 854          64,                    /* bitsize */
 855          FALSE,                 /* pc_relative */
 856          0,                     /* bitpos */
 857          complain_overflow_dont, /* complain_on_overflow */
 858          bfd_elf_generic_reloc, /* special_function */
 859          "R_PPC64_UADDR64",     /* name */
 860          FALSE,                 /* partial_inplace */
 861          0,                     /* src_mask */
 862          ONES (64),             /* dst_mask */
 863          FALSE),                /* pcrel_offset */
 864
 865   /* 64-bit relative relocation.  */
 866   HOWTO (R_PPC64_REL64,         /* type */
 867          0,                     /* rightshift */
 868          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 869          64,                    /* bitsize */
 870          TRUE,                  /* pc_relative */
 871          0,                     /* bitpos */
 872          complain_overflow_dont, /* complain_on_overflow */
 873          bfd_elf_generic_reloc, /* special_function */
 874          "R_PPC64_REL64",       /* name */
 875          FALSE,                 /* partial_inplace */
 876          0,                     /* src_mask */
 877          ONES (64),             /* dst_mask */
 878          TRUE),                 /* pcrel_offset */
 879
 880   /* 64-bit relocation to the symbol's procedure linkage table.  */
 881   HOWTO (R_PPC64_PLT64,         /* type */
 882          0,                     /* rightshift */
 883          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 884          64,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_unhandled_reloc, /* special_function */
 889          "R_PPC64_PLT64",       /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          ONES (64),             /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* 64-bit PC relative relocation to the symbol's procedure linkage
 896      table.  */
 897   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 898   HOWTO (R_PPC64_PLTREL64,      /* type */
 899          0,                     /* rightshift */
 900          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 901          64,                    /* bitsize */
 902          TRUE,                  /* pc_relative */
 903          0,                     /* bitpos */
 904          complain_overflow_dont, /* complain_on_overflow */
 905          ppc64_elf_unhandled_reloc, /* special_function */
 906          "R_PPC64_PLTREL64",    /* name */
 907          FALSE,                 /* partial_inplace */
 908          0,                     /* src_mask */
 909          ONES (64),             /* dst_mask */
 910          TRUE),                 /* pcrel_offset */
 911
 912   /* 16 bit TOC-relative relocation.  */
 913
 914   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 915   HOWTO (R_PPC64_TOC16,         /* type */
 916          0,                     /* rightshift */
 917          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 918          16,                    /* bitsize */
 919          FALSE,                 /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_signed, /* complain_on_overflow */
 922          ppc64_elf_toc_reloc,   /* special_function */
 923          "R_PPC64_TOC16",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          0xffff,                /* dst_mask */
 927          FALSE),                /* pcrel_offset */
 928
 929   /* 16 bit TOC-relative relocation without overflow.  */
 930
 931   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 932   HOWTO (R_PPC64_TOC16_LO,      /* type */
 933          0,                     /* rightshift */
 934          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 935          16,                    /* bitsize */
 936          FALSE,                 /* pc_relative */
 937          0,                     /* bitpos */
 938          complain_overflow_dont, /* complain_on_overflow */
 939          ppc64_elf_toc_reloc,   /* special_function */
 940          "R_PPC64_TOC16_LO",    /* name */
 941          FALSE,                 /* partial_inplace */
 942          0,                     /* src_mask */
 943          0xffff,                /* dst_mask */
 944          FALSE),                /* pcrel_offset */
 945
 946   /* 16 bit TOC-relative relocation, high 16 bits.  */
 947
 948   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 949   HOWTO (R_PPC64_TOC16_HI,      /* type */
 950          16,                    /* rightshift */
 951          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 952          16,                    /* bitsize */
 953          FALSE,                 /* pc_relative */
 954          0,                     /* bitpos */
 955          complain_overflow_dont, /* complain_on_overflow */
 956          ppc64_elf_toc_reloc,   /* special_function */
 957          "R_PPC64_TOC16_HI",    /* name */
 958          FALSE,                 /* partial_inplace */
 959          0,                     /* src_mask */
 960          0xffff,                /* dst_mask */
 961          FALSE),                /* pcrel_offset */
 962
 963   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 964      contents of the low 16 bits, treated as a signed number, is
 965      negative.  */
 966
 967   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 968   HOWTO (R_PPC64_TOC16_HA,      /* type */
 969          16,                    /* rightshift */
 970          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 971          16,                    /* bitsize */
 972          FALSE,                 /* pc_relative */
 973          0,                     /* bitpos */
 974          complain_overflow_dont, /* complain_on_overflow */
 975          ppc64_elf_toc_ha_reloc, /* special_function */
 976          "R_PPC64_TOC16_HA",    /* name */
 977          FALSE,                 /* partial_inplace */
 978          0,                     /* src_mask */
 979          0xffff,                /* dst_mask */
 980          FALSE),                /* pcrel_offset */
 981
 982   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 983
 984   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 985   HOWTO (R_PPC64_TOC,           /* type */
 986          0,                     /* rightshift */
 987          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 988          64,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_bitfield, /* complain_on_overflow */
 992          ppc64_elf_toc64_reloc, /* special_function */
 993          "R_PPC64_TOC",         /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          ONES (64),             /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* Like R_PPC64_GOT16, but also informs the link editor that the
1000      value to relocate may (!) refer to a PLT entry which the link
1001      editor (a) may replace with the symbol value.  If the link editor
1002      is unable to fully resolve the symbol, it may (b) create a PLT
1003      entry and store the address to the new PLT entry in the GOT.
1004      This permits lazy resolution of function symbols at run time.
1005      The link editor may also skip all of this and just (c) emit a
1006      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1007   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1008     HOWTO (R_PPC64_PLTGOT16,    /* type */
1009          0,                     /* rightshift */
1010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          16,                    /* bitsize */
1012          FALSE,                 /* pc_relative */
1013          0,                     /* bitpos */
1014          complain_overflow_signed, /* complain_on_overflow */
1015          ppc64_elf_unhandled_reloc, /* special_function */
1016          "R_PPC64_PLTGOT16",    /* name */
1017          FALSE,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0xffff,                /* dst_mask */
1020          FALSE),                /* pcrel_offset */
1021
1022   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1023   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1024   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1025          0,                     /* rightshift */
1026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1027          16,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_unhandled_reloc, /* special_function */
1032          "R_PPC64_PLTGOT16_LO", /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          0xffff,                /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1039   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1040   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1041          16,                    /* rightshift */
1042          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1043          16,                    /* bitsize */
1044          FALSE,                 /* pc_relative */
1045          0,                     /* bitpos */
1046          complain_overflow_dont, /* complain_on_overflow */
1047          ppc64_elf_unhandled_reloc, /* special_function */
1048          "R_PPC64_PLTGOT16_HI", /* name */
1049          FALSE,                 /* partial_inplace */
1050          0,                     /* src_mask */
1051          0xffff,                /* dst_mask */
1052          FALSE),                /* pcrel_offset */
1053
1054   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055      1 if the contents of the low 16 bits, treated as a signed number,
1056      is negative.  */
1057   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1058   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1059          16,                    /* rightshift */
1060          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1061          16,                    /* bitsize */
1062          FALSE,                 /* pc_relative */
1063          0,                     /* bitpos */
1064          complain_overflow_dont,/* complain_on_overflow */
1065          ppc64_elf_unhandled_reloc, /* special_function */
1066          "R_PPC64_PLTGOT16_HA", /* name */
1067          FALSE,                 /* partial_inplace */
1068          0,                     /* src_mask */
1069          0xffff,                /* dst_mask */
1070          FALSE),                /* pcrel_offset */
1071
1072   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1073   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_bitfield, /* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_PPC64_ADDR16_DS",   /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xfffc,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1088   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1089          0,                     /* rightshift */
1090          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1091          16,                    /* bitsize */
1092          FALSE,                 /* pc_relative */
1093          0,                     /* bitpos */
1094          complain_overflow_dont,/* complain_on_overflow */
1095          bfd_elf_generic_reloc, /* special_function */
1096          "R_PPC64_ADDR16_LO_DS",/* name */
1097          FALSE,                 /* partial_inplace */
1098          0,                     /* src_mask */
1099          0xfffc,                /* dst_mask */
1100          FALSE),                /* pcrel_offset */
1101
1102   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1103   HOWTO (R_PPC64_GOT16_DS,      /* type */
1104          0,                     /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_GOT16_DS",    /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xfffc,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_dont, /* complain_on_overflow */
1125          ppc64_elf_unhandled_reloc, /* special_function */
1126          "R_PPC64_GOT16_LO_DS", /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont, /* complain_on_overflow */
1140          ppc64_elf_unhandled_reloc, /* special_function */
1141          "R_PPC64_PLT16_LO_DS", /* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_bitfield, /* complain_on_overflow */
1155          ppc64_elf_sectoff_reloc, /* special_function */
1156          "R_PPC64_SECTOFF_DS",  /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_sectoff_reloc, /* special_function */
1171          "R_PPC64_SECTOFF_LO_DS",/* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_TOC16_DS,      /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_signed, /* complain_on_overflow */
1185          ppc64_elf_toc_reloc,   /* special_function */
1186          "R_PPC64_TOC16_DS",    /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont, /* complain_on_overflow */
1200          ppc64_elf_toc_reloc,   /* special_function */
1201          "R_PPC64_TOC16_LO_DS", /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1208   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1209   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1210          0,                     /* rightshift */
1211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1212          16,                    /* bitsize */
1213          FALSE,                 /* pc_relative */
1214          0,                     /* bitpos */
1215          complain_overflow_signed, /* complain_on_overflow */
1216          ppc64_elf_unhandled_reloc, /* special_function */
1217          "R_PPC64_PLTGOT16_DS", /* name */
1218          FALSE,                 /* partial_inplace */
1219          0,                     /* src_mask */
1220          0xfffc,                /* dst_mask */
1221          FALSE),                /* pcrel_offset */
1222
1223   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1224   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1225   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226          0,                     /* rightshift */
1227          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1228          16,                    /* bitsize */
1229          FALSE,                 /* pc_relative */
1230          0,                     /* bitpos */
1231          complain_overflow_dont, /* complain_on_overflow */
1232          ppc64_elf_unhandled_reloc, /* special_function */
1233          "R_PPC64_PLTGOT16_LO_DS",/* name */
1234          FALSE,                 /* partial_inplace */
1235          0,                     /* src_mask */
1236          0xfffc,                /* dst_mask */
1237          FALSE),                /* pcrel_offset */
1238
1239   /* Marker relocs for TLS.  */
1240   HOWTO (R_PPC64_TLS,
1241          0,                     /* rightshift */
1242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1243          32,                    /* bitsize */
1244          FALSE,                 /* pc_relative */
1245          0,                     /* bitpos */
1246          complain_overflow_dont, /* complain_on_overflow */
1247          bfd_elf_generic_reloc, /* special_function */
1248          "R_PPC64_TLS",         /* name */
1249          FALSE,                 /* partial_inplace */
1250          0,                     /* src_mask */
1251          0,                     /* dst_mask */
1252          FALSE),                /* pcrel_offset */
1253
1254   HOWTO (R_PPC64_TLSGD,
1255          0,                     /* rightshift */
1256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          32,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_dont, /* complain_on_overflow */
1261          bfd_elf_generic_reloc, /* special_function */
1262          "R_PPC64_TLSGD",       /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0,                     /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   HOWTO (R_PPC64_TLSLD,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLSLD",       /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   /* Computes the load module index of the load module that contains the
1283      definition of its TLS sym.  */
1284   HOWTO (R_PPC64_DTPMOD64,
1285          0,                     /* rightshift */
1286          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1287          64,                    /* bitsize */
1288          FALSE,                 /* pc_relative */
1289          0,                     /* bitpos */
1290          complain_overflow_dont, /* complain_on_overflow */
1291          ppc64_elf_unhandled_reloc, /* special_function */
1292          "R_PPC64_DTPMOD64",    /* name */
1293          FALSE,                 /* partial_inplace */
1294          0,                     /* src_mask */
1295          ONES (64),             /* dst_mask */
1296          FALSE),                /* pcrel_offset */
1297
1298   /* Computes a dtv-relative displacement, the difference between the value
1299      of sym+add and the base address of the thread-local storage block that
1300      contains the definition of sym, minus 0x8000.  */
1301   HOWTO (R_PPC64_DTPREL64,
1302          0,                     /* rightshift */
1303          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          64,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont, /* complain_on_overflow */
1308          ppc64_elf_unhandled_reloc, /* special_function */
1309          "R_PPC64_DTPREL64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* A 16 bit dtprel reloc.  */
1316   HOWTO (R_PPC64_DTPREL16,
1317          0,                     /* rightshift */
1318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1319          16,                    /* bitsize */
1320          FALSE,                 /* pc_relative */
1321          0,                     /* bitpos */
1322          complain_overflow_signed, /* complain_on_overflow */
1323          ppc64_elf_unhandled_reloc, /* special_function */
1324          "R_PPC64_DTPREL16",    /* name */
1325          FALSE,                 /* partial_inplace */
1326          0,                     /* src_mask */
1327          0xffff,                /* dst_mask */
1328          FALSE),                /* pcrel_offset */
1329
1330   /* Like DTPREL16, but no overflow.  */
1331   HOWTO (R_PPC64_DTPREL16_LO,
1332          0,                     /* rightshift */
1333          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          16,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          ppc64_elf_unhandled_reloc, /* special_function */
1339          "R_PPC64_DTPREL16_LO", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0xffff,                /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1346   HOWTO (R_PPC64_DTPREL16_HI,
1347          16,                    /* rightshift */
1348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1349          16,                    /* bitsize */
1350          FALSE,                 /* pc_relative */
1351          0,                     /* bitpos */
1352          complain_overflow_dont, /* complain_on_overflow */
1353          ppc64_elf_unhandled_reloc, /* special_function */
1354          "R_PPC64_DTPREL16_HI", /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1361   HOWTO (R_PPC64_DTPREL16_HA,
1362          16,                    /* rightshift */
1363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1364          16,                    /* bitsize */
1365          FALSE,                 /* pc_relative */
1366          0,                     /* bitpos */
1367          complain_overflow_dont, /* complain_on_overflow */
1368          ppc64_elf_unhandled_reloc, /* special_function */
1369          "R_PPC64_DTPREL16_HA", /* name */
1370          FALSE,                 /* partial_inplace */
1371          0,                     /* src_mask */
1372          0xffff,                /* dst_mask */
1373          FALSE),                /* pcrel_offset */
1374
1375   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1376   HOWTO (R_PPC64_DTPREL16_HIGHER,
1377          32,                    /* rightshift */
1378          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1379          16,                    /* bitsize */
1380          FALSE,                 /* pc_relative */
1381          0,                     /* bitpos */
1382          complain_overflow_dont, /* complain_on_overflow */
1383          ppc64_elf_unhandled_reloc, /* special_function */
1384          "R_PPC64_DTPREL16_HIGHER", /* name */
1385          FALSE,                 /* partial_inplace */
1386          0,                     /* src_mask */
1387          0xffff,                /* dst_mask */
1388          FALSE),                /* pcrel_offset */
1389
1390   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1391   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392          32,                    /* rightshift */
1393          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1394          16,                    /* bitsize */
1395          FALSE,                 /* pc_relative */
1396          0,                     /* bitpos */
1397          complain_overflow_dont, /* complain_on_overflow */
1398          ppc64_elf_unhandled_reloc, /* special_function */
1399          "R_PPC64_DTPREL16_HIGHERA", /* name */
1400          FALSE,                 /* partial_inplace */
1401          0,                     /* src_mask */
1402          0xffff,                /* dst_mask */
1403          FALSE),                /* pcrel_offset */
1404
1405   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1406   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407          48,                    /* rightshift */
1408          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1409          16,                    /* bitsize */
1410          FALSE,                 /* pc_relative */
1411          0,                     /* bitpos */
1412          complain_overflow_dont, /* complain_on_overflow */
1413          ppc64_elf_unhandled_reloc, /* special_function */
1414          "R_PPC64_DTPREL16_HIGHEST", /* name */
1415          FALSE,                 /* partial_inplace */
1416          0,                     /* src_mask */
1417          0xffff,                /* dst_mask */
1418          FALSE),                /* pcrel_offset */
1419
1420   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1421   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422          48,                    /* rightshift */
1423          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1424          16,                    /* bitsize */
1425          FALSE,                 /* pc_relative */
1426          0,                     /* bitpos */
1427          complain_overflow_dont, /* complain_on_overflow */
1428          ppc64_elf_unhandled_reloc, /* special_function */
1429          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430          FALSE,                 /* partial_inplace */
1431          0,                     /* src_mask */
1432          0xffff,                /* dst_mask */
1433          FALSE),                /* pcrel_offset */
1434
1435   /* Like DTPREL16, but for insns with a DS field.  */
1436   HOWTO (R_PPC64_DTPREL16_DS,
1437          0,                     /* rightshift */
1438          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1439          16,                    /* bitsize */
1440          FALSE,                 /* pc_relative */
1441          0,                     /* bitpos */
1442          complain_overflow_signed, /* complain_on_overflow */
1443          ppc64_elf_unhandled_reloc, /* special_function */
1444          "R_PPC64_DTPREL16_DS", /* name */
1445          FALSE,                 /* partial_inplace */
1446          0,                     /* src_mask */
1447          0xfffc,                /* dst_mask */
1448          FALSE),                /* pcrel_offset */
1449
1450   /* Like DTPREL16_DS, but no overflow.  */
1451   HOWTO (R_PPC64_DTPREL16_LO_DS,
1452          0,                     /* rightshift */
1453          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1454          16,                    /* bitsize */
1455          FALSE,                 /* pc_relative */
1456          0,                     /* bitpos */
1457          complain_overflow_dont, /* complain_on_overflow */
1458          ppc64_elf_unhandled_reloc, /* special_function */
1459          "R_PPC64_DTPREL16_LO_DS", /* name */
1460          FALSE,                 /* partial_inplace */
1461          0,                     /* src_mask */
1462          0xfffc,                /* dst_mask */
1463          FALSE),                /* pcrel_offset */
1464
1465   /* Computes a tp-relative displacement, the difference between the value of
1466      sym+add and the value of the thread pointer (r13).  */
1467   HOWTO (R_PPC64_TPREL64,
1468          0,                     /* rightshift */
1469          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          64,                    /* bitsize */
1471          FALSE,                 /* pc_relative */
1472          0,                     /* bitpos */
1473          complain_overflow_dont, /* complain_on_overflow */
1474          ppc64_elf_unhandled_reloc, /* special_function */
1475          "R_PPC64_TPREL64",     /* name */
1476          FALSE,                 /* partial_inplace */
1477          0,                     /* src_mask */
1478          ONES (64),             /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   /* A 16 bit tprel reloc.  */
1482   HOWTO (R_PPC64_TPREL16,
1483          0,                     /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_signed, /* complain_on_overflow */
1489          ppc64_elf_unhandled_reloc, /* special_function */
1490          "R_PPC64_TPREL16",     /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Like TPREL16, but no overflow.  */
1497   HOWTO (R_PPC64_TPREL16_LO,
1498          0,                     /* rightshift */
1499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1500          16,                    /* bitsize */
1501          FALSE,                 /* pc_relative */
1502          0,                     /* bitpos */
1503          complain_overflow_dont, /* complain_on_overflow */
1504          ppc64_elf_unhandled_reloc, /* special_function */
1505          "R_PPC64_TPREL16_LO",  /* name */
1506          FALSE,                 /* partial_inplace */
1507          0,                     /* src_mask */
1508          0xffff,                /* dst_mask */
1509          FALSE),                /* pcrel_offset */
1510
1511   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1512   HOWTO (R_PPC64_TPREL16_HI,
1513          16,                    /* rightshift */
1514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1515          16,                    /* bitsize */
1516          FALSE,                 /* pc_relative */
1517          0,                     /* bitpos */
1518          complain_overflow_dont, /* complain_on_overflow */
1519          ppc64_elf_unhandled_reloc, /* special_function */
1520          "R_PPC64_TPREL16_HI",  /* name */
1521          FALSE,                 /* partial_inplace */
1522          0,                     /* src_mask */
1523          0xffff,                /* dst_mask */
1524          FALSE),                /* pcrel_offset */
1525
1526   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1527   HOWTO (R_PPC64_TPREL16_HA,
1528          16,                    /* rightshift */
1529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1530          16,                    /* bitsize */
1531          FALSE,                 /* pc_relative */
1532          0,                     /* bitpos */
1533          complain_overflow_dont, /* complain_on_overflow */
1534          ppc64_elf_unhandled_reloc, /* special_function */
1535          "R_PPC64_TPREL16_HA",  /* name */
1536          FALSE,                 /* partial_inplace */
1537          0,                     /* src_mask */
1538          0xffff,                /* dst_mask */
1539          FALSE),                /* pcrel_offset */
1540
1541   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1542   HOWTO (R_PPC64_TPREL16_HIGHER,
1543          32,                    /* rightshift */
1544          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1545          16,                    /* bitsize */
1546          FALSE,                 /* pc_relative */
1547          0,                     /* bitpos */
1548          complain_overflow_dont, /* complain_on_overflow */
1549          ppc64_elf_unhandled_reloc, /* special_function */
1550          "R_PPC64_TPREL16_HIGHER",      /* name */
1551          FALSE,                 /* partial_inplace */
1552          0,                     /* src_mask */
1553          0xffff,                /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1557   HOWTO (R_PPC64_TPREL16_HIGHERA,
1558          32,                    /* rightshift */
1559          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1560          16,                    /* bitsize */
1561          FALSE,                 /* pc_relative */
1562          0,                     /* bitpos */
1563          complain_overflow_dont, /* complain_on_overflow */
1564          ppc64_elf_unhandled_reloc, /* special_function */
1565          "R_PPC64_TPREL16_HIGHERA", /* name */
1566          FALSE,                 /* partial_inplace */
1567          0,                     /* src_mask */
1568          0xffff,                /* dst_mask */
1569          FALSE),                /* pcrel_offset */
1570
1571   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1572   HOWTO (R_PPC64_TPREL16_HIGHEST,
1573          48,                    /* rightshift */
1574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1575          16,                    /* bitsize */
1576          FALSE,                 /* pc_relative */
1577          0,                     /* bitpos */
1578          complain_overflow_dont, /* complain_on_overflow */
1579          ppc64_elf_unhandled_reloc, /* special_function */
1580          "R_PPC64_TPREL16_HIGHEST", /* name */
1581          FALSE,                 /* partial_inplace */
1582          0,                     /* src_mask */
1583          0xffff,                /* dst_mask */
1584          FALSE),                /* pcrel_offset */
1585
1586   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1587   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588          48,                    /* rightshift */
1589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1590          16,                    /* bitsize */
1591          FALSE,                 /* pc_relative */
1592          0,                     /* bitpos */
1593          complain_overflow_dont, /* complain_on_overflow */
1594          ppc64_elf_unhandled_reloc, /* special_function */
1595          "R_PPC64_TPREL16_HIGHESTA", /* name */
1596          FALSE,                 /* partial_inplace */
1597          0,                     /* src_mask */
1598          0xffff,                /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600
1601   /* Like TPREL16, but for insns with a DS field.  */
1602   HOWTO (R_PPC64_TPREL16_DS,
1603          0,                     /* rightshift */
1604          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          16,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_signed, /* complain_on_overflow */
1609          ppc64_elf_unhandled_reloc, /* special_function */
1610          "R_PPC64_TPREL16_DS",  /* name */
1611          FALSE,                 /* partial_inplace */
1612          0,                     /* src_mask */
1613          0xfffc,                /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   /* Like TPREL16_DS, but no overflow.  */
1617   HOWTO (R_PPC64_TPREL16_LO_DS,
1618          0,                     /* rightshift */
1619          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1620          16,                    /* bitsize */
1621          FALSE,                 /* pc_relative */
1622          0,                     /* bitpos */
1623          complain_overflow_dont, /* complain_on_overflow */
1624          ppc64_elf_unhandled_reloc, /* special_function */
1625          "R_PPC64_TPREL16_LO_DS", /* name */
1626          FALSE,                 /* partial_inplace */
1627          0,                     /* src_mask */
1628          0xfffc,                /* dst_mask */
1629          FALSE),                /* pcrel_offset */
1630
1631   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633      to the first entry relative to the TOC base (r2).  */
1634   HOWTO (R_PPC64_GOT_TLSGD16,
1635          0,                     /* rightshift */
1636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1637          16,                    /* bitsize */
1638          FALSE,                 /* pc_relative */
1639          0,                     /* bitpos */
1640          complain_overflow_signed, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_GOT_TLSGD16", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xffff,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Like GOT_TLSGD16, but no overflow.  */
1649   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650          0,                     /* rightshift */
1651          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1652          16,                    /* bitsize */
1653          FALSE,                 /* pc_relative */
1654          0,                     /* bitpos */
1655          complain_overflow_dont, /* complain_on_overflow */
1656          ppc64_elf_unhandled_reloc, /* special_function */
1657          "R_PPC64_GOT_TLSGD16_LO", /* name */
1658          FALSE,                 /* partial_inplace */
1659          0,                     /* src_mask */
1660          0xffff,                /* dst_mask */
1661          FALSE),                /* pcrel_offset */
1662
1663   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1664   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665          16,                    /* rightshift */
1666          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1667          16,                    /* bitsize */
1668          FALSE,                 /* pc_relative */
1669          0,                     /* bitpos */
1670          complain_overflow_dont, /* complain_on_overflow */
1671          ppc64_elf_unhandled_reloc, /* special_function */
1672          "R_PPC64_GOT_TLSGD16_HI", /* name */
1673          FALSE,                 /* partial_inplace */
1674          0,                     /* src_mask */
1675          0xffff,                /* dst_mask */
1676          FALSE),                /* pcrel_offset */
1677
1678   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1679   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680          16,                    /* rightshift */
1681          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1682          16,                    /* bitsize */
1683          FALSE,                 /* pc_relative */
1684          0,                     /* bitpos */
1685          complain_overflow_dont, /* complain_on_overflow */
1686          ppc64_elf_unhandled_reloc, /* special_function */
1687          "R_PPC64_GOT_TLSGD16_HA", /* name */
1688          FALSE,                 /* partial_inplace */
1689          0,                     /* src_mask */
1690          0xffff,                /* dst_mask */
1691          FALSE),                /* pcrel_offset */
1692
1693   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694      with values (sym+add)@dtpmod and zero, and computes the offset to the
1695      first entry relative to the TOC base (r2).  */
1696   HOWTO (R_PPC64_GOT_TLSLD16,
1697          0,                     /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_signed, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSLD16", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Like GOT_TLSLD16, but no overflow.  */
1711   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712          0,                     /* rightshift */
1713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1714          16,                    /* bitsize */
1715          FALSE,                 /* pc_relative */
1716          0,                     /* bitpos */
1717          complain_overflow_dont, /* complain_on_overflow */
1718          ppc64_elf_unhandled_reloc, /* special_function */
1719          "R_PPC64_GOT_TLSLD16_LO", /* name */
1720          FALSE,                 /* partial_inplace */
1721          0,                     /* src_mask */
1722          0xffff,                /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1726   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727          16,                    /* rightshift */
1728          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1729          16,                    /* bitsize */
1730          FALSE,                 /* pc_relative */
1731          0,                     /* bitpos */
1732          complain_overflow_dont, /* complain_on_overflow */
1733          ppc64_elf_unhandled_reloc, /* special_function */
1734          "R_PPC64_GOT_TLSLD16_HI", /* name */
1735          FALSE,                 /* partial_inplace */
1736          0,                     /* src_mask */
1737          0xffff,                /* dst_mask */
1738          FALSE),                /* pcrel_offset */
1739
1740   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1741   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742          16,                    /* rightshift */
1743          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1744          16,                    /* bitsize */
1745          FALSE,                 /* pc_relative */
1746          0,                     /* bitpos */
1747          complain_overflow_dont, /* complain_on_overflow */
1748          ppc64_elf_unhandled_reloc, /* special_function */
1749          "R_PPC64_GOT_TLSLD16_HA", /* name */
1750          FALSE,                 /* partial_inplace */
1751          0,                     /* src_mask */
1752          0xffff,                /* dst_mask */
1753          FALSE),                /* pcrel_offset */
1754
1755   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756      the offset to the entry relative to the TOC base (r2).  */
1757   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758          0,                     /* rightshift */
1759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1760          16,                    /* bitsize */
1761          FALSE,                 /* pc_relative */
1762          0,                     /* bitpos */
1763          complain_overflow_signed, /* complain_on_overflow */
1764          ppc64_elf_unhandled_reloc, /* special_function */
1765          "R_PPC64_GOT_DTPREL16_DS", /* name */
1766          FALSE,                 /* partial_inplace */
1767          0,                     /* src_mask */
1768          0xfffc,                /* dst_mask */
1769          FALSE),                /* pcrel_offset */
1770
1771   /* Like GOT_DTPREL16_DS, but no overflow.  */
1772   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773          0,                     /* rightshift */
1774          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1775          16,                    /* bitsize */
1776          FALSE,                 /* pc_relative */
1777          0,                     /* bitpos */
1778          complain_overflow_dont, /* complain_on_overflow */
1779          ppc64_elf_unhandled_reloc, /* special_function */
1780          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1781          FALSE,                 /* partial_inplace */
1782          0,                     /* src_mask */
1783          0xfffc,                /* dst_mask */
1784          FALSE),                /* pcrel_offset */
1785
1786   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1787   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788          16,                    /* rightshift */
1789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1790          16,                    /* bitsize */
1791          FALSE,                 /* pc_relative */
1792          0,                     /* bitpos */
1793          complain_overflow_dont, /* complain_on_overflow */
1794          ppc64_elf_unhandled_reloc, /* special_function */
1795          "R_PPC64_GOT_DTPREL16_HI", /* name */
1796          FALSE,                 /* partial_inplace */
1797          0,                     /* src_mask */
1798          0xffff,                /* dst_mask */
1799          FALSE),                /* pcrel_offset */
1800
1801   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1802   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803          16,                    /* rightshift */
1804          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1805          16,                    /* bitsize */
1806          FALSE,                 /* pc_relative */
1807          0,                     /* bitpos */
1808          complain_overflow_dont, /* complain_on_overflow */
1809          ppc64_elf_unhandled_reloc, /* special_function */
1810          "R_PPC64_GOT_DTPREL16_HA", /* name */
1811          FALSE,                 /* partial_inplace */
1812          0,                     /* src_mask */
1813          0xffff,                /* dst_mask */
1814          FALSE),                /* pcrel_offset */
1815
1816   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817      offset to the entry relative to the TOC base (r2).  */
1818   HOWTO (R_PPC64_GOT_TPREL16_DS,
1819          0,                     /* rightshift */
1820          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1821          16,                    /* bitsize */
1822          FALSE,                 /* pc_relative */
1823          0,                     /* bitpos */
1824          complain_overflow_signed, /* complain_on_overflow */
1825          ppc64_elf_unhandled_reloc, /* special_function */
1826          "R_PPC64_GOT_TPREL16_DS", /* name */
1827          FALSE,                 /* partial_inplace */
1828          0,                     /* src_mask */
1829          0xfffc,                /* dst_mask */
1830          FALSE),                /* pcrel_offset */
1831
1832   /* Like GOT_TPREL16_DS, but no overflow.  */
1833   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834          0,                     /* rightshift */
1835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1836          16,                    /* bitsize */
1837          FALSE,                 /* pc_relative */
1838          0,                     /* bitpos */
1839          complain_overflow_dont, /* complain_on_overflow */
1840          ppc64_elf_unhandled_reloc, /* special_function */
1841          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1842          FALSE,                 /* partial_inplace */
1843          0,                     /* src_mask */
1844          0xfffc,                /* dst_mask */
1845          FALSE),                /* pcrel_offset */
1846
1847   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1848   HOWTO (R_PPC64_GOT_TPREL16_HI,
1849          16,                    /* rightshift */
1850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1851          16,                    /* bitsize */
1852          FALSE,                 /* pc_relative */
1853          0,                     /* bitpos */
1854          complain_overflow_dont, /* complain_on_overflow */
1855          ppc64_elf_unhandled_reloc, /* special_function */
1856          "R_PPC64_GOT_TPREL16_HI", /* name */
1857          FALSE,                 /* partial_inplace */
1858          0,                     /* src_mask */
1859          0xffff,                /* dst_mask */
1860          FALSE),                /* pcrel_offset */
1861
1862   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1863   HOWTO (R_PPC64_GOT_TPREL16_HA,
1864          16,                    /* rightshift */
1865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1866          16,                    /* bitsize */
1867          FALSE,                 /* pc_relative */
1868          0,                     /* bitpos */
1869          complain_overflow_dont, /* complain_on_overflow */
1870          ppc64_elf_unhandled_reloc, /* special_function */
1871          "R_PPC64_GOT_TPREL16_HA", /* name */
1872          FALSE,                 /* partial_inplace */
1873          0,                     /* src_mask */
1874          0xffff,                /* dst_mask */
1875          FALSE),                /* pcrel_offset */
1876
1877   HOWTO (R_PPC64_JMP_IREL,      /* type */
1878          0,                     /* rightshift */
1879          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880          0,                     /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_dont, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_JMP_IREL",    /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0,                     /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   HOWTO (R_PPC64_IRELATIVE,     /* type */
1892          0,                     /* rightshift */
1893          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1894          64,                    /* bitsize */
1895          FALSE,                 /* pc_relative */
1896          0,                     /* bitpos */
1897          complain_overflow_dont, /* complain_on_overflow */
1898          bfd_elf_generic_reloc, /* special_function */
1899          "R_PPC64_IRELATIVE",   /* name */
1900          FALSE,                 /* partial_inplace */
1901          0,                     /* src_mask */
1902          ONES (64),             /* dst_mask */
1903          FALSE),                /* pcrel_offset */
1904
1905   /* A 16 bit relative relocation.  */
1906   HOWTO (R_PPC64_REL16,         /* type */
1907          0,                     /* rightshift */
1908          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1909          16,                    /* bitsize */
1910          TRUE,                  /* pc_relative */
1911          0,                     /* bitpos */
1912          complain_overflow_bitfield, /* complain_on_overflow */
1913          bfd_elf_generic_reloc, /* special_function */
1914          "R_PPC64_REL16",       /* name */
1915          FALSE,                 /* partial_inplace */
1916          0,                     /* src_mask */
1917          0xffff,                /* dst_mask */
1918          TRUE),                 /* pcrel_offset */
1919
1920   /* A 16 bit relative relocation without overflow.  */
1921   HOWTO (R_PPC64_REL16_LO,      /* type */
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          TRUE,                  /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_dont,/* complain_on_overflow */
1928          bfd_elf_generic_reloc, /* special_function */
1929          "R_PPC64_REL16_LO",    /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xffff,                /* dst_mask */
1933          TRUE),                 /* pcrel_offset */
1934
1935   /* The high order 16 bits of a relative address.  */
1936   HOWTO (R_PPC64_REL16_HI,      /* type */
1937          16,                    /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          TRUE,                  /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          bfd_elf_generic_reloc, /* special_function */
1944          "R_PPC64_REL16_HI",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xffff,                /* dst_mask */
1948          TRUE),                 /* pcrel_offset */
1949
1950   /* The high order 16 bits of a relative address, plus 1 if the contents of
1951      the low 16 bits, treated as a signed number, is negative.  */
1952   HOWTO (R_PPC64_REL16_HA,      /* type */
1953          16,                    /* rightshift */
1954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1955          16,                    /* bitsize */
1956          TRUE,                  /* pc_relative */
1957          0,                     /* bitpos */
1958          complain_overflow_dont, /* complain_on_overflow */
1959          ppc64_elf_ha_reloc,    /* special_function */
1960          "R_PPC64_REL16_HA",    /* name */
1961          FALSE,                 /* partial_inplace */
1962          0,                     /* src_mask */
1963          0xffff,                /* dst_mask */
1964          TRUE),                 /* pcrel_offset */
1965
1966   /* GNU extension to record C++ vtable hierarchy.  */
1967   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1968          0,                     /* rightshift */
1969          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1970          0,                     /* bitsize */
1971          FALSE,                 /* pc_relative */
1972          0,                     /* bitpos */
1973          complain_overflow_dont, /* complain_on_overflow */
1974          NULL,                  /* special_function */
1975          "R_PPC64_GNU_VTINHERIT", /* name */
1976          FALSE,                 /* partial_inplace */
1977          0,                     /* src_mask */
1978          0,                     /* dst_mask */
1979          FALSE),                /* pcrel_offset */
1980
1981   /* GNU extension to record C++ vtable member usage.  */
1982   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1983          0,                     /* rightshift */
1984          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1985          0,                     /* bitsize */
1986          FALSE,                 /* pc_relative */
1987          0,                     /* bitpos */
1988          complain_overflow_dont, /* complain_on_overflow */
1989          NULL,                  /* special_function */
1990          "R_PPC64_GNU_VTENTRY", /* name */
1991          FALSE,                 /* partial_inplace */
1992          0,                     /* src_mask */
1993          0,                     /* dst_mask */
1994          FALSE),                /* pcrel_offset */
1995 };
1996
1997 \f
1998 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1999    be done.  */
2000
2001 static void
2002 ppc_howto_init (void)
2003 {
2004   unsigned int i, type;
2005
2006   for (i = 0;
2007        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2008        i++)
2009     {
2010       type = ppc64_elf_howto_raw[i].type;
2011       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2012                           / sizeof (ppc64_elf_howto_table[0])));
2013       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2014     }
2015 }
2016
2017 static reloc_howto_type *
2018 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2019                              bfd_reloc_code_real_type code)
2020 {
2021   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2022
2023   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2024     /* Initialize howto table if needed.  */
2025     ppc_howto_init ();
2026
2027   switch (code)
2028     {
2029     default:
2030       return NULL;
2031
2032     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2033       break;
2034     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2035       break;
2036     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2037       break;
2038     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2039       break;
2040     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2041       break;
2042     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2043       break;
2044     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2045       break;
2046     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2047       break;
2048     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2049       break;
2050     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2051       break;
2052     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2053       break;
2054     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2055       break;
2056     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2057       break;
2058     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2059       break;
2060     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2061       break;
2062     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2063       break;
2064     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2065       break;
2066     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2067       break;
2068     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2069       break;
2070     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2071       break;
2072     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2073       break;
2074     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2075       break;
2076     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2077       break;
2078     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2079       break;
2080     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2081       break;
2082     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2083       break;
2084     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2085       break;
2086     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2087       break;
2088     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2089       break;
2090     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2091       break;
2092     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2093       break;
2094     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2095       break;
2096     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2097       break;
2098     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2099       break;
2100     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2101       break;
2102     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2103       break;
2104     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2105       break;
2106     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2107       break;
2108     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2109       break;
2110     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2111       break;
2112     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2113       break;
2114     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2115       break;
2116     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2117       break;
2118     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2119       break;
2120     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2121       break;
2122     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2123       break;
2124     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2125       break;
2126     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2127       break;
2128     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2129       break;
2130     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2131       break;
2132     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2133       break;
2134     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2135       break;
2136     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2137       break;
2138     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2139       break;
2140     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2141       break;
2142     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2143       break;
2144     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2145       break;
2146     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2147       break;
2148     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2149       break;
2150     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2151       break;
2152     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2153       break;
2154     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2155       break;
2156     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2157       break;
2158     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2159       break;
2160     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2161       break;
2162     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2163       break;
2164     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2165       break;
2166     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2167       break;
2168     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2169       break;
2170     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2171       break;
2172     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2173       break;
2174     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2175       break;
2176     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2177       break;
2178     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2179       break;
2180     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2181       break;
2182     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2183       break;
2184     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2185       break;
2186     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2187       break;
2188     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2189       break;
2190     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2191       break;
2192     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2193       break;
2194     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2195       break;
2196     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2197       break;
2198     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2199       break;
2200     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2201       break;
2202     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2203       break;
2204     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2205       break;
2206     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2207       break;
2208     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2209       break;
2210     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2211       break;
2212     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2213       break;
2214     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2215       break;
2216     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2217       break;
2218     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2219       break;
2220     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2221       break;
2222     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2223       break;
2224     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2225       break;
2226     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2227       break;
2228     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2229       break;
2230     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2231       break;
2232     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2233       break;
2234     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2235       break;
2236     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2237       break;
2238     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2241       break;
2242     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2243       break;
2244     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2245       break;
2246     }
2247
2248   return ppc64_elf_howto_table[r];
2249 };
2250
2251 static reloc_howto_type *
2252 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2253                              const char *r_name)
2254 {
2255   unsigned int i;
2256
2257   for (i = 0;
2258        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2259        i++)
2260     if (ppc64_elf_howto_raw[i].name != NULL
2261         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2262       return &ppc64_elf_howto_raw[i];
2263
2264   return NULL;
2265 }
2266
2267 /* Set the howto pointer for a PowerPC ELF reloc.  */
2268
2269 static void
2270 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2271                          Elf_Internal_Rela *dst)
2272 {
2273   unsigned int type;
2274
2275   /* Initialize howto table if needed.  */
2276   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2277     ppc_howto_init ();
2278
2279   type = ELF64_R_TYPE (dst->r_info);
2280   if (type >= (sizeof (ppc64_elf_howto_table)
2281                / sizeof (ppc64_elf_howto_table[0])))
2282     {
2283       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2284                              abfd, (int) type);
2285       type = R_PPC64_NONE;
2286     }
2287   cache_ptr->howto = ppc64_elf_howto_table[type];
2288 }
2289
2290 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2291
2292 static bfd_reloc_status_type
2293 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2294                     void *data, asection *input_section,
2295                     bfd *output_bfd, char **error_message)
2296 {
2297   /* If this is a relocatable link (output_bfd test tells us), just
2298      call the generic function.  Any adjustment will be done at final
2299      link time.  */
2300   if (output_bfd != NULL)
2301     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2302                                   input_section, output_bfd, error_message);
2303
2304   /* Adjust the addend for sign extension of the low 16 bits.
2305      We won't actually be using the low 16 bits, so trashing them
2306      doesn't matter.  */
2307   reloc_entry->addend += 0x8000;
2308   return bfd_reloc_continue;
2309 }
2310
2311 static bfd_reloc_status_type
2312 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2313                         void *data, asection *input_section,
2314                         bfd *output_bfd, char **error_message)
2315 {
2316   if (output_bfd != NULL)
2317     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2318                                   input_section, output_bfd, error_message);
2319
2320   if (strcmp (symbol->section->name, ".opd") == 0
2321       && (symbol->section->owner->flags & DYNAMIC) == 0)
2322     {
2323       bfd_vma dest = opd_entry_value (symbol->section,
2324                                       symbol->value + reloc_entry->addend,
2325                                       NULL, NULL);
2326       if (dest != (bfd_vma) -1)
2327         reloc_entry->addend = dest - (symbol->value
2328                                       + symbol->section->output_section->vma
2329                                       + symbol->section->output_offset);
2330     }
2331   return bfd_reloc_continue;
2332 }
2333
2334 static bfd_reloc_status_type
2335 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2336                          void *data, asection *input_section,
2337                          bfd *output_bfd, char **error_message)
2338 {
2339   long insn;
2340   enum elf_ppc64_reloc_type r_type;
2341   bfd_size_type octets;
2342   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2343   bfd_boolean is_power4 = FALSE;
2344
2345   /* If this is a relocatable link (output_bfd test tells us), just
2346      call the generic function.  Any adjustment will be done at final
2347      link time.  */
2348   if (output_bfd != NULL)
2349     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2350                                   input_section, output_bfd, error_message);
2351
2352   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2353   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2354   insn &= ~(0x01 << 21);
2355   r_type = reloc_entry->howto->type;
2356   if (r_type == R_PPC64_ADDR14_BRTAKEN
2357       || r_type == R_PPC64_REL14_BRTAKEN)
2358     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2359
2360   if (is_power4)
2361     {
2362       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2363          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2364          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2365       if ((insn & (0x14 << 21)) == (0x04 << 21))
2366         insn |= 0x02 << 21;
2367       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2368         insn |= 0x08 << 21;
2369       else
2370         goto out;
2371     }
2372   else
2373     {
2374       bfd_vma target = 0;
2375       bfd_vma from;
2376
2377       if (!bfd_is_com_section (symbol->section))
2378         target = symbol->value;
2379       target += symbol->section->output_section->vma;
2380       target += symbol->section->output_offset;
2381       target += reloc_entry->addend;
2382
2383       from = (reloc_entry->address
2384               + input_section->output_offset
2385               + input_section->output_section->vma);
2386
2387       /* Invert 'y' bit if not the default.  */
2388       if ((bfd_signed_vma) (target - from) < 0)
2389         insn ^= 0x01 << 21;
2390     }
2391   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2392  out:
2393   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2394                                  input_section, output_bfd, error_message);
2395 }
2396
2397 static bfd_reloc_status_type
2398 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2399                          void *data, asection *input_section,
2400                          bfd *output_bfd, char **error_message)
2401 {
2402   /* If this is a relocatable link (output_bfd test tells us), just
2403      call the generic function.  Any adjustment will be done at final
2404      link time.  */
2405   if (output_bfd != NULL)
2406     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2407                                   input_section, output_bfd, error_message);
2408
2409   /* Subtract the symbol section base address.  */
2410   reloc_entry->addend -= symbol->section->output_section->vma;
2411   return bfd_reloc_continue;
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416                             void *data, asection *input_section,
2417                             bfd *output_bfd, char **error_message)
2418 {
2419   /* If this is a relocatable link (output_bfd test tells us), just
2420      call the generic function.  Any adjustment will be done at final
2421      link time.  */
2422   if (output_bfd != NULL)
2423     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424                                   input_section, output_bfd, error_message);
2425
2426   /* Subtract the symbol section base address.  */
2427   reloc_entry->addend -= symbol->section->output_section->vma;
2428
2429   /* Adjust the addend for sign extension of the low 16 bits.  */
2430   reloc_entry->addend += 0x8000;
2431   return bfd_reloc_continue;
2432 }
2433
2434 static bfd_reloc_status_type
2435 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2436                      void *data, asection *input_section,
2437                      bfd *output_bfd, char **error_message)
2438 {
2439   bfd_vma TOCstart;
2440
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2449   if (TOCstart == 0)
2450     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2451
2452   /* Subtract the TOC base address.  */
2453   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2454   return bfd_reloc_continue;
2455 }
2456
2457 static bfd_reloc_status_type
2458 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2459                         void *data, asection *input_section,
2460                         bfd *output_bfd, char **error_message)
2461 {
2462   bfd_vma TOCstart;
2463
2464   /* If this is a relocatable link (output_bfd test tells us), just
2465      call the generic function.  Any adjustment will be done at final
2466      link time.  */
2467   if (output_bfd != NULL)
2468     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2469                                   input_section, output_bfd, error_message);
2470
2471   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2472   if (TOCstart == 0)
2473     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2474
2475   /* Subtract the TOC base address.  */
2476   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2477
2478   /* Adjust the addend for sign extension of the low 16 bits.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                        void *data, asection *input_section,
2486                        bfd *output_bfd, char **error_message)
2487 {
2488   bfd_vma TOCstart;
2489   bfd_size_type octets;
2490
2491   /* If this is a relocatable link (output_bfd test tells us), just
2492      call the generic function.  Any adjustment will be done at final
2493      link time.  */
2494   if (output_bfd != NULL)
2495     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496                                   input_section, output_bfd, error_message);
2497
2498   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2499   if (TOCstart == 0)
2500     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2501
2502   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2503   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2504   return bfd_reloc_ok;
2505 }
2506
2507 static bfd_reloc_status_type
2508 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2509                            void *data, asection *input_section,
2510                            bfd *output_bfd, char **error_message)
2511 {
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   if (error_message != NULL)
2520     {
2521       static char buf[60];
2522       sprintf (buf, "generic linker can't handle %s",
2523                reloc_entry->howto->name);
2524       *error_message = buf;
2525     }
2526   return bfd_reloc_dangerous;
2527 }
2528
2529 /* Track GOT entries needed for a given symbol.  We might need more
2530    than one got entry per symbol.  */
2531 struct got_entry
2532 {
2533   struct got_entry *next;
2534
2535   /* The symbol addend that we'll be placing in the GOT.  */
2536   bfd_vma addend;
2537
2538   /* Unlike other ELF targets, we use separate GOT entries for the same
2539      symbol referenced from different input files.  This is to support
2540      automatic multiple TOC/GOT sections, where the TOC base can vary
2541      from one input file to another.  After partitioning into TOC groups
2542      we merge entries within the group.
2543
2544      Point to the BFD owning this GOT entry.  */
2545   bfd *owner;
2546
2547   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2548      TLS_TPREL or TLS_DTPREL for tls entries.  */
2549   unsigned char tls_type;
2550
2551   /* Non-zero if got.ent points to real entry.  */
2552   unsigned char is_indirect;
2553
2554   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2555   union
2556     {
2557       bfd_signed_vma refcount;
2558       bfd_vma offset;
2559       struct got_entry *ent;
2560     } got;
2561 };
2562
2563 /* The same for PLT.  */
2564 struct plt_entry
2565 {
2566   struct plt_entry *next;
2567
2568   bfd_vma addend;
2569
2570   union
2571     {
2572       bfd_signed_vma refcount;
2573       bfd_vma offset;
2574     } plt;
2575 };
2576
2577 struct ppc64_elf_obj_tdata
2578 {
2579   struct elf_obj_tdata elf;
2580
2581   /* Shortcuts to dynamic linker sections.  */
2582   asection *got;
2583   asection *relgot;
2584
2585   /* Used during garbage collection.  We attach global symbols defined
2586      on removed .opd entries to this section so that the sym is removed.  */
2587   asection *deleted_section;
2588
2589   /* TLS local dynamic got entry handling.  Support for multiple GOT
2590      sections means we potentially need one of these for each input bfd.  */
2591   struct got_entry tlsld_got;
2592
2593   /* A copy of relocs before they are modified for --emit-relocs.  */
2594   Elf_Internal_Rela *opd_relocs;
2595
2596   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2597      the reloc to be in the range -32768 to 32767.  */
2598   unsigned int has_small_toc_reloc;
2599 };
2600
2601 #define ppc64_elf_tdata(bfd) \
2602   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2603
2604 #define ppc64_tlsld_got(bfd) \
2605   (&ppc64_elf_tdata (bfd)->tlsld_got)
2606
2607 #define is_ppc64_elf(bfd) \
2608   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2609    && elf_object_id (bfd) == PPC64_ELF_DATA)
2610
2611 /* Override the generic function because we store some extras.  */
2612
2613 static bfd_boolean
2614 ppc64_elf_mkobject (bfd *abfd)
2615 {
2616   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2617                                   PPC64_ELF_DATA);
2618 }
2619
2620 /* Fix bad default arch selected for a 64 bit input bfd when the
2621    default is 32 bit.  */
2622
2623 static bfd_boolean
2624 ppc64_elf_object_p (bfd *abfd)
2625 {
2626   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2627     {
2628       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2629
2630       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2631         {
2632           /* Relies on arch after 32 bit default being 64 bit default.  */
2633           abfd->arch_info = abfd->arch_info->next;
2634           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2635         }
2636     }
2637   return TRUE;
2638 }
2639
2640 /* Support for core dump NOTE sections.  */
2641
2642 static bfd_boolean
2643 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2644 {
2645   size_t offset, size;
2646
2647   if (note->descsz != 504)
2648     return FALSE;
2649
2650   /* pr_cursig */
2651   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2652
2653   /* pr_pid */
2654   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2655
2656   /* pr_reg */
2657   offset = 112;
2658   size = 384;
2659
2660   /* Make a ".reg/999" section.  */
2661   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2662                                           size, note->descpos + offset);
2663 }
2664
2665 static bfd_boolean
2666 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2667 {
2668   if (note->descsz != 136)
2669     return FALSE;
2670
2671   elf_tdata (abfd)->core_program
2672     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2673   elf_tdata (abfd)->core_command
2674     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2675
2676   return TRUE;
2677 }
2678
2679 static char *
2680 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2681                            ...)
2682 {
2683   switch (note_type)
2684     {
2685     default:
2686       return NULL;
2687
2688     case NT_PRPSINFO:
2689       {
2690         char data[136];
2691         va_list ap;
2692
2693         va_start (ap, note_type);
2694         memset (data, 0, 40);
2695         strncpy (data + 40, va_arg (ap, const char *), 16);
2696         strncpy (data + 56, va_arg (ap, const char *), 80);
2697         va_end (ap);
2698         return elfcore_write_note (abfd, buf, bufsiz,
2699                                    "CORE", note_type, data, sizeof (data));
2700       }
2701
2702     case NT_PRSTATUS:
2703       {
2704         char data[504];
2705         va_list ap;
2706         long pid;
2707         int cursig;
2708         const void *greg;
2709
2710         va_start (ap, note_type);
2711         memset (data, 0, 112);
2712         pid = va_arg (ap, long);
2713         bfd_put_32 (abfd, pid, data + 32);
2714         cursig = va_arg (ap, int);
2715         bfd_put_16 (abfd, cursig, data + 12);
2716         greg = va_arg (ap, const void *);
2717         memcpy (data + 112, greg, 384);
2718         memset (data + 496, 0, 8);
2719         va_end (ap);
2720         return elfcore_write_note (abfd, buf, bufsiz,
2721                                    "CORE", note_type, data, sizeof (data));
2722       }
2723     }
2724 }
2725
2726 /* Merge backend specific data from an object file to the output
2727    object file when linking.  */
2728
2729 static bfd_boolean
2730 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2731 {
2732   /* Check if we have the same endianess.  */
2733   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2734       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2735       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2736     {
2737       const char *msg;
2738
2739       if (bfd_big_endian (ibfd))
2740         msg = _("%B: compiled for a big endian system "
2741                 "and target is little endian");
2742       else
2743         msg = _("%B: compiled for a little endian system "
2744                 "and target is big endian");
2745
2746       (*_bfd_error_handler) (msg, ibfd);
2747
2748       bfd_set_error (bfd_error_wrong_format);
2749       return FALSE;
2750     }
2751
2752   return TRUE;
2753 }
2754
2755 /* Add extra PPC sections.  */
2756
2757 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2758 {
2759   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2760   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2761   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2762   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2763   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2764   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2765   { NULL,                     0,  0, 0,            0 }
2766 };
2767
2768 enum _ppc64_sec_type {
2769   sec_normal = 0,
2770   sec_opd = 1,
2771   sec_toc = 2
2772 };
2773
2774 struct _ppc64_elf_section_data
2775 {
2776   struct bfd_elf_section_data elf;
2777
2778   union
2779   {
2780     /* An array with one entry for each opd function descriptor.  */
2781     struct _opd_sec_data
2782     {
2783       /* Points to the function code section for local opd entries.  */
2784       asection **func_sec;
2785
2786       /* After editing .opd, adjust references to opd local syms.  */
2787       long *adjust;
2788     } opd;
2789
2790     /* An array for toc sections, indexed by offset/8.  */
2791     struct _toc_sec_data
2792     {
2793       /* Specifies the relocation symbol index used at a given toc offset.  */
2794       unsigned *symndx;
2795
2796       /* And the relocation addend.  */
2797       bfd_vma *add;
2798     } toc;
2799   } u;
2800
2801   enum _ppc64_sec_type sec_type:2;
2802
2803   /* Flag set when small branches are detected.  Used to
2804      select suitable defaults for the stub group size.  */
2805   unsigned int has_14bit_branch:1;
2806 };
2807
2808 #define ppc64_elf_section_data(sec) \
2809   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2810
2811 static bfd_boolean
2812 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2813 {
2814   if (!sec->used_by_bfd)
2815     {
2816       struct _ppc64_elf_section_data *sdata;
2817       bfd_size_type amt = sizeof (*sdata);
2818
2819       sdata = bfd_zalloc (abfd, amt);
2820       if (sdata == NULL)
2821         return FALSE;
2822       sec->used_by_bfd = sdata;
2823     }
2824
2825   return _bfd_elf_new_section_hook (abfd, sec);
2826 }
2827
2828 static struct _opd_sec_data *
2829 get_opd_info (asection * sec)
2830 {
2831   if (sec != NULL
2832       && ppc64_elf_section_data (sec) != NULL
2833       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2834     return &ppc64_elf_section_data (sec)->u.opd;
2835   return NULL;
2836 }
2837 \f
2838 /* Parameters for the qsort hook.  */
2839 static bfd_boolean synthetic_relocatable;
2840
2841 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2842
2843 static int
2844 compare_symbols (const void *ap, const void *bp)
2845 {
2846   const asymbol *a = * (const asymbol **) ap;
2847   const asymbol *b = * (const asymbol **) bp;
2848
2849   /* Section symbols first.  */
2850   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2851     return -1;
2852   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2853     return 1;
2854
2855   /* then .opd symbols.  */
2856   if (strcmp (a->section->name, ".opd") == 0
2857       && strcmp (b->section->name, ".opd") != 0)
2858     return -1;
2859   if (strcmp (a->section->name, ".opd") != 0
2860       && strcmp (b->section->name, ".opd") == 0)
2861     return 1;
2862
2863   /* then other code symbols.  */
2864   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2865       == (SEC_CODE | SEC_ALLOC)
2866       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867          != (SEC_CODE | SEC_ALLOC))
2868     return -1;
2869
2870   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2871       != (SEC_CODE | SEC_ALLOC)
2872       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2873          == (SEC_CODE | SEC_ALLOC))
2874     return 1;
2875
2876   if (synthetic_relocatable)
2877     {
2878       if (a->section->id < b->section->id)
2879         return -1;
2880
2881       if (a->section->id > b->section->id)
2882         return 1;
2883     }
2884
2885   if (a->value + a->section->vma < b->value + b->section->vma)
2886     return -1;
2887
2888   if (a->value + a->section->vma > b->value + b->section->vma)
2889     return 1;
2890
2891   /* For syms with the same value, prefer strong dynamic global function
2892      syms over other syms.  */
2893   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2894     return -1;
2895
2896   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2897     return 1;
2898
2899   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2900     return -1;
2901
2902   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2903     return 1;
2904
2905   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2906     return -1;
2907
2908   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2909     return 1;
2910
2911   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2912     return -1;
2913
2914   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2915     return 1;
2916
2917   return 0;
2918 }
2919
2920 /* Search SYMS for a symbol of the given VALUE.  */
2921
2922 static asymbol *
2923 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2924 {
2925   long mid;
2926
2927   if (id == -1)
2928     {
2929       while (lo < hi)
2930         {
2931           mid = (lo + hi) >> 1;
2932           if (syms[mid]->value + syms[mid]->section->vma < value)
2933             lo = mid + 1;
2934           else if (syms[mid]->value + syms[mid]->section->vma > value)
2935             hi = mid;
2936           else
2937             return syms[mid];
2938         }
2939     }
2940   else
2941     {
2942       while (lo < hi)
2943         {
2944           mid = (lo + hi) >> 1;
2945           if (syms[mid]->section->id < id)
2946             lo = mid + 1;
2947           else if (syms[mid]->section->id > id)
2948             hi = mid;
2949           else if (syms[mid]->value < value)
2950             lo = mid + 1;
2951           else if (syms[mid]->value > value)
2952             hi = mid;
2953           else
2954             return syms[mid];
2955         }
2956     }
2957   return NULL;
2958 }
2959
2960 static bfd_boolean
2961 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2962 {
2963   bfd_vma vma = *(bfd_vma *) ptr;
2964   return ((section->flags & SEC_ALLOC) != 0
2965           && section->vma <= vma
2966           && vma < section->vma + section->size);
2967 }
2968
2969 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2970    entry syms.  Also generate @plt symbols for the glink branch table.  */
2971
2972 static long
2973 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2974                                 long static_count, asymbol **static_syms,
2975                                 long dyn_count, asymbol **dyn_syms,
2976                                 asymbol **ret)
2977 {
2978   asymbol *s;
2979   long i;
2980   long count;
2981   char *names;
2982   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2983   asection *opd;
2984   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2985   asymbol **syms;
2986
2987   *ret = NULL;
2988
2989   opd = bfd_get_section_by_name (abfd, ".opd");
2990   if (opd == NULL)
2991     return 0;
2992
2993   symcount = static_count;
2994   if (!relocatable)
2995     symcount += dyn_count;
2996   if (symcount == 0)
2997     return 0;
2998
2999   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3000   if (syms == NULL)
3001     return -1;
3002
3003   if (!relocatable && static_count != 0 && dyn_count != 0)
3004     {
3005       /* Use both symbol tables.  */
3006       memcpy (syms, static_syms, static_count * sizeof (*syms));
3007       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3008     }
3009   else if (!relocatable && static_count == 0)
3010     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3011   else
3012     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3013
3014   synthetic_relocatable = relocatable;
3015   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3016
3017   if (!relocatable && symcount > 1)
3018     {
3019       long j;
3020       /* Trim duplicate syms, since we may have merged the normal and
3021          dynamic symbols.  Actually, we only care about syms that have
3022          different values, so trim any with the same value.  */
3023       for (i = 1, j = 1; i < symcount; ++i)
3024         if (syms[i - 1]->value + syms[i - 1]->section->vma
3025             != syms[i]->value + syms[i]->section->vma)
3026           syms[j++] = syms[i];
3027       symcount = j;
3028     }
3029
3030   i = 0;
3031   if (strcmp (syms[i]->section->name, ".opd") == 0)
3032     ++i;
3033   codesecsym = i;
3034
3035   for (; i < symcount; ++i)
3036     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3037          != (SEC_CODE | SEC_ALLOC))
3038         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3039       break;
3040   codesecsymend = i;
3041
3042   for (; i < symcount; ++i)
3043     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3044       break;
3045   secsymend = i;
3046
3047   for (; i < symcount; ++i)
3048     if (strcmp (syms[i]->section->name, ".opd") != 0)
3049       break;
3050   opdsymend = i;
3051
3052   for (; i < symcount; ++i)
3053     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3054         != (SEC_CODE | SEC_ALLOC))
3055       break;
3056   symcount = i;
3057
3058   count = 0;
3059
3060   if (relocatable)
3061     {
3062       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3063       arelent *r;
3064       size_t size;
3065       long relcount;
3066
3067       if (opdsymend == secsymend)
3068         goto done;
3069
3070       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3071       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3072       if (relcount == 0)
3073         goto done;
3074
3075       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3076         {
3077           count = -1;
3078           goto done;
3079         }
3080
3081       size = 0;
3082       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3083         {
3084           asymbol *sym;
3085
3086           while (r < opd->relocation + relcount
3087                  && r->address < syms[i]->value + opd->vma)
3088             ++r;
3089
3090           if (r == opd->relocation + relcount)
3091             break;
3092
3093           if (r->address != syms[i]->value + opd->vma)
3094             continue;
3095
3096           if (r->howto->type != R_PPC64_ADDR64)
3097             continue;
3098
3099           sym = *r->sym_ptr_ptr;
3100           if (!sym_exists_at (syms, opdsymend, symcount,
3101                               sym->section->id, sym->value + r->addend))
3102             {
3103               ++count;
3104               size += sizeof (asymbol);
3105               size += strlen (syms[i]->name) + 2;
3106             }
3107         }
3108
3109       s = *ret = bfd_malloc (size);
3110       if (s == NULL)
3111         {
3112           count = -1;
3113           goto done;
3114         }
3115
3116       names = (char *) (s + count);
3117
3118       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3119         {
3120           asymbol *sym;
3121
3122           while (r < opd->relocation + relcount
3123                  && r->address < syms[i]->value + opd->vma)
3124             ++r;
3125
3126           if (r == opd->relocation + relcount)
3127             break;
3128
3129           if (r->address != syms[i]->value + opd->vma)
3130             continue;
3131
3132           if (r->howto->type != R_PPC64_ADDR64)
3133             continue;
3134
3135           sym = *r->sym_ptr_ptr;
3136           if (!sym_exists_at (syms, opdsymend, symcount,
3137                               sym->section->id, sym->value + r->addend))
3138             {
3139               size_t len;
3140
3141               *s = *syms[i];
3142               s->flags |= BSF_SYNTHETIC;
3143               s->section = sym->section;
3144               s->value = sym->value + r->addend;
3145               s->name = names;
3146               *names++ = '.';
3147               len = strlen (syms[i]->name);
3148               memcpy (names, syms[i]->name, len + 1);
3149               names += len + 1;
3150               /* Have udata.p point back to the original symbol this
3151                  synthetic symbol was derived from.  */
3152               s->udata.p = syms[i];
3153               s++;
3154             }
3155         }
3156     }
3157   else
3158     {
3159       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3160       bfd_byte *contents;
3161       size_t size;
3162       long plt_count = 0;
3163       bfd_vma glink_vma = 0, resolv_vma = 0;
3164       asection *dynamic, *glink = NULL, *relplt = NULL;
3165       arelent *p;
3166
3167       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3168         {
3169           if (contents)
3170             {
3171             free_contents_and_exit:
3172               free (contents);
3173             }
3174           count = -1;
3175           goto done;
3176         }
3177
3178       size = 0;
3179       for (i = secsymend; i < opdsymend; ++i)
3180         {
3181           bfd_vma ent;
3182
3183           /* Ignore bogus symbols.  */
3184           if (syms[i]->value > opd->size - 8)
3185             continue;
3186
3187           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3188           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3189             {
3190               ++count;
3191               size += sizeof (asymbol);
3192               size += strlen (syms[i]->name) + 2;
3193             }
3194         }
3195
3196       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3197       if (dyn_count != 0
3198           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3199         {
3200           bfd_byte *dynbuf, *extdyn, *extdynend;
3201           size_t extdynsize;
3202           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3203
3204           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3205             goto free_contents_and_exit;
3206
3207           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3208           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3209
3210           extdyn = dynbuf;
3211           extdynend = extdyn + dynamic->size;
3212           for (; extdyn < extdynend; extdyn += extdynsize)
3213             {
3214               Elf_Internal_Dyn dyn;
3215               (*swap_dyn_in) (abfd, extdyn, &dyn);
3216
3217               if (dyn.d_tag == DT_NULL)
3218                 break;
3219
3220               if (dyn.d_tag == DT_PPC64_GLINK)
3221                 {
3222                   /* The first glink stub starts at offset 32; see comment in
3223                      ppc64_elf_finish_dynamic_sections. */
3224                   glink_vma = dyn.d_un.d_val + 32;
3225                   /* The .glink section usually does not survive the final
3226                      link; search for the section (usually .text) where the
3227                      glink stubs now reside.  */
3228                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3229                                                 &glink_vma);
3230                   break;
3231                 }
3232             }
3233
3234           free (dynbuf);
3235         }
3236
3237       if (glink != NULL)
3238         {
3239           /* Determine __glink trampoline by reading the relative branch
3240              from the first glink stub.  */
3241           bfd_byte buf[4];
3242           if (bfd_get_section_contents (abfd, glink, buf,
3243                                         glink_vma + 4 - glink->vma, 4))
3244             {
3245               unsigned int insn = bfd_get_32 (abfd, buf);
3246               insn ^= B_DOT;
3247               if ((insn & ~0x3fffffc) == 0)
3248                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3249             }
3250
3251           if (resolv_vma)
3252             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3253
3254           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3255           if (relplt != NULL)
3256             {
3257               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3258               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3259                 goto free_contents_and_exit;
3260
3261               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3262               size += plt_count * sizeof (asymbol);
3263
3264               p = relplt->relocation;
3265               for (i = 0; i < plt_count; i++, p++)
3266                 {
3267                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3268                   if (p->addend != 0)
3269                     size += sizeof ("+0x") - 1 + 16;
3270                 }
3271             }
3272         }
3273
3274       s = *ret = bfd_malloc (size);
3275       if (s == NULL)
3276         goto free_contents_and_exit;
3277
3278       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3279
3280       for (i = secsymend; i < opdsymend; ++i)
3281         {
3282           bfd_vma ent;
3283
3284           if (syms[i]->value > opd->size - 8)
3285             continue;
3286
3287           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3288           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3289             {
3290               long lo, hi;
3291               size_t len;
3292               asection *sec = abfd->sections;
3293
3294               *s = *syms[i];
3295               lo = codesecsym;
3296               hi = codesecsymend;
3297               while (lo < hi)
3298                 {
3299                   long mid = (lo + hi) >> 1;
3300                   if (syms[mid]->section->vma < ent)
3301                     lo = mid + 1;
3302                   else if (syms[mid]->section->vma > ent)
3303                     hi = mid;
3304                   else
3305                     {
3306                       sec = syms[mid]->section;
3307                       break;
3308                     }
3309                 }
3310
3311               if (lo >= hi && lo > codesecsym)
3312                 sec = syms[lo - 1]->section;
3313
3314               for (; sec != NULL; sec = sec->next)
3315                 {
3316                   if (sec->vma > ent)
3317                     break;
3318                   if ((sec->flags & SEC_ALLOC) == 0
3319                       || (sec->flags & SEC_LOAD) == 0)
3320                     break;
3321                   if ((sec->flags & SEC_CODE) != 0)
3322                     s->section = sec;
3323                 }
3324               s->flags |= BSF_SYNTHETIC;
3325               s->value = ent - s->section->vma;
3326               s->name = names;
3327               *names++ = '.';
3328               len = strlen (syms[i]->name);
3329               memcpy (names, syms[i]->name, len + 1);
3330               names += len + 1;
3331               /* Have udata.p point back to the original symbol this
3332                  synthetic symbol was derived from.  */
3333               s->udata.p = syms[i];
3334               s++;
3335             }
3336         }
3337       free (contents);
3338
3339       if (glink != NULL && relplt != NULL)
3340         {
3341           if (resolv_vma)
3342             {
3343               /* Add a symbol for the main glink trampoline.  */
3344               memset (s, 0, sizeof *s);
3345               s->the_bfd = abfd;
3346               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3347               s->section = glink;
3348               s->value = resolv_vma - glink->vma;
3349               s->name = names;
3350               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3351               names += sizeof ("__glink_PLTresolve");
3352               s++;
3353               count++;
3354             }
3355
3356           /* FIXME: It would be very much nicer to put sym@plt on the
3357              stub rather than on the glink branch table entry.  The
3358              objdump disassembler would then use a sensible symbol
3359              name on plt calls.  The difficulty in doing so is
3360              a) finding the stubs, and,
3361              b) matching stubs against plt entries, and,
3362              c) there can be multiple stubs for a given plt entry.
3363
3364              Solving (a) could be done by code scanning, but older
3365              ppc64 binaries used different stubs to current code.
3366              (b) is the tricky one since you need to known the toc
3367              pointer for at least one function that uses a pic stub to
3368              be able to calculate the plt address referenced.
3369              (c) means gdb would need to set multiple breakpoints (or
3370              find the glink branch itself) when setting breakpoints
3371              for pending shared library loads.  */
3372           p = relplt->relocation;
3373           for (i = 0; i < plt_count; i++, p++)
3374             {
3375               size_t len;
3376
3377               *s = **p->sym_ptr_ptr;
3378               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3379                  we are defining a symbol, ensure one of them is set.  */
3380               if ((s->flags & BSF_LOCAL) == 0)
3381                 s->flags |= BSF_GLOBAL;
3382               s->flags |= BSF_SYNTHETIC;
3383               s->section = glink;
3384               s->value = glink_vma - glink->vma;
3385               s->name = names;
3386               s->udata.p = NULL;
3387               len = strlen ((*p->sym_ptr_ptr)->name);
3388               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3389               names += len;
3390               if (p->addend != 0)
3391                 {
3392                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3393                   names += sizeof ("+0x") - 1;
3394                   bfd_sprintf_vma (abfd, names, p->addend);
3395                   names += strlen (names);
3396                 }
3397               memcpy (names, "@plt", sizeof ("@plt"));
3398               names += sizeof ("@plt");
3399               s++;
3400               glink_vma += 8;
3401               if (i >= 0x8000)
3402                 glink_vma += 4;
3403             }
3404           count += plt_count;
3405         }
3406     }
3407
3408  done:
3409   free (syms);
3410   return count;
3411 }
3412 \f
3413 /* The following functions are specific to the ELF linker, while
3414    functions above are used generally.  Those named ppc64_elf_* are
3415    called by the main ELF linker code.  They appear in this file more
3416    or less in the order in which they are called.  eg.
3417    ppc64_elf_check_relocs is called early in the link process,
3418    ppc64_elf_finish_dynamic_sections is one of the last functions
3419    called.
3420
3421    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3422    functions have both a function code symbol and a function descriptor
3423    symbol.  A call to foo in a relocatable object file looks like:
3424
3425    .            .text
3426    .    x:
3427    .            bl      .foo
3428    .            nop
3429
3430    The function definition in another object file might be:
3431
3432    .            .section .opd
3433    .    foo:    .quad   .foo
3434    .            .quad   .TOC.@tocbase
3435    .            .quad   0
3436    .
3437    .            .text
3438    .    .foo:   blr
3439
3440    When the linker resolves the call during a static link, the branch
3441    unsurprisingly just goes to .foo and the .opd information is unused.
3442    If the function definition is in a shared library, things are a little
3443    different:  The call goes via a plt call stub, the opd information gets
3444    copied to the plt, and the linker patches the nop.
3445
3446    .    x:
3447    .            bl      .foo_stub
3448    .            ld      2,40(1)
3449    .
3450    .
3451    .    .foo_stub:
3452    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3453    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3454    .            std     2,40(1)                 # this is the general idea
3455    .            ld      11,0(12)
3456    .            ld      2,8(12)
3457    .            mtctr   11
3458    .            ld      11,16(12)
3459    .            bctr
3460    .
3461    .            .section .plt
3462    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3463
3464    The "reloc ()" notation is supposed to indicate that the linker emits
3465    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3466    copying.
3467
3468    What are the difficulties here?  Well, firstly, the relocations
3469    examined by the linker in check_relocs are against the function code
3470    sym .foo, while the dynamic relocation in the plt is emitted against
3471    the function descriptor symbol, foo.  Somewhere along the line, we need
3472    to carefully copy dynamic link information from one symbol to the other.
3473    Secondly, the generic part of the elf linker will make .foo a dynamic
3474    symbol as is normal for most other backends.  We need foo dynamic
3475    instead, at least for an application final link.  However, when
3476    creating a shared library containing foo, we need to have both symbols
3477    dynamic so that references to .foo are satisfied during the early
3478    stages of linking.  Otherwise the linker might decide to pull in a
3479    definition from some other object, eg. a static library.
3480
3481    Update: As of August 2004, we support a new convention.  Function
3482    calls may use the function descriptor symbol, ie. "bl foo".  This
3483    behaves exactly as "bl .foo".  */
3484
3485 /* The linker needs to keep track of the number of relocs that it
3486    decides to copy as dynamic relocs in check_relocs for each symbol.
3487    This is so that it can later discard them if they are found to be
3488    unnecessary.  We store the information in a field extending the
3489    regular ELF linker hash table.  */
3490
3491 struct ppc_dyn_relocs
3492 {
3493   struct ppc_dyn_relocs *next;
3494
3495   /* The input section of the reloc.  */
3496   asection *sec;
3497
3498   /* Total number of relocs copied for the input section.  */
3499   bfd_size_type count;
3500
3501   /* Number of pc-relative relocs copied for the input section.  */
3502   bfd_size_type pc_count;
3503 };
3504
3505 /* Of those relocs that might be copied as dynamic relocs, this function
3506    selects those that must be copied when linking a shared library,
3507    even when the symbol is local.  */
3508
3509 static int
3510 must_be_dyn_reloc (struct bfd_link_info *info,
3511                    enum elf_ppc64_reloc_type r_type)
3512 {
3513   switch (r_type)
3514     {
3515     default:
3516       return 1;
3517
3518     case R_PPC64_REL32:
3519     case R_PPC64_REL64:
3520     case R_PPC64_REL30:
3521       return 0;
3522
3523     case R_PPC64_TPREL16:
3524     case R_PPC64_TPREL16_LO:
3525     case R_PPC64_TPREL16_HI:
3526     case R_PPC64_TPREL16_HA:
3527     case R_PPC64_TPREL16_DS:
3528     case R_PPC64_TPREL16_LO_DS:
3529     case R_PPC64_TPREL16_HIGHER:
3530     case R_PPC64_TPREL16_HIGHERA:
3531     case R_PPC64_TPREL16_HIGHEST:
3532     case R_PPC64_TPREL16_HIGHESTA:
3533     case R_PPC64_TPREL64:
3534       return !info->executable;
3535     }
3536 }
3537
3538 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3539    copying dynamic variables from a shared lib into an app's dynbss
3540    section, and instead use a dynamic relocation to point into the
3541    shared lib.  With code that gcc generates, it's vital that this be
3542    enabled;  In the PowerPC64 ABI, the address of a function is actually
3543    the address of a function descriptor, which resides in the .opd
3544    section.  gcc uses the descriptor directly rather than going via the
3545    GOT as some other ABI's do, which means that initialized function
3546    pointers must reference the descriptor.  Thus, a function pointer
3547    initialized to the address of a function in a shared library will
3548    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3549    redefines the function descriptor symbol to point to the copy.  This
3550    presents a problem as a plt entry for that function is also
3551    initialized from the function descriptor symbol and the copy reloc
3552    may not be initialized first.  */
3553 #define ELIMINATE_COPY_RELOCS 1
3554
3555 /* Section name for stubs is the associated section name plus this
3556    string.  */
3557 #define STUB_SUFFIX ".stub"
3558
3559 /* Linker stubs.
3560    ppc_stub_long_branch:
3561    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3562    destination, but a 24 bit branch in a stub section will reach.
3563    .    b       dest
3564
3565    ppc_stub_plt_branch:
3566    Similar to the above, but a 24 bit branch in the stub section won't
3567    reach its destination.
3568    .    addis   %r12,%r2,xxx@toc@ha
3569    .    ld      %r11,xxx@toc@l(%r12)
3570    .    mtctr   %r11
3571    .    bctr
3572
3573    ppc_stub_plt_call:
3574    Used to call a function in a shared library.  If it so happens that
3575    the plt entry referenced crosses a 64k boundary, then an extra
3576    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3577    .    addis   %r12,%r2,xxx@toc@ha
3578    .    std     %r2,40(%r1)
3579    .    ld      %r11,xxx+0@toc@l(%r12)
3580    .    mtctr   %r11
3581    .    ld      %r2,xxx+8@toc@l(%r12)
3582    .    ld      %r11,xxx+16@toc@l(%r12)
3583    .    bctr
3584
3585    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3586    code to adjust the value and save r2 to support multiple toc sections.
3587    A ppc_stub_long_branch with an r2 offset looks like:
3588    .    std     %r2,40(%r1)
3589    .    addis   %r2,%r2,off@ha
3590    .    addi    %r2,%r2,off@l
3591    .    b       dest
3592
3593    A ppc_stub_plt_branch with an r2 offset looks like:
3594    .    std     %r2,40(%r1)
3595    .    addis   %r12,%r2,xxx@toc@ha
3596    .    ld      %r11,xxx@toc@l(%r12)
3597    .    addis   %r2,%r2,off@ha
3598    .    addi    %r2,%r2,off@l
3599    .    mtctr   %r11
3600    .    bctr
3601
3602    In cases where the "addis" instruction would add zero, the "addis" is
3603    omitted and following instructions modified slightly in some cases.
3604 */
3605
3606 enum ppc_stub_type {
3607   ppc_stub_none,
3608   ppc_stub_long_branch,
3609   ppc_stub_long_branch_r2off,
3610   ppc_stub_plt_branch,
3611   ppc_stub_plt_branch_r2off,
3612   ppc_stub_plt_call
3613 };
3614
3615 struct ppc_stub_hash_entry {
3616
3617   /* Base hash table entry structure.  */
3618   struct bfd_hash_entry root;
3619
3620   enum ppc_stub_type stub_type;
3621
3622   /* The stub section.  */
3623   asection *stub_sec;
3624
3625   /* Offset within stub_sec of the beginning of this stub.  */
3626   bfd_vma stub_offset;
3627
3628   /* Given the symbol's value and its section we can determine its final
3629      value when building the stubs (so the stub knows where to jump.  */
3630   bfd_vma target_value;
3631   asection *target_section;
3632
3633   /* The symbol table entry, if any, that this was derived from.  */
3634   struct ppc_link_hash_entry *h;
3635   struct plt_entry *plt_ent;
3636
3637   /* And the reloc addend that this was derived from.  */
3638   bfd_vma addend;
3639
3640   /* Where this stub is being called from, or, in the case of combined
3641      stub sections, the first input section in the group.  */
3642   asection *id_sec;
3643 };
3644
3645 struct ppc_branch_hash_entry {
3646
3647   /* Base hash table entry structure.  */
3648   struct bfd_hash_entry root;
3649
3650   /* Offset within branch lookup table.  */
3651   unsigned int offset;
3652
3653   /* Generation marker.  */
3654   unsigned int iter;
3655 };
3656
3657 struct ppc_link_hash_entry
3658 {
3659   struct elf_link_hash_entry elf;
3660
3661   union {
3662     /* A pointer to the most recently used stub hash entry against this
3663        symbol.  */
3664     struct ppc_stub_hash_entry *stub_cache;
3665
3666     /* A pointer to the next symbol starting with a '.'  */
3667     struct ppc_link_hash_entry *next_dot_sym;
3668   } u;
3669
3670   /* Track dynamic relocs copied for this symbol.  */
3671   struct ppc_dyn_relocs *dyn_relocs;
3672
3673   /* Link between function code and descriptor symbols.  */
3674   struct ppc_link_hash_entry *oh;
3675
3676   /* Flag function code and descriptor symbols.  */
3677   unsigned int is_func:1;
3678   unsigned int is_func_descriptor:1;
3679   unsigned int fake:1;
3680
3681   /* Whether global opd/toc sym has been adjusted or not.
3682      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3683      should be set for all globals defined in any opd/toc section.  */
3684   unsigned int adjust_done:1;
3685
3686   /* Set if we twiddled this symbol to weak at some stage.  */
3687   unsigned int was_undefined:1;
3688
3689   /* Contexts in which symbol is used in the GOT (or TOC).
3690      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3691      corresponding relocs are encountered during check_relocs.
3692      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3693      indicate the corresponding GOT entry type is not needed.
3694      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3695      a TPREL one.  We use a separate flag rather than setting TPREL
3696      just for convenience in distinguishing the two cases.  */
3697 #define TLS_GD           1      /* GD reloc. */
3698 #define TLS_LD           2      /* LD reloc. */
3699 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3700 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3701 #define TLS_TLS         16      /* Any TLS reloc.  */
3702 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3703 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3704 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3705   unsigned char tls_mask;
3706 };
3707
3708 /* ppc64 ELF linker hash table.  */
3709
3710 struct ppc_link_hash_table
3711 {
3712   struct elf_link_hash_table elf;
3713
3714   /* The stub hash table.  */
3715   struct bfd_hash_table stub_hash_table;
3716
3717   /* Another hash table for plt_branch stubs.  */
3718   struct bfd_hash_table branch_hash_table;
3719
3720   /* Linker stub bfd.  */
3721   bfd *stub_bfd;
3722
3723   /* Linker call-backs.  */
3724   asection * (*add_stub_section) (const char *, asection *);
3725   void (*layout_sections_again) (void);
3726
3727   /* Array to keep track of which stub sections have been created, and
3728      information on stub grouping.  */
3729   struct map_stub {
3730     /* This is the section to which stubs in the group will be attached.  */
3731     asection *link_sec;
3732     /* The stub section.  */
3733     asection *stub_sec;
3734     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3735     bfd_vma toc_off;
3736   } *stub_group;
3737
3738   /* Temp used when calculating TOC pointers.  */
3739   bfd_vma toc_curr;
3740   bfd *toc_bfd;
3741   asection *toc_first_sec;
3742
3743   /* Highest input section id.  */
3744   int top_id;
3745
3746   /* Highest output section index.  */
3747   int top_index;
3748
3749   /* Used when adding symbols.  */
3750   struct ppc_link_hash_entry *dot_syms;
3751
3752   /* List of input sections for each output section.  */
3753   asection **input_list;
3754
3755   /* Short-cuts to get to dynamic linker sections.  */
3756   asection *got;
3757   asection *plt;
3758   asection *relplt;
3759   asection *iplt;
3760   asection *reliplt;
3761   asection *dynbss;
3762   asection *relbss;
3763   asection *glink;
3764   asection *sfpr;
3765   asection *brlt;
3766   asection *relbrlt;
3767
3768   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3769   struct ppc_link_hash_entry *tls_get_addr;
3770   struct ppc_link_hash_entry *tls_get_addr_fd;
3771
3772   /* The size of reliplt used by got entry relocs.  */
3773   bfd_size_type got_reli_size;
3774
3775   /* Statistics.  */
3776   unsigned long stub_count[ppc_stub_plt_call];
3777
3778   /* Number of stubs against global syms.  */
3779   unsigned long stub_globals;
3780
3781   /* Set if we should emit symbols for stubs.  */
3782   unsigned int emit_stub_syms:1;
3783
3784   /* Set if __tls_get_addr optimization should not be done.  */
3785   unsigned int no_tls_get_addr_opt:1;
3786
3787   /* Support for multiple toc sections.  */
3788   unsigned int do_multi_toc:1;
3789   unsigned int multi_toc_needed:1;
3790   unsigned int second_toc_pass:1;
3791
3792   /* Set on error.  */
3793   unsigned int stub_error:1;
3794
3795   /* Temp used by ppc64_elf_process_dot_syms.  */
3796   unsigned int twiddled_syms:1;
3797
3798   /* Incremented every time we size stubs.  */
3799   unsigned int stub_iteration;
3800
3801   /* Small local sym cache.  */
3802   struct sym_cache sym_cache;
3803 };
3804
3805 /* Rename some of the generic section flags to better document how they
3806    are used here.  */
3807
3808 /* Nonzero if this section has TLS related relocations.  */
3809 #define has_tls_reloc sec_flg0
3810
3811 /* Nonzero if this section has a call to __tls_get_addr.  */
3812 #define has_tls_get_addr_call sec_flg1
3813
3814 /* Nonzero if this section has any toc or got relocs.  */
3815 #define has_toc_reloc sec_flg2
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_flg3
3820
3821 /* Recursion protection when determining above flag.  */
3822 #define call_check_in_progress sec_flg4
3823 #define call_check_done sec_flg5
3824
3825 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3826
3827 #define ppc_hash_table(p) \
3828   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3829   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3830
3831 #define ppc_stub_hash_lookup(table, string, create, copy) \
3832   ((struct ppc_stub_hash_entry *) \
3833    bfd_hash_lookup ((table), (string), (create), (copy)))
3834
3835 #define ppc_branch_hash_lookup(table, string, create, copy) \
3836   ((struct ppc_branch_hash_entry *) \
3837    bfd_hash_lookup ((table), (string), (create), (copy)))
3838
3839 /* Create an entry in the stub hash table.  */
3840
3841 static struct bfd_hash_entry *
3842 stub_hash_newfunc (struct bfd_hash_entry *entry,
3843                    struct bfd_hash_table *table,
3844                    const char *string)
3845 {
3846   /* Allocate the structure if it has not already been allocated by a
3847      subclass.  */
3848   if (entry == NULL)
3849     {
3850       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3851       if (entry == NULL)
3852         return entry;
3853     }
3854
3855   /* Call the allocation method of the superclass.  */
3856   entry = bfd_hash_newfunc (entry, table, string);
3857   if (entry != NULL)
3858     {
3859       struct ppc_stub_hash_entry *eh;
3860
3861       /* Initialize the local fields.  */
3862       eh = (struct ppc_stub_hash_entry *) entry;
3863       eh->stub_type = ppc_stub_none;
3864       eh->stub_sec = NULL;
3865       eh->stub_offset = 0;
3866       eh->target_value = 0;
3867       eh->target_section = NULL;
3868       eh->h = NULL;
3869       eh->id_sec = NULL;
3870     }
3871
3872   return entry;
3873 }
3874
3875 /* Create an entry in the branch hash table.  */
3876
3877 static struct bfd_hash_entry *
3878 branch_hash_newfunc (struct bfd_hash_entry *entry,
3879                      struct bfd_hash_table *table,
3880                      const char *string)
3881 {
3882   /* Allocate the structure if it has not already been allocated by a
3883      subclass.  */
3884   if (entry == NULL)
3885     {
3886       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3887       if (entry == NULL)
3888         return entry;
3889     }
3890
3891   /* Call the allocation method of the superclass.  */
3892   entry = bfd_hash_newfunc (entry, table, string);
3893   if (entry != NULL)
3894     {
3895       struct ppc_branch_hash_entry *eh;
3896
3897       /* Initialize the local fields.  */
3898       eh = (struct ppc_branch_hash_entry *) entry;
3899       eh->offset = 0;
3900       eh->iter = 0;
3901     }
3902
3903   return entry;
3904 }
3905
3906 /* Create an entry in a ppc64 ELF linker hash table.  */
3907
3908 static struct bfd_hash_entry *
3909 link_hash_newfunc (struct bfd_hash_entry *entry,
3910                    struct bfd_hash_table *table,
3911                    const char *string)
3912 {
3913   /* Allocate the structure if it has not already been allocated by a
3914      subclass.  */
3915   if (entry == NULL)
3916     {
3917       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3918       if (entry == NULL)
3919         return entry;
3920     }
3921
3922   /* Call the allocation method of the superclass.  */
3923   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3924   if (entry != NULL)
3925     {
3926       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3927
3928       memset (&eh->u.stub_cache, 0,
3929               (sizeof (struct ppc_link_hash_entry)
3930                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3931
3932       /* When making function calls, old ABI code references function entry
3933          points (dot symbols), while new ABI code references the function
3934          descriptor symbol.  We need to make any combination of reference and
3935          definition work together, without breaking archive linking.
3936
3937          For a defined function "foo" and an undefined call to "bar":
3938          An old object defines "foo" and ".foo", references ".bar" (possibly
3939          "bar" too).
3940          A new object defines "foo" and references "bar".
3941
3942          A new object thus has no problem with its undefined symbols being
3943          satisfied by definitions in an old object.  On the other hand, the
3944          old object won't have ".bar" satisfied by a new object.
3945
3946          Keep a list of newly added dot-symbols.  */
3947
3948       if (string[0] == '.')
3949         {
3950           struct ppc_link_hash_table *htab;
3951
3952           htab = (struct ppc_link_hash_table *) table;
3953           eh->u.next_dot_sym = htab->dot_syms;
3954           htab->dot_syms = eh;
3955         }
3956     }
3957
3958   return entry;
3959 }
3960
3961 /* Create a ppc64 ELF linker hash table.  */
3962
3963 static struct bfd_link_hash_table *
3964 ppc64_elf_link_hash_table_create (bfd *abfd)
3965 {
3966   struct ppc_link_hash_table *htab;
3967   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3968
3969   htab = bfd_zmalloc (amt);
3970   if (htab == NULL)
3971     return NULL;
3972
3973   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3974                                       sizeof (struct ppc_link_hash_entry),
3975                                       PPC64_ELF_DATA))
3976     {
3977       free (htab);
3978       return NULL;
3979     }
3980
3981   /* Init the stub hash table too.  */
3982   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3983                             sizeof (struct ppc_stub_hash_entry)))
3984     return NULL;
3985
3986   /* And the branch hash table.  */
3987   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3988                             sizeof (struct ppc_branch_hash_entry)))
3989     return NULL;
3990
3991   /* Initializing two fields of the union is just cosmetic.  We really
3992      only care about glist, but when compiled on a 32-bit host the
3993      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3994      debugger inspection of these fields look nicer.  */
3995   htab->elf.init_got_refcount.refcount = 0;
3996   htab->elf.init_got_refcount.glist = NULL;
3997   htab->elf.init_plt_refcount.refcount = 0;
3998   htab->elf.init_plt_refcount.glist = NULL;
3999   htab->elf.init_got_offset.offset = 0;
4000   htab->elf.init_got_offset.glist = NULL;
4001   htab->elf.init_plt_offset.offset = 0;
4002   htab->elf.init_plt_offset.glist = NULL;
4003
4004   return &htab->elf.root;
4005 }
4006
4007 /* Free the derived linker hash table.  */
4008
4009 static void
4010 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4011 {
4012   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
4013
4014   bfd_hash_table_free (&ret->stub_hash_table);
4015   bfd_hash_table_free (&ret->branch_hash_table);
4016   _bfd_generic_link_hash_table_free (hash);
4017 }
4018
4019 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4020
4021 void
4022 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4023 {
4024   struct ppc_link_hash_table *htab;
4025
4026   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4027
4028 /* Always hook our dynamic sections into the first bfd, which is the
4029    linker created stub bfd.  This ensures that the GOT header is at
4030    the start of the output TOC section.  */
4031   htab = ppc_hash_table (info);
4032   if (htab == NULL)
4033     return;
4034   htab->stub_bfd = abfd;
4035   htab->elf.dynobj = abfd;
4036 }
4037
4038 /* Build a name for an entry in the stub hash table.  */
4039
4040 static char *
4041 ppc_stub_name (const asection *input_section,
4042                const asection *sym_sec,
4043                const struct ppc_link_hash_entry *h,
4044                const Elf_Internal_Rela *rel)
4045 {
4046   char *stub_name;
4047   bfd_size_type len;
4048
4049   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4050      offsets from a sym as a branch target?  In fact, we could
4051      probably assume the addend is always zero.  */
4052   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4053
4054   if (h)
4055     {
4056       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4057       stub_name = bfd_malloc (len);
4058       if (stub_name == NULL)
4059         return stub_name;
4060
4061       sprintf (stub_name, "%08x.%s+%x",
4062                input_section->id & 0xffffffff,
4063                h->elf.root.root.string,
4064                (int) rel->r_addend & 0xffffffff);
4065     }
4066   else
4067     {
4068       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4069       stub_name = bfd_malloc (len);
4070       if (stub_name == NULL)
4071         return stub_name;
4072
4073       sprintf (stub_name, "%08x.%x:%x+%x",
4074                input_section->id & 0xffffffff,
4075                sym_sec->id & 0xffffffff,
4076                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4077                (int) rel->r_addend & 0xffffffff);
4078     }
4079   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4080     stub_name[len - 2] = 0;
4081   return stub_name;
4082 }
4083
4084 /* Look up an entry in the stub hash.  Stub entries are cached because
4085    creating the stub name takes a bit of time.  */
4086
4087 static struct ppc_stub_hash_entry *
4088 ppc_get_stub_entry (const asection *input_section,
4089                     const asection *sym_sec,
4090                     struct ppc_link_hash_entry *h,
4091                     const Elf_Internal_Rela *rel,
4092                     struct ppc_link_hash_table *htab)
4093 {
4094   struct ppc_stub_hash_entry *stub_entry;
4095   const asection *id_sec;
4096
4097   /* If this input section is part of a group of sections sharing one
4098      stub section, then use the id of the first section in the group.
4099      Stub names need to include a section id, as there may well be
4100      more than one stub used to reach say, printf, and we need to
4101      distinguish between them.  */
4102   id_sec = htab->stub_group[input_section->id].link_sec;
4103
4104   if (h != NULL && h->u.stub_cache != NULL
4105       && h->u.stub_cache->h == h
4106       && h->u.stub_cache->id_sec == id_sec)
4107     {
4108       stub_entry = h->u.stub_cache;
4109     }
4110   else
4111     {
4112       char *stub_name;
4113
4114       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4115       if (stub_name == NULL)
4116         return NULL;
4117
4118       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4119                                          stub_name, FALSE, FALSE);
4120       if (h != NULL)
4121         h->u.stub_cache = stub_entry;
4122
4123       free (stub_name);
4124     }
4125
4126   return stub_entry;
4127 }
4128
4129 /* Add a new stub entry to the stub hash.  Not all fields of the new
4130    stub entry are initialised.  */
4131
4132 static struct ppc_stub_hash_entry *
4133 ppc_add_stub (const char *stub_name,
4134               asection *section,
4135               struct ppc_link_hash_table *htab)
4136 {
4137   asection *link_sec;
4138   asection *stub_sec;
4139   struct ppc_stub_hash_entry *stub_entry;
4140
4141   link_sec = htab->stub_group[section->id].link_sec;
4142   stub_sec = htab->stub_group[section->id].stub_sec;
4143   if (stub_sec == NULL)
4144     {
4145       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4146       if (stub_sec == NULL)
4147         {
4148           size_t namelen;
4149           bfd_size_type len;
4150           char *s_name;
4151
4152           namelen = strlen (link_sec->name);
4153           len = namelen + sizeof (STUB_SUFFIX);
4154           s_name = bfd_alloc (htab->stub_bfd, len);
4155           if (s_name == NULL)
4156             return NULL;
4157
4158           memcpy (s_name, link_sec->name, namelen);
4159           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4160           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4161           if (stub_sec == NULL)
4162             return NULL;
4163           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4164         }
4165       htab->stub_group[section->id].stub_sec = stub_sec;
4166     }
4167
4168   /* Enter this entry into the linker stub hash table.  */
4169   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4170                                      TRUE, FALSE);
4171   if (stub_entry == NULL)
4172     {
4173       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4174                              section->owner, stub_name);
4175       return NULL;
4176     }
4177
4178   stub_entry->stub_sec = stub_sec;
4179   stub_entry->stub_offset = 0;
4180   stub_entry->id_sec = link_sec;
4181   return stub_entry;
4182 }
4183
4184 /* Create sections for linker generated code.  */
4185
4186 static bfd_boolean
4187 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4188 {
4189   struct ppc_link_hash_table *htab;
4190   flagword flags;
4191
4192   htab = ppc_hash_table (info);
4193   if (htab == NULL)
4194     return FALSE;
4195
4196   /* Create .sfpr for code to save and restore fp regs.  */
4197   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4198            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4199   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4200                                                    flags);
4201   if (htab->sfpr == NULL
4202       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4203     return FALSE;
4204
4205   /* Create .glink for lazy dynamic linking support.  */
4206   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4207                                                     flags);
4208   if (htab->glink == NULL
4209       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4210     return FALSE;
4211
4212   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4213   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4214   if (htab->iplt == NULL
4215       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4216     return FALSE;
4217
4218   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4219            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4220   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4221                                                       ".rela.iplt",
4222                                                       flags);
4223   if (htab->reliplt == NULL
4224       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4225     return FALSE;
4226
4227   /* Create branch lookup table for plt_branch stubs.  */
4228   flags = (SEC_ALLOC | SEC_LOAD
4229            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4230   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4231                                                    flags);
4232   if (htab->brlt == NULL
4233       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4234     return FALSE;
4235
4236   if (!info->shared)
4237     return TRUE;
4238
4239   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4240            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4241   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4242                                                       ".rela.branch_lt",
4243                                                       flags);
4244   if (htab->relbrlt == NULL
4245       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4246     return FALSE;
4247
4248   return TRUE;
4249 }
4250
4251 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4252    not already done.  */
4253
4254 static bfd_boolean
4255 create_got_section (bfd *abfd, struct bfd_link_info *info)
4256 {
4257   asection *got, *relgot;
4258   flagword flags;
4259   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4260
4261   if (!is_ppc64_elf (abfd))
4262     return FALSE;
4263   if (htab == NULL)
4264     return FALSE;
4265
4266   if (!htab->got)
4267     {
4268       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4269         return FALSE;
4270
4271       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4272       if (!htab->got)
4273         abort ();
4274     }
4275
4276   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4277            | SEC_LINKER_CREATED);
4278
4279   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4280   if (!got
4281       || !bfd_set_section_alignment (abfd, got, 3))
4282     return FALSE;
4283
4284   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4285                                                flags | SEC_READONLY);
4286   if (!relgot
4287       || ! bfd_set_section_alignment (abfd, relgot, 3))
4288     return FALSE;
4289
4290   ppc64_elf_tdata (abfd)->got = got;
4291   ppc64_elf_tdata (abfd)->relgot = relgot;
4292   return TRUE;
4293 }
4294
4295 /* Create the dynamic sections, and set up shortcuts.  */
4296
4297 static bfd_boolean
4298 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4299 {
4300   struct ppc_link_hash_table *htab;
4301
4302   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4303     return FALSE;
4304
4305   htab = ppc_hash_table (info);
4306   if (htab == NULL)
4307     return FALSE;
4308
4309   if (!htab->got)
4310     htab->got = bfd_get_section_by_name (dynobj, ".got");
4311   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4312   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4313   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4314   if (!info->shared)
4315     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4316
4317   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4318       || (!info->shared && !htab->relbss))
4319     abort ();
4320
4321   return TRUE;
4322 }
4323
4324 /* Follow indirect and warning symbol links.  */
4325
4326 static inline struct bfd_link_hash_entry *
4327 follow_link (struct bfd_link_hash_entry *h)
4328 {
4329   while (h->type == bfd_link_hash_indirect
4330          || h->type == bfd_link_hash_warning)
4331     h = h->u.i.link;
4332   return h;
4333 }
4334
4335 static inline struct elf_link_hash_entry *
4336 elf_follow_link (struct elf_link_hash_entry *h)
4337 {
4338   return (struct elf_link_hash_entry *) follow_link (&h->root);
4339 }
4340
4341 static inline struct ppc_link_hash_entry *
4342 ppc_follow_link (struct ppc_link_hash_entry *h)
4343 {
4344   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4345 }
4346
4347 /* Merge PLT info on FROM with that on TO.  */
4348
4349 static void
4350 move_plt_plist (struct ppc_link_hash_entry *from,
4351                 struct ppc_link_hash_entry *to)
4352 {
4353   if (from->elf.plt.plist != NULL)
4354     {
4355       if (to->elf.plt.plist != NULL)
4356         {
4357           struct plt_entry **entp;
4358           struct plt_entry *ent;
4359
4360           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4361             {
4362               struct plt_entry *dent;
4363
4364               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4365                 if (dent->addend == ent->addend)
4366                   {
4367                     dent->plt.refcount += ent->plt.refcount;
4368                     *entp = ent->next;
4369                     break;
4370                   }
4371               if (dent == NULL)
4372                 entp = &ent->next;
4373             }
4374           *entp = to->elf.plt.plist;
4375         }
4376
4377       to->elf.plt.plist = from->elf.plt.plist;
4378       from->elf.plt.plist = NULL;
4379     }
4380 }
4381
4382 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4383
4384 static void
4385 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4386                                 struct elf_link_hash_entry *dir,
4387                                 struct elf_link_hash_entry *ind)
4388 {
4389   struct ppc_link_hash_entry *edir, *eind;
4390
4391   edir = (struct ppc_link_hash_entry *) dir;
4392   eind = (struct ppc_link_hash_entry *) ind;
4393
4394   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4395   if (eind->dyn_relocs != NULL)
4396     {
4397       if (edir->dyn_relocs != NULL)
4398         {
4399           struct ppc_dyn_relocs **pp;
4400           struct ppc_dyn_relocs *p;
4401
4402           /* Add reloc counts against the indirect sym to the direct sym
4403              list.  Merge any entries against the same section.  */
4404           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4405             {
4406               struct ppc_dyn_relocs *q;
4407
4408               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4409                 if (q->sec == p->sec)
4410                   {
4411                     q->pc_count += p->pc_count;
4412                     q->count += p->count;
4413                     *pp = p->next;
4414                     break;
4415                   }
4416               if (q == NULL)
4417                 pp = &p->next;
4418             }
4419           *pp = edir->dyn_relocs;
4420         }
4421
4422       edir->dyn_relocs = eind->dyn_relocs;
4423       eind->dyn_relocs = NULL;
4424     }
4425
4426   edir->is_func |= eind->is_func;
4427   edir->is_func_descriptor |= eind->is_func_descriptor;
4428   edir->tls_mask |= eind->tls_mask;
4429   if (eind->oh != NULL)
4430     edir->oh = ppc_follow_link (eind->oh);
4431
4432   /* If called to transfer flags for a weakdef during processing
4433      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4434      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4435   if (!(ELIMINATE_COPY_RELOCS
4436         && eind->elf.root.type != bfd_link_hash_indirect
4437         && edir->elf.dynamic_adjusted))
4438     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4439
4440   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4441   edir->elf.ref_regular |= eind->elf.ref_regular;
4442   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4443   edir->elf.needs_plt |= eind->elf.needs_plt;
4444
4445   /* If we were called to copy over info for a weak sym, that's all.  */
4446   if (eind->elf.root.type != bfd_link_hash_indirect)
4447     return;
4448
4449   /* Copy over got entries that we may have already seen to the
4450      symbol which just became indirect.  */
4451   if (eind->elf.got.glist != NULL)
4452     {
4453       if (edir->elf.got.glist != NULL)
4454         {
4455           struct got_entry **entp;
4456           struct got_entry *ent;
4457
4458           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4459             {
4460               struct got_entry *dent;
4461
4462               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4463                 if (dent->addend == ent->addend
4464                     && dent->owner == ent->owner
4465                     && dent->tls_type == ent->tls_type)
4466                   {
4467                     dent->got.refcount += ent->got.refcount;
4468                     *entp = ent->next;
4469                     break;
4470                   }
4471               if (dent == NULL)
4472                 entp = &ent->next;
4473             }
4474           *entp = edir->elf.got.glist;
4475         }
4476
4477       edir->elf.got.glist = eind->elf.got.glist;
4478       eind->elf.got.glist = NULL;
4479     }
4480
4481   /* And plt entries.  */
4482   move_plt_plist (eind, edir);
4483
4484   if (eind->elf.dynindx != -1)
4485     {
4486       if (edir->elf.dynindx != -1)
4487         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4488                                 edir->elf.dynstr_index);
4489       edir->elf.dynindx = eind->elf.dynindx;
4490       edir->elf.dynstr_index = eind->elf.dynstr_index;
4491       eind->elf.dynindx = -1;
4492       eind->elf.dynstr_index = 0;
4493     }
4494 }
4495
4496 /* Find the function descriptor hash entry from the given function code
4497    hash entry FH.  Link the entries via their OH fields.  */
4498
4499 static struct ppc_link_hash_entry *
4500 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4501 {
4502   struct ppc_link_hash_entry *fdh = fh->oh;
4503
4504   if (fdh == NULL)
4505     {
4506       const char *fd_name = fh->elf.root.root.string + 1;
4507
4508       fdh = (struct ppc_link_hash_entry *)
4509         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4510       if (fdh == NULL)
4511         return fdh;
4512
4513       fdh->is_func_descriptor = 1;
4514       fdh->oh = fh;
4515       fh->is_func = 1;
4516       fh->oh = fdh;
4517     }
4518
4519   return ppc_follow_link (fdh);
4520 }
4521
4522 /* Make a fake function descriptor sym for the code sym FH.  */
4523
4524 static struct ppc_link_hash_entry *
4525 make_fdh (struct bfd_link_info *info,
4526           struct ppc_link_hash_entry *fh)
4527 {
4528   bfd *abfd;
4529   asymbol *newsym;
4530   struct bfd_link_hash_entry *bh;
4531   struct ppc_link_hash_entry *fdh;
4532
4533   abfd = fh->elf.root.u.undef.abfd;
4534   newsym = bfd_make_empty_symbol (abfd);
4535   newsym->name = fh->elf.root.root.string + 1;
4536   newsym->section = bfd_und_section_ptr;
4537   newsym->value = 0;
4538   newsym->flags = BSF_WEAK;
4539
4540   bh = NULL;
4541   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4542                                          newsym->flags, newsym->section,
4543                                          newsym->value, NULL, FALSE, FALSE,
4544                                          &bh))
4545     return NULL;
4546
4547   fdh = (struct ppc_link_hash_entry *) bh;
4548   fdh->elf.non_elf = 0;
4549   fdh->fake = 1;
4550   fdh->is_func_descriptor = 1;
4551   fdh->oh = fh;
4552   fh->is_func = 1;
4553   fh->oh = fdh;
4554   return fdh;
4555 }
4556
4557 /* Fix function descriptor symbols defined in .opd sections to be
4558    function type.  */
4559
4560 static bfd_boolean
4561 ppc64_elf_add_symbol_hook (bfd *ibfd,
4562                            struct bfd_link_info *info,
4563                            Elf_Internal_Sym *isym,
4564                            const char **name ATTRIBUTE_UNUSED,
4565                            flagword *flags ATTRIBUTE_UNUSED,
4566                            asection **sec,
4567                            bfd_vma *value ATTRIBUTE_UNUSED)
4568 {
4569   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4570     {
4571       if ((ibfd->flags & DYNAMIC) == 0)
4572         elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4573     }
4574   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4575     ;
4576   else if (*sec != NULL
4577            && strcmp ((*sec)->name, ".opd") == 0)
4578     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4579
4580   return TRUE;
4581 }
4582
4583 /* This function makes an old ABI object reference to ".bar" cause the
4584    inclusion of a new ABI object archive that defines "bar".
4585    NAME is a symbol defined in an archive.  Return a symbol in the hash
4586    table that might be satisfied by the archive symbols.  */
4587
4588 static struct elf_link_hash_entry *
4589 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4590                                  struct bfd_link_info *info,
4591                                  const char *name)
4592 {
4593   struct elf_link_hash_entry *h;
4594   char *dot_name;
4595   size_t len;
4596
4597   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4598   if (h != NULL
4599       /* Don't return this sym if it is a fake function descriptor
4600          created by add_symbol_adjust.  */
4601       && !(h->root.type == bfd_link_hash_undefweak
4602            && ((struct ppc_link_hash_entry *) h)->fake))
4603     return h;
4604
4605   if (name[0] == '.')
4606     return h;
4607
4608   len = strlen (name);
4609   dot_name = bfd_alloc (abfd, len + 2);
4610   if (dot_name == NULL)
4611     return (struct elf_link_hash_entry *) 0 - 1;
4612   dot_name[0] = '.';
4613   memcpy (dot_name + 1, name, len + 1);
4614   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4615   bfd_release (abfd, dot_name);
4616   return h;
4617 }
4618
4619 /* This function satisfies all old ABI object references to ".bar" if a
4620    new ABI object defines "bar".  Well, at least, undefined dot symbols
4621    are made weak.  This stops later archive searches from including an
4622    object if we already have a function descriptor definition.  It also
4623    prevents the linker complaining about undefined symbols.
4624    We also check and correct mismatched symbol visibility here.  The
4625    most restrictive visibility of the function descriptor and the
4626    function entry symbol is used.  */
4627
4628 static bfd_boolean
4629 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4630 {
4631   struct ppc_link_hash_table *htab;
4632   struct ppc_link_hash_entry *fdh;
4633
4634   if (eh->elf.root.type == bfd_link_hash_indirect)
4635     return TRUE;
4636
4637   if (eh->elf.root.type == bfd_link_hash_warning)
4638     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4639
4640   if (eh->elf.root.root.string[0] != '.')
4641     abort ();
4642
4643   htab = ppc_hash_table (info);
4644   if (htab == NULL)
4645     return FALSE;
4646
4647   fdh = lookup_fdh (eh, htab);
4648   if (fdh == NULL)
4649     {
4650       if (!info->relocatable
4651           && (eh->elf.root.type == bfd_link_hash_undefined
4652               || eh->elf.root.type == bfd_link_hash_undefweak)
4653           && eh->elf.ref_regular)
4654         {
4655           /* Make an undefweak function descriptor sym, which is enough to
4656              pull in an --as-needed shared lib, but won't cause link
4657              errors.  Archives are handled elsewhere.  */
4658           fdh = make_fdh (info, eh);
4659           if (fdh == NULL)
4660             return FALSE;
4661           fdh->elf.ref_regular = 1;
4662         }
4663     }
4664   else
4665     {
4666       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4667       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4668       if (entry_vis < descr_vis)
4669         fdh->elf.other += entry_vis - descr_vis;
4670       else if (entry_vis > descr_vis)
4671         eh->elf.other += descr_vis - entry_vis;
4672
4673       if ((fdh->elf.root.type == bfd_link_hash_defined
4674            || fdh->elf.root.type == bfd_link_hash_defweak)
4675           && eh->elf.root.type == bfd_link_hash_undefined)
4676         {
4677           eh->elf.root.type = bfd_link_hash_undefweak;
4678           eh->was_undefined = 1;
4679           htab->twiddled_syms = 1;
4680         }
4681     }
4682
4683   return TRUE;
4684 }
4685
4686 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4687
4688 static bfd_boolean
4689 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4690 {
4691   struct ppc_link_hash_table *htab;
4692   struct ppc_link_hash_entry **p, *eh;
4693
4694   if (!is_ppc64_elf (info->output_bfd))
4695     return TRUE;
4696   htab = ppc_hash_table (info);
4697   if (htab == NULL)
4698     return FALSE;
4699
4700   if (is_ppc64_elf (ibfd))
4701     {
4702       p = &htab->dot_syms;
4703       while ((eh = *p) != NULL)
4704         {
4705           *p = NULL;
4706           if (!add_symbol_adjust (eh, info))
4707             return FALSE;
4708           p = &eh->u.next_dot_sym;
4709         }
4710     }
4711
4712   /* Clear the list for non-ppc64 input files.  */
4713   p = &htab->dot_syms;
4714   while ((eh = *p) != NULL)
4715     {
4716       *p = NULL;
4717       p = &eh->u.next_dot_sym;
4718     }
4719
4720   /* We need to fix the undefs list for any syms we have twiddled to
4721      undef_weak.  */
4722   if (htab->twiddled_syms)
4723     {
4724       bfd_link_repair_undef_list (&htab->elf.root);
4725       htab->twiddled_syms = 0;
4726     }
4727   return TRUE;
4728 }
4729
4730 /* Undo hash table changes when an --as-needed input file is determined
4731    not to be needed.  */
4732
4733 static bfd_boolean
4734 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4735                              struct bfd_link_info *info)
4736 {
4737   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4738
4739   if (htab == NULL)
4740     return FALSE;
4741
4742   htab->dot_syms = NULL;
4743   return TRUE;
4744 }
4745
4746 static struct plt_entry **
4747 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4748                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4749 {
4750   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4751   struct plt_entry **local_plt;
4752   unsigned char *local_got_tls_masks;
4753
4754   if (local_got_ents == NULL)
4755     {
4756       bfd_size_type size = symtab_hdr->sh_info;
4757
4758       size *= (sizeof (*local_got_ents)
4759                + sizeof (*local_plt)
4760                + sizeof (*local_got_tls_masks));
4761       local_got_ents = bfd_zalloc (abfd, size);
4762       if (local_got_ents == NULL)
4763         return NULL;
4764       elf_local_got_ents (abfd) = local_got_ents;
4765     }
4766
4767   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4768     {
4769       struct got_entry *ent;
4770
4771       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4772         if (ent->addend == r_addend
4773             && ent->owner == abfd
4774             && ent->tls_type == tls_type)
4775           break;
4776       if (ent == NULL)
4777         {
4778           bfd_size_type amt = sizeof (*ent);
4779           ent = bfd_alloc (abfd, amt);
4780           if (ent == NULL)
4781             return FALSE;
4782           ent->next = local_got_ents[r_symndx];
4783           ent->addend = r_addend;
4784           ent->owner = abfd;
4785           ent->tls_type = tls_type;
4786           ent->is_indirect = FALSE;
4787           ent->got.refcount = 0;
4788           local_got_ents[r_symndx] = ent;
4789         }
4790       ent->got.refcount += 1;
4791     }
4792
4793   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4794   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4795   local_got_tls_masks[r_symndx] |= tls_type;
4796
4797   return local_plt + r_symndx;
4798 }
4799
4800 static bfd_boolean
4801 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4802 {
4803   struct plt_entry *ent;
4804
4805   for (ent = *plist; ent != NULL; ent = ent->next)
4806     if (ent->addend == addend)
4807       break;
4808   if (ent == NULL)
4809     {
4810       bfd_size_type amt = sizeof (*ent);
4811       ent = bfd_alloc (abfd, amt);
4812       if (ent == NULL)
4813         return FALSE;
4814       ent->next = *plist;
4815       ent->addend = addend;
4816       ent->plt.refcount = 0;
4817       *plist = ent;
4818     }
4819   ent->plt.refcount += 1;
4820   return TRUE;
4821 }
4822
4823 static bfd_boolean
4824 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4825 {
4826   return (r_type == R_PPC64_REL24
4827           || r_type == R_PPC64_REL14
4828           || r_type == R_PPC64_REL14_BRTAKEN
4829           || r_type == R_PPC64_REL14_BRNTAKEN
4830           || r_type == R_PPC64_ADDR24
4831           || r_type == R_PPC64_ADDR14
4832           || r_type == R_PPC64_ADDR14_BRTAKEN
4833           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4834 }
4835
4836 /* Look through the relocs for a section during the first phase, and
4837    calculate needed space in the global offset table, procedure
4838    linkage table, and dynamic reloc sections.  */
4839
4840 static bfd_boolean
4841 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4842                         asection *sec, const Elf_Internal_Rela *relocs)
4843 {
4844   struct ppc_link_hash_table *htab;
4845   Elf_Internal_Shdr *symtab_hdr;
4846   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4847   const Elf_Internal_Rela *rel;
4848   const Elf_Internal_Rela *rel_end;
4849   asection *sreloc;
4850   asection **opd_sym_map;
4851   struct elf_link_hash_entry *tga, *dottga;
4852
4853   if (info->relocatable)
4854     return TRUE;
4855
4856   /* Don't do anything special with non-loaded, non-alloced sections.
4857      In particular, any relocs in such sections should not affect GOT
4858      and PLT reference counting (ie. we don't allow them to create GOT
4859      or PLT entries), there's no possibility or desire to optimize TLS
4860      relocs, and there's not much point in propagating relocs to shared
4861      libs that the dynamic linker won't relocate.  */
4862   if ((sec->flags & SEC_ALLOC) == 0)
4863     return TRUE;
4864
4865   BFD_ASSERT (is_ppc64_elf (abfd));
4866
4867   htab = ppc_hash_table (info);
4868   if (htab == NULL)
4869     return FALSE;
4870
4871   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4872                               FALSE, FALSE, TRUE);
4873   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4874                                  FALSE, FALSE, TRUE);
4875   symtab_hdr = &elf_symtab_hdr (abfd);
4876
4877   sym_hashes = elf_sym_hashes (abfd);
4878   sym_hashes_end = (sym_hashes
4879                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4880                     - symtab_hdr->sh_info);
4881
4882   sreloc = NULL;
4883   opd_sym_map = NULL;
4884   if (strcmp (sec->name, ".opd") == 0)
4885     {
4886       /* Garbage collection needs some extra help with .opd sections.
4887          We don't want to necessarily keep everything referenced by
4888          relocs in .opd, as that would keep all functions.  Instead,
4889          if we reference an .opd symbol (a function descriptor), we
4890          want to keep the function code symbol's section.  This is
4891          easy for global symbols, but for local syms we need to keep
4892          information about the associated function section.  */
4893       bfd_size_type amt;
4894
4895       amt = sec->size * sizeof (*opd_sym_map) / 8;
4896       opd_sym_map = bfd_zalloc (abfd, amt);
4897       if (opd_sym_map == NULL)
4898         return FALSE;
4899       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4900       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4901       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4902     }
4903
4904   if (htab->sfpr == NULL
4905       && !create_linkage_sections (htab->elf.dynobj, info))
4906     return FALSE;
4907
4908   rel_end = relocs + sec->reloc_count;
4909   for (rel = relocs; rel < rel_end; rel++)
4910     {
4911       unsigned long r_symndx;
4912       struct elf_link_hash_entry *h;
4913       enum elf_ppc64_reloc_type r_type;
4914       int tls_type;
4915       struct _ppc64_elf_section_data *ppc64_sec;
4916       struct plt_entry **ifunc;
4917
4918       r_symndx = ELF64_R_SYM (rel->r_info);
4919       if (r_symndx < symtab_hdr->sh_info)
4920         h = NULL;
4921       else
4922         {
4923           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4924           h = elf_follow_link (h);
4925         }
4926
4927       tls_type = 0;
4928       ifunc = NULL;
4929       if (h != NULL)
4930         {
4931           if (h->type == STT_GNU_IFUNC)
4932             {
4933               h->needs_plt = 1;
4934               ifunc = &h->plt.plist;
4935             }
4936         }
4937       else
4938         {
4939           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4940                                                           abfd, r_symndx);
4941           if (isym == NULL)
4942             return FALSE;
4943
4944           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4945             {
4946               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4947                                              rel->r_addend, PLT_IFUNC);
4948               if (ifunc == NULL)
4949                 return FALSE;
4950             }
4951         }
4952       r_type = ELF64_R_TYPE (rel->r_info);
4953       if (is_branch_reloc (r_type))
4954         {
4955           if (h != NULL && (h == tga || h == dottga))
4956             {
4957               if (rel != relocs
4958                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4959                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4960                 /* We have a new-style __tls_get_addr call with a marker
4961                    reloc.  */
4962                 ;
4963               else
4964                 /* Mark this section as having an old-style call.  */
4965                 sec->has_tls_get_addr_call = 1;
4966             }
4967
4968           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4969           if (ifunc != NULL
4970               && !update_plt_info (abfd, ifunc, rel->r_addend))
4971             return FALSE;
4972         }
4973
4974       switch (r_type)
4975         {
4976         case R_PPC64_TLSGD:
4977         case R_PPC64_TLSLD:
4978           /* These special tls relocs tie a call to __tls_get_addr with
4979              its parameter symbol.  */
4980           break;
4981
4982         case R_PPC64_GOT_TLSLD16:
4983         case R_PPC64_GOT_TLSLD16_LO:
4984         case R_PPC64_GOT_TLSLD16_HI:
4985         case R_PPC64_GOT_TLSLD16_HA:
4986           tls_type = TLS_TLS | TLS_LD;
4987           goto dogottls;
4988
4989         case R_PPC64_GOT_TLSGD16:
4990         case R_PPC64_GOT_TLSGD16_LO:
4991         case R_PPC64_GOT_TLSGD16_HI:
4992         case R_PPC64_GOT_TLSGD16_HA:
4993           tls_type = TLS_TLS | TLS_GD;
4994           goto dogottls;
4995
4996         case R_PPC64_GOT_TPREL16_DS:
4997         case R_PPC64_GOT_TPREL16_LO_DS:
4998         case R_PPC64_GOT_TPREL16_HI:
4999         case R_PPC64_GOT_TPREL16_HA:
5000           if (!info->executable)
5001             info->flags |= DF_STATIC_TLS;
5002           tls_type = TLS_TLS | TLS_TPREL;
5003           goto dogottls;
5004
5005         case R_PPC64_GOT_DTPREL16_DS:
5006         case R_PPC64_GOT_DTPREL16_LO_DS:
5007         case R_PPC64_GOT_DTPREL16_HI:
5008         case R_PPC64_GOT_DTPREL16_HA:
5009           tls_type = TLS_TLS | TLS_DTPREL;
5010         dogottls:
5011           sec->has_tls_reloc = 1;
5012           /* Fall thru */
5013
5014         case R_PPC64_GOT16:
5015         case R_PPC64_GOT16_DS:
5016         case R_PPC64_GOT16_HA:
5017         case R_PPC64_GOT16_HI:
5018         case R_PPC64_GOT16_LO:
5019         case R_PPC64_GOT16_LO_DS:
5020           /* This symbol requires a global offset table entry.  */
5021           sec->has_toc_reloc = 1;
5022           if (r_type == R_PPC64_GOT_TLSLD16
5023               || r_type == R_PPC64_GOT_TLSGD16
5024               || r_type == R_PPC64_GOT_TPREL16_DS
5025               || r_type == R_PPC64_GOT_DTPREL16_DS
5026               || r_type == R_PPC64_GOT16
5027               || r_type == R_PPC64_GOT16_DS)
5028             {
5029               htab->do_multi_toc = 1;
5030               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5031             }
5032
5033           if (ppc64_elf_tdata (abfd)->got == NULL
5034               && !create_got_section (abfd, info))
5035             return FALSE;
5036
5037           if (h != NULL)
5038             {
5039               struct ppc_link_hash_entry *eh;
5040               struct got_entry *ent;
5041
5042               eh = (struct ppc_link_hash_entry *) h;
5043               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5044                 if (ent->addend == rel->r_addend
5045                     && ent->owner == abfd
5046                     && ent->tls_type == tls_type)
5047                   break;
5048               if (ent == NULL)
5049                 {
5050                   bfd_size_type amt = sizeof (*ent);
5051                   ent = bfd_alloc (abfd, amt);
5052                   if (ent == NULL)
5053                     return FALSE;
5054                   ent->next = eh->elf.got.glist;
5055                   ent->addend = rel->r_addend;
5056                   ent->owner = abfd;
5057                   ent->tls_type = tls_type;
5058                   ent->is_indirect = FALSE;
5059                   ent->got.refcount = 0;
5060                   eh->elf.got.glist = ent;
5061                 }
5062               ent->got.refcount += 1;
5063               eh->tls_mask |= tls_type;
5064             }
5065           else
5066             /* This is a global offset table entry for a local symbol.  */
5067             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5068                                         rel->r_addend, tls_type))
5069               return FALSE;
5070           break;
5071
5072         case R_PPC64_PLT16_HA:
5073         case R_PPC64_PLT16_HI:
5074         case R_PPC64_PLT16_LO:
5075         case R_PPC64_PLT32:
5076         case R_PPC64_PLT64:
5077           /* This symbol requires a procedure linkage table entry.  We
5078              actually build the entry in adjust_dynamic_symbol,
5079              because this might be a case of linking PIC code without
5080              linking in any dynamic objects, in which case we don't
5081              need to generate a procedure linkage table after all.  */
5082           if (h == NULL)
5083             {
5084               /* It does not make sense to have a procedure linkage
5085                  table entry for a local symbol.  */
5086               bfd_set_error (bfd_error_bad_value);
5087               return FALSE;
5088             }
5089           else
5090             {
5091               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5092                 return FALSE;
5093               h->needs_plt = 1;
5094               if (h->root.root.string[0] == '.'
5095                   && h->root.root.string[1] != '\0')
5096                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5097             }
5098           break;
5099
5100           /* The following relocations don't need to propagate the
5101              relocation if linking a shared object since they are
5102              section relative.  */
5103         case R_PPC64_SECTOFF:
5104         case R_PPC64_SECTOFF_LO:
5105         case R_PPC64_SECTOFF_HI:
5106         case R_PPC64_SECTOFF_HA:
5107         case R_PPC64_SECTOFF_DS:
5108         case R_PPC64_SECTOFF_LO_DS:
5109         case R_PPC64_DTPREL16:
5110         case R_PPC64_DTPREL16_LO:
5111         case R_PPC64_DTPREL16_HI:
5112         case R_PPC64_DTPREL16_HA:
5113         case R_PPC64_DTPREL16_DS:
5114         case R_PPC64_DTPREL16_LO_DS:
5115         case R_PPC64_DTPREL16_HIGHER:
5116         case R_PPC64_DTPREL16_HIGHERA:
5117         case R_PPC64_DTPREL16_HIGHEST:
5118         case R_PPC64_DTPREL16_HIGHESTA:
5119           break;
5120
5121           /* Nor do these.  */
5122         case R_PPC64_REL16:
5123         case R_PPC64_REL16_LO:
5124         case R_PPC64_REL16_HI:
5125         case R_PPC64_REL16_HA:
5126           break;
5127
5128         case R_PPC64_TOC16:
5129         case R_PPC64_TOC16_DS:
5130           htab->do_multi_toc = 1;
5131           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5132         case R_PPC64_TOC16_LO:
5133         case R_PPC64_TOC16_HI:
5134         case R_PPC64_TOC16_HA:
5135         case R_PPC64_TOC16_LO_DS:
5136           sec->has_toc_reloc = 1;
5137           break;
5138
5139           /* This relocation describes the C++ object vtable hierarchy.
5140              Reconstruct it for later use during GC.  */
5141         case R_PPC64_GNU_VTINHERIT:
5142           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5143             return FALSE;
5144           break;
5145
5146           /* This relocation describes which C++ vtable entries are actually
5147              used.  Record for later use during GC.  */
5148         case R_PPC64_GNU_VTENTRY:
5149           BFD_ASSERT (h != NULL);
5150           if (h != NULL
5151               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5152             return FALSE;
5153           break;
5154
5155         case R_PPC64_REL14:
5156         case R_PPC64_REL14_BRTAKEN:
5157         case R_PPC64_REL14_BRNTAKEN:
5158           {
5159             asection *dest = NULL;
5160
5161             /* Heuristic: If jumping outside our section, chances are
5162                we are going to need a stub.  */
5163             if (h != NULL)
5164               {
5165                 /* If the sym is weak it may be overridden later, so
5166                    don't assume we know where a weak sym lives.  */
5167                 if (h->root.type == bfd_link_hash_defined)
5168                   dest = h->root.u.def.section;
5169               }
5170             else
5171               {
5172                 Elf_Internal_Sym *isym;
5173
5174                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5175                                               abfd, r_symndx);
5176                 if (isym == NULL)
5177                   return FALSE;
5178
5179                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5180               }
5181
5182             if (dest != sec)
5183               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5184           }
5185           /* Fall through.  */
5186
5187         case R_PPC64_REL24:
5188           if (h != NULL && ifunc == NULL)
5189             {
5190               /* We may need a .plt entry if the function this reloc
5191                  refers to is in a shared lib.  */
5192               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5193                 return FALSE;
5194               h->needs_plt = 1;
5195               if (h->root.root.string[0] == '.'
5196                   && h->root.root.string[1] != '\0')
5197                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5198               if (h == tga || h == dottga)
5199                 sec->has_tls_reloc = 1;
5200             }
5201           break;
5202
5203         case R_PPC64_TPREL64:
5204           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5205           if (!info->executable)
5206             info->flags |= DF_STATIC_TLS;
5207           goto dotlstoc;
5208
5209         case R_PPC64_DTPMOD64:
5210           if (rel + 1 < rel_end
5211               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5212               && rel[1].r_offset == rel->r_offset + 8)
5213             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5214           else
5215             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5216           goto dotlstoc;
5217
5218         case R_PPC64_DTPREL64:
5219           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5220           if (rel != relocs
5221               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5222               && rel[-1].r_offset == rel->r_offset - 8)
5223             /* This is the second reloc of a dtpmod, dtprel pair.
5224                Don't mark with TLS_DTPREL.  */
5225             goto dodyn;
5226
5227         dotlstoc:
5228           sec->has_tls_reloc = 1;
5229           if (h != NULL)
5230             {
5231               struct ppc_link_hash_entry *eh;
5232               eh = (struct ppc_link_hash_entry *) h;
5233               eh->tls_mask |= tls_type;
5234             }
5235           else
5236             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5237                                         rel->r_addend, tls_type))
5238               return FALSE;
5239
5240           ppc64_sec = ppc64_elf_section_data (sec);
5241           if (ppc64_sec->sec_type != sec_toc)
5242             {
5243               bfd_size_type amt;
5244
5245               /* One extra to simplify get_tls_mask.  */
5246               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5247               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5248               if (ppc64_sec->u.toc.symndx == NULL)
5249                 return FALSE;
5250               amt = sec->size * sizeof (bfd_vma) / 8;
5251               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5252               if (ppc64_sec->u.toc.add == NULL)
5253                 return FALSE;
5254               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5255               ppc64_sec->sec_type = sec_toc;
5256             }
5257           BFD_ASSERT (rel->r_offset % 8 == 0);
5258           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5259           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5260
5261           /* Mark the second slot of a GD or LD entry.
5262              -1 to indicate GD and -2 to indicate LD.  */
5263           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5264             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5265           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5266             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5267           goto dodyn;
5268
5269         case R_PPC64_TPREL16:
5270         case R_PPC64_TPREL16_LO:
5271         case R_PPC64_TPREL16_HI:
5272         case R_PPC64_TPREL16_HA:
5273         case R_PPC64_TPREL16_DS:
5274         case R_PPC64_TPREL16_LO_DS:
5275         case R_PPC64_TPREL16_HIGHER:
5276         case R_PPC64_TPREL16_HIGHERA:
5277         case R_PPC64_TPREL16_HIGHEST:
5278         case R_PPC64_TPREL16_HIGHESTA:
5279           if (info->shared)
5280             {
5281               if (!info->executable)
5282                 info->flags |= DF_STATIC_TLS;
5283               goto dodyn;
5284             }
5285           break;
5286
5287         case R_PPC64_ADDR64:
5288           if (opd_sym_map != NULL
5289               && rel + 1 < rel_end
5290               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5291             {
5292               if (h != NULL)
5293                 {
5294                   if (h->root.root.string[0] == '.'
5295                       && h->root.root.string[1] != 0
5296                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5297                     ;
5298                   else
5299                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5300                 }
5301               else
5302                 {
5303                   asection *s;
5304                   Elf_Internal_Sym *isym;
5305
5306                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5307                                                 abfd, r_symndx);
5308                   if (isym == NULL)
5309                     return FALSE;
5310
5311                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5312                   if (s != NULL && s != sec)
5313                     opd_sym_map[rel->r_offset / 8] = s;
5314                 }
5315             }
5316           /* Fall through.  */
5317
5318         case R_PPC64_REL30:
5319         case R_PPC64_REL32:
5320         case R_PPC64_REL64:
5321         case R_PPC64_ADDR14:
5322         case R_PPC64_ADDR14_BRNTAKEN:
5323         case R_PPC64_ADDR14_BRTAKEN:
5324         case R_PPC64_ADDR16:
5325         case R_PPC64_ADDR16_DS:
5326         case R_PPC64_ADDR16_HA:
5327         case R_PPC64_ADDR16_HI:
5328         case R_PPC64_ADDR16_HIGHER:
5329         case R_PPC64_ADDR16_HIGHERA:
5330         case R_PPC64_ADDR16_HIGHEST:
5331         case R_PPC64_ADDR16_HIGHESTA:
5332         case R_PPC64_ADDR16_LO:
5333         case R_PPC64_ADDR16_LO_DS:
5334         case R_PPC64_ADDR24:
5335         case R_PPC64_ADDR32:
5336         case R_PPC64_UADDR16:
5337         case R_PPC64_UADDR32:
5338         case R_PPC64_UADDR64:
5339         case R_PPC64_TOC:
5340           if (h != NULL && !info->shared)
5341             /* We may need a copy reloc.  */
5342             h->non_got_ref = 1;
5343
5344           /* Don't propagate .opd relocs.  */
5345           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5346             break;
5347
5348           /* If we are creating a shared library, and this is a reloc
5349              against a global symbol, or a non PC relative reloc
5350              against a local symbol, then we need to copy the reloc
5351              into the shared library.  However, if we are linking with
5352              -Bsymbolic, we do not need to copy a reloc against a
5353              global symbol which is defined in an object we are
5354              including in the link (i.e., DEF_REGULAR is set).  At
5355              this point we have not seen all the input files, so it is
5356              possible that DEF_REGULAR is not set now but will be set
5357              later (it is never cleared).  In case of a weak definition,
5358              DEF_REGULAR may be cleared later by a strong definition in
5359              a shared library.  We account for that possibility below by
5360              storing information in the dyn_relocs field of the hash
5361              table entry.  A similar situation occurs when creating
5362              shared libraries and symbol visibility changes render the
5363              symbol local.
5364
5365              If on the other hand, we are creating an executable, we
5366              may need to keep relocations for symbols satisfied by a
5367              dynamic library if we manage to avoid copy relocs for the
5368              symbol.  */
5369         dodyn:
5370           if ((info->shared
5371                && (must_be_dyn_reloc (info, r_type)
5372                    || (h != NULL
5373                        && (! info->symbolic
5374                            || h->root.type == bfd_link_hash_defweak
5375                            || !h->def_regular))))
5376               || (ELIMINATE_COPY_RELOCS
5377                   && !info->shared
5378                   && h != NULL
5379                   && (h->root.type == bfd_link_hash_defweak
5380                       || !h->def_regular))
5381               || (!info->shared
5382                   && ifunc != NULL))
5383             {
5384               struct ppc_dyn_relocs *p;
5385               struct ppc_dyn_relocs **head;
5386
5387               /* We must copy these reloc types into the output file.
5388                  Create a reloc section in dynobj and make room for
5389                  this reloc.  */
5390               if (sreloc == NULL)
5391                 {
5392                   sreloc = _bfd_elf_make_dynamic_reloc_section
5393                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5394
5395                   if (sreloc == NULL)
5396                     return FALSE;
5397                 }
5398
5399               /* If this is a global symbol, we count the number of
5400                  relocations we need for this symbol.  */
5401               if (h != NULL)
5402                 {
5403                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5404                 }
5405               else
5406                 {
5407                   /* Track dynamic relocs needed for local syms too.
5408                      We really need local syms available to do this
5409                      easily.  Oh well.  */
5410                   asection *s;
5411                   void *vpp;
5412                   Elf_Internal_Sym *isym;
5413
5414                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5415                                                 abfd, r_symndx);
5416                   if (isym == NULL)
5417                     return FALSE;
5418
5419                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5420                   if (s == NULL)
5421                     s = sec;
5422
5423                   vpp = &elf_section_data (s)->local_dynrel;
5424                   head = (struct ppc_dyn_relocs **) vpp;
5425                 }
5426
5427               p = *head;
5428               if (p == NULL || p->sec != sec)
5429                 {
5430                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5431                   if (p == NULL)
5432                     return FALSE;
5433                   p->next = *head;
5434                   *head = p;
5435                   p->sec = sec;
5436                   p->count = 0;
5437                   p->pc_count = 0;
5438                 }
5439
5440               p->count += 1;
5441               if (!must_be_dyn_reloc (info, r_type))
5442                 p->pc_count += 1;
5443             }
5444           break;
5445
5446         default:
5447           break;
5448         }
5449     }
5450
5451   return TRUE;
5452 }
5453
5454 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5455    of the code entry point, and its section.  */
5456
5457 static bfd_vma
5458 opd_entry_value (asection *opd_sec,
5459                  bfd_vma offset,
5460                  asection **code_sec,
5461                  bfd_vma *code_off)
5462 {
5463   bfd *opd_bfd = opd_sec->owner;
5464   Elf_Internal_Rela *relocs;
5465   Elf_Internal_Rela *lo, *hi, *look;
5466   bfd_vma val;
5467
5468   /* No relocs implies we are linking a --just-symbols object.  */
5469   if (opd_sec->reloc_count == 0)
5470     {
5471       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5472         return (bfd_vma) -1;
5473
5474       if (code_sec != NULL)
5475         {
5476           asection *sec, *likely = NULL;
5477           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5478             if (sec->vma <= val
5479                 && (sec->flags & SEC_LOAD) != 0
5480                 && (sec->flags & SEC_ALLOC) != 0)
5481               likely = sec;
5482           if (likely != NULL)
5483             {
5484               *code_sec = likely;
5485               if (code_off != NULL)
5486                 *code_off = val - likely->vma;
5487             }
5488         }
5489       return val;
5490     }
5491
5492   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5493
5494   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5495   if (relocs == NULL)
5496     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5497
5498   /* Go find the opd reloc at the sym address.  */
5499   lo = relocs;
5500   BFD_ASSERT (lo != NULL);
5501   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5502   val = (bfd_vma) -1;
5503   while (lo < hi)
5504     {
5505       look = lo + (hi - lo) / 2;
5506       if (look->r_offset < offset)
5507         lo = look + 1;
5508       else if (look->r_offset > offset)
5509         hi = look;
5510       else
5511         {
5512           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5513
5514           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5515               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5516             {
5517               unsigned long symndx = ELF64_R_SYM (look->r_info);
5518               asection *sec;
5519
5520               if (symndx < symtab_hdr->sh_info)
5521                 {
5522                   Elf_Internal_Sym *sym;
5523
5524                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5525                   if (sym == NULL)
5526                     {
5527                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5528                                                   symtab_hdr->sh_info,
5529                                                   0, NULL, NULL, NULL);
5530                       if (sym == NULL)
5531                         break;
5532                       symtab_hdr->contents = (bfd_byte *) sym;
5533                     }
5534
5535                   sym += symndx;
5536                   val = sym->st_value;
5537                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5538                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5539                 }
5540               else
5541                 {
5542                   struct elf_link_hash_entry **sym_hashes;
5543                   struct elf_link_hash_entry *rh;
5544
5545                   sym_hashes = elf_sym_hashes (opd_bfd);
5546                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5547                   rh = elf_follow_link (rh);
5548                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5549                               || rh->root.type == bfd_link_hash_defweak);
5550                   val = rh->root.u.def.value;
5551                   sec = rh->root.u.def.section;
5552                 }
5553               val += look->r_addend;
5554               if (code_off != NULL)
5555                 *code_off = val;
5556               if (code_sec != NULL)
5557                 *code_sec = sec;
5558               if (sec != NULL && sec->output_section != NULL)
5559                 val += sec->output_section->vma + sec->output_offset;
5560             }
5561           break;
5562         }
5563     }
5564
5565   return val;
5566 }
5567
5568 /* If FDH is a function descriptor symbol, return the associated code
5569    entry symbol if it is defined.  Return NULL otherwise.  */
5570
5571 static struct ppc_link_hash_entry *
5572 defined_code_entry (struct ppc_link_hash_entry *fdh)
5573 {
5574   if (fdh->is_func_descriptor)
5575     {
5576       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5577       if (fh->elf.root.type == bfd_link_hash_defined
5578           || fh->elf.root.type == bfd_link_hash_defweak)
5579         return fh;
5580     }
5581   return NULL;
5582 }
5583
5584 /* If FH is a function code entry symbol, return the associated
5585    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5586
5587 static struct ppc_link_hash_entry *
5588 defined_func_desc (struct ppc_link_hash_entry *fh)
5589 {
5590   if (fh->oh != NULL
5591       && fh->oh->is_func_descriptor)
5592     {
5593       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5594       if (fdh->elf.root.type == bfd_link_hash_defined
5595           || fdh->elf.root.type == bfd_link_hash_defweak)
5596         return fdh;
5597     }
5598   return NULL;
5599 }
5600
5601 /* Mark all our entry sym sections, both opd and code section.  */
5602
5603 static void
5604 ppc64_elf_gc_keep (struct bfd_link_info *info)
5605 {
5606   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5607   struct bfd_sym_chain *sym;
5608
5609   if (htab == NULL)
5610     return;
5611
5612   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5613     {
5614       struct ppc_link_hash_entry *eh, *fh;
5615       asection *sec;
5616
5617       eh = (struct ppc_link_hash_entry *)
5618         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5619       if (eh == NULL)
5620         continue;
5621       if (eh->elf.root.type != bfd_link_hash_defined
5622           && eh->elf.root.type != bfd_link_hash_defweak)
5623         continue;
5624
5625       fh = defined_code_entry (eh);
5626       if (fh != NULL)
5627         {
5628           sec = fh->elf.root.u.def.section;
5629           sec->flags |= SEC_KEEP;
5630         }
5631       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5632                && opd_entry_value (eh->elf.root.u.def.section,
5633                                    eh->elf.root.u.def.value,
5634                                    &sec, NULL) != (bfd_vma) -1)
5635         sec->flags |= SEC_KEEP;
5636
5637       sec = eh->elf.root.u.def.section;
5638       sec->flags |= SEC_KEEP;
5639     }
5640 }
5641
5642 /* Mark sections containing dynamically referenced symbols.  When
5643    building shared libraries, we must assume that any visible symbol is
5644    referenced.  */
5645
5646 static bfd_boolean
5647 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5648 {
5649   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5650   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5651   struct ppc_link_hash_entry *fdh;
5652
5653   if (eh->elf.root.type == bfd_link_hash_warning)
5654     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5655
5656   /* Dynamic linking info is on the func descriptor sym.  */
5657   fdh = defined_func_desc (eh);
5658   if (fdh != NULL)
5659     eh = fdh;
5660
5661   if ((eh->elf.root.type == bfd_link_hash_defined
5662        || eh->elf.root.type == bfd_link_hash_defweak)
5663       && (eh->elf.ref_dynamic
5664           || (!info->executable
5665               && eh->elf.def_regular
5666               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5667               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5668     {
5669       asection *code_sec;
5670       struct ppc_link_hash_entry *fh;
5671
5672       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5673
5674       /* Function descriptor syms cause the associated
5675          function code sym section to be marked.  */
5676       fh = defined_code_entry (eh);
5677       if (fh != NULL)
5678         {
5679           code_sec = fh->elf.root.u.def.section;
5680           code_sec->flags |= SEC_KEEP;
5681         }
5682       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5683                && opd_entry_value (eh->elf.root.u.def.section,
5684                                    eh->elf.root.u.def.value,
5685                                    &code_sec, NULL) != (bfd_vma) -1)
5686         code_sec->flags |= SEC_KEEP;
5687     }
5688
5689   return TRUE;
5690 }
5691
5692 /* Return the section that should be marked against GC for a given
5693    relocation.  */
5694
5695 static asection *
5696 ppc64_elf_gc_mark_hook (asection *sec,
5697                         struct bfd_link_info *info,
5698                         Elf_Internal_Rela *rel,
5699                         struct elf_link_hash_entry *h,
5700                         Elf_Internal_Sym *sym)
5701 {
5702   asection *rsec;
5703
5704   /* Syms return NULL if we're marking .opd, so we avoid marking all
5705      function sections, as all functions are referenced in .opd.  */
5706   rsec = NULL;
5707   if (get_opd_info (sec) != NULL)
5708     return rsec;
5709
5710   if (h != NULL)
5711     {
5712       enum elf_ppc64_reloc_type r_type;
5713       struct ppc_link_hash_entry *eh, *fh, *fdh;
5714
5715       r_type = ELF64_R_TYPE (rel->r_info);
5716       switch (r_type)
5717         {
5718         case R_PPC64_GNU_VTINHERIT:
5719         case R_PPC64_GNU_VTENTRY:
5720           break;
5721
5722         default:
5723           switch (h->root.type)
5724             {
5725             case bfd_link_hash_defined:
5726             case bfd_link_hash_defweak:
5727               eh = (struct ppc_link_hash_entry *) h;
5728               fdh = defined_func_desc (eh);
5729               if (fdh != NULL)
5730                 eh = fdh;
5731
5732               /* Function descriptor syms cause the associated
5733                  function code sym section to be marked.  */
5734               fh = defined_code_entry (eh);
5735               if (fh != NULL)
5736                 {
5737                   /* They also mark their opd section.  */
5738                   eh->elf.root.u.def.section->gc_mark = 1;
5739
5740                   rsec = fh->elf.root.u.def.section;
5741                 }
5742               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5743                        && opd_entry_value (eh->elf.root.u.def.section,
5744                                            eh->elf.root.u.def.value,
5745                                            &rsec, NULL) != (bfd_vma) -1)
5746                 eh->elf.root.u.def.section->gc_mark = 1;
5747               else
5748                 rsec = h->root.u.def.section;
5749               break;
5750
5751             case bfd_link_hash_common:
5752               rsec = h->root.u.c.p->section;
5753               break;
5754
5755             default:
5756               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5757             }
5758         }
5759     }
5760   else
5761     {
5762       struct _opd_sec_data *opd;
5763
5764       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5765       opd = get_opd_info (rsec);
5766       if (opd != NULL && opd->func_sec != NULL)
5767         {
5768           rsec->gc_mark = 1;
5769
5770           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5771         }
5772     }
5773
5774   return rsec;
5775 }
5776
5777 /* Update the .got, .plt. and dynamic reloc reference counts for the
5778    section being removed.  */
5779
5780 static bfd_boolean
5781 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5782                          asection *sec, const Elf_Internal_Rela *relocs)
5783 {
5784   struct ppc_link_hash_table *htab;
5785   Elf_Internal_Shdr *symtab_hdr;
5786   struct elf_link_hash_entry **sym_hashes;
5787   struct got_entry **local_got_ents;
5788   const Elf_Internal_Rela *rel, *relend;
5789
5790   if (info->relocatable)
5791     return TRUE;
5792
5793   if ((sec->flags & SEC_ALLOC) == 0)
5794     return TRUE;
5795
5796   elf_section_data (sec)->local_dynrel = NULL;
5797
5798   htab = ppc_hash_table (info);
5799   if (htab == NULL)
5800     return FALSE;
5801
5802   symtab_hdr = &elf_symtab_hdr (abfd);
5803   sym_hashes = elf_sym_hashes (abfd);
5804   local_got_ents = elf_local_got_ents (abfd);
5805
5806   relend = relocs + sec->reloc_count;
5807   for (rel = relocs; rel < relend; rel++)
5808     {
5809       unsigned long r_symndx;
5810       enum elf_ppc64_reloc_type r_type;
5811       struct elf_link_hash_entry *h = NULL;
5812       unsigned char tls_type = 0;
5813
5814       r_symndx = ELF64_R_SYM (rel->r_info);
5815       r_type = ELF64_R_TYPE (rel->r_info);
5816       if (r_symndx >= symtab_hdr->sh_info)
5817         {
5818           struct ppc_link_hash_entry *eh;
5819           struct ppc_dyn_relocs **pp;
5820           struct ppc_dyn_relocs *p;
5821
5822           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5823           h = elf_follow_link (h);
5824           eh = (struct ppc_link_hash_entry *) h;
5825
5826           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5827             if (p->sec == sec)
5828               {
5829                 /* Everything must go for SEC.  */
5830                 *pp = p->next;
5831                 break;
5832               }
5833         }
5834
5835       if (is_branch_reloc (r_type))
5836         {
5837           struct plt_entry **ifunc = NULL;
5838           if (h != NULL)
5839             {
5840               if (h->type == STT_GNU_IFUNC)
5841                 ifunc = &h->plt.plist;
5842             }
5843           else if (local_got_ents != NULL)
5844             {
5845               struct plt_entry **local_plt = (struct plt_entry **)
5846                 (local_got_ents + symtab_hdr->sh_info);
5847               unsigned char *local_got_tls_masks = (unsigned char *)
5848                 (local_plt + symtab_hdr->sh_info);
5849               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5850                 ifunc = local_plt + r_symndx;
5851             }
5852           if (ifunc != NULL)
5853             {
5854               struct plt_entry *ent;
5855
5856               for (ent = *ifunc; ent != NULL; ent = ent->next)
5857                 if (ent->addend == rel->r_addend)
5858                   break;
5859               if (ent == NULL)
5860                 abort ();
5861               if (ent->plt.refcount > 0)
5862                 ent->plt.refcount -= 1;
5863               continue;
5864             }
5865         }
5866
5867       switch (r_type)
5868         {
5869         case R_PPC64_GOT_TLSLD16:
5870         case R_PPC64_GOT_TLSLD16_LO:
5871         case R_PPC64_GOT_TLSLD16_HI:
5872         case R_PPC64_GOT_TLSLD16_HA:
5873           tls_type = TLS_TLS | TLS_LD;
5874           goto dogot;
5875
5876         case R_PPC64_GOT_TLSGD16:
5877         case R_PPC64_GOT_TLSGD16_LO:
5878         case R_PPC64_GOT_TLSGD16_HI:
5879         case R_PPC64_GOT_TLSGD16_HA:
5880           tls_type = TLS_TLS | TLS_GD;
5881           goto dogot;
5882
5883         case R_PPC64_GOT_TPREL16_DS:
5884         case R_PPC64_GOT_TPREL16_LO_DS:
5885         case R_PPC64_GOT_TPREL16_HI:
5886         case R_PPC64_GOT_TPREL16_HA:
5887           tls_type = TLS_TLS | TLS_TPREL;
5888           goto dogot;
5889
5890         case R_PPC64_GOT_DTPREL16_DS:
5891         case R_PPC64_GOT_DTPREL16_LO_DS:
5892         case R_PPC64_GOT_DTPREL16_HI:
5893         case R_PPC64_GOT_DTPREL16_HA:
5894           tls_type = TLS_TLS | TLS_DTPREL;
5895           goto dogot;
5896
5897         case R_PPC64_GOT16:
5898         case R_PPC64_GOT16_DS:
5899         case R_PPC64_GOT16_HA:
5900         case R_PPC64_GOT16_HI:
5901         case R_PPC64_GOT16_LO:
5902         case R_PPC64_GOT16_LO_DS:
5903         dogot:
5904           {
5905             struct got_entry *ent;
5906
5907             if (h != NULL)
5908               ent = h->got.glist;
5909             else
5910               ent = local_got_ents[r_symndx];
5911
5912             for (; ent != NULL; ent = ent->next)
5913               if (ent->addend == rel->r_addend
5914                   && ent->owner == abfd
5915                   && ent->tls_type == tls_type)
5916                 break;
5917             if (ent == NULL)
5918               abort ();
5919             if (ent->got.refcount > 0)
5920               ent->got.refcount -= 1;
5921           }
5922           break;
5923
5924         case R_PPC64_PLT16_HA:
5925         case R_PPC64_PLT16_HI:
5926         case R_PPC64_PLT16_LO:
5927         case R_PPC64_PLT32:
5928         case R_PPC64_PLT64:
5929         case R_PPC64_REL14:
5930         case R_PPC64_REL14_BRNTAKEN:
5931         case R_PPC64_REL14_BRTAKEN:
5932         case R_PPC64_REL24:
5933           if (h != NULL)
5934             {
5935               struct plt_entry *ent;
5936
5937               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5938                 if (ent->addend == rel->r_addend)
5939                   break;
5940               if (ent != NULL && ent->plt.refcount > 0)
5941                 ent->plt.refcount -= 1;
5942             }
5943           break;
5944
5945         default:
5946           break;
5947         }
5948     }
5949   return TRUE;
5950 }
5951
5952 /* The maximum size of .sfpr.  */
5953 #define SFPR_MAX (218*4)
5954
5955 struct sfpr_def_parms
5956 {
5957   const char name[12];
5958   unsigned char lo, hi;
5959   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5960   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5961 };
5962
5963 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5964
5965 static bfd_boolean
5966 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5967 {
5968   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5969   unsigned int i;
5970   size_t len = strlen (parm->name);
5971   bfd_boolean writing = FALSE;
5972   char sym[16];
5973
5974   if (htab == NULL)
5975     return FALSE;
5976
5977   memcpy (sym, parm->name, len);
5978   sym[len + 2] = 0;
5979
5980   for (i = parm->lo; i <= parm->hi; i++)
5981     {
5982       struct elf_link_hash_entry *h;
5983
5984       sym[len + 0] = i / 10 + '0';
5985       sym[len + 1] = i % 10 + '0';
5986       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5987       if (h != NULL
5988           && !h->def_regular)
5989         {
5990           h->root.type = bfd_link_hash_defined;
5991           h->root.u.def.section = htab->sfpr;
5992           h->root.u.def.value = htab->sfpr->size;
5993           h->type = STT_FUNC;
5994           h->def_regular = 1;
5995           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5996           writing = TRUE;
5997           if (htab->sfpr->contents == NULL)
5998             {
5999               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6000               if (htab->sfpr->contents == NULL)
6001                 return FALSE;
6002             }
6003         }
6004       if (writing)
6005         {
6006           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6007           if (i != parm->hi)
6008             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6009           else
6010             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6011           htab->sfpr->size = p - htab->sfpr->contents;
6012         }
6013     }
6014
6015   return TRUE;
6016 }
6017
6018 static bfd_byte *
6019 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6020 {
6021   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6022   return p + 4;
6023 }
6024
6025 static bfd_byte *
6026 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6027 {
6028   p = savegpr0 (abfd, p, r);
6029   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6030   p = p + 4;
6031   bfd_put_32 (abfd, BLR, p);
6032   return p + 4;
6033 }
6034
6035 static bfd_byte *
6036 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6037 {
6038   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6039   return p + 4;
6040 }
6041
6042 static bfd_byte *
6043 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6044 {
6045   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6046   p = p + 4;
6047   p = restgpr0 (abfd, p, r);
6048   bfd_put_32 (abfd, MTLR_R0, p);
6049   p = p + 4;
6050   if (r == 29)
6051     {
6052       p = restgpr0 (abfd, p, 30);
6053       p = restgpr0 (abfd, p, 31);
6054     }
6055   bfd_put_32 (abfd, BLR, p);
6056   return p + 4;
6057 }
6058
6059 static bfd_byte *
6060 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6061 {
6062   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6063   return p + 4;
6064 }
6065
6066 static bfd_byte *
6067 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6068 {
6069   p = savegpr1 (abfd, p, r);
6070   bfd_put_32 (abfd, BLR, p);
6071   return p + 4;
6072 }
6073
6074 static bfd_byte *
6075 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6076 {
6077   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6078   return p + 4;
6079 }
6080
6081 static bfd_byte *
6082 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6083 {
6084   p = restgpr1 (abfd, p, r);
6085   bfd_put_32 (abfd, BLR, p);
6086   return p + 4;
6087 }
6088
6089 static bfd_byte *
6090 savefpr (bfd *abfd, bfd_byte *p, int r)
6091 {
6092   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6093   return p + 4;
6094 }
6095
6096 static bfd_byte *
6097 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6098 {
6099   p = savefpr (abfd, p, r);
6100   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6101   p = p + 4;
6102   bfd_put_32 (abfd, BLR, p);
6103   return p + 4;
6104 }
6105
6106 static bfd_byte *
6107 restfpr (bfd *abfd, bfd_byte *p, int r)
6108 {
6109   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6110   return p + 4;
6111 }
6112
6113 static bfd_byte *
6114 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6115 {
6116   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6117   p = p + 4;
6118   p = restfpr (abfd, p, r);
6119   bfd_put_32 (abfd, MTLR_R0, p);
6120   p = p + 4;
6121   if (r == 29)
6122     {
6123       p = restfpr (abfd, p, 30);
6124       p = restfpr (abfd, p, 31);
6125     }
6126   bfd_put_32 (abfd, BLR, p);
6127   return p + 4;
6128 }
6129
6130 static bfd_byte *
6131 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6132 {
6133   p = savefpr (abfd, p, r);
6134   bfd_put_32 (abfd, BLR, p);
6135   return p + 4;
6136 }
6137
6138 static bfd_byte *
6139 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6140 {
6141   p = restfpr (abfd, p, r);
6142   bfd_put_32 (abfd, BLR, p);
6143   return p + 4;
6144 }
6145
6146 static bfd_byte *
6147 savevr (bfd *abfd, bfd_byte *p, int r)
6148 {
6149   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6150   p = p + 4;
6151   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6152   return p + 4;
6153 }
6154
6155 static bfd_byte *
6156 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6157 {
6158   p = savevr (abfd, p, r);
6159   bfd_put_32 (abfd, BLR, p);
6160   return p + 4;
6161 }
6162
6163 static bfd_byte *
6164 restvr (bfd *abfd, bfd_byte *p, int r)
6165 {
6166   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6167   p = p + 4;
6168   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6169   return p + 4;
6170 }
6171
6172 static bfd_byte *
6173 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6174 {
6175   p = restvr (abfd, p, r);
6176   bfd_put_32 (abfd, BLR, p);
6177   return p + 4;
6178 }
6179
6180 /* Called via elf_link_hash_traverse to transfer dynamic linking
6181    information on function code symbol entries to their corresponding
6182    function descriptor symbol entries.  */
6183
6184 static bfd_boolean
6185 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6186 {
6187   struct bfd_link_info *info;
6188   struct ppc_link_hash_table *htab;
6189   struct plt_entry *ent;
6190   struct ppc_link_hash_entry *fh;
6191   struct ppc_link_hash_entry *fdh;
6192   bfd_boolean force_local;
6193
6194   fh = (struct ppc_link_hash_entry *) h;
6195   if (fh->elf.root.type == bfd_link_hash_indirect)
6196     return TRUE;
6197
6198   if (fh->elf.root.type == bfd_link_hash_warning)
6199     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6200
6201   info = inf;
6202   htab = ppc_hash_table (info);
6203   if (htab == NULL)
6204     return FALSE;
6205
6206   /* Resolve undefined references to dot-symbols as the value
6207      in the function descriptor, if we have one in a regular object.
6208      This is to satisfy cases like ".quad .foo".  Calls to functions
6209      in dynamic objects are handled elsewhere.  */
6210   if (fh->elf.root.type == bfd_link_hash_undefweak
6211       && fh->was_undefined
6212       && (fdh = defined_func_desc (fh)) != NULL
6213       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6214       && opd_entry_value (fdh->elf.root.u.def.section,
6215                           fdh->elf.root.u.def.value,
6216                           &fh->elf.root.u.def.section,
6217                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6218     {
6219       fh->elf.root.type = fdh->elf.root.type;
6220       fh->elf.forced_local = 1;
6221       fh->elf.def_regular = fdh->elf.def_regular;
6222       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6223     }
6224
6225   /* If this is a function code symbol, transfer dynamic linking
6226      information to the function descriptor symbol.  */
6227   if (!fh->is_func)
6228     return TRUE;
6229
6230   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6231     if (ent->plt.refcount > 0)
6232       break;
6233   if (ent == NULL
6234       || fh->elf.root.root.string[0] != '.'
6235       || fh->elf.root.root.string[1] == '\0')
6236     return TRUE;
6237
6238   /* Find the corresponding function descriptor symbol.  Create it
6239      as undefined if necessary.  */
6240
6241   fdh = lookup_fdh (fh, htab);
6242   if (fdh == NULL
6243       && !info->executable
6244       && (fh->elf.root.type == bfd_link_hash_undefined
6245           || fh->elf.root.type == bfd_link_hash_undefweak))
6246     {
6247       fdh = make_fdh (info, fh);
6248       if (fdh == NULL)
6249         return FALSE;
6250     }
6251
6252   /* Fake function descriptors are made undefweak.  If the function
6253      code symbol is strong undefined, make the fake sym the same.
6254      If the function code symbol is defined, then force the fake
6255      descriptor local;  We can't support overriding of symbols in a
6256      shared library on a fake descriptor.  */
6257
6258   if (fdh != NULL
6259       && fdh->fake
6260       && fdh->elf.root.type == bfd_link_hash_undefweak)
6261     {
6262       if (fh->elf.root.type == bfd_link_hash_undefined)
6263         {
6264           fdh->elf.root.type = bfd_link_hash_undefined;
6265           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6266         }
6267       else if (fh->elf.root.type == bfd_link_hash_defined
6268                || fh->elf.root.type == bfd_link_hash_defweak)
6269         {
6270           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6271         }
6272     }
6273
6274   if (fdh != NULL
6275       && !fdh->elf.forced_local
6276       && (!info->executable
6277           || fdh->elf.def_dynamic
6278           || fdh->elf.ref_dynamic
6279           || (fdh->elf.root.type == bfd_link_hash_undefweak
6280               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6281     {
6282       if (fdh->elf.dynindx == -1)
6283         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6284           return FALSE;
6285       fdh->elf.ref_regular |= fh->elf.ref_regular;
6286       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6287       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6288       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6289       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6290         {
6291           move_plt_plist (fh, fdh);
6292           fdh->elf.needs_plt = 1;
6293         }
6294       fdh->is_func_descriptor = 1;
6295       fdh->oh = fh;
6296       fh->oh = fdh;
6297     }
6298
6299   /* Now that the info is on the function descriptor, clear the
6300      function code sym info.  Any function code syms for which we
6301      don't have a definition in a regular file, we force local.
6302      This prevents a shared library from exporting syms that have
6303      been imported from another library.  Function code syms that
6304      are really in the library we must leave global to prevent the
6305      linker dragging in a definition from a static library.  */
6306   force_local = (!fh->elf.def_regular
6307                  || fdh == NULL
6308                  || !fdh->elf.def_regular
6309                  || fdh->elf.forced_local);
6310   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6311
6312   return TRUE;
6313 }
6314
6315 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6316    this hook to a) provide some gcc support functions, and b) transfer
6317    dynamic linking information gathered so far on function code symbol
6318    entries, to their corresponding function descriptor symbol entries.  */
6319
6320 static bfd_boolean
6321 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6322                             struct bfd_link_info *info)
6323 {
6324   struct ppc_link_hash_table *htab;
6325   unsigned int i;
6326   const struct sfpr_def_parms funcs[] =
6327     {
6328       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6329       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6330       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6331       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6332       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6333       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6334       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6335       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6336       { "._savef", 14, 31, savefpr, savefpr1_tail },
6337       { "._restf", 14, 31, restfpr, restfpr1_tail },
6338       { "_savevr_", 20, 31, savevr, savevr_tail },
6339       { "_restvr_", 20, 31, restvr, restvr_tail }
6340     };
6341
6342   htab = ppc_hash_table (info);
6343   if (htab == NULL)
6344     return FALSE;
6345
6346   if (htab->sfpr == NULL)
6347     /* We don't have any relocs.  */
6348     return TRUE;
6349
6350   /* Provide any missing _save* and _rest* functions.  */
6351   htab->sfpr->size = 0;
6352   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6353     if (!sfpr_define (info, &funcs[i]))
6354       return FALSE;
6355
6356   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6357
6358   if (htab->sfpr->size == 0)
6359     htab->sfpr->flags |= SEC_EXCLUDE;
6360
6361   return TRUE;
6362 }
6363
6364 /* Adjust a symbol defined by a dynamic object and referenced by a
6365    regular object.  The current definition is in some section of the
6366    dynamic object, but we're not including those sections.  We have to
6367    change the definition to something the rest of the link can
6368    understand.  */
6369
6370 static bfd_boolean
6371 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6372                                  struct elf_link_hash_entry *h)
6373 {
6374   struct ppc_link_hash_table *htab;
6375   asection *s;
6376
6377   htab = ppc_hash_table (info);
6378   if (htab == NULL)
6379     return FALSE;
6380
6381   /* Deal with function syms.  */
6382   if (h->type == STT_FUNC
6383       || h->type == STT_GNU_IFUNC
6384       || h->needs_plt)
6385     {
6386       /* Clear procedure linkage table information for any symbol that
6387          won't need a .plt entry.  */
6388       struct plt_entry *ent;
6389       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6390         if (ent->plt.refcount > 0)
6391           break;
6392       if (ent == NULL
6393           || (h->type != STT_GNU_IFUNC
6394               && (SYMBOL_CALLS_LOCAL (info, h)
6395                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6396                       && h->root.type == bfd_link_hash_undefweak))))
6397         {
6398           h->plt.plist = NULL;
6399           h->needs_plt = 0;
6400         }
6401     }
6402   else
6403     h->plt.plist = NULL;
6404
6405   /* If this is a weak symbol, and there is a real definition, the
6406      processor independent code will have arranged for us to see the
6407      real definition first, and we can just use the same value.  */
6408   if (h->u.weakdef != NULL)
6409     {
6410       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6411                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6412       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6413       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6414       if (ELIMINATE_COPY_RELOCS)
6415         h->non_got_ref = h->u.weakdef->non_got_ref;
6416       return TRUE;
6417     }
6418
6419   /* If we are creating a shared library, we must presume that the
6420      only references to the symbol are via the global offset table.
6421      For such cases we need not do anything here; the relocations will
6422      be handled correctly by relocate_section.  */
6423   if (info->shared)
6424     return TRUE;
6425
6426   /* If there are no references to this symbol that do not use the
6427      GOT, we don't need to generate a copy reloc.  */
6428   if (!h->non_got_ref)
6429     return TRUE;
6430
6431   /* Don't generate a copy reloc for symbols defined in the executable.  */
6432   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6433     return TRUE;
6434
6435   if (ELIMINATE_COPY_RELOCS)
6436     {
6437       struct ppc_link_hash_entry * eh;
6438       struct ppc_dyn_relocs *p;
6439
6440       eh = (struct ppc_link_hash_entry *) h;
6441       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6442         {
6443           s = p->sec->output_section;
6444           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6445             break;
6446         }
6447
6448       /* If we didn't find any dynamic relocs in read-only sections, then
6449          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6450       if (p == NULL)
6451         {
6452           h->non_got_ref = 0;
6453           return TRUE;
6454         }
6455     }
6456
6457   if (h->plt.plist != NULL)
6458     {
6459       /* We should never get here, but unfortunately there are versions
6460          of gcc out there that improperly (for this ABI) put initialized
6461          function pointers, vtable refs and suchlike in read-only
6462          sections.  Allow them to proceed, but warn that this might
6463          break at runtime.  */
6464       (*_bfd_error_handler)
6465         (_("copy reloc against `%s' requires lazy plt linking; "
6466            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6467          h->root.root.string);
6468     }
6469
6470   /* This is a reference to a symbol defined by a dynamic object which
6471      is not a function.  */
6472
6473   if (h->size == 0)
6474     {
6475       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6476                              h->root.root.string);
6477       return TRUE;
6478     }
6479
6480   /* We must allocate the symbol in our .dynbss section, which will
6481      become part of the .bss section of the executable.  There will be
6482      an entry for this symbol in the .dynsym section.  The dynamic
6483      object will contain position independent code, so all references
6484      from the dynamic object to this symbol will go through the global
6485      offset table.  The dynamic linker will use the .dynsym entry to
6486      determine the address it must put in the global offset table, so
6487      both the dynamic object and the regular object will refer to the
6488      same memory location for the variable.  */
6489
6490   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6491      to copy the initial value out of the dynamic object and into the
6492      runtime process image.  We need to remember the offset into the
6493      .rela.bss section we are going to use.  */
6494   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6495     {
6496       htab->relbss->size += sizeof (Elf64_External_Rela);
6497       h->needs_copy = 1;
6498     }
6499
6500   s = htab->dynbss;
6501
6502   return _bfd_elf_adjust_dynamic_copy (h, s);
6503 }
6504
6505 /* If given a function descriptor symbol, hide both the function code
6506    sym and the descriptor.  */
6507 static void
6508 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6509                        struct elf_link_hash_entry *h,
6510                        bfd_boolean force_local)
6511 {
6512   struct ppc_link_hash_entry *eh;
6513   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6514
6515   eh = (struct ppc_link_hash_entry *) h;
6516   if (eh->is_func_descriptor)
6517     {
6518       struct ppc_link_hash_entry *fh = eh->oh;
6519
6520       if (fh == NULL)
6521         {
6522           const char *p, *q;
6523           struct ppc_link_hash_table *htab;
6524           char save;
6525
6526           /* We aren't supposed to use alloca in BFD because on
6527              systems which do not have alloca the version in libiberty
6528              calls xmalloc, which might cause the program to crash
6529              when it runs out of memory.  This function doesn't have a
6530              return status, so there's no way to gracefully return an
6531              error.  So cheat.  We know that string[-1] can be safely
6532              accessed;  It's either a string in an ELF string table,
6533              or allocated in an objalloc structure.  */
6534
6535           p = eh->elf.root.root.string - 1;
6536           save = *p;
6537           *(char *) p = '.';
6538           htab = ppc_hash_table (info);
6539           if (htab == NULL)
6540             return;
6541
6542           fh = (struct ppc_link_hash_entry *)
6543             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6544           *(char *) p = save;
6545
6546           /* Unfortunately, if it so happens that the string we were
6547              looking for was allocated immediately before this string,
6548              then we overwrote the string terminator.  That's the only
6549              reason the lookup should fail.  */
6550           if (fh == NULL)
6551             {
6552               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6553               while (q >= eh->elf.root.root.string && *q == *p)
6554                 --q, --p;
6555               if (q < eh->elf.root.root.string && *p == '.')
6556                 fh = (struct ppc_link_hash_entry *)
6557                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6558             }
6559           if (fh != NULL)
6560             {
6561               eh->oh = fh;
6562               fh->oh = eh;
6563             }
6564         }
6565       if (fh != NULL)
6566         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6567     }
6568 }
6569
6570 static bfd_boolean
6571 get_sym_h (struct elf_link_hash_entry **hp,
6572            Elf_Internal_Sym **symp,
6573            asection **symsecp,
6574            unsigned char **tls_maskp,
6575            Elf_Internal_Sym **locsymsp,
6576            unsigned long r_symndx,
6577            bfd *ibfd)
6578 {
6579   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6580
6581   if (r_symndx >= symtab_hdr->sh_info)
6582     {
6583       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6584       struct elf_link_hash_entry *h;
6585
6586       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6587       h = elf_follow_link (h);
6588
6589       if (hp != NULL)
6590         *hp = h;
6591
6592       if (symp != NULL)
6593         *symp = NULL;
6594
6595       if (symsecp != NULL)
6596         {
6597           asection *symsec = NULL;
6598           if (h->root.type == bfd_link_hash_defined
6599               || h->root.type == bfd_link_hash_defweak)
6600             symsec = h->root.u.def.section;
6601           *symsecp = symsec;
6602         }
6603
6604       if (tls_maskp != NULL)
6605         {
6606           struct ppc_link_hash_entry *eh;
6607
6608           eh = (struct ppc_link_hash_entry *) h;
6609           *tls_maskp = &eh->tls_mask;
6610         }
6611     }
6612   else
6613     {
6614       Elf_Internal_Sym *sym;
6615       Elf_Internal_Sym *locsyms = *locsymsp;
6616
6617       if (locsyms == NULL)
6618         {
6619           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6620           if (locsyms == NULL)
6621             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6622                                             symtab_hdr->sh_info,
6623                                             0, NULL, NULL, NULL);
6624           if (locsyms == NULL)
6625             return FALSE;
6626           *locsymsp = locsyms;
6627         }
6628       sym = locsyms + r_symndx;
6629
6630       if (hp != NULL)
6631         *hp = NULL;
6632
6633       if (symp != NULL)
6634         *symp = sym;
6635
6636       if (symsecp != NULL)
6637         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6638
6639       if (tls_maskp != NULL)
6640         {
6641           struct got_entry **lgot_ents;
6642           unsigned char *tls_mask;
6643
6644           tls_mask = NULL;
6645           lgot_ents = elf_local_got_ents (ibfd);
6646           if (lgot_ents != NULL)
6647             {
6648               struct plt_entry **local_plt = (struct plt_entry **)
6649                 (lgot_ents + symtab_hdr->sh_info);
6650               unsigned char *lgot_masks = (unsigned char *)
6651                 (local_plt + symtab_hdr->sh_info);
6652               tls_mask = &lgot_masks[r_symndx];
6653             }
6654           *tls_maskp = tls_mask;
6655         }
6656     }
6657   return TRUE;
6658 }
6659
6660 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6661    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6662    type suitable for optimization, and 1 otherwise.  */
6663
6664 static int
6665 get_tls_mask (unsigned char **tls_maskp,
6666               unsigned long *toc_symndx,
6667               bfd_vma *toc_addend,
6668               Elf_Internal_Sym **locsymsp,
6669               const Elf_Internal_Rela *rel,
6670               bfd *ibfd)
6671 {
6672   unsigned long r_symndx;
6673   int next_r;
6674   struct elf_link_hash_entry *h;
6675   Elf_Internal_Sym *sym;
6676   asection *sec;
6677   bfd_vma off;
6678
6679   r_symndx = ELF64_R_SYM (rel->r_info);
6680   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6681     return 0;
6682
6683   if ((*tls_maskp != NULL && **tls_maskp != 0)
6684       || sec == NULL
6685       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6686     return 1;
6687
6688   /* Look inside a TOC section too.  */
6689   if (h != NULL)
6690     {
6691       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6692       off = h->root.u.def.value;
6693     }
6694   else
6695     off = sym->st_value;
6696   off += rel->r_addend;
6697   BFD_ASSERT (off % 8 == 0);
6698   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6699   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6700   if (toc_symndx != NULL)
6701     *toc_symndx = r_symndx;
6702   if (toc_addend != NULL)
6703     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6704   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6705     return 0;
6706   if ((h == NULL
6707        || ((h->root.type == bfd_link_hash_defined
6708             || h->root.type == bfd_link_hash_defweak)
6709            && !h->def_dynamic))
6710       && (next_r == -1 || next_r == -2))
6711     return 1 - next_r;
6712   return 1;
6713 }
6714
6715 /* Adjust all global syms defined in opd sections.  In gcc generated
6716    code for the old ABI, these will already have been done.  */
6717
6718 static bfd_boolean
6719 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6720 {
6721   struct ppc_link_hash_entry *eh;
6722   asection *sym_sec;
6723   struct _opd_sec_data *opd;
6724
6725   if (h->root.type == bfd_link_hash_indirect)
6726     return TRUE;
6727
6728   if (h->root.type == bfd_link_hash_warning)
6729     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6730
6731   if (h->root.type != bfd_link_hash_defined
6732       && h->root.type != bfd_link_hash_defweak)
6733     return TRUE;
6734
6735   eh = (struct ppc_link_hash_entry *) h;
6736   if (eh->adjust_done)
6737     return TRUE;
6738
6739   sym_sec = eh->elf.root.u.def.section;
6740   opd = get_opd_info (sym_sec);
6741   if (opd != NULL && opd->adjust != NULL)
6742     {
6743       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6744       if (adjust == -1)
6745         {
6746           /* This entry has been deleted.  */
6747           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6748           if (dsec == NULL)
6749             {
6750               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6751                 if (elf_discarded_section (dsec))
6752                   {
6753                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6754                     break;
6755                   }
6756             }
6757           eh->elf.root.u.def.value = 0;
6758           eh->elf.root.u.def.section = dsec;
6759         }
6760       else
6761         eh->elf.root.u.def.value += adjust;
6762       eh->adjust_done = 1;
6763     }
6764   return TRUE;
6765 }
6766
6767 /* Handles decrementing dynamic reloc counts for the reloc specified by
6768    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6769    have already been determined.  */
6770
6771 static bfd_boolean
6772 dec_dynrel_count (bfd_vma r_info,
6773                   asection *sec,
6774                   struct bfd_link_info *info,
6775                   Elf_Internal_Sym **local_syms,
6776                   struct elf_link_hash_entry *h,
6777                   asection *sym_sec)
6778 {
6779   enum elf_ppc64_reloc_type r_type;
6780   struct ppc_dyn_relocs *p;
6781   struct ppc_dyn_relocs **pp;
6782
6783   /* Can this reloc be dynamic?  This switch, and later tests here
6784      should be kept in sync with the code in check_relocs.  */
6785   r_type = ELF64_R_TYPE (r_info);
6786   switch (r_type)
6787     {
6788     default:
6789       return TRUE;
6790
6791     case R_PPC64_TPREL16:
6792     case R_PPC64_TPREL16_LO:
6793     case R_PPC64_TPREL16_HI:
6794     case R_PPC64_TPREL16_HA:
6795     case R_PPC64_TPREL16_DS:
6796     case R_PPC64_TPREL16_LO_DS:
6797     case R_PPC64_TPREL16_HIGHER:
6798     case R_PPC64_TPREL16_HIGHERA:
6799     case R_PPC64_TPREL16_HIGHEST:
6800     case R_PPC64_TPREL16_HIGHESTA:
6801       if (!info->shared)
6802         return TRUE;
6803
6804     case R_PPC64_TPREL64:
6805     case R_PPC64_DTPMOD64:
6806     case R_PPC64_DTPREL64:
6807     case R_PPC64_ADDR64:
6808     case R_PPC64_REL30:
6809     case R_PPC64_REL32:
6810     case R_PPC64_REL64:
6811     case R_PPC64_ADDR14:
6812     case R_PPC64_ADDR14_BRNTAKEN:
6813     case R_PPC64_ADDR14_BRTAKEN:
6814     case R_PPC64_ADDR16:
6815     case R_PPC64_ADDR16_DS:
6816     case R_PPC64_ADDR16_HA:
6817     case R_PPC64_ADDR16_HI:
6818     case R_PPC64_ADDR16_HIGHER:
6819     case R_PPC64_ADDR16_HIGHERA:
6820     case R_PPC64_ADDR16_HIGHEST:
6821     case R_PPC64_ADDR16_HIGHESTA:
6822     case R_PPC64_ADDR16_LO:
6823     case R_PPC64_ADDR16_LO_DS:
6824     case R_PPC64_ADDR24:
6825     case R_PPC64_ADDR32:
6826     case R_PPC64_UADDR16:
6827     case R_PPC64_UADDR32:
6828     case R_PPC64_UADDR64:
6829     case R_PPC64_TOC:
6830       break;
6831     }
6832
6833   if (local_syms != NULL)
6834     {
6835       unsigned long r_symndx;
6836       Elf_Internal_Sym *sym;
6837       bfd *ibfd = sec->owner;
6838
6839       r_symndx = ELF64_R_SYM (r_info);
6840       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6841         return FALSE;
6842     }
6843
6844   if ((info->shared
6845        && (must_be_dyn_reloc (info, r_type)
6846            || (h != NULL
6847                && (!info->symbolic
6848                    || h->root.type == bfd_link_hash_defweak
6849                    || !h->def_regular))))
6850       || (ELIMINATE_COPY_RELOCS
6851           && !info->shared
6852           && h != NULL
6853           && (h->root.type == bfd_link_hash_defweak
6854               || !h->def_regular)))
6855     ;
6856   else
6857     return TRUE;
6858
6859   if (h != NULL)
6860     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6861   else
6862     {
6863       if (sym_sec != NULL)
6864         {
6865           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6866           pp = (struct ppc_dyn_relocs **) vpp;
6867         }
6868       else
6869         {
6870           void *vpp = &elf_section_data (sec)->local_dynrel;
6871           pp = (struct ppc_dyn_relocs **) vpp;
6872         }
6873
6874       /* elf_gc_sweep may have already removed all dyn relocs associated
6875          with local syms for a given section.  Don't report a dynreloc
6876          miscount.  */
6877       if (*pp == NULL)
6878         return TRUE;
6879     }
6880
6881   while ((p = *pp) != NULL)
6882     {
6883       if (p->sec == sec)
6884         {
6885           if (!must_be_dyn_reloc (info, r_type))
6886             p->pc_count -= 1;
6887           p->count -= 1;
6888           if (p->count == 0)
6889             *pp = p->next;
6890           return TRUE;
6891         }
6892       pp = &p->next;
6893     }
6894
6895   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6896                            sec->owner, sec);
6897   bfd_set_error (bfd_error_bad_value);
6898   return FALSE;
6899 }
6900
6901 /* Remove unused Official Procedure Descriptor entries.  Currently we
6902    only remove those associated with functions in discarded link-once
6903    sections, or weakly defined functions that have been overridden.  It
6904    would be possible to remove many more entries for statically linked
6905    applications.  */
6906
6907 bfd_boolean
6908 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
6909 {
6910   bfd *ibfd;
6911   bfd_boolean some_edited = FALSE;
6912   asection *need_pad = NULL;
6913
6914   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6915     {
6916       asection *sec;
6917       Elf_Internal_Rela *relstart, *rel, *relend;
6918       Elf_Internal_Shdr *symtab_hdr;
6919       Elf_Internal_Sym *local_syms;
6920       struct elf_link_hash_entry **sym_hashes;
6921       bfd_vma offset;
6922       struct _opd_sec_data *opd;
6923       bfd_boolean need_edit, add_aux_fields;
6924       bfd_size_type cnt_16b = 0;
6925
6926       sec = bfd_get_section_by_name (ibfd, ".opd");
6927       if (sec == NULL || sec->size == 0)
6928         continue;
6929
6930       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6931         continue;
6932
6933       if (sec->output_section == bfd_abs_section_ptr)
6934         continue;
6935
6936       /* Look through the section relocs.  */
6937       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6938         continue;
6939
6940       local_syms = NULL;
6941       symtab_hdr = &elf_symtab_hdr (ibfd);
6942       sym_hashes = elf_sym_hashes (ibfd);
6943
6944       /* Read the relocations.  */
6945       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6946                                             info->keep_memory);
6947       if (relstart == NULL)
6948         return FALSE;
6949
6950       /* First run through the relocs to check they are sane, and to
6951          determine whether we need to edit this opd section.  */
6952       need_edit = FALSE;
6953       need_pad = sec;
6954       offset = 0;
6955       relend = relstart + sec->reloc_count;
6956       for (rel = relstart; rel < relend; )
6957         {
6958           enum elf_ppc64_reloc_type r_type;
6959           unsigned long r_symndx;
6960           asection *sym_sec;
6961           struct elf_link_hash_entry *h;
6962           Elf_Internal_Sym *sym;
6963
6964           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6965              only interested in the reloc pointing to a function entry
6966              point.  */
6967           if (rel->r_offset != offset
6968               || rel + 1 >= relend
6969               || (rel + 1)->r_offset != offset + 8)
6970             {
6971               /* If someone messes with .opd alignment then after a
6972                  "ld -r" we might have padding in the middle of .opd.
6973                  Also, there's nothing to prevent someone putting
6974                  something silly in .opd with the assembler.  No .opd
6975                  optimization for them!  */
6976             broken_opd:
6977               (*_bfd_error_handler)
6978                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6979               need_edit = FALSE;
6980               break;
6981             }
6982
6983           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6984               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6985             {
6986               (*_bfd_error_handler)
6987                 (_("%B: unexpected reloc type %u in .opd section"),
6988                  ibfd, r_type);
6989               need_edit = FALSE;
6990               break;
6991             }
6992
6993           r_symndx = ELF64_R_SYM (rel->r_info);
6994           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6995                           r_symndx, ibfd))
6996             goto error_ret;
6997
6998           if (sym_sec == NULL || sym_sec->owner == NULL)
6999             {
7000               const char *sym_name;
7001               if (h != NULL)
7002                 sym_name = h->root.root.string;
7003               else
7004                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7005                                              sym_sec);
7006
7007               (*_bfd_error_handler)
7008                 (_("%B: undefined sym `%s' in .opd section"),
7009                  ibfd, sym_name);
7010               need_edit = FALSE;
7011               break;
7012             }
7013
7014           /* opd entries are always for functions defined in the
7015              current input bfd.  If the symbol isn't defined in the
7016              input bfd, then we won't be using the function in this
7017              bfd;  It must be defined in a linkonce section in another
7018              bfd, or is weak.  It's also possible that we are
7019              discarding the function due to a linker script /DISCARD/,
7020              which we test for via the output_section.  */
7021           if (sym_sec->owner != ibfd
7022               || sym_sec->output_section == bfd_abs_section_ptr)
7023             need_edit = TRUE;
7024
7025           rel += 2;
7026           if (rel == relend
7027               || (rel + 1 == relend && rel->r_offset == offset + 16))
7028             {
7029               if (sec->size == offset + 24)
7030                 {
7031                   need_pad = NULL;
7032                   break;
7033                 }
7034               if (rel == relend && sec->size == offset + 16)
7035                 {
7036                   cnt_16b++;
7037                   break;
7038                 }
7039               goto broken_opd;
7040             }
7041
7042           if (rel->r_offset == offset + 24)
7043             offset += 24;
7044           else if (rel->r_offset != offset + 16)
7045             goto broken_opd;
7046           else if (rel + 1 < relend
7047                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7048                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7049             {
7050               offset += 16;
7051               cnt_16b++;
7052             }
7053           else if (rel + 2 < relend
7054                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7055                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7056             {
7057               offset += 24;
7058               rel += 1;
7059             }
7060           else
7061             goto broken_opd;
7062         }
7063
7064       add_aux_fields = non_overlapping && cnt_16b > 0;
7065
7066       if (need_edit || add_aux_fields)
7067         {
7068           Elf_Internal_Rela *write_rel;
7069           bfd_byte *rptr, *wptr;
7070           bfd_byte *new_contents;
7071           bfd_boolean skip;
7072           long opd_ent_size;
7073           bfd_size_type amt;
7074
7075           new_contents = NULL;
7076           amt = sec->size * sizeof (long) / 8;
7077           opd = &ppc64_elf_section_data (sec)->u.opd;
7078           opd->adjust = bfd_zalloc (sec->owner, amt);
7079           if (opd->adjust == NULL)
7080             return FALSE;
7081           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7082
7083           /* This seems a waste of time as input .opd sections are all
7084              zeros as generated by gcc, but I suppose there's no reason
7085              this will always be so.  We might start putting something in
7086              the third word of .opd entries.  */
7087           if ((sec->flags & SEC_IN_MEMORY) == 0)
7088             {
7089               bfd_byte *loc;
7090               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7091                 {
7092                   if (loc != NULL)
7093                     free (loc);
7094                 error_ret:
7095                   if (local_syms != NULL
7096                       && symtab_hdr->contents != (unsigned char *) local_syms)
7097                     free (local_syms);
7098                   if (elf_section_data (sec)->relocs != relstart)
7099                     free (relstart);
7100                   return FALSE;
7101                 }
7102               sec->contents = loc;
7103               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7104             }
7105
7106           elf_section_data (sec)->relocs = relstart;
7107
7108           new_contents = sec->contents;
7109           if (add_aux_fields)
7110             {
7111               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7112               if (new_contents == NULL)
7113                 return FALSE;
7114               need_pad = FALSE;
7115             }
7116           wptr = new_contents;
7117           rptr = sec->contents;
7118
7119           write_rel = relstart;
7120           skip = FALSE;
7121           offset = 0;
7122           opd_ent_size = 0;
7123           for (rel = relstart; rel < relend; rel++)
7124             {
7125               unsigned long r_symndx;
7126               asection *sym_sec;
7127               struct elf_link_hash_entry *h;
7128               Elf_Internal_Sym *sym;
7129
7130               r_symndx = ELF64_R_SYM (rel->r_info);
7131               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7132                               r_symndx, ibfd))
7133                 goto error_ret;
7134
7135               if (rel->r_offset == offset)
7136                 {
7137                   struct ppc_link_hash_entry *fdh = NULL;
7138
7139                   /* See if the .opd entry is full 24 byte or
7140                      16 byte (with fd_aux entry overlapped with next
7141                      fd_func).  */
7142                   opd_ent_size = 24;
7143                   if ((rel + 2 == relend && sec->size == offset + 16)
7144                       || (rel + 3 < relend
7145                           && rel[2].r_offset == offset + 16
7146                           && rel[3].r_offset == offset + 24
7147                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7148                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7149                     opd_ent_size = 16;
7150
7151                   if (h != NULL
7152                       && h->root.root.string[0] == '.')
7153                     {
7154                       struct ppc_link_hash_table *htab;
7155
7156                       htab = ppc_hash_table (info);
7157                       if (htab != NULL)
7158                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7159                                           htab);
7160                       if (fdh != NULL
7161                           && fdh->elf.root.type != bfd_link_hash_defined
7162                           && fdh->elf.root.type != bfd_link_hash_defweak)
7163                         fdh = NULL;
7164                     }
7165
7166                   skip = (sym_sec->owner != ibfd
7167                           || sym_sec->output_section == bfd_abs_section_ptr);
7168                   if (skip)
7169                     {
7170                       if (fdh != NULL && sym_sec->owner == ibfd)
7171                         {
7172                           /* Arrange for the function descriptor sym
7173                              to be dropped.  */
7174                           fdh->elf.root.u.def.value = 0;
7175                           fdh->elf.root.u.def.section = sym_sec;
7176                         }
7177                       opd->adjust[rel->r_offset / 8] = -1;
7178                     }
7179                   else
7180                     {
7181                       /* We'll be keeping this opd entry.  */
7182
7183                       if (fdh != NULL)
7184                         {
7185                           /* Redefine the function descriptor symbol to
7186                              this location in the opd section.  It is
7187                              necessary to update the value here rather
7188                              than using an array of adjustments as we do
7189                              for local symbols, because various places
7190                              in the generic ELF code use the value
7191                              stored in u.def.value.  */
7192                           fdh->elf.root.u.def.value = wptr - new_contents;
7193                           fdh->adjust_done = 1;
7194                         }
7195
7196                       /* Local syms are a bit tricky.  We could
7197                          tweak them as they can be cached, but
7198                          we'd need to look through the local syms
7199                          for the function descriptor sym which we
7200                          don't have at the moment.  So keep an
7201                          array of adjustments.  */
7202                       opd->adjust[rel->r_offset / 8]
7203                         = (wptr - new_contents) - (rptr - sec->contents);
7204
7205                       if (wptr != rptr)
7206                         memcpy (wptr, rptr, opd_ent_size);
7207                       wptr += opd_ent_size;
7208                       if (add_aux_fields && opd_ent_size == 16)
7209                         {
7210                           memset (wptr, '\0', 8);
7211                           wptr += 8;
7212                         }
7213                     }
7214                   rptr += opd_ent_size;
7215                   offset += opd_ent_size;
7216                 }
7217
7218               if (skip)
7219                 {
7220                   if (!NO_OPD_RELOCS
7221                       && !info->relocatable
7222                       && !dec_dynrel_count (rel->r_info, sec, info,
7223                                             NULL, h, sym_sec))
7224                     goto error_ret;
7225                 }
7226               else
7227                 {
7228                   /* We need to adjust any reloc offsets to point to the
7229                      new opd entries.  While we're at it, we may as well
7230                      remove redundant relocs.  */
7231                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7232                   if (write_rel != rel)
7233                     memcpy (write_rel, rel, sizeof (*rel));
7234                   ++write_rel;
7235                 }
7236             }
7237
7238           sec->size = wptr - new_contents;
7239           sec->reloc_count = write_rel - relstart;
7240           if (add_aux_fields)
7241             {
7242               free (sec->contents);
7243               sec->contents = new_contents;
7244             }
7245
7246           /* Fudge the header size too, as this is used later in
7247              elf_bfd_final_link if we are emitting relocs.  */
7248           elf_section_data (sec)->rel_hdr.sh_size
7249             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7250           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7251           some_edited = TRUE;
7252         }
7253       else if (elf_section_data (sec)->relocs != relstart)
7254         free (relstart);
7255
7256       if (local_syms != NULL
7257           && symtab_hdr->contents != (unsigned char *) local_syms)
7258         {
7259           if (!info->keep_memory)
7260             free (local_syms);
7261           else
7262             symtab_hdr->contents = (unsigned char *) local_syms;
7263         }
7264     }
7265
7266   if (some_edited)
7267     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7268
7269   /* If we are doing a final link and the last .opd entry is just 16 byte
7270      long, add a 8 byte padding after it.  */
7271   if (need_pad != NULL && !info->relocatable)
7272     {
7273       bfd_byte *p;
7274
7275       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7276         {
7277           BFD_ASSERT (need_pad->size > 0);
7278
7279           p = bfd_malloc (need_pad->size + 8);
7280           if (p == NULL)
7281             return FALSE;
7282
7283           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7284                                           p, 0, need_pad->size))
7285             return FALSE;
7286
7287           need_pad->contents = p;
7288           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7289         }
7290       else
7291         {
7292           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7293           if (p == NULL)
7294             return FALSE;
7295
7296           need_pad->contents = p;
7297         }
7298
7299       memset (need_pad->contents + need_pad->size, 0, 8);
7300       need_pad->size += 8;
7301     }
7302
7303   return TRUE;
7304 }
7305
7306 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7307
7308 asection *
7309 ppc64_elf_tls_setup (struct bfd_link_info *info,
7310                      int no_tls_get_addr_opt,
7311                      int *no_multi_toc)
7312 {
7313   struct ppc_link_hash_table *htab;
7314
7315   htab = ppc_hash_table (info);
7316   if (htab == NULL)
7317     return NULL;
7318
7319   if (*no_multi_toc)
7320     htab->do_multi_toc = 0;
7321   else if (!htab->do_multi_toc)
7322     *no_multi_toc = 1;
7323
7324   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7325                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7326                                               FALSE, FALSE, TRUE));
7327   /* Move dynamic linking info to the function descriptor sym.  */
7328   if (htab->tls_get_addr != NULL)
7329     func_desc_adjust (&htab->tls_get_addr->elf, info);
7330   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7331                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7332                                                  FALSE, FALSE, TRUE));
7333   if (!no_tls_get_addr_opt)
7334     {
7335       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7336
7337       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7338                                   FALSE, FALSE, TRUE);
7339       if (opt != NULL)
7340         func_desc_adjust (opt, info);
7341       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7342                                      FALSE, FALSE, TRUE);
7343       if (opt_fd != NULL
7344           && (opt_fd->root.type == bfd_link_hash_defined
7345               || opt_fd->root.type == bfd_link_hash_defweak))
7346         {
7347           /* If glibc supports an optimized __tls_get_addr call stub,
7348              signalled by the presence of __tls_get_addr_opt, and we'll
7349              be calling __tls_get_addr via a plt call stub, then
7350              make __tls_get_addr point to __tls_get_addr_opt.  */
7351           tga_fd = &htab->tls_get_addr_fd->elf;
7352           if (htab->elf.dynamic_sections_created
7353               && tga_fd != NULL
7354               && (tga_fd->type == STT_FUNC
7355                   || tga_fd->needs_plt)
7356               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7357                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7358                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7359             {
7360               struct plt_entry *ent;
7361
7362               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7363                 if (ent->plt.refcount > 0)
7364                   break;
7365               if (ent != NULL)
7366                 {
7367                   tga_fd->root.type = bfd_link_hash_indirect;
7368                   tga_fd->root.u.i.link = &opt_fd->root;
7369                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7370                   if (opt_fd->dynindx != -1)
7371                     {
7372                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7373                       opt_fd->dynindx = -1;
7374                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7375                                               opt_fd->dynstr_index);
7376                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7377                         return FALSE;
7378                     }
7379                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7380                   tga = &htab->tls_get_addr->elf;
7381                   if (opt != NULL && tga != NULL)
7382                     {
7383                       tga->root.type = bfd_link_hash_indirect;
7384                       tga->root.u.i.link = &opt->root;
7385                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7386                       _bfd_elf_link_hash_hide_symbol (info, opt,
7387                                                       tga->forced_local);
7388                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7389                     }
7390                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7391                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7392                   if (htab->tls_get_addr != NULL)
7393                     {
7394                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7395                       htab->tls_get_addr->is_func = 1;
7396                     }
7397                 }
7398             }
7399         }
7400       else
7401         no_tls_get_addr_opt = TRUE;
7402     }
7403   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7404   return _bfd_elf_tls_setup (info->output_bfd, info);
7405 }
7406
7407 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7408    HASH1 or HASH2.  */
7409
7410 static bfd_boolean
7411 branch_reloc_hash_match (const bfd *ibfd,
7412                          const Elf_Internal_Rela *rel,
7413                          const struct ppc_link_hash_entry *hash1,
7414                          const struct ppc_link_hash_entry *hash2)
7415 {
7416   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7417   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7418   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7419
7420   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7421     {
7422       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7423       struct elf_link_hash_entry *h;
7424
7425       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7426       h = elf_follow_link (h);
7427       if (h == &hash1->elf || h == &hash2->elf)
7428         return TRUE;
7429     }
7430   return FALSE;
7431 }
7432
7433 /* Run through all the TLS relocs looking for optimization
7434    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7435    a preliminary section layout so that we know the TLS segment
7436    offsets.  We can't optimize earlier because some optimizations need
7437    to know the tp offset, and we need to optimize before allocating
7438    dynamic relocations.  */
7439
7440 bfd_boolean
7441 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7442 {
7443   bfd *ibfd;
7444   asection *sec;
7445   struct ppc_link_hash_table *htab;
7446   int pass;
7447
7448   if (info->relocatable || !info->executable)
7449     return TRUE;
7450
7451   htab = ppc_hash_table (info);
7452   if (htab == NULL)
7453     return FALSE;
7454
7455   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7456     {
7457       Elf_Internal_Sym *locsyms = NULL;
7458       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7459       unsigned char *toc_ref = NULL;
7460
7461       /* Look at all the sections for this file.  Make two passes over
7462          the relocs.  On the first pass, mark toc entries involved
7463          with tls relocs, and check that tls relocs involved in
7464          setting up a tls_get_addr call are indeed followed by such a
7465          call.  If they are not, exclude them from the optimizations
7466          done on the second pass.  */
7467       for (pass = 0; pass < 2; ++pass)
7468         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7469           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7470             {
7471               Elf_Internal_Rela *relstart, *rel, *relend;
7472
7473               /* Read the relocations.  */
7474               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7475                                                     info->keep_memory);
7476               if (relstart == NULL)
7477                 return FALSE;
7478
7479               relend = relstart + sec->reloc_count;
7480               for (rel = relstart; rel < relend; rel++)
7481                 {
7482                   enum elf_ppc64_reloc_type r_type;
7483                   unsigned long r_symndx;
7484                   struct elf_link_hash_entry *h;
7485                   Elf_Internal_Sym *sym;
7486                   asection *sym_sec;
7487                   unsigned char *tls_mask;
7488                   unsigned char tls_set, tls_clear, tls_type = 0;
7489                   bfd_vma value;
7490                   bfd_boolean ok_tprel, is_local;
7491                   long toc_ref_index = 0;
7492                   int expecting_tls_get_addr = 0;
7493
7494                   r_symndx = ELF64_R_SYM (rel->r_info);
7495                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7496                                   r_symndx, ibfd))
7497                     {
7498                     err_free_rel:
7499                       if (elf_section_data (sec)->relocs != relstart)
7500                         free (relstart);
7501                       if (toc_ref != NULL)
7502                         free (toc_ref);
7503                       if (locsyms != NULL
7504                           && (elf_symtab_hdr (ibfd).contents
7505                               != (unsigned char *) locsyms))
7506                         free (locsyms);
7507                       return FALSE;
7508                     }
7509
7510                   if (h != NULL)
7511                     {
7512                       if (h->root.type == bfd_link_hash_defined
7513                           || h->root.type == bfd_link_hash_defweak)
7514                         value = h->root.u.def.value;
7515                       else if (h->root.type == bfd_link_hash_undefweak)
7516                         value = 0;
7517                       else
7518                         continue;
7519                     }
7520                   else
7521                     /* Symbols referenced by TLS relocs must be of type
7522                        STT_TLS.  So no need for .opd local sym adjust.  */
7523                     value = sym->st_value;
7524
7525                   ok_tprel = FALSE;
7526                   is_local = FALSE;
7527                   if (h == NULL
7528                       || !h->def_dynamic)
7529                     {
7530                       is_local = TRUE;
7531                       if (h != NULL
7532                           && h->root.type == bfd_link_hash_undefweak)
7533                         ok_tprel = TRUE;
7534                       else
7535                         {
7536                           value += sym_sec->output_offset;
7537                           value += sym_sec->output_section->vma;
7538                           value -= htab->elf.tls_sec->vma;
7539                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7540                                       < (bfd_vma) 1 << 32);
7541                         }
7542                     }
7543
7544                   r_type = ELF64_R_TYPE (rel->r_info);
7545                   switch (r_type)
7546                     {
7547                     case R_PPC64_GOT_TLSLD16:
7548                     case R_PPC64_GOT_TLSLD16_LO:
7549                       expecting_tls_get_addr = 1;
7550                       /* Fall thru */
7551
7552                     case R_PPC64_GOT_TLSLD16_HI:
7553                     case R_PPC64_GOT_TLSLD16_HA:
7554                       /* These relocs should never be against a symbol
7555                          defined in a shared lib.  Leave them alone if
7556                          that turns out to be the case.  */
7557                       if (!is_local)
7558                         continue;
7559
7560                       /* LD -> LE */
7561                       tls_set = 0;
7562                       tls_clear = TLS_LD;
7563                       tls_type = TLS_TLS | TLS_LD;
7564                       break;
7565
7566                     case R_PPC64_GOT_TLSGD16:
7567                     case R_PPC64_GOT_TLSGD16_LO:
7568                       expecting_tls_get_addr = 1;
7569                       /* Fall thru */
7570
7571                     case R_PPC64_GOT_TLSGD16_HI:
7572                     case R_PPC64_GOT_TLSGD16_HA:
7573                       if (ok_tprel)
7574                         /* GD -> LE */
7575                         tls_set = 0;
7576                       else
7577                         /* GD -> IE */
7578                         tls_set = TLS_TLS | TLS_TPRELGD;
7579                       tls_clear = TLS_GD;
7580                       tls_type = TLS_TLS | TLS_GD;
7581                       break;
7582
7583                     case R_PPC64_GOT_TPREL16_DS:
7584                     case R_PPC64_GOT_TPREL16_LO_DS:
7585                     case R_PPC64_GOT_TPREL16_HI:
7586                     case R_PPC64_GOT_TPREL16_HA:
7587                       if (ok_tprel)
7588                         {
7589                           /* IE -> LE */
7590                           tls_set = 0;
7591                           tls_clear = TLS_TPREL;
7592                           tls_type = TLS_TLS | TLS_TPREL;
7593                           break;
7594                         }
7595                       continue;
7596
7597                     case R_PPC64_TOC16:
7598                     case R_PPC64_TOC16_LO:
7599                     case R_PPC64_TLS:
7600                     case R_PPC64_TLSGD:
7601                     case R_PPC64_TLSLD:
7602                       if (sym_sec == NULL || sym_sec != toc)
7603                         continue;
7604
7605                       /* Mark this toc entry as referenced by a TLS
7606                          code sequence.  We can do that now in the
7607                          case of R_PPC64_TLS, and after checking for
7608                          tls_get_addr for the TOC16 relocs.  */
7609                       if (toc_ref == NULL)
7610                         {
7611                           toc_ref = bfd_zmalloc (toc->size / 8);
7612                           if (toc_ref == NULL)
7613                             goto err_free_rel;
7614                         }
7615                       if (h != NULL)
7616                         value = h->root.u.def.value;
7617                       else
7618                         value = sym->st_value;
7619                       value += rel->r_addend;
7620                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7621                       toc_ref_index = value / 8;
7622                       if (r_type == R_PPC64_TLS
7623                           || r_type == R_PPC64_TLSGD
7624                           || r_type == R_PPC64_TLSLD)
7625                         {
7626                           toc_ref[toc_ref_index] = 1;
7627                           continue;
7628                         }
7629
7630                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7631                         continue;
7632
7633                       tls_set = 0;
7634                       tls_clear = 0;
7635                       expecting_tls_get_addr = 2;
7636                       break;
7637
7638                     case R_PPC64_TPREL64:
7639                       if (pass == 0
7640                           || sec != toc
7641                           || toc_ref == NULL
7642                           || !toc_ref[rel->r_offset / 8])
7643                         continue;
7644                       if (ok_tprel)
7645                         {
7646                           /* IE -> LE */
7647                           tls_set = TLS_EXPLICIT;
7648                           tls_clear = TLS_TPREL;
7649                           break;
7650                         }
7651                       continue;
7652
7653                     case R_PPC64_DTPMOD64:
7654                       if (pass == 0
7655                           || sec != toc
7656                           || toc_ref == NULL
7657                           || !toc_ref[rel->r_offset / 8])
7658                         continue;
7659                       if (rel + 1 < relend
7660                           && (rel[1].r_info
7661                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7662                           && rel[1].r_offset == rel->r_offset + 8)
7663                         {
7664                           if (ok_tprel)
7665                             /* GD -> LE */
7666                             tls_set = TLS_EXPLICIT | TLS_GD;
7667                           else
7668                             /* GD -> IE */
7669                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7670                           tls_clear = TLS_GD;
7671                         }
7672                       else
7673                         {
7674                           if (!is_local)
7675                             continue;
7676
7677                           /* LD -> LE */
7678                           tls_set = TLS_EXPLICIT;
7679                           tls_clear = TLS_LD;
7680                         }
7681                       break;
7682
7683                     default:
7684                       continue;
7685                     }
7686
7687                   if (pass == 0)
7688                     {
7689                       if (!expecting_tls_get_addr
7690                           || !sec->has_tls_get_addr_call)
7691                         continue;
7692
7693                       if (rel + 1 < relend
7694                           && branch_reloc_hash_match (ibfd, rel + 1,
7695                                                       htab->tls_get_addr,
7696                                                       htab->tls_get_addr_fd))
7697                         {
7698                           if (expecting_tls_get_addr == 2)
7699                             {
7700                               /* Check for toc tls entries.  */
7701                               unsigned char *toc_tls;
7702                               int retval;
7703
7704                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7705                                                      &locsyms,
7706                                                      rel, ibfd);
7707                               if (retval == 0)
7708                                 goto err_free_rel;
7709                               if (retval > 1 && toc_tls != NULL)
7710                                 toc_ref[toc_ref_index] = 1;
7711                             }
7712                           continue;
7713                         }
7714
7715                       if (expecting_tls_get_addr != 1)
7716                         continue;
7717
7718                       /* Uh oh, we didn't find the expected call.  We
7719                          could just mark this symbol to exclude it
7720                          from tls optimization but it's safer to skip
7721                          the entire section.  */
7722                       sec->has_tls_reloc = 0;
7723                       break;
7724                     }
7725
7726                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7727                     {
7728                       struct plt_entry *ent;
7729                       for (ent = htab->tls_get_addr->elf.plt.plist;
7730                            ent != NULL;
7731                            ent = ent->next)
7732                         if (ent->addend == 0)
7733                           {
7734                             if (ent->plt.refcount > 0)
7735                               {
7736                                 ent->plt.refcount -= 1;
7737                                 expecting_tls_get_addr = 0;
7738                               }
7739                             break;
7740                           }
7741                     }
7742
7743                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7744                     {
7745                       struct plt_entry *ent;
7746                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7747                            ent != NULL;
7748                            ent = ent->next)
7749                         if (ent->addend == 0)
7750                           {
7751                             if (ent->plt.refcount > 0)
7752                               ent->plt.refcount -= 1;
7753                             break;
7754                           }
7755                     }
7756
7757                   if (tls_clear == 0)
7758                     continue;
7759
7760                   if ((tls_set & TLS_EXPLICIT) == 0)
7761                     {
7762                       struct got_entry *ent;
7763
7764                       /* Adjust got entry for this reloc.  */
7765                       if (h != NULL)
7766                         ent = h->got.glist;
7767                       else
7768                         ent = elf_local_got_ents (ibfd)[r_symndx];
7769
7770                       for (; ent != NULL; ent = ent->next)
7771                         if (ent->addend == rel->r_addend
7772                             && ent->owner == ibfd
7773                             && ent->tls_type == tls_type)
7774                           break;
7775                       if (ent == NULL)
7776                         abort ();
7777
7778                       if (tls_set == 0)
7779                         {
7780                           /* We managed to get rid of a got entry.  */
7781                           if (ent->got.refcount > 0)
7782                             ent->got.refcount -= 1;
7783                         }
7784                     }
7785                   else
7786                     {
7787                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7788                          we'll lose one or two dyn relocs.  */
7789                       if (!dec_dynrel_count (rel->r_info, sec, info,
7790                                              NULL, h, sym_sec))
7791                         return FALSE;
7792
7793                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7794                         {
7795                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7796                                                  NULL, h, sym_sec))
7797                             return FALSE;
7798                         }
7799                     }
7800
7801                   *tls_mask |= tls_set;
7802                   *tls_mask &= ~tls_clear;
7803                 }
7804
7805               if (elf_section_data (sec)->relocs != relstart)
7806                 free (relstart);
7807             }
7808
7809       if (toc_ref != NULL)
7810         free (toc_ref);
7811
7812       if (locsyms != NULL
7813           && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7814         {
7815           if (!info->keep_memory)
7816             free (locsyms);
7817           else
7818             elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7819         }
7820     }
7821   return TRUE;
7822 }
7823
7824 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7825    the values of any global symbols in a toc section that has been
7826    edited.  Globals in toc sections should be a rarity, so this function
7827    sets a flag if any are found in toc sections other than the one just
7828    edited, so that futher hash table traversals can be avoided.  */
7829
7830 struct adjust_toc_info
7831 {
7832   asection *toc;
7833   unsigned long *skip;
7834   bfd_boolean global_toc_syms;
7835 };
7836
7837 static bfd_boolean
7838 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7839 {
7840   struct ppc_link_hash_entry *eh;
7841   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7842
7843   if (h->root.type == bfd_link_hash_indirect)
7844     return TRUE;
7845
7846   if (h->root.type == bfd_link_hash_warning)
7847     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7848
7849   if (h->root.type != bfd_link_hash_defined
7850       && h->root.type != bfd_link_hash_defweak)
7851     return TRUE;
7852
7853   eh = (struct ppc_link_hash_entry *) h;
7854   if (eh->adjust_done)
7855     return TRUE;
7856
7857   if (eh->elf.root.u.def.section == toc_inf->toc)
7858     {
7859       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7860       if (skip != (unsigned long) -1)
7861         eh->elf.root.u.def.value -= skip;
7862       else
7863         {
7864           (*_bfd_error_handler)
7865             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7866           eh->elf.root.u.def.section = &bfd_abs_section;
7867           eh->elf.root.u.def.value = 0;
7868         }
7869       eh->adjust_done = 1;
7870     }
7871   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7872     toc_inf->global_toc_syms = TRUE;
7873
7874   return TRUE;
7875 }
7876
7877 /* Examine all relocs referencing .toc sections in order to remove
7878    unused .toc entries.  */
7879
7880 bfd_boolean
7881 ppc64_elf_edit_toc (struct bfd_link_info *info)
7882 {
7883   bfd *ibfd;
7884   struct adjust_toc_info toc_inf;
7885
7886   toc_inf.global_toc_syms = TRUE;
7887   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7888     {
7889       asection *toc, *sec;
7890       Elf_Internal_Shdr *symtab_hdr;
7891       Elf_Internal_Sym *local_syms;
7892       struct elf_link_hash_entry **sym_hashes;
7893       Elf_Internal_Rela *relstart, *rel;
7894       unsigned long *skip, *drop;
7895       unsigned char *used;
7896       unsigned char *keep, last, some_unused;
7897
7898       toc = bfd_get_section_by_name (ibfd, ".toc");
7899       if (toc == NULL
7900           || toc->size == 0
7901           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7902           || elf_discarded_section (toc))
7903         continue;
7904
7905       local_syms = NULL;
7906       symtab_hdr = &elf_symtab_hdr (ibfd);
7907       sym_hashes = elf_sym_hashes (ibfd);
7908
7909       /* Look at sections dropped from the final link.  */
7910       skip = NULL;
7911       relstart = NULL;
7912       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7913         {
7914           if (sec->reloc_count == 0
7915               || !elf_discarded_section (sec)
7916               || get_opd_info (sec)
7917               || (sec->flags & SEC_ALLOC) == 0
7918               || (sec->flags & SEC_DEBUGGING) != 0)
7919             continue;
7920
7921           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7922           if (relstart == NULL)
7923             goto error_ret;
7924
7925           /* Run through the relocs to see which toc entries might be
7926              unused.  */
7927           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7928             {
7929               enum elf_ppc64_reloc_type r_type;
7930               unsigned long r_symndx;
7931               asection *sym_sec;
7932               struct elf_link_hash_entry *h;
7933               Elf_Internal_Sym *sym;
7934               bfd_vma val;
7935
7936               r_type = ELF64_R_TYPE (rel->r_info);
7937               switch (r_type)
7938                 {
7939                 default:
7940                   continue;
7941
7942                 case R_PPC64_TOC16:
7943                 case R_PPC64_TOC16_LO:
7944                 case R_PPC64_TOC16_HI:
7945                 case R_PPC64_TOC16_HA:
7946                 case R_PPC64_TOC16_DS:
7947                 case R_PPC64_TOC16_LO_DS:
7948                   break;
7949                 }
7950
7951               r_symndx = ELF64_R_SYM (rel->r_info);
7952               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7953                               r_symndx, ibfd))
7954                 goto error_ret;
7955
7956               if (sym_sec != toc)
7957                 continue;
7958
7959               if (h != NULL)
7960                 val = h->root.u.def.value;
7961               else
7962                 val = sym->st_value;
7963               val += rel->r_addend;
7964
7965               if (val >= toc->size)
7966                 continue;
7967
7968               /* Anything in the toc ought to be aligned to 8 bytes.
7969                  If not, don't mark as unused.  */
7970               if (val & 7)
7971                 continue;
7972
7973               if (skip == NULL)
7974                 {
7975                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7976                   if (skip == NULL)
7977                     goto error_ret;
7978                 }
7979
7980               skip[val >> 3] = 1;
7981             }
7982
7983           if (elf_section_data (sec)->relocs != relstart)
7984             free (relstart);
7985         }
7986
7987       if (skip == NULL)
7988         continue;
7989
7990       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7991       if (used == NULL)
7992         {
7993         error_ret:
7994           if (local_syms != NULL
7995               && symtab_hdr->contents != (unsigned char *) local_syms)
7996             free (local_syms);
7997           if (sec != NULL
7998               && relstart != NULL
7999               && elf_section_data (sec)->relocs != relstart)
8000             free (relstart);
8001           if (skip != NULL)
8002             free (skip);
8003           return FALSE;
8004         }
8005
8006       /* Now check all kept sections that might reference the toc.
8007          Check the toc itself last.  */
8008       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8009                   : ibfd->sections);
8010            sec != NULL;
8011            sec = (sec == toc ? NULL
8012                   : sec->next == NULL ? toc
8013                   : sec->next == toc && toc->next ? toc->next
8014                   : sec->next))
8015         {
8016           int repeat;
8017
8018           if (sec->reloc_count == 0
8019               || elf_discarded_section (sec)
8020               || get_opd_info (sec)
8021               || (sec->flags & SEC_ALLOC) == 0
8022               || (sec->flags & SEC_DEBUGGING) != 0)
8023             continue;
8024
8025           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
8026           if (relstart == NULL)
8027             goto error_ret;
8028
8029           /* Mark toc entries referenced as used.  */
8030           repeat = 0;
8031           do
8032             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8033               {
8034                 enum elf_ppc64_reloc_type r_type;
8035                 unsigned long r_symndx;
8036                 asection *sym_sec;
8037                 struct elf_link_hash_entry *h;
8038                 Elf_Internal_Sym *sym;
8039                 bfd_vma val;
8040
8041                 r_type = ELF64_R_TYPE (rel->r_info);
8042                 switch (r_type)
8043                   {
8044                   case R_PPC64_TOC16:
8045                   case R_PPC64_TOC16_LO:
8046                   case R_PPC64_TOC16_HI:
8047                   case R_PPC64_TOC16_HA:
8048                   case R_PPC64_TOC16_DS:
8049                   case R_PPC64_TOC16_LO_DS:
8050                     /* In case we're taking addresses of toc entries.  */
8051                   case R_PPC64_ADDR64:
8052                     break;
8053
8054                   default:
8055                     continue;
8056                   }
8057
8058                 r_symndx = ELF64_R_SYM (rel->r_info);
8059                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8060                                 r_symndx, ibfd))
8061                   {
8062                     free (used);
8063                     goto error_ret;
8064                   }
8065
8066                 if (sym_sec != toc)
8067                   continue;
8068
8069                 if (h != NULL)
8070                   val = h->root.u.def.value;
8071                 else
8072                   val = sym->st_value;
8073                 val += rel->r_addend;
8074
8075                 if (val >= toc->size)
8076                   continue;
8077
8078                 /* For the toc section, we only mark as used if
8079                    this entry itself isn't unused.  */
8080                 if (sec == toc
8081                     && !used[val >> 3]
8082                     && (used[rel->r_offset >> 3]
8083                         || !skip[rel->r_offset >> 3]))
8084                   /* Do all the relocs again, to catch reference
8085                      chains.  */
8086                   repeat = 1;
8087
8088                 used[val >> 3] = 1;
8089               }
8090           while (repeat);
8091         }
8092
8093       /* Merge the used and skip arrays.  Assume that TOC
8094          doublewords not appearing as either used or unused belong
8095          to to an entry more than one doubleword in size.  */
8096       for (drop = skip, keep = used, last = 0, some_unused = 0;
8097            drop < skip + (toc->size + 7) / 8;
8098            ++drop, ++keep)
8099         {
8100           if (*keep)
8101             {
8102               *drop = 0;
8103               last = 0;
8104             }
8105           else if (*drop)
8106             {
8107               some_unused = 1;
8108               last = 1;
8109             }
8110           else
8111             *drop = last;
8112         }
8113
8114       free (used);
8115
8116       if (some_unused)
8117         {
8118           bfd_byte *contents, *src;
8119           unsigned long off;
8120
8121           /* Shuffle the toc contents, and at the same time convert the
8122              skip array from booleans into offsets.  */
8123           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8124             goto error_ret;
8125
8126           elf_section_data (toc)->this_hdr.contents = contents;
8127
8128           for (src = contents, off = 0, drop = skip;
8129                src < contents + toc->size;
8130                src += 8, ++drop)
8131             {
8132               if (*drop)
8133                 {
8134                   *drop = (unsigned long) -1;
8135                   off += 8;
8136                 }
8137               else if (off != 0)
8138                 {
8139                   *drop = off;
8140                   memcpy (src - off, src, 8);
8141                 }
8142             }
8143           toc->rawsize = toc->size;
8144           toc->size = src - contents - off;
8145
8146           if (toc->reloc_count != 0)
8147             {
8148               Elf_Internal_Rela *wrel;
8149               bfd_size_type sz;
8150
8151               /* Read toc relocs.  */
8152               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8153                                                     TRUE);
8154               if (relstart == NULL)
8155                 goto error_ret;
8156
8157               /* Remove unused toc relocs, and adjust those we keep.  */
8158               wrel = relstart;
8159               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8160                 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
8161                   {
8162                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8163                     wrel->r_info = rel->r_info;
8164                     wrel->r_addend = rel->r_addend;
8165                     ++wrel;
8166                   }
8167                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8168                                             &local_syms, NULL, NULL))
8169                   goto error_ret;
8170
8171               toc->reloc_count = wrel - relstart;
8172               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
8173               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
8174               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
8175             }
8176
8177           /* Adjust addends for relocs against the toc section sym.  */
8178           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8179             {
8180               if (sec->reloc_count == 0
8181                   || elf_discarded_section (sec))
8182                 continue;
8183
8184               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8185                                                     TRUE);
8186               if (relstart == NULL)
8187                 goto error_ret;
8188
8189               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8190                 {
8191                   enum elf_ppc64_reloc_type r_type;
8192                   unsigned long r_symndx;
8193                   asection *sym_sec;
8194                   struct elf_link_hash_entry *h;
8195                   Elf_Internal_Sym *sym;
8196
8197                   r_type = ELF64_R_TYPE (rel->r_info);
8198                   switch (r_type)
8199                     {
8200                     default:
8201                       continue;
8202
8203                     case R_PPC64_TOC16:
8204                     case R_PPC64_TOC16_LO:
8205                     case R_PPC64_TOC16_HI:
8206                     case R_PPC64_TOC16_HA:
8207                     case R_PPC64_TOC16_DS:
8208                     case R_PPC64_TOC16_LO_DS:
8209                     case R_PPC64_ADDR64:
8210                       break;
8211                     }
8212
8213                   r_symndx = ELF64_R_SYM (rel->r_info);
8214                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8215                                   r_symndx, ibfd))
8216                     goto error_ret;
8217
8218                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
8219                     continue;
8220
8221                   rel->r_addend -= skip[rel->r_addend >> 3];
8222                 }
8223             }
8224
8225           /* We shouldn't have local or global symbols defined in the TOC,
8226              but handle them anyway.  */
8227           if (local_syms != NULL)
8228             {
8229               Elf_Internal_Sym *sym;
8230
8231               for (sym = local_syms;
8232                    sym < local_syms + symtab_hdr->sh_info;
8233                    ++sym)
8234                 if (sym->st_value != 0
8235                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8236                   {
8237                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
8238                       sym->st_value -= skip[sym->st_value >> 3];
8239                     else
8240                       {
8241                         (*_bfd_error_handler)
8242                           (_("%s defined in removed toc entry"),
8243                            bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8244                                              NULL));
8245                         sym->st_value = 0;
8246                         sym->st_shndx = SHN_ABS;
8247                       }
8248                     symtab_hdr->contents = (unsigned char *) local_syms;
8249                   }
8250             }
8251
8252           /* Finally, adjust any global syms defined in the toc.  */
8253           if (toc_inf.global_toc_syms)
8254             {
8255               toc_inf.toc = toc;
8256               toc_inf.skip = skip;
8257               toc_inf.global_toc_syms = FALSE;
8258               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8259                                       &toc_inf);
8260             }
8261         }
8262
8263       if (local_syms != NULL
8264           && symtab_hdr->contents != (unsigned char *) local_syms)
8265         {
8266           if (!info->keep_memory)
8267             free (local_syms);
8268           else
8269             symtab_hdr->contents = (unsigned char *) local_syms;
8270         }
8271       free (skip);
8272     }
8273
8274   return TRUE;
8275 }
8276
8277 /* Return true iff input section I references the TOC using
8278    instructions limited to +/-32k offsets.  */
8279
8280 bfd_boolean
8281 ppc64_elf_has_small_toc_reloc (asection *i)
8282 {
8283   return (is_ppc64_elf (i->owner)
8284           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8285 }
8286
8287 /* Allocate space for one GOT entry.  */
8288
8289 static void
8290 allocate_got (struct elf_link_hash_entry *h,
8291               struct bfd_link_info *info,
8292               struct got_entry *gent)
8293 {
8294   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8295   bfd_boolean dyn;
8296   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8297   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8298                  ? 16 : 8);
8299   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8300                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8301   asection *got = ppc64_elf_tdata (gent->owner)->got;
8302
8303   gent->got.offset = got->size;
8304   got->size += entsize;
8305
8306   dyn = htab->elf.dynamic_sections_created;
8307   if ((info->shared
8308        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8309             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8310                 || h->root.type != bfd_link_hash_undefweak))
8311     {
8312       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8313       relgot->size += rentsize;
8314     }
8315   else if (h->type == STT_GNU_IFUNC)
8316     {
8317       asection *relgot = htab->reliplt;
8318       relgot->size += rentsize;
8319       htab->got_reli_size += rentsize;
8320     }
8321 }
8322
8323 /* This function merges got entries in the same toc group.  */
8324
8325 static void
8326 merge_got_entries (struct got_entry **pent)
8327 {
8328   struct got_entry *ent, *ent2;
8329
8330   for (ent = *pent; ent != NULL; ent = ent->next)
8331     if (!ent->is_indirect)
8332       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8333         if (!ent2->is_indirect
8334             && ent2->addend == ent->addend
8335             && ent2->tls_type == ent->tls_type
8336             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8337           {
8338             ent2->is_indirect = TRUE;
8339             ent2->got.ent = ent;
8340           }
8341 }
8342
8343 /* Allocate space in .plt, .got and associated reloc sections for
8344    dynamic relocs.  */
8345
8346 static bfd_boolean
8347 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8348 {
8349   struct bfd_link_info *info;
8350   struct ppc_link_hash_table *htab;
8351   asection *s;
8352   struct ppc_link_hash_entry *eh;
8353   struct ppc_dyn_relocs *p;
8354   struct got_entry **pgent, *gent;
8355
8356   if (h->root.type == bfd_link_hash_indirect)
8357     return TRUE;
8358
8359   if (h->root.type == bfd_link_hash_warning)
8360     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8361
8362   info = (struct bfd_link_info *) inf;
8363   htab = ppc_hash_table (info);
8364   if (htab == NULL)
8365     return FALSE;
8366
8367   if ((htab->elf.dynamic_sections_created
8368        && h->dynindx != -1
8369        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8370       || h->type == STT_GNU_IFUNC)
8371     {
8372       struct plt_entry *pent;
8373       bfd_boolean doneone = FALSE;
8374       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8375         if (pent->plt.refcount > 0)
8376           {
8377             if (!htab->elf.dynamic_sections_created
8378                 || h->dynindx == -1)
8379               {
8380                 s = htab->iplt;
8381                 pent->plt.offset = s->size;
8382                 s->size += PLT_ENTRY_SIZE;
8383                 s = htab->reliplt;
8384               }
8385             else
8386               {
8387                 /* If this is the first .plt entry, make room for the special
8388                    first entry.  */
8389                 s = htab->plt;
8390                 if (s->size == 0)
8391                   s->size += PLT_INITIAL_ENTRY_SIZE;
8392
8393                 pent->plt.offset = s->size;
8394
8395                 /* Make room for this entry.  */
8396                 s->size += PLT_ENTRY_SIZE;
8397
8398                 /* Make room for the .glink code.  */
8399                 s = htab->glink;
8400                 if (s->size == 0)
8401                   s->size += GLINK_CALL_STUB_SIZE;
8402                 /* We need bigger stubs past index 32767.  */
8403                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8404                   s->size += 4;
8405                 s->size += 2*4;
8406
8407                 /* We also need to make an entry in the .rela.plt section.  */
8408                 s = htab->relplt;
8409               }
8410             s->size += sizeof (Elf64_External_Rela);
8411             doneone = TRUE;
8412           }
8413         else
8414           pent->plt.offset = (bfd_vma) -1;
8415       if (!doneone)
8416         {
8417           h->plt.plist = NULL;
8418           h->needs_plt = 0;
8419         }
8420     }
8421   else
8422     {
8423       h->plt.plist = NULL;
8424       h->needs_plt = 0;
8425     }
8426
8427   eh = (struct ppc_link_hash_entry *) h;
8428   /* Run through the TLS GD got entries first if we're changing them
8429      to TPREL.  */
8430   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8431     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8432       if (gent->got.refcount > 0
8433           && (gent->tls_type & TLS_GD) != 0)
8434         {
8435           /* This was a GD entry that has been converted to TPREL.  If
8436              there happens to be a TPREL entry we can use that one.  */
8437           struct got_entry *ent;
8438           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8439             if (ent->got.refcount > 0
8440                 && (ent->tls_type & TLS_TPREL) != 0
8441                 && ent->addend == gent->addend
8442                 && ent->owner == gent->owner)
8443               {
8444                 gent->got.refcount = 0;
8445                 break;
8446               }
8447
8448           /* If not, then we'll be using our own TPREL entry.  */
8449           if (gent->got.refcount != 0)
8450             gent->tls_type = TLS_TLS | TLS_TPREL;
8451         }
8452
8453   /* Remove any list entry that won't generate a word in the GOT before
8454      we call merge_got_entries.  Otherwise we risk merging to empty
8455      entries.  */
8456   pgent = &h->got.glist;
8457   while ((gent = *pgent) != NULL)
8458     if (gent->got.refcount > 0)
8459       {
8460         if ((gent->tls_type & TLS_LD) != 0
8461             && !h->def_dynamic)
8462           {
8463             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8464             *pgent = gent->next;
8465           }
8466         else
8467           pgent = &gent->next;
8468       }
8469     else
8470       *pgent = gent->next;
8471
8472   if (!htab->do_multi_toc)
8473     merge_got_entries (&h->got.glist);
8474
8475   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8476     if (!gent->is_indirect)
8477       {
8478         /* Make sure this symbol is output as a dynamic symbol.
8479            Undefined weak syms won't yet be marked as dynamic,
8480            nor will all TLS symbols.  */
8481         if (h->dynindx == -1
8482             && !h->forced_local
8483             && h->type != STT_GNU_IFUNC
8484             && htab->elf.dynamic_sections_created)
8485           {
8486             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8487               return FALSE;
8488           }
8489
8490         if (!is_ppc64_elf (gent->owner))
8491           abort ();
8492
8493         allocate_got (h, info, gent);
8494       }
8495
8496   if (eh->dyn_relocs == NULL
8497       || (!htab->elf.dynamic_sections_created
8498           && h->type != STT_GNU_IFUNC))
8499     return TRUE;
8500
8501   /* In the shared -Bsymbolic case, discard space allocated for
8502      dynamic pc-relative relocs against symbols which turn out to be
8503      defined in regular objects.  For the normal shared case, discard
8504      space for relocs that have become local due to symbol visibility
8505      changes.  */
8506
8507   if (info->shared)
8508     {
8509       /* Relocs that use pc_count are those that appear on a call insn,
8510          or certain REL relocs (see must_be_dyn_reloc) that can be
8511          generated via assembly.  We want calls to protected symbols to
8512          resolve directly to the function rather than going via the plt.
8513          If people want function pointer comparisons to work as expected
8514          then they should avoid writing weird assembly.  */
8515       if (SYMBOL_CALLS_LOCAL (info, h))
8516         {
8517           struct ppc_dyn_relocs **pp;
8518
8519           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8520             {
8521               p->count -= p->pc_count;
8522               p->pc_count = 0;
8523               if (p->count == 0)
8524                 *pp = p->next;
8525               else
8526                 pp = &p->next;
8527             }
8528         }
8529
8530       /* Also discard relocs on undefined weak syms with non-default
8531          visibility.  */
8532       if (eh->dyn_relocs != NULL
8533           && h->root.type == bfd_link_hash_undefweak)
8534         {
8535           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8536             eh->dyn_relocs = NULL;
8537
8538           /* Make sure this symbol is output as a dynamic symbol.
8539              Undefined weak syms won't yet be marked as dynamic.  */
8540           else if (h->dynindx == -1
8541                    && !h->forced_local)
8542             {
8543               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8544                 return FALSE;
8545             }
8546         }
8547     }
8548   else if (h->type == STT_GNU_IFUNC)
8549     {
8550       if (!h->non_got_ref)
8551         eh->dyn_relocs = NULL;
8552     }
8553   else if (ELIMINATE_COPY_RELOCS)
8554     {
8555       /* For the non-shared case, discard space for relocs against
8556          symbols which turn out to need copy relocs or are not
8557          dynamic.  */
8558
8559       if (!h->non_got_ref
8560           && !h->def_regular)
8561         {
8562           /* Make sure this symbol is output as a dynamic symbol.
8563              Undefined weak syms won't yet be marked as dynamic.  */
8564           if (h->dynindx == -1
8565               && !h->forced_local)
8566             {
8567               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8568                 return FALSE;
8569             }
8570
8571           /* If that succeeded, we know we'll be keeping all the
8572              relocs.  */
8573           if (h->dynindx != -1)
8574             goto keep;
8575         }
8576
8577       eh->dyn_relocs = NULL;
8578
8579     keep: ;
8580     }
8581
8582   /* Finally, allocate space.  */
8583   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8584     {
8585       asection *sreloc = elf_section_data (p->sec)->sreloc;
8586       if (!htab->elf.dynamic_sections_created)
8587         sreloc = htab->reliplt;
8588       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8589     }
8590
8591   return TRUE;
8592 }
8593
8594 /* Find any dynamic relocs that apply to read-only sections.  */
8595
8596 static bfd_boolean
8597 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8598 {
8599   struct ppc_link_hash_entry *eh;
8600   struct ppc_dyn_relocs *p;
8601
8602   if (h->root.type == bfd_link_hash_warning)
8603     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8604
8605   eh = (struct ppc_link_hash_entry *) h;
8606   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8607     {
8608       asection *s = p->sec->output_section;
8609
8610       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8611         {
8612           struct bfd_link_info *info = inf;
8613
8614           info->flags |= DF_TEXTREL;
8615
8616           /* Not an error, just cut short the traversal.  */
8617           return FALSE;
8618         }
8619     }
8620   return TRUE;
8621 }
8622
8623 /* Set the sizes of the dynamic sections.  */
8624
8625 static bfd_boolean
8626 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8627                                  struct bfd_link_info *info)
8628 {
8629   struct ppc_link_hash_table *htab;
8630   bfd *dynobj;
8631   asection *s;
8632   bfd_boolean relocs;
8633   bfd *ibfd;
8634   struct got_entry *first_tlsld;
8635
8636   htab = ppc_hash_table (info);
8637   if (htab == NULL)
8638     return FALSE;
8639
8640   dynobj = htab->elf.dynobj;
8641   if (dynobj == NULL)
8642     abort ();
8643
8644   if (htab->elf.dynamic_sections_created)
8645     {
8646       /* Set the contents of the .interp section to the interpreter.  */
8647       if (info->executable)
8648         {
8649           s = bfd_get_section_by_name (dynobj, ".interp");
8650           if (s == NULL)
8651             abort ();
8652           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8653           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8654         }
8655     }
8656
8657   /* Set up .got offsets for local syms, and space for local dynamic
8658      relocs.  */
8659   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8660     {
8661       struct got_entry **lgot_ents;
8662       struct got_entry **end_lgot_ents;
8663       struct plt_entry **local_plt;
8664       struct plt_entry **end_local_plt;
8665       unsigned char *lgot_masks;
8666       bfd_size_type locsymcount;
8667       Elf_Internal_Shdr *symtab_hdr;
8668       asection *srel;
8669
8670       if (!is_ppc64_elf (ibfd))
8671         continue;
8672
8673       for (s = ibfd->sections; s != NULL; s = s->next)
8674         {
8675           struct ppc_dyn_relocs *p;
8676
8677           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8678             {
8679               if (!bfd_is_abs_section (p->sec)
8680                   && bfd_is_abs_section (p->sec->output_section))
8681                 {
8682                   /* Input section has been discarded, either because
8683                      it is a copy of a linkonce section or due to
8684                      linker script /DISCARD/, so we'll be discarding
8685                      the relocs too.  */
8686                 }
8687               else if (p->count != 0)
8688                 {
8689                   srel = elf_section_data (p->sec)->sreloc;
8690                   if (!htab->elf.dynamic_sections_created)
8691                     srel = htab->reliplt;
8692                   srel->size += p->count * sizeof (Elf64_External_Rela);
8693                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8694                     info->flags |= DF_TEXTREL;
8695                 }
8696             }
8697         }
8698
8699       lgot_ents = elf_local_got_ents (ibfd);
8700       if (!lgot_ents)
8701         continue;
8702
8703       symtab_hdr = &elf_symtab_hdr (ibfd);
8704       locsymcount = symtab_hdr->sh_info;
8705       end_lgot_ents = lgot_ents + locsymcount;
8706       local_plt = (struct plt_entry **) end_lgot_ents;
8707       end_local_plt = local_plt + locsymcount;
8708       lgot_masks = (unsigned char *) end_local_plt;
8709       s = ppc64_elf_tdata (ibfd)->got;
8710       srel = ppc64_elf_tdata (ibfd)->relgot;
8711       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8712         {
8713           struct got_entry **pent, *ent;
8714
8715           pent = lgot_ents;
8716           while ((ent = *pent) != NULL)
8717             if (ent->got.refcount > 0)
8718               {
8719                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8720                   {
8721                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
8722                     *pent = ent->next;
8723                   }
8724                 else
8725                   {
8726                     unsigned int num = 1;
8727                     ent->got.offset = s->size;
8728                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8729                       num = 2;
8730                     s->size += num * 8;
8731                     if (info->shared)
8732                       srel->size += num * sizeof (Elf64_External_Rela);
8733                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8734                       {
8735                         htab->reliplt->size
8736                           += num * sizeof (Elf64_External_Rela);
8737                         htab->got_reli_size
8738                           += num * sizeof (Elf64_External_Rela);
8739                       }
8740                     pent = &ent->next;
8741                   }
8742               }
8743             else
8744               *pent = ent->next;
8745         }
8746
8747       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8748       for (; local_plt < end_local_plt; ++local_plt)
8749         {
8750           struct plt_entry *ent;
8751
8752           for (ent = *local_plt; ent != NULL; ent = ent->next)
8753             if (ent->plt.refcount > 0)
8754               {
8755                 s = htab->iplt;
8756                 ent->plt.offset = s->size;
8757                 s->size += PLT_ENTRY_SIZE;
8758
8759                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8760               }
8761             else
8762               ent->plt.offset = (bfd_vma) -1;
8763         }
8764     }
8765
8766   /* Allocate global sym .plt and .got entries, and space for global
8767      sym dynamic relocs.  */
8768   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8769
8770   first_tlsld = NULL;
8771   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8772     {
8773       struct got_entry *ent;
8774
8775       if (!is_ppc64_elf (ibfd))
8776         continue;
8777
8778       ent = ppc64_tlsld_got (ibfd);
8779       if (ent->got.refcount > 0)
8780         {
8781           if (!htab->do_multi_toc && first_tlsld != NULL)
8782             {
8783               ent->is_indirect = TRUE;
8784               ent->got.ent = first_tlsld;
8785             }
8786           else
8787             {
8788               if (first_tlsld == NULL)
8789                 first_tlsld = ent;
8790               s = ppc64_elf_tdata (ibfd)->got;
8791               ent->got.offset = s->size;
8792               ent->owner = ibfd;
8793               s->size += 16;
8794               if (info->shared)
8795                 {
8796                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8797                   srel->size += sizeof (Elf64_External_Rela);
8798                 }
8799             }
8800         }
8801       else
8802         ent->got.offset = (bfd_vma) -1;
8803     }
8804
8805   /* We now have determined the sizes of the various dynamic sections.
8806      Allocate memory for them.  */
8807   relocs = FALSE;
8808   for (s = dynobj->sections; s != NULL; s = s->next)
8809     {
8810       if ((s->flags & SEC_LINKER_CREATED) == 0)
8811         continue;
8812
8813       if (s == htab->brlt || s == htab->relbrlt)
8814         /* These haven't been allocated yet;  don't strip.  */
8815         continue;
8816       else if (s == htab->got
8817                || s == htab->plt
8818                || s == htab->iplt
8819                || s == htab->glink
8820                || s == htab->dynbss)
8821         {
8822           /* Strip this section if we don't need it; see the
8823              comment below.  */
8824         }
8825       else if (CONST_STRNEQ (s->name, ".rela"))
8826         {
8827           if (s->size != 0)
8828             {
8829               if (s != htab->relplt)
8830                 relocs = TRUE;
8831
8832               /* We use the reloc_count field as a counter if we need
8833                  to copy relocs into the output file.  */
8834               s->reloc_count = 0;
8835             }
8836         }
8837       else
8838         {
8839           /* It's not one of our sections, so don't allocate space.  */
8840           continue;
8841         }
8842
8843       if (s->size == 0)
8844         {
8845           /* If we don't need this section, strip it from the
8846              output file.  This is mostly to handle .rela.bss and
8847              .rela.plt.  We must create both sections in
8848              create_dynamic_sections, because they must be created
8849              before the linker maps input sections to output
8850              sections.  The linker does that before
8851              adjust_dynamic_symbol is called, and it is that
8852              function which decides whether anything needs to go
8853              into these sections.  */
8854           s->flags |= SEC_EXCLUDE;
8855           continue;
8856         }
8857
8858       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8859         continue;
8860
8861       /* Allocate memory for the section contents.  We use bfd_zalloc
8862          here in case unused entries are not reclaimed before the
8863          section's contents are written out.  This should not happen,
8864          but this way if it does we get a R_PPC64_NONE reloc in .rela
8865          sections instead of garbage.
8866          We also rely on the section contents being zero when writing
8867          the GOT.  */
8868       s->contents = bfd_zalloc (dynobj, s->size);
8869       if (s->contents == NULL)
8870         return FALSE;
8871     }
8872
8873   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8874     {
8875       if (!is_ppc64_elf (ibfd))
8876         continue;
8877
8878       s = ppc64_elf_tdata (ibfd)->got;
8879       if (s != NULL && s != htab->got)
8880         {
8881           if (s->size == 0)
8882             s->flags |= SEC_EXCLUDE;
8883           else
8884             {
8885               s->contents = bfd_zalloc (ibfd, s->size);
8886               if (s->contents == NULL)
8887                 return FALSE;
8888             }
8889         }
8890       s = ppc64_elf_tdata (ibfd)->relgot;
8891       if (s != NULL)
8892         {
8893           if (s->size == 0)
8894             s->flags |= SEC_EXCLUDE;
8895           else
8896             {
8897               s->contents = bfd_zalloc (ibfd, s->size);
8898               if (s->contents == NULL)
8899                 return FALSE;
8900               relocs = TRUE;
8901               s->reloc_count = 0;
8902             }
8903         }
8904     }
8905
8906   if (htab->elf.dynamic_sections_created)
8907     {
8908       /* Add some entries to the .dynamic section.  We fill in the
8909          values later, in ppc64_elf_finish_dynamic_sections, but we
8910          must add the entries now so that we get the correct size for
8911          the .dynamic section.  The DT_DEBUG entry is filled in by the
8912          dynamic linker and used by the debugger.  */
8913 #define add_dynamic_entry(TAG, VAL) \
8914   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8915
8916       if (info->executable)
8917         {
8918           if (!add_dynamic_entry (DT_DEBUG, 0))
8919             return FALSE;
8920         }
8921
8922       if (htab->plt != NULL && htab->plt->size != 0)
8923         {
8924           if (!add_dynamic_entry (DT_PLTGOT, 0)
8925               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8926               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8927               || !add_dynamic_entry (DT_JMPREL, 0)
8928               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8929             return FALSE;
8930         }
8931
8932       if (NO_OPD_RELOCS)
8933         {
8934           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8935               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8936             return FALSE;
8937         }
8938
8939       if (!htab->no_tls_get_addr_opt
8940           && htab->tls_get_addr_fd != NULL
8941           && htab->tls_get_addr_fd->elf.plt.plist != NULL
8942           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
8943         return FALSE;
8944
8945       if (relocs)
8946         {
8947           if (!add_dynamic_entry (DT_RELA, 0)
8948               || !add_dynamic_entry (DT_RELASZ, 0)
8949               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8950             return FALSE;
8951
8952           /* If any dynamic relocs apply to a read-only section,
8953              then we need a DT_TEXTREL entry.  */
8954           if ((info->flags & DF_TEXTREL) == 0)
8955             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8956
8957           if ((info->flags & DF_TEXTREL) != 0)
8958             {
8959               if (!add_dynamic_entry (DT_TEXTREL, 0))
8960                 return FALSE;
8961             }
8962         }
8963     }
8964 #undef add_dynamic_entry
8965
8966   return TRUE;
8967 }
8968
8969 /* Determine the type of stub needed, if any, for a call.  */
8970
8971 static inline enum ppc_stub_type
8972 ppc_type_of_stub (asection *input_sec,
8973                   const Elf_Internal_Rela *rel,
8974                   struct ppc_link_hash_entry **hash,
8975                   struct plt_entry **plt_ent,
8976                   bfd_vma destination)
8977 {
8978   struct ppc_link_hash_entry *h = *hash;
8979   bfd_vma location;
8980   bfd_vma branch_offset;
8981   bfd_vma max_branch_offset;
8982   enum elf_ppc64_reloc_type r_type;
8983
8984   if (h != NULL)
8985     {
8986       struct plt_entry *ent;
8987       struct ppc_link_hash_entry *fdh = h;
8988       if (h->oh != NULL
8989           && h->oh->is_func_descriptor)
8990         {
8991           fdh = ppc_follow_link (h->oh);
8992           *hash = fdh;
8993         }
8994
8995       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8996         if (ent->addend == rel->r_addend
8997             && ent->plt.offset != (bfd_vma) -1)
8998           {
8999             *plt_ent = ent;
9000             return ppc_stub_plt_call;
9001           }
9002
9003       /* Here, we know we don't have a plt entry.  If we don't have a
9004          either a defined function descriptor or a defined entry symbol
9005          in a regular object file, then it is pointless trying to make
9006          any other type of stub.  */
9007       if (!((fdh->elf.root.type == bfd_link_hash_defined
9008             || fdh->elf.root.type == bfd_link_hash_defweak)
9009             && fdh->elf.root.u.def.section->output_section != NULL)
9010           && !((h->elf.root.type == bfd_link_hash_defined
9011                 || h->elf.root.type == bfd_link_hash_defweak)
9012                && h->elf.root.u.def.section->output_section != NULL))
9013         return ppc_stub_none;
9014     }
9015   else if (elf_local_got_ents (input_sec->owner) != NULL)
9016     {
9017       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9018       struct plt_entry **local_plt = (struct plt_entry **)
9019         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9020       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9021
9022       if (local_plt[r_symndx] != NULL)
9023         {
9024           struct plt_entry *ent;
9025
9026           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9027             if (ent->addend == rel->r_addend
9028                 && ent->plt.offset != (bfd_vma) -1)
9029               {
9030                 *plt_ent = ent;
9031                 return ppc_stub_plt_call;
9032               }
9033         }
9034     }
9035
9036   /* Determine where the call point is.  */
9037   location = (input_sec->output_offset
9038               + input_sec->output_section->vma
9039               + rel->r_offset);
9040
9041   branch_offset = destination - location;
9042   r_type = ELF64_R_TYPE (rel->r_info);
9043
9044   /* Determine if a long branch stub is needed.  */
9045   max_branch_offset = 1 << 25;
9046   if (r_type != R_PPC64_REL24)
9047     max_branch_offset = 1 << 15;
9048
9049   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9050     /* We need a stub.  Figure out whether a long_branch or plt_branch
9051        is needed later.  */
9052     return ppc_stub_long_branch;
9053
9054   return ppc_stub_none;
9055 }
9056
9057 /* Build a .plt call stub.  */
9058
9059 static inline bfd_byte *
9060 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
9061 {
9062 #define PPC_LO(v) ((v) & 0xffff)
9063 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9064 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9065
9066   if (PPC_HA (offset) != 0)
9067     {
9068       if (r != NULL)
9069         {
9070           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9071           r[1].r_offset = r[0].r_offset + 8;
9072           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9073           r[1].r_addend = r[0].r_addend;
9074           if (PPC_HA (offset + 16) != PPC_HA (offset))
9075             {
9076               r[2].r_offset = r[1].r_offset + 4;
9077               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9078               r[2].r_addend = r[0].r_addend;
9079             }
9080           else
9081             {
9082               r[2].r_offset = r[1].r_offset + 8;
9083               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9084               r[2].r_addend = r[0].r_addend + 8;
9085               r[3].r_offset = r[2].r_offset + 4;
9086               r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9087               r[3].r_addend = r[0].r_addend + 16;
9088             }
9089         }
9090       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9091       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9092       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9093       if (PPC_HA (offset + 16) != PPC_HA (offset))
9094         {
9095           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9096           offset = 0;
9097         }
9098       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9099       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9100       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9101       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9102     }
9103   else
9104     {
9105       if (r != NULL)
9106         {
9107           r[0].r_offset += 4;
9108           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9109           if (PPC_HA (offset + 16) != PPC_HA (offset))
9110             {
9111               r[1].r_offset = r[0].r_offset + 4;
9112               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9113               r[1].r_addend = r[0].r_addend;
9114             }
9115           else
9116             {
9117               r[1].r_offset = r[0].r_offset + 8;
9118               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9119               r[1].r_addend = r[0].r_addend + 16;
9120               r[2].r_offset = r[1].r_offset + 4;
9121               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9122               r[2].r_addend = r[0].r_addend + 8;
9123             }
9124         }
9125       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9126       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9127       if (PPC_HA (offset + 16) != PPC_HA (offset))
9128         {
9129           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9130           offset = 0;
9131         }
9132       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9133       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
9134       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9135       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9136     }
9137   return p;
9138 }
9139
9140 /* Build a special .plt call stub for __tls_get_addr.  */
9141
9142 #define LD_R11_0R3      0xe9630000
9143 #define LD_R12_0R3      0xe9830000
9144 #define MR_R0_R3        0x7c601b78
9145 #define CMPDI_R11_0     0x2c2b0000
9146 #define ADD_R3_R12_R13  0x7c6c6a14
9147 #define BEQLR           0x4d820020
9148 #define MR_R3_R0        0x7c030378
9149 #define MFLR_R11        0x7d6802a6
9150 #define STD_R11_0R1     0xf9610000
9151 #define BCTRL           0x4e800421
9152 #define LD_R11_0R1      0xe9610000
9153 #define LD_R2_0R1       0xe8410000
9154 #define MTLR_R11        0x7d6803a6
9155
9156 static inline bfd_byte *
9157 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9158                          Elf_Internal_Rela *r)
9159 {
9160   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9161   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9162   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9163   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9164   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9165   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9166   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9167   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9168   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9169
9170   if (r != NULL)
9171     r[0].r_offset += 9 * 4;
9172   p = build_plt_stub (obfd, p, offset, r);
9173   bfd_put_32 (obfd, BCTRL, p - 4);
9174
9175   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9176   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9177   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9178   bfd_put_32 (obfd, BLR, p),                    p += 4;
9179
9180   return p;
9181 }
9182
9183 static Elf_Internal_Rela *
9184 get_relocs (asection *sec, int count)
9185 {
9186   Elf_Internal_Rela *relocs;
9187   struct bfd_elf_section_data *elfsec_data;
9188
9189   elfsec_data = elf_section_data (sec);
9190   relocs = elfsec_data->relocs;
9191   if (relocs == NULL)
9192     {
9193       bfd_size_type relsize;
9194       relsize = sec->reloc_count * sizeof (*relocs);
9195       relocs = bfd_alloc (sec->owner, relsize);
9196       if (relocs == NULL)
9197         return NULL;
9198       elfsec_data->relocs = relocs;
9199       elfsec_data->rel_hdr.sh_size = (sec->reloc_count
9200                                       * sizeof (Elf64_External_Rela));
9201       elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
9202       sec->reloc_count = 0;
9203     }
9204   relocs += sec->reloc_count;
9205   sec->reloc_count += count;
9206   return relocs;
9207 }
9208
9209 static bfd_boolean
9210 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9211 {
9212   struct ppc_stub_hash_entry *stub_entry;
9213   struct ppc_branch_hash_entry *br_entry;
9214   struct bfd_link_info *info;
9215   struct ppc_link_hash_table *htab;
9216   bfd_byte *loc;
9217   bfd_byte *p;
9218   bfd_vma dest, off;
9219   int size;
9220   Elf_Internal_Rela *r;
9221   asection *plt;
9222
9223   /* Massage our args to the form they really have.  */
9224   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9225   info = in_arg;
9226
9227   htab = ppc_hash_table (info);
9228   if (htab == NULL)
9229     return FALSE;
9230
9231   /* Make a note of the offset within the stubs for this entry.  */
9232   stub_entry->stub_offset = stub_entry->stub_sec->size;
9233   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9234
9235   htab->stub_count[stub_entry->stub_type - 1] += 1;
9236   switch (stub_entry->stub_type)
9237     {
9238     case ppc_stub_long_branch:
9239     case ppc_stub_long_branch_r2off:
9240       /* Branches are relative.  This is where we are going to.  */
9241       off = dest = (stub_entry->target_value
9242                     + stub_entry->target_section->output_offset
9243                     + stub_entry->target_section->output_section->vma);
9244
9245       /* And this is where we are coming from.  */
9246       off -= (stub_entry->stub_offset
9247               + stub_entry->stub_sec->output_offset
9248               + stub_entry->stub_sec->output_section->vma);
9249
9250       size = 4;
9251       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9252         {
9253           bfd_vma r2off;
9254
9255           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9256                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9257           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9258           loc += 4;
9259           size = 12;
9260           if (PPC_HA (r2off) != 0)
9261             {
9262               size = 16;
9263               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9264               loc += 4;
9265             }
9266           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9267           loc += 4;
9268           off -= size - 4;
9269         }
9270       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9271
9272       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9273         {
9274           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9275                                  stub_entry->root.string);
9276           htab->stub_error = TRUE;
9277           return FALSE;
9278         }
9279
9280       if (info->emitrelocations)
9281         {
9282           r = get_relocs (stub_entry->stub_sec, 1);
9283           if (r == NULL)
9284             return FALSE;
9285           r->r_offset = loc - stub_entry->stub_sec->contents;
9286           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9287           r->r_addend = dest;
9288           if (stub_entry->h != NULL)
9289             {
9290               struct elf_link_hash_entry **hashes;
9291               unsigned long symndx;
9292               struct ppc_link_hash_entry *h;
9293
9294               hashes = elf_sym_hashes (htab->stub_bfd);
9295               if (hashes == NULL)
9296                 {
9297                   bfd_size_type hsize;
9298
9299                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9300                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9301                   if (hashes == NULL)
9302                     return FALSE;
9303                   elf_sym_hashes (htab->stub_bfd) = hashes;
9304                   htab->stub_globals = 1;
9305                 }
9306               symndx = htab->stub_globals++;
9307               h = stub_entry->h;
9308               hashes[symndx] = &h->elf;
9309               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9310               if (h->oh != NULL && h->oh->is_func)
9311                 h = ppc_follow_link (h->oh);
9312               if (h->elf.root.u.def.section != stub_entry->target_section)
9313                 /* H is an opd symbol.  The addend must be zero.  */
9314                 r->r_addend = 0;
9315               else
9316                 {
9317                   off = (h->elf.root.u.def.value
9318                          + h->elf.root.u.def.section->output_offset
9319                          + h->elf.root.u.def.section->output_section->vma);
9320                   r->r_addend -= off;
9321                 }
9322             }
9323         }
9324       break;
9325
9326     case ppc_stub_plt_branch:
9327     case ppc_stub_plt_branch_r2off:
9328       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9329                                          stub_entry->root.string + 9,
9330                                          FALSE, FALSE);
9331       if (br_entry == NULL)
9332         {
9333           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9334                                  stub_entry->root.string);
9335           htab->stub_error = TRUE;
9336           return FALSE;
9337         }
9338
9339       dest = (stub_entry->target_value
9340               + stub_entry->target_section->output_offset
9341               + stub_entry->target_section->output_section->vma);
9342
9343       bfd_put_64 (htab->brlt->owner, dest,
9344                   htab->brlt->contents + br_entry->offset);
9345
9346       if (br_entry->iter == htab->stub_iteration)
9347         {
9348           br_entry->iter = 0;
9349
9350           if (htab->relbrlt != NULL)
9351             {
9352               /* Create a reloc for the branch lookup table entry.  */
9353               Elf_Internal_Rela rela;
9354               bfd_byte *rl;
9355
9356               rela.r_offset = (br_entry->offset
9357                                + htab->brlt->output_offset
9358                                + htab->brlt->output_section->vma);
9359               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9360               rela.r_addend = dest;
9361
9362               rl = htab->relbrlt->contents;
9363               rl += (htab->relbrlt->reloc_count++
9364                      * sizeof (Elf64_External_Rela));
9365               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9366             }
9367           else if (info->emitrelocations)
9368             {
9369               r = get_relocs (htab->brlt, 1);
9370               if (r == NULL)
9371                 return FALSE;
9372               /* brlt, being SEC_LINKER_CREATED does not go through the
9373                  normal reloc processing.  Symbols and offsets are not
9374                  translated from input file to output file form, so
9375                  set up the offset per the output file.  */
9376               r->r_offset = (br_entry->offset
9377                              + htab->brlt->output_offset
9378                              + htab->brlt->output_section->vma);
9379               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9380               r->r_addend = dest;
9381             }
9382         }
9383
9384       dest = (br_entry->offset
9385               + htab->brlt->output_offset
9386               + htab->brlt->output_section->vma);
9387
9388       off = (dest
9389              - elf_gp (htab->brlt->output_section->owner)
9390              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9391
9392       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9393         {
9394           (*_bfd_error_handler)
9395             (_("linkage table error against `%s'"),
9396              stub_entry->root.string);
9397           bfd_set_error (bfd_error_bad_value);
9398           htab->stub_error = TRUE;
9399           return FALSE;
9400         }
9401
9402       if (info->emitrelocations)
9403         {
9404           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9405           if (r == NULL)
9406             return FALSE;
9407           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9408           if (bfd_big_endian (info->output_bfd))
9409             r[0].r_offset += 2;
9410           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9411             r[0].r_offset += 4;
9412           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9413           r[0].r_addend = dest;
9414           if (PPC_HA (off) != 0)
9415             {
9416               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9417               r[1].r_offset = r[0].r_offset + 4;
9418               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9419               r[1].r_addend = r[0].r_addend;
9420             }
9421         }
9422
9423       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9424         {
9425           if (PPC_HA (off) != 0)
9426             {
9427               size = 16;
9428               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9429               loc += 4;
9430               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9431             }
9432           else
9433             {
9434               size = 12;
9435               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9436             }
9437         }
9438       else
9439         {
9440           bfd_vma r2off;
9441
9442           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9443                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9444           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9445           loc += 4;
9446           size = 20;
9447           if (PPC_HA (off) != 0)
9448             {
9449               size += 4;
9450               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9451               loc += 4;
9452               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9453               loc += 4;
9454             }
9455           else
9456             {
9457               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9458               loc += 4;
9459             }
9460
9461           if (PPC_HA (r2off) != 0)
9462             {
9463               size += 4;
9464               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9465               loc += 4;
9466             }
9467           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9468         }
9469       loc += 4;
9470       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9471       loc += 4;
9472       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9473       break;
9474
9475     case ppc_stub_plt_call:
9476       if (stub_entry->h != NULL
9477           && stub_entry->h->is_func_descriptor
9478           && stub_entry->h->oh != NULL)
9479         {
9480           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9481
9482           /* If the old-ABI "dot-symbol" is undefined make it weak so
9483              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9484              FIXME: We used to define the symbol on one of the call
9485              stubs instead, which is why we test symbol section id
9486              against htab->top_id in various places.  Likely all
9487              these checks could now disappear.  */
9488           if (fh->elf.root.type == bfd_link_hash_undefined)
9489             fh->elf.root.type = bfd_link_hash_undefweak;
9490         }
9491
9492       /* Now build the stub.  */
9493       dest = stub_entry->plt_ent->plt.offset & ~1;
9494       if (dest >= (bfd_vma) -2)
9495         abort ();
9496
9497       plt = htab->plt;
9498       if (!htab->elf.dynamic_sections_created
9499           || stub_entry->h == NULL
9500           || stub_entry->h->elf.dynindx == -1)
9501         plt = htab->iplt;
9502
9503       dest += plt->output_offset + plt->output_section->vma;
9504
9505       if (stub_entry->h == NULL
9506           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9507         {
9508           Elf_Internal_Rela rela;
9509           bfd_byte *rl;
9510
9511           rela.r_offset = dest;
9512           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9513           rela.r_addend = (stub_entry->target_value
9514                            + stub_entry->target_section->output_offset
9515                            + stub_entry->target_section->output_section->vma);
9516
9517           rl = (htab->reliplt->contents
9518                 + (htab->reliplt->reloc_count++
9519                    * sizeof (Elf64_External_Rela)));
9520           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9521           stub_entry->plt_ent->plt.offset |= 1;
9522         }
9523
9524       off = (dest
9525              - elf_gp (plt->output_section->owner)
9526              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9527
9528       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9529         {
9530           (*_bfd_error_handler)
9531             (_("linkage table error against `%s'"),
9532              stub_entry->h != NULL
9533              ? stub_entry->h->elf.root.root.string
9534              : "<local sym>");
9535           bfd_set_error (bfd_error_bad_value);
9536           htab->stub_error = TRUE;
9537           return FALSE;
9538         }
9539
9540       r = NULL;
9541       if (info->emitrelocations)
9542         {
9543           r = get_relocs (stub_entry->stub_sec,
9544                           (2 + (PPC_HA (off) != 0)
9545                            + (PPC_HA (off + 16) == PPC_HA (off))));
9546           if (r == NULL)
9547             return FALSE;
9548           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9549           if (bfd_big_endian (info->output_bfd))
9550             r[0].r_offset += 2;
9551           r[0].r_addend = dest;
9552         }
9553       if (stub_entry->h != NULL
9554           && (stub_entry->h == htab->tls_get_addr_fd
9555               || stub_entry->h == htab->tls_get_addr)
9556           && !htab->no_tls_get_addr_opt)
9557         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9558       else
9559         p = build_plt_stub (htab->stub_bfd, loc, off, r);
9560       size = p - loc;
9561       break;
9562
9563     default:
9564       BFD_FAIL ();
9565       return FALSE;
9566     }
9567
9568   stub_entry->stub_sec->size += size;
9569
9570   if (htab->emit_stub_syms)
9571     {
9572       struct elf_link_hash_entry *h;
9573       size_t len1, len2;
9574       char *name;
9575       const char *const stub_str[] = { "long_branch",
9576                                        "long_branch_r2off",
9577                                        "plt_branch",
9578                                        "plt_branch_r2off",
9579                                        "plt_call" };
9580
9581       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9582       len2 = strlen (stub_entry->root.string);
9583       name = bfd_malloc (len1 + len2 + 2);
9584       if (name == NULL)
9585         return FALSE;
9586       memcpy (name, stub_entry->root.string, 9);
9587       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9588       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9589       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9590       if (h == NULL)
9591         return FALSE;
9592       if (h->root.type == bfd_link_hash_new)
9593         {
9594           h->root.type = bfd_link_hash_defined;
9595           h->root.u.def.section = stub_entry->stub_sec;
9596           h->root.u.def.value = stub_entry->stub_offset;
9597           h->ref_regular = 1;
9598           h->def_regular = 1;
9599           h->ref_regular_nonweak = 1;
9600           h->forced_local = 1;
9601           h->non_elf = 0;
9602         }
9603     }
9604
9605   return TRUE;
9606 }
9607
9608 /* As above, but don't actually build the stub.  Just bump offset so
9609    we know stub section sizes, and select plt_branch stubs where
9610    long_branch stubs won't do.  */
9611
9612 static bfd_boolean
9613 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9614 {
9615   struct ppc_stub_hash_entry *stub_entry;
9616   struct bfd_link_info *info;
9617   struct ppc_link_hash_table *htab;
9618   bfd_vma off;
9619   int size;
9620
9621   /* Massage our args to the form they really have.  */
9622   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9623   info = in_arg;
9624
9625   htab = ppc_hash_table (info);
9626   if (htab == NULL)
9627     return FALSE;
9628
9629   if (stub_entry->stub_type == ppc_stub_plt_call)
9630     {
9631       asection *plt;
9632       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9633       if (off >= (bfd_vma) -2)
9634         abort ();
9635       plt = htab->plt;
9636       if (!htab->elf.dynamic_sections_created
9637           || stub_entry->h == NULL
9638           || stub_entry->h->elf.dynindx == -1)
9639         plt = htab->iplt;
9640       off += (plt->output_offset
9641               + plt->output_section->vma
9642               - elf_gp (plt->output_section->owner)
9643               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9644
9645       size = PLT_CALL_STUB_SIZE;
9646       if (PPC_HA (off) == 0)
9647         size -= 4;
9648       if (PPC_HA (off + 16) != PPC_HA (off))
9649         size += 4;
9650       if (stub_entry->h != NULL
9651           && (stub_entry->h == htab->tls_get_addr_fd
9652               || stub_entry->h == htab->tls_get_addr)
9653           && !htab->no_tls_get_addr_opt)
9654         size += 13 * 4;
9655       if (info->emitrelocations)
9656         {
9657           stub_entry->stub_sec->reloc_count
9658             += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9659           stub_entry->stub_sec->flags |= SEC_RELOC;
9660         }
9661     }
9662   else
9663     {
9664       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9665          variants.  */
9666       bfd_vma r2off = 0;
9667
9668       off = (stub_entry->target_value
9669              + stub_entry->target_section->output_offset
9670              + stub_entry->target_section->output_section->vma);
9671       off -= (stub_entry->stub_sec->size
9672               + stub_entry->stub_sec->output_offset
9673               + stub_entry->stub_sec->output_section->vma);
9674
9675       /* Reset the stub type from the plt variant in case we now
9676          can reach with a shorter stub.  */
9677       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9678         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9679
9680       size = 4;
9681       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9682         {
9683           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9684                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9685           size = 12;
9686           if (PPC_HA (r2off) != 0)
9687             size = 16;
9688           off -= size - 4;
9689         }
9690
9691       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9692       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9693         {
9694           struct ppc_branch_hash_entry *br_entry;
9695
9696           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9697                                              stub_entry->root.string + 9,
9698                                              TRUE, FALSE);
9699           if (br_entry == NULL)
9700             {
9701               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9702                                      stub_entry->root.string);
9703               htab->stub_error = TRUE;
9704               return FALSE;
9705             }
9706
9707           if (br_entry->iter != htab->stub_iteration)
9708             {
9709               br_entry->iter = htab->stub_iteration;
9710               br_entry->offset = htab->brlt->size;
9711               htab->brlt->size += 8;
9712
9713               if (htab->relbrlt != NULL)
9714                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9715               else if (info->emitrelocations)
9716                 {
9717                   htab->brlt->reloc_count += 1;
9718                   htab->brlt->flags |= SEC_RELOC;
9719                 }
9720             }
9721
9722           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9723           off = (br_entry->offset
9724                  + htab->brlt->output_offset
9725                  + htab->brlt->output_section->vma
9726                  - elf_gp (htab->brlt->output_section->owner)
9727                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
9728
9729           if (info->emitrelocations)
9730             {
9731               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9732               stub_entry->stub_sec->flags |= SEC_RELOC;
9733             }
9734
9735           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9736             {
9737               size = 12;
9738               if (PPC_HA (off) != 0)
9739                 size = 16;
9740             }
9741           else
9742             {
9743               size = 20;
9744               if (PPC_HA (off) != 0)
9745                 size += 4;
9746
9747               if (PPC_HA (r2off) != 0)
9748                 size += 4;
9749             }
9750         }
9751       else if (info->emitrelocations)
9752         {
9753           stub_entry->stub_sec->reloc_count += 1;
9754           stub_entry->stub_sec->flags |= SEC_RELOC;
9755         }
9756     }
9757
9758   stub_entry->stub_sec->size += size;
9759   return TRUE;
9760 }
9761
9762 /* Set up various things so that we can make a list of input sections
9763    for each output section included in the link.  Returns -1 on error,
9764    0 when no stubs will be needed, and 1 on success.  */
9765
9766 int
9767 ppc64_elf_setup_section_lists
9768   (struct bfd_link_info *info,
9769    asection *(*add_stub_section) (const char *, asection *),
9770    void (*layout_sections_again) (void))
9771 {
9772   bfd *input_bfd;
9773   int top_id, top_index, id;
9774   asection *section;
9775   asection **input_list;
9776   bfd_size_type amt;
9777   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9778
9779   if (htab == NULL)
9780     return -1;
9781   /* Stash our params away.  */
9782   htab->add_stub_section = add_stub_section;
9783   htab->layout_sections_again = layout_sections_again;
9784
9785   if (htab->brlt == NULL)
9786     return 0;
9787
9788   /* Find the top input section id.  */
9789   for (input_bfd = info->input_bfds, top_id = 3;
9790        input_bfd != NULL;
9791        input_bfd = input_bfd->link_next)
9792     {
9793       for (section = input_bfd->sections;
9794            section != NULL;
9795            section = section->next)
9796         {
9797           if (top_id < section->id)
9798             top_id = section->id;
9799         }
9800     }
9801
9802   htab->top_id = top_id;
9803   amt = sizeof (struct map_stub) * (top_id + 1);
9804   htab->stub_group = bfd_zmalloc (amt);
9805   if (htab->stub_group == NULL)
9806     return -1;
9807
9808   /* Set toc_off for com, und, abs and ind sections.  */
9809   for (id = 0; id < 3; id++)
9810     htab->stub_group[id].toc_off = TOC_BASE_OFF;
9811
9812   /* We can't use output_bfd->section_count here to find the top output
9813      section index as some sections may have been removed, and
9814      strip_excluded_output_sections doesn't renumber the indices.  */
9815   for (section = info->output_bfd->sections, top_index = 0;
9816        section != NULL;
9817        section = section->next)
9818     {
9819       if (top_index < section->index)
9820         top_index = section->index;
9821     }
9822
9823   htab->top_index = top_index;
9824   amt = sizeof (asection *) * (top_index + 1);
9825   input_list = bfd_zmalloc (amt);
9826   htab->input_list = input_list;
9827   if (input_list == NULL)
9828     return -1;
9829
9830   return 1;
9831 }
9832
9833 /* Set up for first pass at multitoc partitioning.  */
9834
9835 void
9836 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
9837 {
9838   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9839
9840   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
9841   htab->toc_curr = elf_gp (info->output_bfd);
9842   htab->toc_bfd = NULL;
9843   htab->toc_first_sec = NULL;
9844 }
9845
9846 /* The linker repeatedly calls this function for each TOC input section
9847    and linker generated GOT section.  Group input bfds such that the toc
9848    within a group is less than 64k in size.  */
9849
9850 bfd_boolean
9851 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9852 {
9853   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9854   bfd_vma addr, off, limit;
9855
9856   if (htab == NULL)
9857     return FALSE;
9858
9859   if (!htab->second_toc_pass)
9860     {
9861       /* Keep track of the first .toc or .got section for this input bfd.  */
9862       if (htab->toc_bfd != isec->owner)
9863         {
9864           htab->toc_bfd = isec->owner;
9865           htab->toc_first_sec = isec;
9866         }
9867
9868       addr = isec->output_offset + isec->output_section->vma;
9869       off = addr - htab->toc_curr;
9870       limit = 0x80008000;
9871       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
9872         limit = 0x10000;
9873       if (off + isec->size > limit)
9874         {
9875           addr = (htab->toc_first_sec->output_offset
9876                   + htab->toc_first_sec->output_section->vma);
9877           htab->toc_curr = addr;
9878         }
9879
9880       /* toc_curr is the base address of this toc group.  Set elf_gp
9881          for the input section to be the offset relative to the
9882          output toc base plus 0x8000.  Making the input elf_gp an
9883          offset allows us to move the toc as a whole without
9884          recalculating input elf_gp.  */
9885       off = htab->toc_curr - elf_gp (isec->output_section->owner);
9886       off += TOC_BASE_OFF;
9887
9888       /* Die if someone uses a linker script that doesn't keep input
9889          file .toc and .got together.  */
9890       if (elf_gp (isec->owner) != 0
9891           && elf_gp (isec->owner) != off)
9892         return FALSE;
9893
9894       elf_gp (isec->owner) = off;
9895       return TRUE;
9896     }
9897
9898   /* During the second pass toc_first_sec points to the start of
9899      a toc group, and toc_curr is used to track the old elf_gp.
9900      We use toc_bfd to ensure we only look at each bfd once.  */
9901   if (htab->toc_bfd == isec->owner)
9902     return TRUE;
9903   htab->toc_bfd = isec->owner;
9904
9905   if (htab->toc_first_sec == NULL
9906       || htab->toc_curr != elf_gp (isec->owner))
9907     {
9908       htab->toc_curr = elf_gp (isec->owner);
9909       htab->toc_first_sec = isec;
9910     }
9911   addr = (htab->toc_first_sec->output_offset
9912           + htab->toc_first_sec->output_section->vma);
9913   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
9914   elf_gp (isec->owner) = off;
9915
9916   return TRUE;
9917 }
9918
9919 /* Called via elf_link_hash_traverse to merge GOT entries for global
9920    symbol H.  */
9921
9922 static bfd_boolean
9923 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9924 {
9925   if (h->root.type == bfd_link_hash_indirect)
9926     return TRUE;
9927
9928   if (h->root.type == bfd_link_hash_warning)
9929     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9930
9931   merge_got_entries (&h->got.glist);
9932
9933   return TRUE;
9934 }
9935
9936 /* Called via elf_link_hash_traverse to allocate GOT entries for global
9937    symbol H.  */
9938
9939 static bfd_boolean
9940 reallocate_got (struct elf_link_hash_entry *h, void *inf)
9941 {
9942   struct got_entry *gent;
9943
9944   if (h->root.type == bfd_link_hash_indirect)
9945     return TRUE;
9946
9947   if (h->root.type == bfd_link_hash_warning)
9948     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9949
9950   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9951     if (!gent->is_indirect)
9952       allocate_got (h, (struct bfd_link_info *) inf, gent);
9953   return TRUE;
9954 }
9955
9956 /* Called on the first multitoc pass after the last call to
9957    ppc64_elf_next_toc_section.  This function removes duplicate GOT
9958    entries.  */
9959
9960 bfd_boolean
9961 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
9962 {
9963   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9964   struct bfd *ibfd, *ibfd2;
9965   bfd_boolean done_something;
9966
9967   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
9968
9969   if (!htab->do_multi_toc)
9970     return FALSE;
9971
9972   /* Merge global sym got entries within a toc group.  */
9973   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
9974
9975   /* And tlsld_got.  */
9976   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9977     {
9978       struct got_entry *ent, *ent2;
9979
9980       if (!is_ppc64_elf (ibfd))
9981         continue;
9982
9983       ent = ppc64_tlsld_got (ibfd);
9984       if (!ent->is_indirect
9985           && ent->got.offset != (bfd_vma) -1)
9986         {
9987           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
9988             {
9989               if (!is_ppc64_elf (ibfd2))
9990                 continue;
9991
9992               ent2 = ppc64_tlsld_got (ibfd2);
9993               if (!ent2->is_indirect
9994                   && ent2->got.offset != (bfd_vma) -1
9995                   && elf_gp (ibfd2) == elf_gp (ibfd))
9996                 {
9997                   ent2->is_indirect = TRUE;
9998                   ent2->got.ent = ent;
9999                 }
10000             }
10001         }
10002     }
10003
10004   /* Zap sizes of got sections.  */
10005   htab->reliplt->rawsize = htab->reliplt->size;
10006   htab->reliplt->size -= htab->got_reli_size;
10007   htab->got_reli_size = 0;
10008
10009   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10010     {
10011       asection *got, *relgot;
10012
10013       if (!is_ppc64_elf (ibfd))
10014         continue;
10015
10016       got = ppc64_elf_tdata (ibfd)->got;
10017       if (got != NULL)
10018         {
10019           got->rawsize = got->size;
10020           got->size = 0;
10021           relgot = ppc64_elf_tdata (ibfd)->relgot;
10022           relgot->rawsize = relgot->size;
10023           relgot->size = 0;
10024         }
10025     }
10026
10027   /* Now reallocate the got, local syms first.  We don't need to
10028      allocate section contents again since we never increase size.  */
10029   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10030     {
10031       struct got_entry **lgot_ents;
10032       struct got_entry **end_lgot_ents;
10033       struct plt_entry **local_plt;
10034       struct plt_entry **end_local_plt;
10035       unsigned char *lgot_masks;
10036       bfd_size_type locsymcount;
10037       Elf_Internal_Shdr *symtab_hdr;
10038       asection *s, *srel;
10039
10040       if (!is_ppc64_elf (ibfd))
10041         continue;
10042
10043       lgot_ents = elf_local_got_ents (ibfd);
10044       if (!lgot_ents)
10045         continue;
10046
10047       symtab_hdr = &elf_symtab_hdr (ibfd);
10048       locsymcount = symtab_hdr->sh_info;
10049       end_lgot_ents = lgot_ents + locsymcount;
10050       local_plt = (struct plt_entry **) end_lgot_ents;
10051       end_local_plt = local_plt + locsymcount;
10052       lgot_masks = (unsigned char *) end_local_plt;
10053       s = ppc64_elf_tdata (ibfd)->got;
10054       srel = ppc64_elf_tdata (ibfd)->relgot;
10055       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10056         {
10057           struct got_entry *ent;
10058
10059           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10060             {
10061               unsigned int num = 1;
10062               ent->got.offset = s->size;
10063               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10064                 num = 2;
10065               s->size += num * 8;
10066               if (info->shared)
10067                 srel->size += num * sizeof (Elf64_External_Rela);
10068               else if ((*lgot_masks & PLT_IFUNC) != 0)
10069                 {
10070                   htab->reliplt->size
10071                     += num * sizeof (Elf64_External_Rela);
10072                   htab->got_reli_size
10073                     += num * sizeof (Elf64_External_Rela);
10074                 }
10075             }
10076         }
10077     }
10078
10079   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10080
10081   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10082     {
10083       struct got_entry *ent;
10084
10085       if (!is_ppc64_elf (ibfd))
10086         continue;
10087
10088       ent = ppc64_tlsld_got (ibfd);
10089       if (!ent->is_indirect
10090           && ent->got.offset != (bfd_vma) -1)
10091         {
10092           asection *s = ppc64_elf_tdata (ibfd)->got;
10093           ent->got.offset = s->size;
10094           s->size += 16;
10095           if (info->shared)
10096             {
10097               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10098               srel->size += sizeof (Elf64_External_Rela);
10099             }
10100         }
10101     }
10102
10103   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10104   if (!done_something)
10105     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10106       {
10107         asection *got;
10108
10109         if (!is_ppc64_elf (ibfd))
10110           continue;
10111
10112         got = ppc64_elf_tdata (ibfd)->got;
10113         if (got != NULL)
10114           {
10115             done_something = got->rawsize != got->size;
10116             if (done_something)
10117               break;
10118           }
10119       }
10120
10121   if (done_something)
10122     (*htab->layout_sections_again) ();
10123
10124   /* Set up for second pass over toc sections to recalculate elf_gp
10125      on input sections.  */
10126   htab->toc_bfd = NULL;
10127   htab->toc_first_sec = NULL;
10128   htab->second_toc_pass = TRUE;
10129   return done_something;
10130 }
10131
10132 /* Called after second pass of multitoc partitioning.  */
10133
10134 void
10135 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10136 {
10137   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10138
10139   /* After the second pass, toc_curr tracks the TOC offset used
10140      for code sections below in ppc64_elf_next_input_section.  */
10141   htab->toc_curr = TOC_BASE_OFF;
10142 }
10143
10144 /* No toc references were found in ISEC.  If the code in ISEC makes no
10145    calls, then there's no need to use toc adjusting stubs when branching
10146    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10147    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10148    needed, and 2 if a cyclical call-graph was found but no other reason
10149    for a stub was detected.  If called from the top level, a return of
10150    2 means the same as a return of 0.  */
10151
10152 static int
10153 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10154 {
10155   int ret;
10156
10157   /* Mark this section as checked.  */
10158   isec->call_check_done = 1;
10159
10160   /* We know none of our code bearing sections will need toc stubs.  */
10161   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10162     return 0;
10163
10164   if (isec->size == 0)
10165     return 0;
10166
10167   if (isec->output_section == NULL)
10168     return 0;
10169
10170   ret = 0;
10171   if (isec->reloc_count != 0)
10172     {
10173       Elf_Internal_Rela *relstart, *rel;
10174       Elf_Internal_Sym *local_syms;
10175       struct ppc_link_hash_table *htab;
10176
10177       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10178                                             info->keep_memory);
10179       if (relstart == NULL)
10180         return -1;
10181
10182       /* Look for branches to outside of this section.  */
10183       local_syms = NULL;
10184       htab = ppc_hash_table (info);
10185       if (htab == NULL)
10186         return -1;
10187
10188       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10189         {
10190           enum elf_ppc64_reloc_type r_type;
10191           unsigned long r_symndx;
10192           struct elf_link_hash_entry *h;
10193           struct ppc_link_hash_entry *eh;
10194           Elf_Internal_Sym *sym;
10195           asection *sym_sec;
10196           struct _opd_sec_data *opd;
10197           bfd_vma sym_value;
10198           bfd_vma dest;
10199
10200           r_type = ELF64_R_TYPE (rel->r_info);
10201           if (r_type != R_PPC64_REL24
10202               && r_type != R_PPC64_REL14
10203               && r_type != R_PPC64_REL14_BRTAKEN
10204               && r_type != R_PPC64_REL14_BRNTAKEN)
10205             continue;
10206
10207           r_symndx = ELF64_R_SYM (rel->r_info);
10208           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10209                           isec->owner))
10210             {
10211               ret = -1;
10212               break;
10213             }
10214
10215           /* Calls to dynamic lib functions go through a plt call stub
10216              that uses r2.  */
10217           eh = (struct ppc_link_hash_entry *) h;
10218           if (eh != NULL
10219               && (eh->elf.plt.plist != NULL
10220                   || (eh->oh != NULL
10221                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10222             {
10223               ret = 1;
10224               break;
10225             }
10226
10227           if (sym_sec == NULL)
10228             /* Ignore other undefined symbols.  */
10229             continue;
10230
10231           /* Assume branches to other sections not included in the
10232              link need stubs too, to cover -R and absolute syms.  */
10233           if (sym_sec->output_section == NULL)
10234             {
10235               ret = 1;
10236               break;
10237             }
10238
10239           if (h == NULL)
10240             sym_value = sym->st_value;
10241           else
10242             {
10243               if (h->root.type != bfd_link_hash_defined
10244                   && h->root.type != bfd_link_hash_defweak)
10245                 abort ();
10246               sym_value = h->root.u.def.value;
10247             }
10248           sym_value += rel->r_addend;
10249
10250           /* If this branch reloc uses an opd sym, find the code section.  */
10251           opd = get_opd_info (sym_sec);
10252           if (opd != NULL)
10253             {
10254               if (h == NULL && opd->adjust != NULL)
10255                 {
10256                   long adjust;
10257
10258                   adjust = opd->adjust[sym->st_value / 8];
10259                   if (adjust == -1)
10260                     /* Assume deleted functions won't ever be called.  */
10261                     continue;
10262                   sym_value += adjust;
10263                 }
10264
10265               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10266               if (dest == (bfd_vma) -1)
10267                 continue;
10268             }
10269           else
10270             dest = (sym_value
10271                     + sym_sec->output_offset
10272                     + sym_sec->output_section->vma);
10273
10274           /* Ignore branch to self.  */
10275           if (sym_sec == isec)
10276             continue;
10277
10278           /* If the called function uses the toc, we need a stub.  */
10279           if (sym_sec->has_toc_reloc
10280               || sym_sec->makes_toc_func_call)
10281             {
10282               ret = 1;
10283               break;
10284             }
10285
10286           /* Assume any branch that needs a long branch stub might in fact
10287              need a plt_branch stub.  A plt_branch stub uses r2.  */
10288           else if (dest - (isec->output_offset
10289                            + isec->output_section->vma
10290                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10291             {
10292               ret = 1;
10293               break;
10294             }
10295
10296           /* If calling back to a section in the process of being
10297              tested, we can't say for sure that no toc adjusting stubs
10298              are needed, so don't return zero.  */
10299           else if (sym_sec->call_check_in_progress)
10300             ret = 2;
10301
10302           /* Branches to another section that itself doesn't have any TOC
10303              references are OK.  Recursively call ourselves to check.  */
10304           else if (!sym_sec->call_check_done)
10305             {
10306               int recur;
10307
10308               /* Mark current section as indeterminate, so that other
10309                  sections that call back to current won't be marked as
10310                  known.  */
10311               isec->call_check_in_progress = 1;
10312               recur = toc_adjusting_stub_needed (info, sym_sec);
10313               isec->call_check_in_progress = 0;
10314
10315               if (recur != 0)
10316                 {
10317                   ret = recur;
10318                   if (recur != 2)
10319                     break;
10320                 }
10321             }
10322         }
10323
10324       if (local_syms != NULL
10325           && (elf_symtab_hdr (isec->owner).contents
10326               != (unsigned char *) local_syms))
10327         free (local_syms);
10328       if (elf_section_data (isec)->relocs != relstart)
10329         free (relstart);
10330     }
10331
10332   if ((ret & 1) == 0
10333       && isec->map_head.s != NULL
10334       && (strcmp (isec->output_section->name, ".init") == 0
10335           || strcmp (isec->output_section->name, ".fini") == 0))
10336     {
10337       if (isec->map_head.s->has_toc_reloc
10338           || isec->map_head.s->makes_toc_func_call)
10339         ret = 1;
10340       else if (!isec->map_head.s->call_check_done)
10341         {
10342           int recur;
10343           isec->call_check_in_progress = 1;
10344           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10345           isec->call_check_in_progress = 0;
10346           if (recur != 0)
10347             ret = recur;
10348         }
10349     }
10350
10351   if (ret == 1)
10352     isec->makes_toc_func_call = 1;
10353
10354   return ret;
10355 }
10356
10357 /* The linker repeatedly calls this function for each input section,
10358    in the order that input sections are linked into output sections.
10359    Build lists of input sections to determine groupings between which
10360    we may insert linker stubs.  */
10361
10362 bfd_boolean
10363 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10364 {
10365   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10366
10367   if (htab == NULL)
10368     return FALSE;
10369
10370   if ((isec->output_section->flags & SEC_CODE) != 0
10371       && isec->output_section->index <= htab->top_index)
10372     {
10373       asection **list = htab->input_list + isec->output_section->index;
10374       /* Steal the link_sec pointer for our list.  */
10375 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10376       /* This happens to make the list in reverse order,
10377          which is what we want.  */
10378       PREV_SEC (isec) = *list;
10379       *list = isec;
10380     }
10381
10382   if (htab->multi_toc_needed)
10383     {
10384       /* If a code section has a function that uses the TOC then we need
10385          to use the right TOC (obviously).  Also, make sure that .opd gets
10386          the correct TOC value for R_PPC64_TOC relocs that don't have or
10387          can't find their function symbol (shouldn't ever happen now).
10388          Also specially treat .fixup for the linux kernel.  .fixup
10389          contains branches, but only back to the function that hit an
10390          exception.  */
10391       if (isec->has_toc_reloc
10392           || (isec->flags & SEC_CODE) == 0
10393           || strcmp (isec->name, ".fixup") == 0)
10394         {
10395           if (elf_gp (isec->owner) != 0)
10396             htab->toc_curr = elf_gp (isec->owner);
10397         }
10398       else if (!isec->call_check_done
10399                && toc_adjusting_stub_needed (info, isec) < 0)
10400         return FALSE;
10401     }
10402
10403   /* Functions that don't use the TOC can belong in any TOC group.
10404      Use the last TOC base.  This happens to make _init and _fini
10405      pasting work, because the fragments generally don't use the TOC.  */
10406   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10407   return TRUE;
10408 }
10409
10410 /* Check that all .init and .fini sections use the same toc, if they
10411    have toc relocs.  */
10412
10413 static bfd_boolean
10414 check_pasted_section (struct bfd_link_info *info, const char *name)
10415 {
10416   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10417
10418   if (o != NULL)
10419     {
10420       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10421       bfd_vma toc_off = 0;
10422       asection *i;
10423
10424       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10425         if (i->has_toc_reloc)
10426           {
10427             if (toc_off == 0)
10428               toc_off = htab->stub_group[i->id].toc_off;
10429             else if (toc_off != htab->stub_group[i->id].toc_off)
10430               return FALSE;
10431           }
10432       /* Make sure the whole pasted function uses the same toc offset.  */
10433       if (toc_off != 0)
10434         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10435           htab->stub_group[i->id].toc_off = toc_off;
10436     }
10437   return TRUE;
10438 }
10439
10440 bfd_boolean
10441 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10442 {
10443   return (check_pasted_section (info, ".init")
10444           & check_pasted_section (info, ".fini"));
10445 }
10446
10447 /* See whether we can group stub sections together.  Grouping stub
10448    sections may result in fewer stubs.  More importantly, we need to
10449    put all .init* and .fini* stubs at the beginning of the .init or
10450    .fini output sections respectively, because glibc splits the
10451    _init and _fini functions into multiple parts.  Putting a stub in
10452    the middle of a function is not a good idea.  */
10453
10454 static void
10455 group_sections (struct ppc_link_hash_table *htab,
10456                 bfd_size_type stub_group_size,
10457                 bfd_boolean stubs_always_before_branch)
10458 {
10459   asection **list;
10460   bfd_size_type stub14_group_size;
10461   bfd_boolean suppress_size_errors;
10462
10463   suppress_size_errors = FALSE;
10464   stub14_group_size = stub_group_size;
10465   if (stub_group_size == 1)
10466     {
10467       /* Default values.  */
10468       if (stubs_always_before_branch)
10469         {
10470           stub_group_size = 0x1e00000;
10471           stub14_group_size = 0x7800;
10472         }
10473       else
10474         {
10475           stub_group_size = 0x1c00000;
10476           stub14_group_size = 0x7000;
10477         }
10478       suppress_size_errors = TRUE;
10479     }
10480
10481   list = htab->input_list + htab->top_index;
10482   do
10483     {
10484       asection *tail = *list;
10485       while (tail != NULL)
10486         {
10487           asection *curr;
10488           asection *prev;
10489           bfd_size_type total;
10490           bfd_boolean big_sec;
10491           bfd_vma curr_toc;
10492
10493           curr = tail;
10494           total = tail->size;
10495           big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
10496                              ? stub14_group_size : stub_group_size);
10497           if (big_sec && !suppress_size_errors)
10498             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10499                                      tail->owner, tail);
10500           curr_toc = htab->stub_group[tail->id].toc_off;
10501
10502           while ((prev = PREV_SEC (curr)) != NULL
10503                  && ((total += curr->output_offset - prev->output_offset)
10504                      < (ppc64_elf_section_data (prev)->has_14bit_branch
10505                         ? stub14_group_size : stub_group_size))
10506                  && htab->stub_group[prev->id].toc_off == curr_toc)
10507             curr = prev;
10508
10509           /* OK, the size from the start of CURR to the end is less
10510              than stub_group_size and thus can be handled by one stub
10511              section.  (or the tail section is itself larger than
10512              stub_group_size, in which case we may be toast.)  We
10513              should really be keeping track of the total size of stubs
10514              added here, as stubs contribute to the final output
10515              section size.  That's a little tricky, and this way will
10516              only break if stubs added make the total size more than
10517              2^25, ie. for the default stub_group_size, if stubs total
10518              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10519           do
10520             {
10521               prev = PREV_SEC (tail);
10522               /* Set up this stub group.  */
10523               htab->stub_group[tail->id].link_sec = curr;
10524             }
10525           while (tail != curr && (tail = prev) != NULL);
10526
10527           /* But wait, there's more!  Input sections up to stub_group_size
10528              bytes before the stub section can be handled by it too.
10529              Don't do this if we have a really large section after the
10530              stubs, as adding more stubs increases the chance that
10531              branches may not reach into the stub section.  */
10532           if (!stubs_always_before_branch && !big_sec)
10533             {
10534               total = 0;
10535               while (prev != NULL
10536                      && ((total += tail->output_offset - prev->output_offset)
10537                          < (ppc64_elf_section_data (prev)->has_14bit_branch
10538                             ? stub14_group_size : stub_group_size))
10539                      && htab->stub_group[prev->id].toc_off == curr_toc)
10540                 {
10541                   tail = prev;
10542                   prev = PREV_SEC (tail);
10543                   htab->stub_group[tail->id].link_sec = curr;
10544                 }
10545             }
10546           tail = prev;
10547         }
10548     }
10549   while (list-- != htab->input_list);
10550   free (htab->input_list);
10551 #undef PREV_SEC
10552 }
10553
10554 /* Determine and set the size of the stub section for a final link.
10555
10556    The basic idea here is to examine all the relocations looking for
10557    PC-relative calls to a target that is unreachable with a "bl"
10558    instruction.  */
10559
10560 bfd_boolean
10561 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size)
10562 {
10563   bfd_size_type stub_group_size;
10564   bfd_boolean stubs_always_before_branch;
10565   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10566
10567   if (htab == NULL)
10568     return FALSE;
10569
10570   stubs_always_before_branch = group_size < 0;
10571   if (group_size < 0)
10572     stub_group_size = -group_size;
10573   else
10574     stub_group_size = group_size;
10575
10576   group_sections (htab, stub_group_size, stubs_always_before_branch);
10577
10578   while (1)
10579     {
10580       bfd *input_bfd;
10581       unsigned int bfd_indx;
10582       asection *stub_sec;
10583
10584       htab->stub_iteration += 1;
10585
10586       for (input_bfd = info->input_bfds, bfd_indx = 0;
10587            input_bfd != NULL;
10588            input_bfd = input_bfd->link_next, bfd_indx++)
10589         {
10590           Elf_Internal_Shdr *symtab_hdr;
10591           asection *section;
10592           Elf_Internal_Sym *local_syms = NULL;
10593
10594           if (!is_ppc64_elf (input_bfd))
10595             continue;
10596
10597           /* We'll need the symbol table in a second.  */
10598           symtab_hdr = &elf_symtab_hdr (input_bfd);
10599           if (symtab_hdr->sh_info == 0)
10600             continue;
10601
10602           /* Walk over each section attached to the input bfd.  */
10603           for (section = input_bfd->sections;
10604                section != NULL;
10605                section = section->next)
10606             {
10607               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10608
10609               /* If there aren't any relocs, then there's nothing more
10610                  to do.  */
10611               if ((section->flags & SEC_RELOC) == 0
10612                   || (section->flags & SEC_ALLOC) == 0
10613                   || (section->flags & SEC_LOAD) == 0
10614                   || (section->flags & SEC_CODE) == 0
10615                   || section->reloc_count == 0)
10616                 continue;
10617
10618               /* If this section is a link-once section that will be
10619                  discarded, then don't create any stubs.  */
10620               if (section->output_section == NULL
10621                   || section->output_section->owner != info->output_bfd)
10622                 continue;
10623
10624               /* Get the relocs.  */
10625               internal_relocs
10626                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10627                                              info->keep_memory);
10628               if (internal_relocs == NULL)
10629                 goto error_ret_free_local;
10630
10631               /* Now examine each relocation.  */
10632               irela = internal_relocs;
10633               irelaend = irela + section->reloc_count;
10634               for (; irela < irelaend; irela++)
10635                 {
10636                   enum elf_ppc64_reloc_type r_type;
10637                   unsigned int r_indx;
10638                   enum ppc_stub_type stub_type;
10639                   struct ppc_stub_hash_entry *stub_entry;
10640                   asection *sym_sec, *code_sec;
10641                   bfd_vma sym_value, code_value;
10642                   bfd_vma destination;
10643                   bfd_boolean ok_dest;
10644                   struct ppc_link_hash_entry *hash;
10645                   struct ppc_link_hash_entry *fdh;
10646                   struct elf_link_hash_entry *h;
10647                   Elf_Internal_Sym *sym;
10648                   char *stub_name;
10649                   const asection *id_sec;
10650                   struct _opd_sec_data *opd;
10651                   struct plt_entry *plt_ent;
10652
10653                   r_type = ELF64_R_TYPE (irela->r_info);
10654                   r_indx = ELF64_R_SYM (irela->r_info);
10655
10656                   if (r_type >= R_PPC64_max)
10657                     {
10658                       bfd_set_error (bfd_error_bad_value);
10659                       goto error_ret_free_internal;
10660                     }
10661
10662                   /* Only look for stubs on branch instructions.  */
10663                   if (r_type != R_PPC64_REL24
10664                       && r_type != R_PPC64_REL14
10665                       && r_type != R_PPC64_REL14_BRTAKEN
10666                       && r_type != R_PPC64_REL14_BRNTAKEN)
10667                     continue;
10668
10669                   /* Now determine the call target, its name, value,
10670                      section.  */
10671                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
10672                                   r_indx, input_bfd))
10673                     goto error_ret_free_internal;
10674                   hash = (struct ppc_link_hash_entry *) h;
10675
10676                   ok_dest = FALSE;
10677                   fdh = NULL;
10678                   sym_value = 0;
10679                   if (hash == NULL)
10680                     {
10681                       sym_value = sym->st_value;
10682                       ok_dest = TRUE;
10683                     }
10684                   else if (hash->elf.root.type == bfd_link_hash_defined
10685                            || hash->elf.root.type == bfd_link_hash_defweak)
10686                     {
10687                       sym_value = hash->elf.root.u.def.value;
10688                       if (sym_sec->output_section != NULL)
10689                         ok_dest = TRUE;
10690                     }
10691                   else if (hash->elf.root.type == bfd_link_hash_undefweak
10692                            || hash->elf.root.type == bfd_link_hash_undefined)
10693                     {
10694                       /* Recognise an old ABI func code entry sym, and
10695                          use the func descriptor sym instead if it is
10696                          defined.  */
10697                       if (hash->elf.root.root.string[0] == '.'
10698                           && (fdh = lookup_fdh (hash, htab)) != NULL)
10699                         {
10700                           if (fdh->elf.root.type == bfd_link_hash_defined
10701                               || fdh->elf.root.type == bfd_link_hash_defweak)
10702                             {
10703                               sym_sec = fdh->elf.root.u.def.section;
10704                               sym_value = fdh->elf.root.u.def.value;
10705                               if (sym_sec->output_section != NULL)
10706                                 ok_dest = TRUE;
10707                             }
10708                           else
10709                             fdh = NULL;
10710                         }
10711                     }
10712                   else
10713                     {
10714                       bfd_set_error (bfd_error_bad_value);
10715                       goto error_ret_free_internal;
10716                     }
10717
10718                   destination = 0;
10719                   if (ok_dest)
10720                     {
10721                       sym_value += irela->r_addend;
10722                       destination = (sym_value
10723                                      + sym_sec->output_offset
10724                                      + sym_sec->output_section->vma);
10725                     }
10726
10727                   code_sec = sym_sec;
10728                   code_value = sym_value;
10729                   opd = get_opd_info (sym_sec);
10730                   if (opd != NULL)
10731                     {
10732                       bfd_vma dest;
10733
10734                       if (hash == NULL && opd->adjust != NULL)
10735                         {
10736                           long adjust = opd->adjust[sym_value / 8];
10737                           if (adjust == -1)
10738                             continue;
10739                           code_value += adjust;
10740                           sym_value += adjust;
10741                         }
10742                       dest = opd_entry_value (sym_sec, sym_value,
10743                                               &code_sec, &code_value);
10744                       if (dest != (bfd_vma) -1)
10745                         {
10746                           destination = dest;
10747                           if (fdh != NULL)
10748                             {
10749                               /* Fixup old ABI sym to point at code
10750                                  entry.  */
10751                               hash->elf.root.type = bfd_link_hash_defweak;
10752                               hash->elf.root.u.def.section = code_sec;
10753                               hash->elf.root.u.def.value = code_value;
10754                             }
10755                         }
10756                     }
10757
10758                   /* Determine what (if any) linker stub is needed.  */
10759                   plt_ent = NULL;
10760                   stub_type = ppc_type_of_stub (section, irela, &hash,
10761                                                 &plt_ent, destination);
10762
10763                   if (stub_type != ppc_stub_plt_call)
10764                     {
10765                       /* Check whether we need a TOC adjusting stub.
10766                          Since the linker pastes together pieces from
10767                          different object files when creating the
10768                          _init and _fini functions, it may be that a
10769                          call to what looks like a local sym is in
10770                          fact a call needing a TOC adjustment.  */
10771                       if (code_sec != NULL
10772                           && code_sec->output_section != NULL
10773                           && (htab->stub_group[code_sec->id].toc_off
10774                               != htab->stub_group[section->id].toc_off)
10775                           && (code_sec->has_toc_reloc
10776                               || code_sec->makes_toc_func_call))
10777                         stub_type = ppc_stub_long_branch_r2off;
10778                     }
10779
10780                   if (stub_type == ppc_stub_none)
10781                     continue;
10782
10783                   /* __tls_get_addr calls might be eliminated.  */
10784                   if (stub_type != ppc_stub_plt_call
10785                       && hash != NULL
10786                       && (hash == htab->tls_get_addr
10787                           || hash == htab->tls_get_addr_fd)
10788                       && section->has_tls_reloc
10789                       && irela != internal_relocs)
10790                     {
10791                       /* Get tls info.  */
10792                       unsigned char *tls_mask;
10793
10794                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
10795                                          irela - 1, input_bfd))
10796                         goto error_ret_free_internal;
10797                       if (*tls_mask != 0)
10798                         continue;
10799                     }
10800
10801                   /* Support for grouping stub sections.  */
10802                   id_sec = htab->stub_group[section->id].link_sec;
10803
10804                   /* Get the name of this stub.  */
10805                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10806                   if (!stub_name)
10807                     goto error_ret_free_internal;
10808
10809                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10810                                                      stub_name, FALSE, FALSE);
10811                   if (stub_entry != NULL)
10812                     {
10813                       /* The proper stub has already been created.  */
10814                       free (stub_name);
10815                       continue;
10816                     }
10817
10818                   stub_entry = ppc_add_stub (stub_name, section, htab);
10819                   if (stub_entry == NULL)
10820                     {
10821                       free (stub_name);
10822                     error_ret_free_internal:
10823                       if (elf_section_data (section)->relocs == NULL)
10824                         free (internal_relocs);
10825                     error_ret_free_local:
10826                       if (local_syms != NULL
10827                           && (symtab_hdr->contents
10828                               != (unsigned char *) local_syms))
10829                         free (local_syms);
10830                       return FALSE;
10831                     }
10832
10833                   stub_entry->stub_type = stub_type;
10834                   if (stub_type != ppc_stub_plt_call)
10835                     {
10836                       stub_entry->target_value = code_value;
10837                       stub_entry->target_section = code_sec;
10838                     }
10839                   else
10840                     {
10841                       stub_entry->target_value = sym_value;
10842                       stub_entry->target_section = sym_sec;
10843                     }
10844                   stub_entry->h = hash;
10845                   stub_entry->plt_ent = plt_ent;
10846                   stub_entry->addend = irela->r_addend;
10847
10848                   if (stub_entry->h != NULL)
10849                     htab->stub_globals += 1;
10850                 }
10851
10852               /* We're done with the internal relocs, free them.  */
10853               if (elf_section_data (section)->relocs != internal_relocs)
10854                 free (internal_relocs);
10855             }
10856
10857           if (local_syms != NULL
10858               && symtab_hdr->contents != (unsigned char *) local_syms)
10859             {
10860               if (!info->keep_memory)
10861                 free (local_syms);
10862               else
10863                 symtab_hdr->contents = (unsigned char *) local_syms;
10864             }
10865         }
10866
10867       /* We may have added some stubs.  Find out the new size of the
10868          stub sections.  */
10869       for (stub_sec = htab->stub_bfd->sections;
10870            stub_sec != NULL;
10871            stub_sec = stub_sec->next)
10872         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10873           {
10874             stub_sec->rawsize = stub_sec->size;
10875             stub_sec->size = 0;
10876             stub_sec->reloc_count = 0;
10877             stub_sec->flags &= ~SEC_RELOC;
10878           }
10879
10880       htab->brlt->size = 0;
10881       htab->brlt->reloc_count = 0;
10882       htab->brlt->flags &= ~SEC_RELOC;
10883       if (htab->relbrlt != NULL)
10884         htab->relbrlt->size = 0;
10885
10886       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
10887
10888       if (info->emitrelocations
10889           && htab->glink != NULL && htab->glink->size != 0)
10890         {
10891           htab->glink->reloc_count = 1;
10892           htab->glink->flags |= SEC_RELOC;
10893         }
10894
10895       for (stub_sec = htab->stub_bfd->sections;
10896            stub_sec != NULL;
10897            stub_sec = stub_sec->next)
10898         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10899             && stub_sec->rawsize != stub_sec->size)
10900           break;
10901
10902       /* Exit from this loop when no stubs have been added, and no stubs
10903          have changed size.  */
10904       if (stub_sec == NULL)
10905         break;
10906
10907       /* Ask the linker to do its stuff.  */
10908       (*htab->layout_sections_again) ();
10909     }
10910
10911   /* It would be nice to strip htab->brlt from the output if the
10912      section is empty, but it's too late.  If we strip sections here,
10913      the dynamic symbol table is corrupted since the section symbol
10914      for the stripped section isn't written.  */
10915
10916   return TRUE;
10917 }
10918
10919 /* Called after we have determined section placement.  If sections
10920    move, we'll be called again.  Provide a value for TOCstart.  */
10921
10922 bfd_vma
10923 ppc64_elf_toc (bfd *obfd)
10924 {
10925   asection *s;
10926   bfd_vma TOCstart;
10927
10928   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10929      order.  The TOC starts where the first of these sections starts.  */
10930   s = bfd_get_section_by_name (obfd, ".got");
10931   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10932     s = bfd_get_section_by_name (obfd, ".toc");
10933   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10934     s = bfd_get_section_by_name (obfd, ".tocbss");
10935   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10936     s = bfd_get_section_by_name (obfd, ".plt");
10937   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10938     {
10939       /* This may happen for
10940          o  references to TOC base (SYM@toc / TOC[tc0]) without a
10941          .toc directive
10942          o  bad linker script
10943          o --gc-sections and empty TOC sections
10944
10945          FIXME: Warn user?  */
10946
10947       /* Look for a likely section.  We probably won't even be
10948          using TOCstart.  */
10949       for (s = obfd->sections; s != NULL; s = s->next)
10950         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10951                          | SEC_EXCLUDE))
10952             == (SEC_ALLOC | SEC_SMALL_DATA))
10953           break;
10954       if (s == NULL)
10955         for (s = obfd->sections; s != NULL; s = s->next)
10956           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
10957               == (SEC_ALLOC | SEC_SMALL_DATA))
10958             break;
10959       if (s == NULL)
10960         for (s = obfd->sections; s != NULL; s = s->next)
10961           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10962               == SEC_ALLOC)
10963             break;
10964       if (s == NULL)
10965         for (s = obfd->sections; s != NULL; s = s->next)
10966           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
10967             break;
10968     }
10969
10970   TOCstart = 0;
10971   if (s != NULL)
10972     TOCstart = s->output_section->vma + s->output_offset;
10973
10974   return TOCstart;
10975 }
10976
10977 /* Build all the stubs associated with the current output file.
10978    The stubs are kept in a hash table attached to the main linker
10979    hash table.  This function is called via gldelf64ppc_finish.  */
10980
10981 bfd_boolean
10982 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10983                        struct bfd_link_info *info,
10984                        char **stats)
10985 {
10986   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10987   asection *stub_sec;
10988   bfd_byte *p;
10989   int stub_sec_count = 0;
10990
10991   if (htab == NULL)
10992     return FALSE;
10993
10994   htab->emit_stub_syms = emit_stub_syms;
10995
10996   /* Allocate memory to hold the linker stubs.  */
10997   for (stub_sec = htab->stub_bfd->sections;
10998        stub_sec != NULL;
10999        stub_sec = stub_sec->next)
11000     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11001         && stub_sec->size != 0)
11002       {
11003         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11004         if (stub_sec->contents == NULL)
11005           return FALSE;
11006         /* We want to check that built size is the same as calculated
11007            size.  rawsize is a convenient location to use.  */
11008         stub_sec->rawsize = stub_sec->size;
11009         stub_sec->size = 0;
11010       }
11011
11012   if (htab->glink != NULL && htab->glink->size != 0)
11013     {
11014       unsigned int indx;
11015       bfd_vma plt0;
11016
11017       /* Build the .glink plt call stub.  */
11018       if (htab->emit_stub_syms)
11019         {
11020           struct elf_link_hash_entry *h;
11021           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11022                                     TRUE, FALSE, FALSE);
11023           if (h == NULL)
11024             return FALSE;
11025           if (h->root.type == bfd_link_hash_new)
11026             {
11027               h->root.type = bfd_link_hash_defined;
11028               h->root.u.def.section = htab->glink;
11029               h->root.u.def.value = 8;
11030               h->ref_regular = 1;
11031               h->def_regular = 1;
11032               h->ref_regular_nonweak = 1;
11033               h->forced_local = 1;
11034               h->non_elf = 0;
11035             }
11036         }
11037       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11038       if (info->emitrelocations)
11039         {
11040           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11041           if (r == NULL)
11042             return FALSE;
11043           r->r_offset = (htab->glink->output_offset
11044                          + htab->glink->output_section->vma);
11045           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11046           r->r_addend = plt0;
11047         }
11048       p = htab->glink->contents;
11049       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11050       bfd_put_64 (htab->glink->owner, plt0, p);
11051       p += 8;
11052       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11053       p += 4;
11054       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11055       p += 4;
11056       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11057       p += 4;
11058       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11059       p += 4;
11060       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11061       p += 4;
11062       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11063       p += 4;
11064       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11065       p += 4;
11066       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11067       p += 4;
11068       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11069       p += 4;
11070       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11071       p += 4;
11072       bfd_put_32 (htab->glink->owner, BCTR, p);
11073       p += 4;
11074       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11075         {
11076           bfd_put_32 (htab->glink->owner, NOP, p);
11077           p += 4;
11078         }
11079
11080       /* Build the .glink lazy link call stubs.  */
11081       indx = 0;
11082       while (p < htab->glink->contents + htab->glink->size)
11083         {
11084           if (indx < 0x8000)
11085             {
11086               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11087               p += 4;
11088             }
11089           else
11090             {
11091               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11092               p += 4;
11093               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11094               p += 4;
11095             }
11096           bfd_put_32 (htab->glink->owner,
11097                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11098           indx++;
11099           p += 4;
11100         }
11101       htab->glink->rawsize = p - htab->glink->contents;
11102     }
11103
11104   if (htab->brlt->size != 0)
11105     {
11106       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11107                                          htab->brlt->size);
11108       if (htab->brlt->contents == NULL)
11109         return FALSE;
11110     }
11111   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11112     {
11113       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11114                                             htab->relbrlt->size);
11115       if (htab->relbrlt->contents == NULL)
11116         return FALSE;
11117     }
11118
11119   /* Build the stubs as directed by the stub hash table.  */
11120   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11121
11122   if (htab->relbrlt != NULL)
11123     htab->relbrlt->reloc_count = 0;
11124
11125   for (stub_sec = htab->stub_bfd->sections;
11126        stub_sec != NULL;
11127        stub_sec = stub_sec->next)
11128     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11129       {
11130         stub_sec_count += 1;
11131         if (stub_sec->rawsize != stub_sec->size)
11132           break;
11133       }
11134
11135   if (stub_sec != NULL
11136       || htab->glink->rawsize != htab->glink->size)
11137     {
11138       htab->stub_error = TRUE;
11139       (*_bfd_error_handler) (_("stubs don't match calculated size"));
11140     }
11141
11142   if (htab->stub_error)
11143     return FALSE;
11144
11145   if (stats != NULL)
11146     {
11147       *stats = bfd_malloc (500);
11148       if (*stats == NULL)
11149         return FALSE;
11150
11151       sprintf (*stats, _("linker stubs in %u group%s\n"
11152                          "  branch       %lu\n"
11153                          "  toc adjust   %lu\n"
11154                          "  long branch  %lu\n"
11155                          "  long toc adj %lu\n"
11156                          "  plt call     %lu"),
11157                stub_sec_count,
11158                stub_sec_count == 1 ? "" : "s",
11159                htab->stub_count[ppc_stub_long_branch - 1],
11160                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11161                htab->stub_count[ppc_stub_plt_branch - 1],
11162                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11163                htab->stub_count[ppc_stub_plt_call - 1]);
11164     }
11165   return TRUE;
11166 }
11167
11168 /* This function undoes the changes made by add_symbol_adjust.  */
11169
11170 static bfd_boolean
11171 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11172 {
11173   struct ppc_link_hash_entry *eh;
11174
11175   if (h->root.type == bfd_link_hash_indirect)
11176     return TRUE;
11177
11178   if (h->root.type == bfd_link_hash_warning)
11179     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11180
11181   eh = (struct ppc_link_hash_entry *) h;
11182   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11183     return TRUE;
11184
11185   eh->elf.root.type = bfd_link_hash_undefined;
11186   return TRUE;
11187 }
11188
11189 void
11190 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11191 {
11192   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11193
11194   if (htab != NULL)
11195     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11196 }
11197
11198 /* What to do when ld finds relocations against symbols defined in
11199    discarded sections.  */
11200
11201 static unsigned int
11202 ppc64_elf_action_discarded (asection *sec)
11203 {
11204   if (strcmp (".opd", sec->name) == 0)
11205     return 0;
11206
11207   if (strcmp (".toc", sec->name) == 0)
11208     return 0;
11209
11210   if (strcmp (".toc1", sec->name) == 0)
11211     return 0;
11212
11213   return _bfd_elf_default_action_discarded (sec);
11214 }
11215
11216 /* The RELOCATE_SECTION function is called by the ELF backend linker
11217    to handle the relocations for a section.
11218
11219    The relocs are always passed as Rela structures; if the section
11220    actually uses Rel structures, the r_addend field will always be
11221    zero.
11222
11223    This function is responsible for adjust the section contents as
11224    necessary, and (if using Rela relocs and generating a
11225    relocatable output file) adjusting the reloc addend as
11226    necessary.
11227
11228    This function does not have to worry about setting the reloc
11229    address or the reloc symbol index.
11230
11231    LOCAL_SYMS is a pointer to the swapped in local symbols.
11232
11233    LOCAL_SECTIONS is an array giving the section in the input file
11234    corresponding to the st_shndx field of each local symbol.
11235
11236    The global hash table entry for the global symbols can be found
11237    via elf_sym_hashes (input_bfd).
11238
11239    When generating relocatable output, this function must handle
11240    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11241    going to be the section symbol corresponding to the output
11242    section, which means that the addend must be adjusted
11243    accordingly.  */
11244
11245 static bfd_boolean
11246 ppc64_elf_relocate_section (bfd *output_bfd,
11247                             struct bfd_link_info *info,
11248                             bfd *input_bfd,
11249                             asection *input_section,
11250                             bfd_byte *contents,
11251                             Elf_Internal_Rela *relocs,
11252                             Elf_Internal_Sym *local_syms,
11253                             asection **local_sections)
11254 {
11255   struct ppc_link_hash_table *htab;
11256   Elf_Internal_Shdr *symtab_hdr;
11257   struct elf_link_hash_entry **sym_hashes;
11258   Elf_Internal_Rela *rel;
11259   Elf_Internal_Rela *relend;
11260   Elf_Internal_Rela outrel;
11261   bfd_byte *loc;
11262   struct got_entry **local_got_ents;
11263   bfd_vma TOCstart;
11264   bfd_boolean ret = TRUE;
11265   bfd_boolean is_opd;
11266   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11267   bfd_boolean is_power4 = FALSE;
11268   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11269
11270   /* Initialize howto table if needed.  */
11271   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11272     ppc_howto_init ();
11273
11274   htab = ppc_hash_table (info);
11275   if (htab == NULL)
11276     return FALSE;
11277
11278   /* Don't relocate stub sections.  */
11279   if (input_section->owner == htab->stub_bfd)
11280     return TRUE;
11281
11282   BFD_ASSERT (is_ppc64_elf (input_bfd));
11283
11284   local_got_ents = elf_local_got_ents (input_bfd);
11285   TOCstart = elf_gp (output_bfd);
11286   symtab_hdr = &elf_symtab_hdr (input_bfd);
11287   sym_hashes = elf_sym_hashes (input_bfd);
11288   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11289
11290   rel = relocs;
11291   relend = relocs + input_section->reloc_count;
11292   for (; rel < relend; rel++)
11293     {
11294       enum elf_ppc64_reloc_type r_type;
11295       bfd_vma addend, orig_addend;
11296       bfd_reloc_status_type r;
11297       Elf_Internal_Sym *sym;
11298       asection *sec;
11299       struct elf_link_hash_entry *h_elf;
11300       struct ppc_link_hash_entry *h;
11301       struct ppc_link_hash_entry *fdh;
11302       const char *sym_name;
11303       unsigned long r_symndx, toc_symndx;
11304       bfd_vma toc_addend;
11305       unsigned char tls_mask, tls_gd, tls_type;
11306       unsigned char sym_type;
11307       bfd_vma relocation;
11308       bfd_boolean unresolved_reloc;
11309       bfd_boolean warned;
11310       unsigned long insn, mask;
11311       struct ppc_stub_hash_entry *stub_entry;
11312       bfd_vma max_br_offset;
11313       bfd_vma from;
11314
11315       r_type = ELF64_R_TYPE (rel->r_info);
11316       r_symndx = ELF64_R_SYM (rel->r_info);
11317
11318       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11319          symbol of the previous ADDR64 reloc.  The symbol gives us the
11320          proper TOC base to use.  */
11321       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11322           && rel != relocs
11323           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11324           && is_opd)
11325         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11326
11327       sym = NULL;
11328       sec = NULL;
11329       h_elf = NULL;
11330       sym_name = NULL;
11331       unresolved_reloc = FALSE;
11332       warned = FALSE;
11333       orig_addend = rel->r_addend;
11334
11335       if (r_symndx < symtab_hdr->sh_info)
11336         {
11337           /* It's a local symbol.  */
11338           struct _opd_sec_data *opd;
11339
11340           sym = local_syms + r_symndx;
11341           sec = local_sections[r_symndx];
11342           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11343           sym_type = ELF64_ST_TYPE (sym->st_info);
11344           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11345           opd = get_opd_info (sec);
11346           if (opd != NULL && opd->adjust != NULL)
11347             {
11348               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11349               if (adjust == -1)
11350                 relocation = 0;
11351               else
11352                 {
11353                   /* If this is a relocation against the opd section sym
11354                      and we have edited .opd, adjust the reloc addend so
11355                      that ld -r and ld --emit-relocs output is correct.
11356                      If it is a reloc against some other .opd symbol,
11357                      then the symbol value will be adjusted later.  */
11358                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11359                     rel->r_addend += adjust;
11360                   else
11361                     relocation += adjust;
11362                 }
11363             }
11364         }
11365       else
11366         {
11367           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11368                                    r_symndx, symtab_hdr, sym_hashes,
11369                                    h_elf, sec, relocation,
11370                                    unresolved_reloc, warned);
11371           sym_name = h_elf->root.root.string;
11372           sym_type = h_elf->type;
11373         }
11374       h = (struct ppc_link_hash_entry *) h_elf;
11375
11376       if (sec != NULL && elf_discarded_section (sec))
11377         {
11378           /* For relocs against symbols from removed linkonce sections,
11379              or sections discarded by a linker script, we just want the
11380              section contents zeroed.  Avoid any special processing.  */
11381           _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
11382                                contents + rel->r_offset);
11383           rel->r_info = 0;
11384           rel->r_addend = 0;
11385           continue;
11386         }
11387
11388       if (info->relocatable)
11389         continue;
11390
11391       /* TLS optimizations.  Replace instruction sequences and relocs
11392          based on information we collected in tls_optimize.  We edit
11393          RELOCS so that --emit-relocs will output something sensible
11394          for the final instruction stream.  */
11395       tls_mask = 0;
11396       tls_gd = 0;
11397       toc_symndx = 0;
11398       if (h != NULL)
11399         tls_mask = h->tls_mask;
11400       else if (local_got_ents != NULL)
11401         {
11402           struct plt_entry **local_plt = (struct plt_entry **)
11403             (local_got_ents + symtab_hdr->sh_info);
11404           unsigned char *lgot_masks = (unsigned char *)
11405             (local_plt + symtab_hdr->sh_info);
11406           tls_mask = lgot_masks[r_symndx];
11407         }
11408       if (tls_mask == 0
11409           && (r_type == R_PPC64_TLS
11410               || r_type == R_PPC64_TLSGD
11411               || r_type == R_PPC64_TLSLD))
11412         {
11413           /* Check for toc tls entries.  */
11414           unsigned char *toc_tls;
11415
11416           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11417                              &local_syms, rel, input_bfd))
11418             return FALSE;
11419
11420           if (toc_tls)
11421             tls_mask = *toc_tls;
11422         }
11423
11424       /* Check that tls relocs are used with tls syms, and non-tls
11425          relocs are used with non-tls syms.  */
11426       if (r_symndx != 0
11427           && r_type != R_PPC64_NONE
11428           && (h == NULL
11429               || h->elf.root.type == bfd_link_hash_defined
11430               || h->elf.root.type == bfd_link_hash_defweak)
11431           && (IS_PPC64_TLS_RELOC (r_type)
11432               != (sym_type == STT_TLS
11433                   || (sym_type == STT_SECTION
11434                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11435         {
11436           if (tls_mask != 0
11437               && (r_type == R_PPC64_TLS
11438                   || r_type == R_PPC64_TLSGD
11439                   || r_type == R_PPC64_TLSLD))
11440             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
11441             ;
11442           else
11443             (*_bfd_error_handler)
11444               (!IS_PPC64_TLS_RELOC (r_type)
11445                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11446                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
11447                input_bfd,
11448                input_section,
11449                (long) rel->r_offset,
11450                ppc64_elf_howto_table[r_type]->name,
11451                sym_name);
11452         }
11453
11454       /* Ensure reloc mapping code below stays sane.  */
11455       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11456           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11457           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
11458           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11459           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11460           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11461           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
11462           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11463           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11464           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11465         abort ();
11466
11467       switch (r_type)
11468         {
11469         default:
11470           break;
11471
11472         case R_PPC64_TOC16:
11473         case R_PPC64_TOC16_LO:
11474         case R_PPC64_TOC16_DS:
11475         case R_PPC64_TOC16_LO_DS:
11476           {
11477             /* Check for toc tls entries.  */
11478             unsigned char *toc_tls;
11479             int retval;
11480
11481             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11482                                    &local_syms, rel, input_bfd);
11483             if (retval == 0)
11484               return FALSE;
11485
11486             if (toc_tls)
11487               {
11488                 tls_mask = *toc_tls;
11489                 if (r_type == R_PPC64_TOC16_DS
11490                     || r_type == R_PPC64_TOC16_LO_DS)
11491                   {
11492                     if (tls_mask != 0
11493                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
11494                       goto toctprel;
11495                   }
11496                 else
11497                   {
11498                     /* If we found a GD reloc pair, then we might be
11499                        doing a GD->IE transition.  */
11500                     if (retval == 2)
11501                       {
11502                         tls_gd = TLS_TPRELGD;
11503                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11504                           goto tls_ldgd_opt;
11505                       }
11506                     else if (retval == 3)
11507                       {
11508                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11509                           goto tls_ldgd_opt;
11510                       }
11511                   }
11512               }
11513           }
11514           break;
11515
11516         case R_PPC64_GOT_TPREL16_DS:
11517         case R_PPC64_GOT_TPREL16_LO_DS:
11518           if (tls_mask != 0
11519               && (tls_mask & TLS_TPREL) == 0)
11520             {
11521             toctprel:
11522               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11523               insn &= 31 << 21;
11524               insn |= 0x3c0d0000;       /* addis 0,13,0 */
11525               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11526               r_type = R_PPC64_TPREL16_HA;
11527               if (toc_symndx != 0)
11528                 {
11529                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11530                   rel->r_addend = toc_addend;
11531                   /* We changed the symbol.  Start over in order to
11532                      get h, sym, sec etc. right.  */
11533                   rel--;
11534                   continue;
11535                 }
11536               else
11537                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11538             }
11539           break;
11540
11541         case R_PPC64_TLS:
11542           if (tls_mask != 0
11543               && (tls_mask & TLS_TPREL) == 0)
11544             {
11545               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11546               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11547               if (insn == 0)
11548                 abort ();
11549               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11550               /* Was PPC64_TLS which sits on insn boundary, now
11551                  PPC64_TPREL16_LO which is at low-order half-word.  */
11552               rel->r_offset += d_offset;
11553               r_type = R_PPC64_TPREL16_LO;
11554               if (toc_symndx != 0)
11555                 {
11556                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11557                   rel->r_addend = toc_addend;
11558                   /* We changed the symbol.  Start over in order to
11559                      get h, sym, sec etc. right.  */
11560                   rel--;
11561                   continue;
11562                 }
11563               else
11564                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11565             }
11566           break;
11567
11568         case R_PPC64_GOT_TLSGD16_HI:
11569         case R_PPC64_GOT_TLSGD16_HA:
11570           tls_gd = TLS_TPRELGD;
11571           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11572             goto tls_gdld_hi;
11573           break;
11574
11575         case R_PPC64_GOT_TLSLD16_HI:
11576         case R_PPC64_GOT_TLSLD16_HA:
11577           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11578             {
11579             tls_gdld_hi:
11580               if ((tls_mask & tls_gd) != 0)
11581                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11582                           + R_PPC64_GOT_TPREL16_DS);
11583               else
11584                 {
11585                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11586                   rel->r_offset -= d_offset;
11587                   r_type = R_PPC64_NONE;
11588                 }
11589               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11590             }
11591           break;
11592
11593         case R_PPC64_GOT_TLSGD16:
11594         case R_PPC64_GOT_TLSGD16_LO:
11595           tls_gd = TLS_TPRELGD;
11596           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11597             goto tls_ldgd_opt;
11598           break;
11599
11600         case R_PPC64_GOT_TLSLD16:
11601         case R_PPC64_GOT_TLSLD16_LO:
11602           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11603             {
11604               unsigned int insn1, insn2, insn3;
11605               bfd_vma offset;
11606
11607             tls_ldgd_opt:
11608               offset = (bfd_vma) -1;
11609               /* If not using the newer R_PPC64_TLSGD/LD to mark
11610                  __tls_get_addr calls, we must trust that the call
11611                  stays with its arg setup insns, ie. that the next
11612                  reloc is the __tls_get_addr call associated with
11613                  the current reloc.  Edit both insns.  */
11614               if (input_section->has_tls_get_addr_call
11615                   && rel + 1 < relend
11616                   && branch_reloc_hash_match (input_bfd, rel + 1,
11617                                               htab->tls_get_addr,
11618                                               htab->tls_get_addr_fd))
11619                 offset = rel[1].r_offset;
11620               if ((tls_mask & tls_gd) != 0)
11621                 {
11622                   /* IE */
11623                   insn1 = bfd_get_32 (output_bfd,
11624                                       contents + rel->r_offset - d_offset);
11625                   insn1 &= (1 << 26) - (1 << 2);
11626                   insn1 |= 58 << 26;    /* ld */
11627                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11628                   if (offset != (bfd_vma) -1)
11629                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11630                   if ((tls_mask & TLS_EXPLICIT) == 0)
11631                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11632                               + R_PPC64_GOT_TPREL16_DS);
11633                   else
11634                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
11635                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11636                 }
11637               else
11638                 {
11639                   /* LE */
11640                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
11641                   insn2 = 0x38630000;   /* addi 3,3,0 */
11642                   if (tls_gd == 0)
11643                     {
11644                       /* Was an LD reloc.  */
11645                       if (toc_symndx)
11646                         sec = local_sections[toc_symndx];
11647                       for (r_symndx = 0;
11648                            r_symndx < symtab_hdr->sh_info;
11649                            r_symndx++)
11650                         if (local_sections[r_symndx] == sec)
11651                           break;
11652                       if (r_symndx >= symtab_hdr->sh_info)
11653                         r_symndx = 0;
11654                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11655                       if (r_symndx != 0)
11656                         rel->r_addend -= (local_syms[r_symndx].st_value
11657                                           + sec->output_offset
11658                                           + sec->output_section->vma);
11659                     }
11660                   else if (toc_symndx != 0)
11661                     {
11662                       r_symndx = toc_symndx;
11663                       rel->r_addend = toc_addend;
11664                     }
11665                   r_type = R_PPC64_TPREL16_HA;
11666                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11667                   if (offset != (bfd_vma) -1)
11668                     {
11669                       rel[1].r_info = ELF64_R_INFO (r_symndx,
11670                                                     R_PPC64_TPREL16_LO);
11671                       rel[1].r_offset = offset + d_offset;
11672                       rel[1].r_addend = rel->r_addend;
11673                     }
11674                 }
11675               bfd_put_32 (output_bfd, insn1,
11676                           contents + rel->r_offset - d_offset);
11677               if (offset != (bfd_vma) -1)
11678                 {
11679                   insn3 = bfd_get_32 (output_bfd,
11680                                       contents + offset + 4);
11681                   if (insn3 == NOP
11682                       || insn3 == CROR_151515 || insn3 == CROR_313131)
11683                     {
11684                       rel[1].r_offset += 4;
11685                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11686                       insn2 = NOP;
11687                     }
11688                   bfd_put_32 (output_bfd, insn2, contents + offset);
11689                 }
11690               if ((tls_mask & tls_gd) == 0
11691                   && (tls_gd == 0 || toc_symndx != 0))
11692                 {
11693                   /* We changed the symbol.  Start over in order
11694                      to get h, sym, sec etc. right.  */
11695                   rel--;
11696                   continue;
11697                 }
11698             }
11699           break;
11700
11701         case R_PPC64_TLSGD:
11702           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11703             {
11704               unsigned int insn2, insn3;
11705               bfd_vma offset = rel->r_offset;
11706
11707               if ((tls_mask & TLS_TPRELGD) != 0)
11708                 {
11709                   /* IE */
11710                   r_type = R_PPC64_NONE;
11711                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11712                 }
11713               else
11714                 {
11715                   /* LE */
11716                   if (toc_symndx != 0)
11717                     {
11718                       r_symndx = toc_symndx;
11719                       rel->r_addend = toc_addend;
11720                     }
11721                   r_type = R_PPC64_TPREL16_LO;
11722                   rel->r_offset = offset + d_offset;
11723                   insn2 = 0x38630000;   /* addi 3,3,0 */
11724                 }
11725               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11726               /* Zap the reloc on the _tls_get_addr call too.  */
11727               BFD_ASSERT (offset == rel[1].r_offset);
11728               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11729               insn3 = bfd_get_32 (output_bfd,
11730                                   contents + offset + 4);
11731               if (insn3 == NOP
11732                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11733                 {
11734                   rel->r_offset += 4;
11735                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11736                   insn2 = NOP;
11737                 }
11738               bfd_put_32 (output_bfd, insn2, contents + offset);
11739               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
11740                 {
11741                   rel--;
11742                   continue;
11743                 }
11744             }
11745           break;
11746
11747         case R_PPC64_TLSLD:
11748           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11749             {
11750               unsigned int insn2, insn3;
11751               bfd_vma offset = rel->r_offset;
11752
11753               if (toc_symndx)
11754                 sec = local_sections[toc_symndx];
11755               for (r_symndx = 0;
11756                    r_symndx < symtab_hdr->sh_info;
11757                    r_symndx++)
11758                 if (local_sections[r_symndx] == sec)
11759                   break;
11760               if (r_symndx >= symtab_hdr->sh_info)
11761                 r_symndx = 0;
11762               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11763               if (r_symndx != 0)
11764                 rel->r_addend -= (local_syms[r_symndx].st_value
11765                                   + sec->output_offset
11766                                   + sec->output_section->vma);
11767
11768               r_type = R_PPC64_TPREL16_LO;
11769               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11770               rel->r_offset = offset + d_offset;
11771               /* Zap the reloc on the _tls_get_addr call too.  */
11772               BFD_ASSERT (offset == rel[1].r_offset);
11773               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11774               insn2 = 0x38630000;       /* addi 3,3,0 */
11775               insn3 = bfd_get_32 (output_bfd,
11776                                   contents + offset + 4);
11777               if (insn3 == NOP
11778                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11779                 {
11780                   rel->r_offset += 4;
11781                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11782                   insn2 = NOP;
11783                 }
11784               bfd_put_32 (output_bfd, insn2, contents + offset);
11785               rel--;
11786               continue;
11787             }
11788           break;
11789
11790         case R_PPC64_DTPMOD64:
11791           if (rel + 1 < relend
11792               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11793               && rel[1].r_offset == rel->r_offset + 8)
11794             {
11795               if ((tls_mask & TLS_GD) == 0)
11796                 {
11797                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11798                   if ((tls_mask & TLS_TPRELGD) != 0)
11799                     r_type = R_PPC64_TPREL64;
11800                   else
11801                     {
11802                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11803                       r_type = R_PPC64_NONE;
11804                     }
11805                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11806                 }
11807             }
11808           else
11809             {
11810               if ((tls_mask & TLS_LD) == 0)
11811                 {
11812                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11813                   r_type = R_PPC64_NONE;
11814                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11815                 }
11816             }
11817           break;
11818
11819         case R_PPC64_TPREL64:
11820           if ((tls_mask & TLS_TPREL) == 0)
11821             {
11822               r_type = R_PPC64_NONE;
11823               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11824             }
11825           break;
11826         }
11827
11828       /* Handle other relocations that tweak non-addend part of insn.  */
11829       insn = 0;
11830       max_br_offset = 1 << 25;
11831       addend = rel->r_addend;
11832       switch (r_type)
11833         {
11834         default:
11835           break;
11836
11837           /* Branch taken prediction relocations.  */
11838         case R_PPC64_ADDR14_BRTAKEN:
11839         case R_PPC64_REL14_BRTAKEN:
11840           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
11841           /* Fall thru.  */
11842
11843           /* Branch not taken prediction relocations.  */
11844         case R_PPC64_ADDR14_BRNTAKEN:
11845         case R_PPC64_REL14_BRNTAKEN:
11846           insn |= bfd_get_32 (output_bfd,
11847                               contents + rel->r_offset) & ~(0x01 << 21);
11848           /* Fall thru.  */
11849
11850         case R_PPC64_REL14:
11851           max_br_offset = 1 << 15;
11852           /* Fall thru.  */
11853
11854         case R_PPC64_REL24:
11855           /* Calls to functions with a different TOC, such as calls to
11856              shared objects, need to alter the TOC pointer.  This is
11857              done using a linkage stub.  A REL24 branching to these
11858              linkage stubs needs to be followed by a nop, as the nop
11859              will be replaced with an instruction to restore the TOC
11860              base pointer.  */
11861           stub_entry = NULL;
11862           fdh = h;
11863           if (h != NULL
11864               && h->oh != NULL
11865               && h->oh->is_func_descriptor)
11866             fdh = ppc_follow_link (h->oh);
11867           if (((fdh != NULL
11868                 && fdh->elf.plt.plist != NULL)
11869                || (sec != NULL
11870                    && sec->output_section != NULL
11871                    && sec->id <= htab->top_id
11872                    && (htab->stub_group[sec->id].toc_off
11873                        != htab->stub_group[input_section->id].toc_off))
11874                || (h == NULL
11875                    && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
11876               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
11877                                                    rel, htab)) != NULL
11878               && (stub_entry->stub_type == ppc_stub_plt_call
11879                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11880                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
11881             {
11882               bfd_boolean can_plt_call = FALSE;
11883
11884               if (rel->r_offset + 8 <= input_section->size)
11885                 {
11886                   unsigned long nop;
11887                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11888                   if (nop == NOP
11889                       || nop == CROR_151515 || nop == CROR_313131)
11890                     {
11891                       if (h != NULL
11892                           && (h == htab->tls_get_addr_fd
11893                               || h == htab->tls_get_addr)
11894                           && !htab->no_tls_get_addr_opt)
11895                         {
11896                           /* Special stub used, leave nop alone.  */
11897                         }
11898                       else
11899                         bfd_put_32 (input_bfd, LD_R2_40R1,
11900                                     contents + rel->r_offset + 4);
11901                       can_plt_call = TRUE;
11902                     }
11903                 }
11904
11905               if (!can_plt_call)
11906                 {
11907                   if (stub_entry->stub_type == ppc_stub_plt_call)
11908                     {
11909                       /* If this is a plain branch rather than a branch
11910                          and link, don't require a nop.  However, don't
11911                          allow tail calls in a shared library as they
11912                          will result in r2 being corrupted.  */
11913                       unsigned long br;
11914                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
11915                       if (info->executable && (br & 1) == 0)
11916                         can_plt_call = TRUE;
11917                       else
11918                         stub_entry = NULL;
11919                     }
11920                   else if (h != NULL
11921                            && strcmp (h->elf.root.root.string,
11922                                       ".__libc_start_main") == 0)
11923                     {
11924                       /* Allow crt1 branch to go via a toc adjusting stub.  */
11925                       can_plt_call = TRUE;
11926                     }
11927                   else
11928                     {
11929                       if (strcmp (input_section->output_section->name,
11930                                   ".init") == 0
11931                           || strcmp (input_section->output_section->name,
11932                                      ".fini") == 0)
11933                         (*_bfd_error_handler)
11934                           (_("%B(%A+0x%lx): automatic multiple TOCs "
11935                              "not supported using your crt files; "
11936                              "recompile with -mminimal-toc or upgrade gcc"),
11937                            input_bfd,
11938                            input_section,
11939                            (long) rel->r_offset);
11940                       else
11941                         (*_bfd_error_handler)
11942                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
11943                              "does not allow automatic multiple TOCs; "
11944                              "recompile with -mminimal-toc or "
11945                              "-fno-optimize-sibling-calls, "
11946                              "or make `%s' extern"),
11947                            input_bfd,
11948                            input_section,
11949                            (long) rel->r_offset,
11950                            sym_name,
11951                            sym_name);
11952                       bfd_set_error (bfd_error_bad_value);
11953                       ret = FALSE;
11954                     }
11955                 }
11956
11957               if (can_plt_call
11958                   && stub_entry->stub_type == ppc_stub_plt_call)
11959                 unresolved_reloc = FALSE;
11960             }
11961
11962           if (stub_entry == NULL
11963               && get_opd_info (sec) != NULL)
11964             {
11965               /* The branch destination is the value of the opd entry. */
11966               bfd_vma off = (relocation + addend
11967                              - sec->output_section->vma
11968                              - sec->output_offset);
11969               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11970               if (dest != (bfd_vma) -1)
11971                 {
11972                   relocation = dest;
11973                   addend = 0;
11974                 }
11975             }
11976
11977           /* If the branch is out of reach we ought to have a long
11978              branch stub.  */
11979           from = (rel->r_offset
11980                   + input_section->output_offset
11981                   + input_section->output_section->vma);
11982
11983           if (stub_entry == NULL
11984               && (relocation + addend - from + max_br_offset
11985                   >= 2 * max_br_offset)
11986               && r_type != R_PPC64_ADDR14_BRTAKEN
11987               && r_type != R_PPC64_ADDR14_BRNTAKEN)
11988             stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel,
11989                                              htab);
11990
11991           if (stub_entry != NULL)
11992             {
11993               /* Munge up the value and addend so that we call the stub
11994                  rather than the procedure directly.  */
11995               relocation = (stub_entry->stub_offset
11996                             + stub_entry->stub_sec->output_offset
11997                             + stub_entry->stub_sec->output_section->vma);
11998               addend = 0;
11999             }
12000
12001           if (insn != 0)
12002             {
12003               if (is_power4)
12004                 {
12005                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12006                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12007                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12008                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12009                     insn |= 0x02 << 21;
12010                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12011                     insn |= 0x08 << 21;
12012                   else
12013                     break;
12014                 }
12015               else
12016                 {
12017                   /* Invert 'y' bit if not the default.  */
12018                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12019                     insn ^= 0x01 << 21;
12020                 }
12021
12022               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12023             }
12024
12025           /* NOP out calls to undefined weak functions.
12026              We can thus call a weak function without first
12027              checking whether the function is defined.  */
12028           else if (h != NULL
12029                    && h->elf.root.type == bfd_link_hash_undefweak
12030                    && h->elf.dynindx == -1
12031                    && r_type == R_PPC64_REL24
12032                    && relocation == 0
12033                    && addend == 0)
12034             {
12035               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12036               continue;
12037             }
12038           break;
12039         }
12040
12041       /* Set `addend'.  */
12042       tls_type = 0;
12043       switch (r_type)
12044         {
12045         default:
12046           (*_bfd_error_handler)
12047             (_("%B: unknown relocation type %d for symbol %s"),
12048              input_bfd, (int) r_type, sym_name);
12049
12050           bfd_set_error (bfd_error_bad_value);
12051           ret = FALSE;
12052           continue;
12053
12054         case R_PPC64_NONE:
12055         case R_PPC64_TLS:
12056         case R_PPC64_TLSGD:
12057         case R_PPC64_TLSLD:
12058         case R_PPC64_GNU_VTINHERIT:
12059         case R_PPC64_GNU_VTENTRY:
12060           continue;
12061
12062           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12063              address in the GOT as relocation value instead of the
12064              symbol's value itself.  Also, create a GOT entry for the
12065              symbol and put the symbol value there.  */
12066         case R_PPC64_GOT_TLSGD16:
12067         case R_PPC64_GOT_TLSGD16_LO:
12068         case R_PPC64_GOT_TLSGD16_HI:
12069         case R_PPC64_GOT_TLSGD16_HA:
12070           tls_type = TLS_TLS | TLS_GD;
12071           goto dogot;
12072
12073         case R_PPC64_GOT_TLSLD16:
12074         case R_PPC64_GOT_TLSLD16_LO:
12075         case R_PPC64_GOT_TLSLD16_HI:
12076         case R_PPC64_GOT_TLSLD16_HA:
12077           tls_type = TLS_TLS | TLS_LD;
12078           goto dogot;
12079
12080         case R_PPC64_GOT_TPREL16_DS:
12081         case R_PPC64_GOT_TPREL16_LO_DS:
12082         case R_PPC64_GOT_TPREL16_HI:
12083         case R_PPC64_GOT_TPREL16_HA:
12084           tls_type = TLS_TLS | TLS_TPREL;
12085           goto dogot;
12086
12087         case R_PPC64_GOT_DTPREL16_DS:
12088         case R_PPC64_GOT_DTPREL16_LO_DS:
12089         case R_PPC64_GOT_DTPREL16_HI:
12090         case R_PPC64_GOT_DTPREL16_HA:
12091           tls_type = TLS_TLS | TLS_DTPREL;
12092           goto dogot;
12093
12094         case R_PPC64_GOT16:
12095         case R_PPC64_GOT16_LO:
12096         case R_PPC64_GOT16_HI:
12097         case R_PPC64_GOT16_HA:
12098         case R_PPC64_GOT16_DS:
12099         case R_PPC64_GOT16_LO_DS:
12100         dogot:
12101           {
12102             /* Relocation is to the entry for this symbol in the global
12103                offset table.  */
12104             asection *got;
12105             bfd_vma *offp;
12106             bfd_vma off;
12107             unsigned long indx = 0;
12108             struct got_entry *ent;
12109
12110             if (tls_type == (TLS_TLS | TLS_LD)
12111                 && (h == NULL
12112                     || !h->elf.def_dynamic))
12113               ent = ppc64_tlsld_got (input_bfd);
12114             else
12115               {
12116
12117                 if (h != NULL)
12118                   {
12119                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12120                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12121                                                           &h->elf)
12122                         || (info->shared
12123                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
12124                       /* This is actually a static link, or it is a
12125                          -Bsymbolic link and the symbol is defined
12126                          locally, or the symbol was forced to be local
12127                          because of a version file.  */
12128                       ;
12129                     else
12130                       {
12131                         indx = h->elf.dynindx;
12132                         unresolved_reloc = FALSE;
12133                       }
12134                     ent = h->elf.got.glist;
12135                   }
12136                 else
12137                   {
12138                     if (local_got_ents == NULL)
12139                       abort ();
12140                     ent = local_got_ents[r_symndx];
12141                   }
12142
12143                 for (; ent != NULL; ent = ent->next)
12144                   if (ent->addend == orig_addend
12145                       && ent->owner == input_bfd
12146                       && ent->tls_type == tls_type)
12147                     break;
12148               }
12149
12150             if (ent == NULL)
12151               abort ();
12152             if (ent->is_indirect)
12153               ent = ent->got.ent;
12154             offp = &ent->got.offset;
12155             got = ppc64_elf_tdata (ent->owner)->got;
12156             if (got == NULL)
12157               abort ();
12158
12159             /* The offset must always be a multiple of 8.  We use the
12160                least significant bit to record whether we have already
12161                processed this entry.  */
12162             off = *offp;
12163             if ((off & 1) != 0)
12164               off &= ~1;
12165             else
12166               {
12167                 /* Generate relocs for the dynamic linker, except in
12168                    the case of TLSLD where we'll use one entry per
12169                    module.  */
12170                 asection *relgot;
12171                 bfd_boolean ifunc;
12172
12173                 *offp = off | 1;
12174                 relgot = NULL;
12175                 ifunc = (h != NULL
12176                          ? h->elf.type == STT_GNU_IFUNC
12177                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12178                 if ((info->shared || indx != 0)
12179                     && (h == NULL
12180                         || (tls_type == (TLS_TLS | TLS_LD)
12181                             && !h->elf.def_dynamic)
12182                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12183                         || h->elf.root.type != bfd_link_hash_undefweak))
12184                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12185                 else if (ifunc)
12186                   relgot = htab->reliplt;
12187                 if (relgot != NULL)
12188                   {
12189                     outrel.r_offset = (got->output_section->vma
12190                                        + got->output_offset
12191                                        + off);
12192                     outrel.r_addend = addend;
12193                     if (tls_type & (TLS_LD | TLS_GD))
12194                       {
12195                         outrel.r_addend = 0;
12196                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12197                         if (tls_type == (TLS_TLS | TLS_GD))
12198                           {
12199                             loc = relgot->contents;
12200                             loc += (relgot->reloc_count++
12201                                     * sizeof (Elf64_External_Rela));
12202                             bfd_elf64_swap_reloca_out (output_bfd,
12203                                                        &outrel, loc);
12204                             outrel.r_offset += 8;
12205                             outrel.r_addend = addend;
12206                             outrel.r_info
12207                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12208                           }
12209                       }
12210                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12211                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12212                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12213                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12214                     else if (indx != 0)
12215                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12216                     else
12217                       {
12218                         if (ifunc)
12219                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12220                         else
12221                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12222
12223                         /* Write the .got section contents for the sake
12224                            of prelink.  */
12225                         loc = got->contents + off;
12226                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12227                                     loc);
12228                       }
12229
12230                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12231                       {
12232                         outrel.r_addend += relocation;
12233                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12234                           outrel.r_addend -= htab->elf.tls_sec->vma;
12235                       }
12236                     loc = relgot->contents;
12237                     loc += (relgot->reloc_count++
12238                             * sizeof (Elf64_External_Rela));
12239                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12240                   }
12241
12242                 /* Init the .got section contents here if we're not
12243                    emitting a reloc.  */
12244                 else
12245                   {
12246                     relocation += addend;
12247                     if (tls_type == (TLS_TLS | TLS_LD))
12248                       relocation = 1;
12249                     else if (tls_type != 0)
12250                       {
12251                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12252                         if (tls_type == (TLS_TLS | TLS_TPREL))
12253                           relocation += DTP_OFFSET - TP_OFFSET;
12254
12255                         if (tls_type == (TLS_TLS | TLS_GD))
12256                           {
12257                             bfd_put_64 (output_bfd, relocation,
12258                                         got->contents + off + 8);
12259                             relocation = 1;
12260                           }
12261                       }
12262
12263                     bfd_put_64 (output_bfd, relocation,
12264                                 got->contents + off);
12265                   }
12266               }
12267
12268             if (off >= (bfd_vma) -2)
12269               abort ();
12270
12271             relocation = got->output_section->vma + got->output_offset + off;
12272             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12273           }
12274           break;
12275
12276         case R_PPC64_PLT16_HA:
12277         case R_PPC64_PLT16_HI:
12278         case R_PPC64_PLT16_LO:
12279         case R_PPC64_PLT32:
12280         case R_PPC64_PLT64:
12281           /* Relocation is to the entry for this symbol in the
12282              procedure linkage table.  */
12283
12284           /* Resolve a PLT reloc against a local symbol directly,
12285              without using the procedure linkage table.  */
12286           if (h == NULL)
12287             break;
12288
12289           /* It's possible that we didn't make a PLT entry for this
12290              symbol.  This happens when statically linking PIC code,
12291              or when using -Bsymbolic.  Go find a match if there is a
12292              PLT entry.  */
12293           if (htab->plt != NULL)
12294             {
12295               struct plt_entry *ent;
12296               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12297                 if (ent->addend == orig_addend
12298                     && ent->plt.offset != (bfd_vma) -1)
12299                   {
12300                     relocation = (htab->plt->output_section->vma
12301                                   + htab->plt->output_offset
12302                                   + ent->plt.offset);
12303                     unresolved_reloc = FALSE;
12304                   }
12305             }
12306           break;
12307
12308         case R_PPC64_TOC:
12309           /* Relocation value is TOC base.  */
12310           relocation = TOCstart;
12311           if (r_symndx == 0)
12312             relocation += htab->stub_group[input_section->id].toc_off;
12313           else if (unresolved_reloc)
12314             ;
12315           else if (sec != NULL && sec->id <= htab->top_id)
12316             relocation += htab->stub_group[sec->id].toc_off;
12317           else
12318             unresolved_reloc = TRUE;
12319           goto dodyn;
12320
12321           /* TOC16 relocs.  We want the offset relative to the TOC base,
12322              which is the address of the start of the TOC plus 0x8000.
12323              The TOC consists of sections .got, .toc, .tocbss, and .plt,
12324              in this order.  */
12325         case R_PPC64_TOC16:
12326         case R_PPC64_TOC16_LO:
12327         case R_PPC64_TOC16_HI:
12328         case R_PPC64_TOC16_DS:
12329         case R_PPC64_TOC16_LO_DS:
12330         case R_PPC64_TOC16_HA:
12331           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12332           break;
12333
12334           /* Relocate against the beginning of the section.  */
12335         case R_PPC64_SECTOFF:
12336         case R_PPC64_SECTOFF_LO:
12337         case R_PPC64_SECTOFF_HI:
12338         case R_PPC64_SECTOFF_DS:
12339         case R_PPC64_SECTOFF_LO_DS:
12340         case R_PPC64_SECTOFF_HA:
12341           if (sec != NULL)
12342             addend -= sec->output_section->vma;
12343           break;
12344
12345         case R_PPC64_REL16:
12346         case R_PPC64_REL16_LO:
12347         case R_PPC64_REL16_HI:
12348         case R_PPC64_REL16_HA:
12349           break;
12350
12351         case R_PPC64_REL14:
12352         case R_PPC64_REL14_BRNTAKEN:
12353         case R_PPC64_REL14_BRTAKEN:
12354         case R_PPC64_REL24:
12355           break;
12356
12357         case R_PPC64_TPREL16:
12358         case R_PPC64_TPREL16_LO:
12359         case R_PPC64_TPREL16_HI:
12360         case R_PPC64_TPREL16_HA:
12361         case R_PPC64_TPREL16_DS:
12362         case R_PPC64_TPREL16_LO_DS:
12363         case R_PPC64_TPREL16_HIGHER:
12364         case R_PPC64_TPREL16_HIGHERA:
12365         case R_PPC64_TPREL16_HIGHEST:
12366         case R_PPC64_TPREL16_HIGHESTA:
12367           if (h != NULL
12368               && h->elf.root.type == bfd_link_hash_undefweak
12369               && h->elf.dynindx == -1)
12370             {
12371               /* Make this relocation against an undefined weak symbol
12372                  resolve to zero.  This is really just a tweak, since
12373                  code using weak externs ought to check that they are
12374                  defined before using them.  */
12375               bfd_byte *p = contents + rel->r_offset - d_offset;
12376
12377               insn = bfd_get_32 (output_bfd, p);
12378               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12379               if (insn != 0)
12380                 bfd_put_32 (output_bfd, insn, p);
12381               break;
12382             }
12383           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12384           if (info->shared)
12385             /* The TPREL16 relocs shouldn't really be used in shared
12386                libs as they will result in DT_TEXTREL being set, but
12387                support them anyway.  */
12388             goto dodyn;
12389           break;
12390
12391         case R_PPC64_DTPREL16:
12392         case R_PPC64_DTPREL16_LO:
12393         case R_PPC64_DTPREL16_HI:
12394         case R_PPC64_DTPREL16_HA:
12395         case R_PPC64_DTPREL16_DS:
12396         case R_PPC64_DTPREL16_LO_DS:
12397         case R_PPC64_DTPREL16_HIGHER:
12398         case R_PPC64_DTPREL16_HIGHERA:
12399         case R_PPC64_DTPREL16_HIGHEST:
12400         case R_PPC64_DTPREL16_HIGHESTA:
12401           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12402           break;
12403
12404         case R_PPC64_DTPMOD64:
12405           relocation = 1;
12406           addend = 0;
12407           goto dodyn;
12408
12409         case R_PPC64_TPREL64:
12410           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12411           goto dodyn;
12412
12413         case R_PPC64_DTPREL64:
12414           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12415           /* Fall thru */
12416
12417           /* Relocations that may need to be propagated if this is a
12418              dynamic object.  */
12419         case R_PPC64_REL30:
12420         case R_PPC64_REL32:
12421         case R_PPC64_REL64:
12422         case R_PPC64_ADDR14:
12423         case R_PPC64_ADDR14_BRNTAKEN:
12424         case R_PPC64_ADDR14_BRTAKEN:
12425         case R_PPC64_ADDR16:
12426         case R_PPC64_ADDR16_DS:
12427         case R_PPC64_ADDR16_HA:
12428         case R_PPC64_ADDR16_HI:
12429         case R_PPC64_ADDR16_HIGHER:
12430         case R_PPC64_ADDR16_HIGHERA:
12431         case R_PPC64_ADDR16_HIGHEST:
12432         case R_PPC64_ADDR16_HIGHESTA:
12433         case R_PPC64_ADDR16_LO:
12434         case R_PPC64_ADDR16_LO_DS:
12435         case R_PPC64_ADDR24:
12436         case R_PPC64_ADDR32:
12437         case R_PPC64_ADDR64:
12438         case R_PPC64_UADDR16:
12439         case R_PPC64_UADDR32:
12440         case R_PPC64_UADDR64:
12441         dodyn:
12442           if ((input_section->flags & SEC_ALLOC) == 0)
12443             break;
12444
12445           if (NO_OPD_RELOCS && is_opd)
12446             break;
12447
12448           if ((info->shared
12449                && (h == NULL
12450                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12451                    || h->elf.root.type != bfd_link_hash_undefweak)
12452                && (must_be_dyn_reloc (info, r_type)
12453                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12454               || (ELIMINATE_COPY_RELOCS
12455                   && !info->shared
12456                   && h != NULL
12457                   && h->elf.dynindx != -1
12458                   && !h->elf.non_got_ref
12459                   && !h->elf.def_regular)
12460               || (!info->shared
12461                   && (h != NULL
12462                       ? h->elf.type == STT_GNU_IFUNC
12463                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12464             {
12465               bfd_boolean skip, relocate;
12466               asection *sreloc;
12467               bfd_vma out_off;
12468
12469               /* When generating a dynamic object, these relocations
12470                  are copied into the output file to be resolved at run
12471                  time.  */
12472
12473               skip = FALSE;
12474               relocate = FALSE;
12475
12476               out_off = _bfd_elf_section_offset (output_bfd, info,
12477                                                  input_section, rel->r_offset);
12478               if (out_off == (bfd_vma) -1)
12479                 skip = TRUE;
12480               else if (out_off == (bfd_vma) -2)
12481                 skip = TRUE, relocate = TRUE;
12482               out_off += (input_section->output_section->vma
12483                           + input_section->output_offset);
12484               outrel.r_offset = out_off;
12485               outrel.r_addend = rel->r_addend;
12486
12487               /* Optimize unaligned reloc use.  */
12488               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
12489                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
12490                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
12491               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
12492                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
12493                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
12494               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
12495                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
12496                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
12497
12498               if (skip)
12499                 memset (&outrel, 0, sizeof outrel);
12500               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
12501                        && !is_opd
12502                        && r_type != R_PPC64_TOC)
12503                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
12504               else
12505                 {
12506                   /* This symbol is local, or marked to become local,
12507                      or this is an opd section reloc which must point
12508                      at a local function.  */
12509                   outrel.r_addend += relocation;
12510                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12511                     {
12512                       if (is_opd && h != NULL)
12513                         {
12514                           /* Lie about opd entries.  This case occurs
12515                              when building shared libraries and we
12516                              reference a function in another shared
12517                              lib.  The same thing happens for a weak
12518                              definition in an application that's
12519                              overridden by a strong definition in a
12520                              shared lib.  (I believe this is a generic
12521                              bug in binutils handling of weak syms.)
12522                              In these cases we won't use the opd
12523                              entry in this lib.  */
12524                           unresolved_reloc = FALSE;
12525                         }
12526                       if (!is_opd
12527                           && r_type == R_PPC64_ADDR64
12528                           && (h != NULL
12529                               ? h->elf.type == STT_GNU_IFUNC
12530                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12531                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12532                       else
12533                         {
12534                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12535
12536                           /* We need to relocate .opd contents for ld.so.
12537                              Prelink also wants simple and consistent rules
12538                              for relocs.  This make all RELATIVE relocs have
12539                              *r_offset equal to r_addend.  */
12540                           relocate = TRUE;
12541                         }
12542                     }
12543                   else
12544                     {
12545                       long indx = 0;
12546
12547                       if (h != NULL
12548                           ? h->elf.type == STT_GNU_IFUNC
12549                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12550                         {
12551                           (*_bfd_error_handler)
12552                             (_("%B(%A+0x%lx): relocation %s for indirect "
12553                                "function %s unsupported"),
12554                              input_bfd,
12555                              input_section,
12556                              (long) rel->r_offset,
12557                              ppc64_elf_howto_table[r_type]->name,
12558                              sym_name);
12559                           ret = FALSE;
12560                         }
12561                       else if (r_symndx == 0 || bfd_is_abs_section (sec))
12562                         ;
12563                       else if (sec == NULL || sec->owner == NULL)
12564                         {
12565                           bfd_set_error (bfd_error_bad_value);
12566                           return FALSE;
12567                         }
12568                       else
12569                         {
12570                           asection *osec;
12571
12572                           osec = sec->output_section;
12573                           indx = elf_section_data (osec)->dynindx;
12574
12575                           if (indx == 0)
12576                             {
12577                               if ((osec->flags & SEC_READONLY) == 0
12578                                   && htab->elf.data_index_section != NULL)
12579                                 osec = htab->elf.data_index_section;
12580                               else
12581                                 osec = htab->elf.text_index_section;
12582                               indx = elf_section_data (osec)->dynindx;
12583                             }
12584                           BFD_ASSERT (indx != 0);
12585
12586                           /* We are turning this relocation into one
12587                              against a section symbol, so subtract out
12588                              the output section's address but not the
12589                              offset of the input section in the output
12590                              section.  */
12591                           outrel.r_addend -= osec->vma;
12592                         }
12593
12594                       outrel.r_info = ELF64_R_INFO (indx, r_type);
12595                     }
12596                 }
12597
12598               sreloc = elf_section_data (input_section)->sreloc;
12599               if (!htab->elf.dynamic_sections_created)
12600                 sreloc = htab->reliplt;
12601               if (sreloc == NULL)
12602                 abort ();
12603
12604               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
12605                   >= sreloc->size)
12606                 abort ();
12607               loc = sreloc->contents;
12608               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
12609               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12610
12611               /* If this reloc is against an external symbol, it will
12612                  be computed at runtime, so there's no need to do
12613                  anything now.  However, for the sake of prelink ensure
12614                  that the section contents are a known value.  */
12615               if (! relocate)
12616                 {
12617                   unresolved_reloc = FALSE;
12618                   /* The value chosen here is quite arbitrary as ld.so
12619                      ignores section contents except for the special
12620                      case of .opd where the contents might be accessed
12621                      before relocation.  Choose zero, as that won't
12622                      cause reloc overflow.  */
12623                   relocation = 0;
12624                   addend = 0;
12625                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
12626                      to improve backward compatibility with older
12627                      versions of ld.  */
12628                   if (r_type == R_PPC64_ADDR64)
12629                     addend = outrel.r_addend;
12630                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
12631                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
12632                     addend = (input_section->output_section->vma
12633                               + input_section->output_offset
12634                               + rel->r_offset);
12635                 }
12636             }
12637           break;
12638
12639         case R_PPC64_COPY:
12640         case R_PPC64_GLOB_DAT:
12641         case R_PPC64_JMP_SLOT:
12642         case R_PPC64_JMP_IREL:
12643         case R_PPC64_RELATIVE:
12644           /* We shouldn't ever see these dynamic relocs in relocatable
12645              files.  */
12646           /* Fall through.  */
12647
12648         case R_PPC64_PLTGOT16:
12649         case R_PPC64_PLTGOT16_DS:
12650         case R_PPC64_PLTGOT16_HA:
12651         case R_PPC64_PLTGOT16_HI:
12652         case R_PPC64_PLTGOT16_LO:
12653         case R_PPC64_PLTGOT16_LO_DS:
12654         case R_PPC64_PLTREL32:
12655         case R_PPC64_PLTREL64:
12656           /* These ones haven't been implemented yet.  */
12657
12658           (*_bfd_error_handler)
12659             (_("%B: relocation %s is not supported for symbol %s."),
12660              input_bfd,
12661              ppc64_elf_howto_table[r_type]->name, sym_name);
12662
12663           bfd_set_error (bfd_error_invalid_operation);
12664           ret = FALSE;
12665           continue;
12666         }
12667
12668       /* Do any further special processing.  */
12669       switch (r_type)
12670         {
12671         default:
12672           break;
12673
12674         case R_PPC64_ADDR16_HA:
12675         case R_PPC64_REL16_HA:
12676         case R_PPC64_ADDR16_HIGHERA:
12677         case R_PPC64_ADDR16_HIGHESTA:
12678         case R_PPC64_TOC16_HA:
12679         case R_PPC64_SECTOFF_HA:
12680         case R_PPC64_TPREL16_HA:
12681         case R_PPC64_DTPREL16_HA:
12682         case R_PPC64_TPREL16_HIGHER:
12683         case R_PPC64_TPREL16_HIGHERA:
12684         case R_PPC64_TPREL16_HIGHEST:
12685         case R_PPC64_TPREL16_HIGHESTA:
12686         case R_PPC64_DTPREL16_HIGHER:
12687         case R_PPC64_DTPREL16_HIGHERA:
12688         case R_PPC64_DTPREL16_HIGHEST:
12689         case R_PPC64_DTPREL16_HIGHESTA:
12690           /* It's just possible that this symbol is a weak symbol
12691              that's not actually defined anywhere. In that case,
12692              'sec' would be NULL, and we should leave the symbol
12693              alone (it will be set to zero elsewhere in the link).  */
12694           if (sec == NULL)
12695             break;
12696           /* Fall thru */
12697
12698         case R_PPC64_GOT16_HA:
12699         case R_PPC64_PLTGOT16_HA:
12700         case R_PPC64_PLT16_HA:
12701         case R_PPC64_GOT_TLSGD16_HA:
12702         case R_PPC64_GOT_TLSLD16_HA:
12703         case R_PPC64_GOT_TPREL16_HA:
12704         case R_PPC64_GOT_DTPREL16_HA:
12705           /* Add 0x10000 if sign bit in 0:15 is set.
12706              Bits 0:15 are not used.  */
12707           addend += 0x8000;
12708           break;
12709
12710         case R_PPC64_ADDR16_DS:
12711         case R_PPC64_ADDR16_LO_DS:
12712         case R_PPC64_GOT16_DS:
12713         case R_PPC64_GOT16_LO_DS:
12714         case R_PPC64_PLT16_LO_DS:
12715         case R_PPC64_SECTOFF_DS:
12716         case R_PPC64_SECTOFF_LO_DS:
12717         case R_PPC64_TOC16_DS:
12718         case R_PPC64_TOC16_LO_DS:
12719         case R_PPC64_PLTGOT16_DS:
12720         case R_PPC64_PLTGOT16_LO_DS:
12721         case R_PPC64_GOT_TPREL16_DS:
12722         case R_PPC64_GOT_TPREL16_LO_DS:
12723         case R_PPC64_GOT_DTPREL16_DS:
12724         case R_PPC64_GOT_DTPREL16_LO_DS:
12725         case R_PPC64_TPREL16_DS:
12726         case R_PPC64_TPREL16_LO_DS:
12727         case R_PPC64_DTPREL16_DS:
12728         case R_PPC64_DTPREL16_LO_DS:
12729           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
12730           mask = 3;
12731           /* If this reloc is against an lq insn, then the value must be
12732              a multiple of 16.  This is somewhat of a hack, but the
12733              "correct" way to do this by defining _DQ forms of all the
12734              _DS relocs bloats all reloc switches in this file.  It
12735              doesn't seem to make much sense to use any of these relocs
12736              in data, so testing the insn should be safe.  */
12737           if ((insn & (0x3f << 26)) == (56u << 26))
12738             mask = 15;
12739           if (((relocation + addend) & mask) != 0)
12740             {
12741               (*_bfd_error_handler)
12742                 (_("%B: error: relocation %s not a multiple of %d"),
12743                  input_bfd,
12744                  ppc64_elf_howto_table[r_type]->name,
12745                  mask + 1);
12746               bfd_set_error (bfd_error_bad_value);
12747               ret = FALSE;
12748               continue;
12749             }
12750           break;
12751         }
12752
12753       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
12754          because such sections are not SEC_ALLOC and thus ld.so will
12755          not process them.  */
12756       if (unresolved_reloc
12757           && !((input_section->flags & SEC_DEBUGGING) != 0
12758                && h->elf.def_dynamic))
12759         {
12760           (*_bfd_error_handler)
12761             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
12762              input_bfd,
12763              input_section,
12764              (long) rel->r_offset,
12765              ppc64_elf_howto_table[(int) r_type]->name,
12766              h->elf.root.root.string);
12767           ret = FALSE;
12768         }
12769
12770       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
12771                                     input_bfd,
12772                                     input_section,
12773                                     contents,
12774                                     rel->r_offset,
12775                                     relocation,
12776                                     addend);
12777
12778       if (r != bfd_reloc_ok)
12779         {
12780           if (sym_name == NULL)
12781             sym_name = "(null)";
12782           if (r == bfd_reloc_overflow)
12783             {
12784               if (warned)
12785                 continue;
12786               if (h != NULL
12787                   && h->elf.root.type == bfd_link_hash_undefweak
12788                   && ppc64_elf_howto_table[r_type]->pc_relative)
12789                 {
12790                   /* Assume this is a call protected by other code that
12791                      detects the symbol is undefined.  If this is the case,
12792                      we can safely ignore the overflow.  If not, the
12793                      program is hosed anyway, and a little warning isn't
12794                      going to help.  */
12795
12796                   continue;
12797                 }
12798
12799               if (!((*info->callbacks->reloc_overflow)
12800                     (info, (h ? &h->elf.root : NULL), sym_name,
12801                      ppc64_elf_howto_table[r_type]->name,
12802                      orig_addend, input_bfd, input_section, rel->r_offset)))
12803                 return FALSE;
12804             }
12805           else
12806             {
12807               (*_bfd_error_handler)
12808                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
12809                  input_bfd,
12810                  input_section,
12811                  (long) rel->r_offset,
12812                  ppc64_elf_howto_table[r_type]->name,
12813                  sym_name,
12814                  (int) r);
12815               ret = FALSE;
12816             }
12817         }
12818     }
12819
12820   /* If we're emitting relocations, then shortly after this function
12821      returns, reloc offsets and addends for this section will be
12822      adjusted.  Worse, reloc symbol indices will be for the output
12823      file rather than the input.  Save a copy of the relocs for
12824      opd_entry_value.  */
12825   if (is_opd && (info->emitrelocations || info->relocatable))
12826     {
12827       bfd_size_type amt;
12828       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
12829       rel = bfd_alloc (input_bfd, amt);
12830       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
12831       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
12832       if (rel == NULL)
12833         return FALSE;
12834       memcpy (rel, relocs, amt);
12835     }
12836   return ret;
12837 }
12838
12839 /* Adjust the value of any local symbols in opd sections.  */
12840
12841 static int
12842 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
12843                               const char *name ATTRIBUTE_UNUSED,
12844                               Elf_Internal_Sym *elfsym,
12845                               asection *input_sec,
12846                               struct elf_link_hash_entry *h)
12847 {
12848   struct _opd_sec_data *opd;
12849   long adjust;
12850   bfd_vma value;
12851
12852   if (h != NULL)
12853     return 1;
12854
12855   opd = get_opd_info (input_sec);
12856   if (opd == NULL || opd->adjust == NULL)
12857     return 1;
12858
12859   value = elfsym->st_value - input_sec->output_offset;
12860   if (!info->relocatable)
12861     value -= input_sec->output_section->vma;
12862
12863   adjust = opd->adjust[value / 8];
12864   if (adjust == -1)
12865     return 2;
12866
12867   elfsym->st_value += adjust;
12868   return 1;
12869 }
12870
12871 /* Finish up dynamic symbol handling.  We set the contents of various
12872    dynamic sections here.  */
12873
12874 static bfd_boolean
12875 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12876                                  struct bfd_link_info *info,
12877                                  struct elf_link_hash_entry *h,
12878                                  Elf_Internal_Sym *sym)
12879 {
12880   struct ppc_link_hash_table *htab;
12881   struct plt_entry *ent;
12882   Elf_Internal_Rela rela;
12883   bfd_byte *loc;
12884
12885   htab = ppc_hash_table (info);
12886   if (htab == NULL)
12887     return FALSE;
12888
12889   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12890     if (ent->plt.offset != (bfd_vma) -1)
12891       {
12892         /* This symbol has an entry in the procedure linkage
12893            table.  Set it up.  */
12894         if (!htab->elf.dynamic_sections_created
12895             || h->dynindx == -1)
12896           {
12897             BFD_ASSERT (h->type == STT_GNU_IFUNC
12898                         && h->def_regular
12899                         && (h->root.type == bfd_link_hash_defined
12900                             || h->root.type == bfd_link_hash_defweak));
12901             rela.r_offset = (htab->iplt->output_section->vma
12902                              + htab->iplt->output_offset
12903                              + ent->plt.offset);
12904             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
12905             rela.r_addend = (h->root.u.def.value
12906                              + h->root.u.def.section->output_offset
12907                              + h->root.u.def.section->output_section->vma
12908                              + ent->addend);
12909             loc = (htab->reliplt->contents
12910                    + (htab->reliplt->reloc_count++
12911                       * sizeof (Elf64_External_Rela)));
12912           }
12913         else
12914           {
12915             rela.r_offset = (htab->plt->output_section->vma
12916                              + htab->plt->output_offset
12917                              + ent->plt.offset);
12918             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12919             rela.r_addend = ent->addend;
12920             loc = (htab->relplt->contents
12921                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12922                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12923           }
12924         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12925       }
12926
12927   if (h->needs_copy)
12928     {
12929       /* This symbol needs a copy reloc.  Set it up.  */
12930
12931       if (h->dynindx == -1
12932           || (h->root.type != bfd_link_hash_defined
12933               && h->root.type != bfd_link_hash_defweak)
12934           || htab->relbss == NULL)
12935         abort ();
12936
12937       rela.r_offset = (h->root.u.def.value
12938                        + h->root.u.def.section->output_section->vma
12939                        + h->root.u.def.section->output_offset);
12940       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12941       rela.r_addend = 0;
12942       loc = htab->relbss->contents;
12943       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
12944       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12945     }
12946
12947   /* Mark some specially defined symbols as absolute.  */
12948   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12949     sym->st_shndx = SHN_ABS;
12950
12951   return TRUE;
12952 }
12953
12954 /* Used to decide how to sort relocs in an optimal manner for the
12955    dynamic linker, before writing them out.  */
12956
12957 static enum elf_reloc_type_class
12958 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
12959 {
12960   enum elf_ppc64_reloc_type r_type;
12961
12962   r_type = ELF64_R_TYPE (rela->r_info);
12963   switch (r_type)
12964     {
12965     case R_PPC64_RELATIVE:
12966       return reloc_class_relative;
12967     case R_PPC64_JMP_SLOT:
12968       return reloc_class_plt;
12969     case R_PPC64_COPY:
12970       return reloc_class_copy;
12971     default:
12972       return reloc_class_normal;
12973     }
12974 }
12975
12976 /* Finish up the dynamic sections.  */
12977
12978 static bfd_boolean
12979 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12980                                    struct bfd_link_info *info)
12981 {
12982   struct ppc_link_hash_table *htab;
12983   bfd *dynobj;
12984   asection *sdyn;
12985
12986   htab = ppc_hash_table (info);
12987   if (htab == NULL)
12988     return FALSE;
12989
12990   dynobj = htab->elf.dynobj;
12991   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12992
12993   if (htab->elf.dynamic_sections_created)
12994     {
12995       Elf64_External_Dyn *dyncon, *dynconend;
12996
12997       if (sdyn == NULL || htab->got == NULL)
12998         abort ();
12999
13000       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13001       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13002       for (; dyncon < dynconend; dyncon++)
13003         {
13004           Elf_Internal_Dyn dyn;
13005           asection *s;
13006
13007           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13008
13009           switch (dyn.d_tag)
13010             {
13011             default:
13012               continue;
13013
13014             case DT_PPC64_GLINK:
13015               s = htab->glink;
13016               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13017               /* We stupidly defined DT_PPC64_GLINK to be the start
13018                  of glink rather than the first entry point, which is
13019                  what ld.so needs, and now have a bigger stub to
13020                  support automatic multiple TOCs.  */
13021               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13022               break;
13023
13024             case DT_PPC64_OPD:
13025               s = bfd_get_section_by_name (output_bfd, ".opd");
13026               if (s == NULL)
13027                 continue;
13028               dyn.d_un.d_ptr = s->vma;
13029               break;
13030
13031             case DT_PPC64_OPDSZ:
13032               s = bfd_get_section_by_name (output_bfd, ".opd");
13033               if (s == NULL)
13034                 continue;
13035               dyn.d_un.d_val = s->size;
13036               break;
13037
13038             case DT_PLTGOT:
13039               s = htab->plt;
13040               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13041               break;
13042
13043             case DT_JMPREL:
13044               s = htab->relplt;
13045               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13046               break;
13047
13048             case DT_PLTRELSZ:
13049               dyn.d_un.d_val = htab->relplt->size;
13050               break;
13051
13052             case DT_RELASZ:
13053               /* Don't count procedure linkage table relocs in the
13054                  overall reloc count.  */
13055               s = htab->relplt;
13056               if (s == NULL)
13057                 continue;
13058               dyn.d_un.d_val -= s->size;
13059               break;
13060
13061             case DT_RELA:
13062               /* We may not be using the standard ELF linker script.
13063                  If .rela.plt is the first .rela section, we adjust
13064                  DT_RELA to not include it.  */
13065               s = htab->relplt;
13066               if (s == NULL)
13067                 continue;
13068               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13069                 continue;
13070               dyn.d_un.d_ptr += s->size;
13071               break;
13072             }
13073
13074           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13075         }
13076     }
13077
13078   if (htab->got != NULL && htab->got->size != 0)
13079     {
13080       /* Fill in the first entry in the global offset table.
13081          We use it to hold the link-time TOCbase.  */
13082       bfd_put_64 (output_bfd,
13083                   elf_gp (output_bfd) + TOC_BASE_OFF,
13084                   htab->got->contents);
13085
13086       /* Set .got entry size.  */
13087       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13088     }
13089
13090   if (htab->plt != NULL && htab->plt->size != 0)
13091     {
13092       /* Set .plt entry size.  */
13093       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13094         = PLT_ENTRY_SIZE;
13095     }
13096
13097   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13098      brlt ourselves if emitrelocations.  */
13099   if (htab->brlt != NULL
13100       && htab->brlt->reloc_count != 0
13101       && !_bfd_elf_link_output_relocs (output_bfd,
13102                                        htab->brlt,
13103                                        &elf_section_data (htab->brlt)->rel_hdr,
13104                                        elf_section_data (htab->brlt)->relocs,
13105                                        NULL))
13106     return FALSE;
13107
13108   if (htab->glink != NULL
13109       && htab->glink->reloc_count != 0
13110       && !_bfd_elf_link_output_relocs (output_bfd,
13111                                        htab->glink,
13112                                        &elf_section_data (htab->glink)->rel_hdr,
13113                                        elf_section_data (htab->glink)->relocs,
13114                                        NULL))
13115     return FALSE;
13116
13117   /* We need to handle writing out multiple GOT sections ourselves,
13118      since we didn't add them to DYNOBJ.  We know dynobj is the first
13119      bfd.  */
13120   while ((dynobj = dynobj->link_next) != NULL)
13121     {
13122       asection *s;
13123
13124       if (!is_ppc64_elf (dynobj))
13125         continue;
13126
13127       s = ppc64_elf_tdata (dynobj)->got;
13128       if (s != NULL
13129           && s->size != 0
13130           && s->output_section != bfd_abs_section_ptr
13131           && !bfd_set_section_contents (output_bfd, s->output_section,
13132                                         s->contents, s->output_offset,
13133                                         s->size))
13134         return FALSE;
13135       s = ppc64_elf_tdata (dynobj)->relgot;
13136       if (s != NULL
13137           && s->size != 0
13138           && s->output_section != bfd_abs_section_ptr
13139           && !bfd_set_section_contents (output_bfd, s->output_section,
13140                                         s->contents, s->output_offset,
13141                                         s->size))
13142         return FALSE;
13143     }
13144
13145   return TRUE;
13146 }
13147
13148 #include "elf64-target.h"