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