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, 2011 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 #include "dwarf2.h"
  38
  39 static bfd_reloc_status_type ppc64_elf_ha_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_branch_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_toc_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57 static bfd_vma opd_entry_value
  58   (asection *, bfd_vma, asection **, bfd_vma *);
  59
  60 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  61 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  62 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  63 #define TARGET_BIG_NAME         "elf64-powerpc"
  64 #define ELF_ARCH                bfd_arch_powerpc
  65 #define ELF_TARGET_ID           PPC64_ELF_DATA
  66 #define ELF_MACHINE_CODE        EM_PPC64
  67 #define ELF_MAXPAGESIZE         0x10000
  68 #define ELF_COMMONPAGESIZE      0x1000
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  _bfd_generic_verify_endian_match
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  99 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 111 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 112 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 113 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 114 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 115 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 116 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 117 #define elf_backend_special_sections          ppc64_elf_special_sections
 118 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 119
 120 /* The name of the dynamic interpreter.  This is put in the .interp
 121    section.  */
 122 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 123
 124 /* The size in bytes of an entry in the procedure linkage table.  */
 125 #define PLT_ENTRY_SIZE 24
 126
 127 /* The initial size of the plt reserved for the dynamic linker.  */
 128 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 129
 130 /* TOC base pointers offset from start of TOC.  */
 131 #define TOC_BASE_OFF    0x8000
 132
 133 /* Offset of tp and dtp pointers from start of TLS block.  */
 134 #define TP_OFFSET       0x7000
 135 #define DTP_OFFSET      0x8000
 136
 137 /* .plt call stub instructions.  The normal stub is like this, but
 138    sometimes the .plt entry crosses a 64k boundary and we need to
 139    insert an addi to adjust r12.  */
 140 #define PLT_CALL_STUB_SIZE (7*4)
 141 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 142 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 143 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 144 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 145 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 146                                         /* ld    %r11,xxx+16@l(%r12) */
 147 #define BCTR            0x4e800420      /* bctr                      */
 148
 149
 150 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 151 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 152 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 153 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 154
 155 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 156 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 157
 158 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 159
 160 /* glink call stub instructions.  We enter with the index in R0.  */
 161 #define GLINK_CALL_STUB_SIZE (16*4)
 162                                         /* 0:                           */
 163                                         /*  .quad plt0-1f               */
 164                                         /* __glink:                     */
 165 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 166 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 167                                         /* 1:                           */
 168 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 169 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 170 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 171 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 172                                         /*  ld %11,0(%12)               */
 173                                         /*  ld %2,8(%12)                */
 174                                         /*  mtctr %11                   */
 175                                         /*  ld %11,16(%12)              */
 176                                         /*  bctr                        */
 177
 178 /* Pad with this.  */
 179 #define NOP             0x60000000
 180
 181 /* Some other nops.  */
 182 #define CROR_151515     0x4def7b82
 183 #define CROR_313131     0x4ffffb82
 184
 185 /* .glink entries for the first 32k functions are two instructions.  */
 186 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 187 #define B_DOT           0x48000000      /* b     .              */
 188
 189 /* After that, we need two instructions to load the index, followed by
 190    a branch.  */
 191 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 192 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 193
 194 /* Instructions used by the save and restore reg functions.  */
 195 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 196 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 197 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 198 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 199 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 200 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 201 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 202 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 203 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 204 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 205 #define BLR             0x4e800020      /* blr                  */
 206
 207 /* Since .opd is an array of descriptors and each entry will end up
 208    with identical R_PPC64_RELATIVE relocs, there is really no need to
 209    propagate .opd relocs;  The dynamic linker should be taught to
 210    relocate .opd without reloc entries.  */
 211 #ifndef NO_OPD_RELOCS
 212 #define NO_OPD_RELOCS 0
 213 #endif
 214 \f
 215 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 216
 217 /* Relocation HOWTO's.  */
 218 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 219
 220 static reloc_howto_type ppc64_elf_howto_raw[] = {
 221   /* This reloc does nothing.  */
 222   HOWTO (R_PPC64_NONE,          /* type */
 223          0,                     /* rightshift */
 224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          32,                    /* bitsize */
 226          FALSE,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_dont, /* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_PPC64_NONE",        /* name */
 231          FALSE,                 /* partial_inplace */
 232          0,                     /* src_mask */
 233          0,                     /* dst_mask */
 234          FALSE),                /* pcrel_offset */
 235
 236   /* A standard 32 bit relocation.  */
 237   HOWTO (R_PPC64_ADDR32,        /* type */
 238          0,                     /* rightshift */
 239          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 240          32,                    /* bitsize */
 241          FALSE,                 /* pc_relative */
 242          0,                     /* bitpos */
 243          complain_overflow_bitfield, /* complain_on_overflow */
 244          bfd_elf_generic_reloc, /* special_function */
 245          "R_PPC64_ADDR32",      /* name */
 246          FALSE,                 /* partial_inplace */
 247          0,                     /* src_mask */
 248          0xffffffff,            /* dst_mask */
 249          FALSE),                /* pcrel_offset */
 250
 251   /* An absolute 26 bit branch; the lower two bits must be zero.
 252      FIXME: we don't check that, we just clear them.  */
 253   HOWTO (R_PPC64_ADDR24,        /* type */
 254          0,                     /* rightshift */
 255          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          26,                    /* bitsize */
 257          FALSE,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_bitfield, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC64_ADDR24",      /* name */
 262          FALSE,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0x03fffffc,            /* dst_mask */
 265          FALSE),                /* pcrel_offset */
 266
 267   /* A standard 16 bit relocation.  */
 268   HOWTO (R_PPC64_ADDR16,        /* type */
 269          0,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          16,                    /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_bitfield, /* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_PPC64_ADDR16",      /* name */
 277          FALSE,                 /* partial_inplace */
 278          0,                     /* src_mask */
 279          0xffff,                /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281
 282   /* A 16 bit relocation without overflow.  */
 283   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 284          0,                     /* rightshift */
 285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          16,                    /* bitsize */
 287          FALSE,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_dont,/* complain_on_overflow */
 290          bfd_elf_generic_reloc, /* special_function */
 291          "R_PPC64_ADDR16_LO",   /* name */
 292          FALSE,                 /* partial_inplace */
 293          0,                     /* src_mask */
 294          0xffff,                /* dst_mask */
 295          FALSE),                /* pcrel_offset */
 296
 297   /* Bits 16-31 of an address.  */
 298   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 299          16,                    /* rightshift */
 300          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 301          16,                    /* bitsize */
 302          FALSE,                 /* pc_relative */
 303          0,                     /* bitpos */
 304          complain_overflow_dont, /* complain_on_overflow */
 305          bfd_elf_generic_reloc, /* special_function */
 306          "R_PPC64_ADDR16_HI",   /* name */
 307          FALSE,                 /* partial_inplace */
 308          0,                     /* src_mask */
 309          0xffff,                /* dst_mask */
 310          FALSE),                /* pcrel_offset */
 311
 312   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 313      bits, treated as a signed number, is negative.  */
 314   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 315          16,                    /* rightshift */
 316          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          16,                    /* bitsize */
 318          FALSE,                 /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_dont, /* complain_on_overflow */
 321          ppc64_elf_ha_reloc,    /* special_function */
 322          "R_PPC64_ADDR16_HA",   /* name */
 323          FALSE,                 /* partial_inplace */
 324          0,                     /* src_mask */
 325          0xffff,                /* dst_mask */
 326          FALSE),                /* pcrel_offset */
 327
 328   /* An absolute 16 bit branch; the lower two bits must be zero.
 329      FIXME: we don't check that, we just clear them.  */
 330   HOWTO (R_PPC64_ADDR14,        /* type */
 331          0,                     /* rightshift */
 332          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_bitfield, /* complain_on_overflow */
 337          ppc64_elf_branch_reloc, /* special_function */
 338          "R_PPC64_ADDR14",      /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0x0000fffc,            /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* An absolute 16 bit branch, for which bit 10 should be set to
 345      indicate that the branch is expected to be taken.  The lower two
 346      bits must be zero.  */
 347   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 348          0,                     /* rightshift */
 349          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          16,                    /* bitsize */
 351          FALSE,                 /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_bitfield, /* complain_on_overflow */
 354          ppc64_elf_brtaken_reloc, /* special_function */
 355          "R_PPC64_ADDR14_BRTAKEN",/* name */
 356          FALSE,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0x0000fffc,            /* dst_mask */
 359          FALSE),                /* pcrel_offset */
 360
 361   /* An absolute 16 bit branch, for which bit 10 should be set to
 362      indicate that the branch is not expected to be taken.  The lower
 363      two bits must be zero.  */
 364   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 365          0,                     /* rightshift */
 366          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 367          16,                    /* bitsize */
 368          FALSE,                 /* pc_relative */
 369          0,                     /* bitpos */
 370          complain_overflow_bitfield, /* complain_on_overflow */
 371          ppc64_elf_brtaken_reloc, /* special_function */
 372          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 373          FALSE,                 /* partial_inplace */
 374          0,                     /* src_mask */
 375          0x0000fffc,            /* dst_mask */
 376          FALSE),                /* pcrel_offset */
 377
 378   /* A relative 26 bit branch; the lower two bits must be zero.  */
 379   HOWTO (R_PPC64_REL24,         /* type */
 380          0,                     /* rightshift */
 381          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          26,                    /* bitsize */
 383          TRUE,                  /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_signed, /* complain_on_overflow */
 386          ppc64_elf_branch_reloc, /* special_function */
 387          "R_PPC64_REL24",       /* name */
 388          FALSE,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0x03fffffc,            /* dst_mask */
 391          TRUE),                 /* pcrel_offset */
 392
 393   /* A relative 16 bit branch; the lower two bits must be zero.  */
 394   HOWTO (R_PPC64_REL14,         /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_branch_reloc, /* special_function */
 402          "R_PPC64_REL14",       /* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 409      the branch is expected to be taken.  The lower two bits must be
 410      zero.  */
 411   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          TRUE,                  /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_REL14_BRTAKEN", /* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          TRUE),                 /* pcrel_offset */
 424
 425   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 426      the branch is not expected to be taken.  The lower two bits must
 427      be zero.  */
 428   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 429          0,                     /* rightshift */
 430          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 431          16,                    /* bitsize */
 432          TRUE,                  /* pc_relative */
 433          0,                     /* bitpos */
 434          complain_overflow_signed, /* complain_on_overflow */
 435          ppc64_elf_brtaken_reloc, /* special_function */
 436          "R_PPC64_REL14_BRNTAKEN",/* name */
 437          FALSE,                 /* partial_inplace */
 438          0,                     /* src_mask */
 439          0x0000fffc,            /* dst_mask */
 440          TRUE),                 /* pcrel_offset */
 441
 442   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 443      symbol.  */
 444   HOWTO (R_PPC64_GOT16,         /* type */
 445          0,                     /* rightshift */
 446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 447          16,                    /* bitsize */
 448          FALSE,                 /* pc_relative */
 449          0,                     /* bitpos */
 450          complain_overflow_signed, /* complain_on_overflow */
 451          ppc64_elf_unhandled_reloc, /* special_function */
 452          "R_PPC64_GOT16",       /* name */
 453          FALSE,                 /* partial_inplace */
 454          0,                     /* src_mask */
 455          0xffff,                /* dst_mask */
 456          FALSE),                /* pcrel_offset */
 457
 458   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 459      the symbol.  */
 460   HOWTO (R_PPC64_GOT16_LO,      /* type */
 461          0,                     /* rightshift */
 462          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 463          16,                    /* bitsize */
 464          FALSE,                 /* pc_relative */
 465          0,                     /* bitpos */
 466          complain_overflow_dont, /* complain_on_overflow */
 467          ppc64_elf_unhandled_reloc, /* special_function */
 468          "R_PPC64_GOT16_LO",    /* name */
 469          FALSE,                 /* partial_inplace */
 470          0,                     /* src_mask */
 471          0xffff,                /* dst_mask */
 472          FALSE),                /* pcrel_offset */
 473
 474   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 475      the symbol.  */
 476   HOWTO (R_PPC64_GOT16_HI,      /* type */
 477          16,                    /* rightshift */
 478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          16,                    /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_dont,/* complain_on_overflow */
 483          ppc64_elf_unhandled_reloc, /* special_function */
 484          "R_PPC64_GOT16_HI",    /* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0xffff,                /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 491      the symbol.  */
 492   HOWTO (R_PPC64_GOT16_HA,      /* type */
 493          16,                    /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          16,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont,/* complain_on_overflow */
 499          ppc64_elf_unhandled_reloc, /* special_function */
 500          "R_PPC64_GOT16_HA",    /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          0xffff,                /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* This is used only by the dynamic linker.  The symbol should exist
 507      both in the object being run and in some shared library.  The
 508      dynamic linker copies the data addressed by the symbol from the
 509      shared library into the object, because the object being
 510      run has to have the data at some particular address.  */
 511   HOWTO (R_PPC64_COPY,          /* type */
 512          0,                     /* rightshift */
 513          0,                     /* this one is variable size */
 514          0,                     /* bitsize */
 515          FALSE,                 /* pc_relative */
 516          0,                     /* bitpos */
 517          complain_overflow_dont, /* complain_on_overflow */
 518          ppc64_elf_unhandled_reloc, /* special_function */
 519          "R_PPC64_COPY",        /* name */
 520          FALSE,                 /* partial_inplace */
 521          0,                     /* src_mask */
 522          0,                     /* dst_mask */
 523          FALSE),                /* pcrel_offset */
 524
 525   /* Like R_PPC64_ADDR64, but used when setting global offset table
 526      entries.  */
 527   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 528          0,                     /* rightshift */
 529          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 530          64,                    /* bitsize */
 531          FALSE,                 /* pc_relative */
 532          0,                     /* bitpos */
 533          complain_overflow_dont, /* complain_on_overflow */
 534          ppc64_elf_unhandled_reloc,  /* special_function */
 535          "R_PPC64_GLOB_DAT",    /* name */
 536          FALSE,                 /* partial_inplace */
 537          0,                     /* src_mask */
 538          ONES (64),             /* dst_mask */
 539          FALSE),                /* pcrel_offset */
 540
 541   /* Created by the link editor.  Marks a procedure linkage table
 542      entry for a symbol.  */
 543   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 544          0,                     /* rightshift */
 545          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          0,                     /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_dont, /* complain_on_overflow */
 550          ppc64_elf_unhandled_reloc, /* special_function */
 551          "R_PPC64_JMP_SLOT",    /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          0,                     /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* Used only by the dynamic linker.  When the object is run, this
 558      doubleword64 is set to the load address of the object, plus the
 559      addend.  */
 560   HOWTO (R_PPC64_RELATIVE,      /* type */
 561          0,                     /* rightshift */
 562          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 563          64,                    /* bitsize */
 564          FALSE,                 /* pc_relative */
 565          0,                     /* bitpos */
 566          complain_overflow_dont, /* complain_on_overflow */
 567          bfd_elf_generic_reloc, /* special_function */
 568          "R_PPC64_RELATIVE",    /* name */
 569          FALSE,                 /* partial_inplace */
 570          0,                     /* src_mask */
 571          ONES (64),             /* dst_mask */
 572          FALSE),                /* pcrel_offset */
 573
 574   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 575   HOWTO (R_PPC64_UADDR32,       /* type */
 576          0,                     /* rightshift */
 577          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 578          32,                    /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          0,                     /* bitpos */
 581          complain_overflow_bitfield, /* complain_on_overflow */
 582          bfd_elf_generic_reloc, /* special_function */
 583          "R_PPC64_UADDR32",     /* name */
 584          FALSE,                 /* partial_inplace */
 585          0,                     /* src_mask */
 586          0xffffffff,            /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 590   HOWTO (R_PPC64_UADDR16,       /* type */
 591          0,                     /* rightshift */
 592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          16,                    /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_bitfield, /* complain_on_overflow */
 597          bfd_elf_generic_reloc, /* special_function */
 598          "R_PPC64_UADDR16",     /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0xffff,                /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* 32-bit PC relative.  */
 605   HOWTO (R_PPC64_REL32,         /* type */
 606          0,                     /* rightshift */
 607          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 608          32,                    /* bitsize */
 609          TRUE,                  /* pc_relative */
 610          0,                     /* bitpos */
 611          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 612          complain_overflow_signed, /* complain_on_overflow */
 613          bfd_elf_generic_reloc, /* special_function */
 614          "R_PPC64_REL32",       /* name */
 615          FALSE,                 /* partial_inplace */
 616          0,                     /* src_mask */
 617          0xffffffff,            /* dst_mask */
 618          TRUE),                 /* pcrel_offset */
 619
 620   /* 32-bit relocation to the symbol's procedure linkage table.  */
 621   HOWTO (R_PPC64_PLT32,         /* type */
 622          0,                     /* rightshift */
 623          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 624          32,                    /* bitsize */
 625          FALSE,                 /* pc_relative */
 626          0,                     /* bitpos */
 627          complain_overflow_bitfield, /* complain_on_overflow */
 628          ppc64_elf_unhandled_reloc, /* special_function */
 629          "R_PPC64_PLT32",       /* name */
 630          FALSE,                 /* partial_inplace */
 631          0,                     /* src_mask */
 632          0xffffffff,            /* dst_mask */
 633          FALSE),                /* pcrel_offset */
 634
 635   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 636      FIXME: R_PPC64_PLTREL32 not supported.  */
 637   HOWTO (R_PPC64_PLTREL32,      /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          32,                    /* bitsize */
 641          TRUE,                  /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_signed, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_PLTREL32",    /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffffffff,            /* dst_mask */
 649          TRUE),                 /* pcrel_offset */
 650
 651   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 652      the symbol.  */
 653   HOWTO (R_PPC64_PLT16_LO,      /* type */
 654          0,                     /* rightshift */
 655          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          16,                    /* bitsize */
 657          FALSE,                 /* pc_relative */
 658          0,                     /* bitpos */
 659          complain_overflow_dont, /* complain_on_overflow */
 660          ppc64_elf_unhandled_reloc, /* special_function */
 661          "R_PPC64_PLT16_LO",    /* name */
 662          FALSE,                 /* partial_inplace */
 663          0,                     /* src_mask */
 664          0xffff,                /* dst_mask */
 665          FALSE),                /* pcrel_offset */
 666
 667   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 668      the symbol.  */
 669   HOWTO (R_PPC64_PLT16_HI,      /* type */
 670          16,                    /* rightshift */
 671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 672          16,                    /* bitsize */
 673          FALSE,                 /* pc_relative */
 674          0,                     /* bitpos */
 675          complain_overflow_dont, /* complain_on_overflow */
 676          ppc64_elf_unhandled_reloc, /* special_function */
 677          "R_PPC64_PLT16_HI",    /* name */
 678          FALSE,                 /* partial_inplace */
 679          0,                     /* src_mask */
 680          0xffff,                /* dst_mask */
 681          FALSE),                /* pcrel_offset */
 682
 683   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 684      the symbol.  */
 685   HOWTO (R_PPC64_PLT16_HA,      /* type */
 686          16,                    /* rightshift */
 687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 688          16,                    /* bitsize */
 689          FALSE,                 /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_dont, /* complain_on_overflow */
 692          ppc64_elf_unhandled_reloc, /* special_function */
 693          "R_PPC64_PLT16_HA",    /* name */
 694          FALSE,                 /* partial_inplace */
 695          0,                     /* src_mask */
 696          0xffff,                /* dst_mask */
 697          FALSE),                /* pcrel_offset */
 698
 699   /* 16-bit section relative relocation.  */
 700   HOWTO (R_PPC64_SECTOFF,       /* type */
 701          0,                     /* rightshift */
 702          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          16,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_bitfield, /* complain_on_overflow */
 707          ppc64_elf_sectoff_reloc, /* special_function */
 708          "R_PPC64_SECTOFF",     /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffff,                /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 715   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 716          0,                     /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_dont, /* complain_on_overflow */
 722          ppc64_elf_sectoff_reloc, /* special_function */
 723          "R_PPC64_SECTOFF_LO",  /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* 16-bit upper half section relative relocation.  */
 730   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 731          16,                    /* rightshift */
 732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 733          16,                    /* bitsize */
 734          FALSE,                 /* pc_relative */
 735          0,                     /* bitpos */
 736          complain_overflow_dont, /* complain_on_overflow */
 737          ppc64_elf_sectoff_reloc, /* special_function */
 738          "R_PPC64_SECTOFF_HI",  /* name */
 739          FALSE,                 /* partial_inplace */
 740          0,                     /* src_mask */
 741          0xffff,                /* dst_mask */
 742          FALSE),                /* pcrel_offset */
 743
 744   /* 16-bit upper half adjusted section relative relocation.  */
 745   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 746          16,                    /* rightshift */
 747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          16,                    /* bitsize */
 749          FALSE,                 /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_dont, /* complain_on_overflow */
 752          ppc64_elf_sectoff_ha_reloc, /* special_function */
 753          "R_PPC64_SECTOFF_HA",  /* name */
 754          FALSE,                 /* partial_inplace */
 755          0,                     /* src_mask */
 756          0xffff,                /* dst_mask */
 757          FALSE),                /* pcrel_offset */
 758
 759   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 760   HOWTO (R_PPC64_REL30,         /* type */
 761          2,                     /* rightshift */
 762          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          30,                    /* bitsize */
 764          TRUE,                  /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_dont, /* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_PPC64_REL30",       /* name */
 769          FALSE,                 /* partial_inplace */
 770          0,                     /* src_mask */
 771          0xfffffffc,            /* dst_mask */
 772          TRUE),                 /* pcrel_offset */
 773
 774   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 775
 776   /* A standard 64-bit relocation.  */
 777   HOWTO (R_PPC64_ADDR64,        /* type */
 778          0,                     /* rightshift */
 779          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 780          64,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_dont, /* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_PPC64_ADDR64",      /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          ONES (64),             /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   /* The bits 32-47 of an address.  */
 792   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 793          32,                    /* rightshift */
 794          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          FALSE,                 /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_dont, /* complain_on_overflow */
 799          bfd_elf_generic_reloc, /* special_function */
 800          "R_PPC64_ADDR16_HIGHER", /* name */
 801          FALSE,                 /* partial_inplace */
 802          0,                     /* src_mask */
 803          0xffff,                /* dst_mask */
 804          FALSE),                /* pcrel_offset */
 805
 806   /* The bits 32-47 of an address, plus 1 if the contents of the low
 807      16 bits, treated as a signed number, is negative.  */
 808   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 809          32,                    /* rightshift */
 810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 811          16,                    /* bitsize */
 812          FALSE,                 /* pc_relative */
 813          0,                     /* bitpos */
 814          complain_overflow_dont, /* complain_on_overflow */
 815          ppc64_elf_ha_reloc,    /* special_function */
 816          "R_PPC64_ADDR16_HIGHERA", /* name */
 817          FALSE,                 /* partial_inplace */
 818          0,                     /* src_mask */
 819          0xffff,                /* dst_mask */
 820          FALSE),                /* pcrel_offset */
 821
 822   /* The bits 48-63 of an address.  */
 823   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 824          48,                    /* rightshift */
 825          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 826          16,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR16_HIGHEST", /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          0xffff,                /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 48-63 of an address, plus 1 if the contents of the low
 838      16 bits, treated as a signed number, is negative.  */
 839   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 840          48,                    /* rightshift */
 841          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 842          16,                    /* bitsize */
 843          FALSE,                 /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          ppc64_elf_ha_reloc,    /* special_function */
 847          "R_PPC64_ADDR16_HIGHESTA", /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          0xffff,                /* dst_mask */
 851          FALSE),                /* pcrel_offset */
 852
 853   /* Like ADDR64, but may be unaligned.  */
 854   HOWTO (R_PPC64_UADDR64,       /* type */
 855          0,                     /* rightshift */
 856          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 857          64,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          bfd_elf_generic_reloc, /* special_function */
 862          "R_PPC64_UADDR64",     /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          ONES (64),             /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* 64-bit relative relocation.  */
 869   HOWTO (R_PPC64_REL64,         /* type */
 870          0,                     /* rightshift */
 871          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 872          64,                    /* bitsize */
 873          TRUE,                  /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_REL64",       /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          ONES (64),             /* dst_mask */
 881          TRUE),                 /* pcrel_offset */
 882
 883   /* 64-bit relocation to the symbol's procedure linkage table.  */
 884   HOWTO (R_PPC64_PLT64,         /* type */
 885          0,                     /* rightshift */
 886          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 887          64,                    /* bitsize */
 888          FALSE,                 /* pc_relative */
 889          0,                     /* bitpos */
 890          complain_overflow_dont, /* complain_on_overflow */
 891          ppc64_elf_unhandled_reloc, /* special_function */
 892          "R_PPC64_PLT64",       /* name */
 893          FALSE,                 /* partial_inplace */
 894          0,                     /* src_mask */
 895          ONES (64),             /* dst_mask */
 896          FALSE),                /* pcrel_offset */
 897
 898   /* 64-bit PC relative relocation to the symbol's procedure linkage
 899      table.  */
 900   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 901   HOWTO (R_PPC64_PLTREL64,      /* type */
 902          0,                     /* rightshift */
 903          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 904          64,                    /* bitsize */
 905          TRUE,                  /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_dont, /* complain_on_overflow */
 908          ppc64_elf_unhandled_reloc, /* special_function */
 909          "R_PPC64_PLTREL64",    /* name */
 910          FALSE,                 /* partial_inplace */
 911          0,                     /* src_mask */
 912          ONES (64),             /* dst_mask */
 913          TRUE),                 /* pcrel_offset */
 914
 915   /* 16 bit TOC-relative relocation.  */
 916
 917   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 918   HOWTO (R_PPC64_TOC16,         /* type */
 919          0,                     /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          FALSE,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_signed, /* complain_on_overflow */
 925          ppc64_elf_toc_reloc,   /* special_function */
 926          "R_PPC64_TOC16",       /* name */
 927          FALSE,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          FALSE),                /* pcrel_offset */
 931
 932   /* 16 bit TOC-relative relocation without overflow.  */
 933
 934   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 935   HOWTO (R_PPC64_TOC16_LO,      /* type */
 936          0,                     /* rightshift */
 937          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 938          16,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_toc_reloc,   /* special_function */
 943          "R_PPC64_TOC16_LO",    /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          0xffff,                /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 16 bit TOC-relative relocation, high 16 bits.  */
 950
 951   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 952   HOWTO (R_PPC64_TOC16_HI,      /* type */
 953          16,                    /* rightshift */
 954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 955          16,                    /* bitsize */
 956          FALSE,                 /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_toc_reloc,   /* special_function */
 960          "R_PPC64_TOC16_HI",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          0xffff,                /* dst_mask */
 964          FALSE),                /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 967      contents of the low 16 bits, treated as a signed number, is
 968      negative.  */
 969
 970   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_HA,      /* type */
 972          16,                    /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_ha_reloc, /* special_function */
 979          "R_PPC64_TOC16_HA",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 986
 987   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 988   HOWTO (R_PPC64_TOC,           /* type */
 989          0,                     /* rightshift */
 990          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 991          64,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_bitfield, /* complain_on_overflow */
 995          ppc64_elf_toc64_reloc, /* special_function */
 996          "R_PPC64_TOC",         /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          ONES (64),             /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* Like R_PPC64_GOT16, but also informs the link editor that the
1003      value to relocate may (!) refer to a PLT entry which the link
1004      editor (a) may replace with the symbol value.  If the link editor
1005      is unable to fully resolve the symbol, it may (b) create a PLT
1006      entry and store the address to the new PLT entry in the GOT.
1007      This permits lazy resolution of function symbols at run time.
1008      The link editor may also skip all of this and just (c) emit a
1009      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1010   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1011     HOWTO (R_PPC64_PLTGOT16,    /* type */
1012          0,                     /* rightshift */
1013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1014          16,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_signed, /* complain_on_overflow */
1018          ppc64_elf_unhandled_reloc, /* special_function */
1019          "R_PPC64_PLTGOT16",    /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          0xffff,                /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1026   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1027   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1028          0,                     /* rightshift */
1029          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1030          16,                    /* bitsize */
1031          FALSE,                 /* pc_relative */
1032          0,                     /* bitpos */
1033          complain_overflow_dont, /* complain_on_overflow */
1034          ppc64_elf_unhandled_reloc, /* special_function */
1035          "R_PPC64_PLTGOT16_LO", /* name */
1036          FALSE,                 /* partial_inplace */
1037          0,                     /* src_mask */
1038          0xffff,                /* dst_mask */
1039          FALSE),                /* pcrel_offset */
1040
1041   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1042   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1043   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1044          16,                    /* rightshift */
1045          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1046          16,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_unhandled_reloc, /* special_function */
1051          "R_PPC64_PLTGOT16_HI", /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          0xffff,                /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1058      1 if the contents of the low 16 bits, treated as a signed number,
1059      is negative.  */
1060   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1061   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1062          16,                    /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_dont,/* complain_on_overflow */
1068          ppc64_elf_unhandled_reloc, /* special_function */
1069          "R_PPC64_PLTGOT16_HA", /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xffff,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1076   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1077          0,                     /* rightshift */
1078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          16,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          0,                     /* bitpos */
1082          complain_overflow_bitfield, /* complain_on_overflow */
1083          bfd_elf_generic_reloc, /* special_function */
1084          "R_PPC64_ADDR16_DS",   /* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0xfffc,                /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1091   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1092          0,                     /* rightshift */
1093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          16,                    /* bitsize */
1095          FALSE,                 /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_dont,/* complain_on_overflow */
1098          bfd_elf_generic_reloc, /* special_function */
1099          "R_PPC64_ADDR16_LO_DS",/* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0xfffc,                /* dst_mask */
1103          FALSE),                /* pcrel_offset */
1104
1105   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1106   HOWTO (R_PPC64_GOT16_DS,      /* type */
1107          0,                     /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_signed, /* complain_on_overflow */
1113          ppc64_elf_unhandled_reloc, /* special_function */
1114          "R_PPC64_GOT16_DS",    /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xfffc,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1121   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1122          0,                     /* rightshift */
1123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1124          16,                    /* bitsize */
1125          FALSE,                 /* pc_relative */
1126          0,                     /* bitpos */
1127          complain_overflow_dont, /* complain_on_overflow */
1128          ppc64_elf_unhandled_reloc, /* special_function */
1129          "R_PPC64_GOT16_LO_DS", /* name */
1130          FALSE,                 /* partial_inplace */
1131          0,                     /* src_mask */
1132          0xfffc,                /* dst_mask */
1133          FALSE),                /* pcrel_offset */
1134
1135   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1136   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1137          0,                     /* rightshift */
1138          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1139          16,                    /* bitsize */
1140          FALSE,                 /* pc_relative */
1141          0,                     /* bitpos */
1142          complain_overflow_dont, /* complain_on_overflow */
1143          ppc64_elf_unhandled_reloc, /* special_function */
1144          "R_PPC64_PLT16_LO_DS", /* name */
1145          FALSE,                 /* partial_inplace */
1146          0,                     /* src_mask */
1147          0xfffc,                /* dst_mask */
1148          FALSE),                /* pcrel_offset */
1149
1150   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1151   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1152          0,                     /* rightshift */
1153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1154          16,                    /* bitsize */
1155          FALSE,                 /* pc_relative */
1156          0,                     /* bitpos */
1157          complain_overflow_bitfield, /* complain_on_overflow */
1158          ppc64_elf_sectoff_reloc, /* special_function */
1159          "R_PPC64_SECTOFF_DS",  /* name */
1160          FALSE,                 /* partial_inplace */
1161          0,                     /* src_mask */
1162          0xfffc,                /* dst_mask */
1163          FALSE),                /* pcrel_offset */
1164
1165   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1166   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1167          0,                     /* rightshift */
1168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1169          16,                    /* bitsize */
1170          FALSE,                 /* pc_relative */
1171          0,                     /* bitpos */
1172          complain_overflow_dont, /* complain_on_overflow */
1173          ppc64_elf_sectoff_reloc, /* special_function */
1174          "R_PPC64_SECTOFF_LO_DS",/* name */
1175          FALSE,                 /* partial_inplace */
1176          0,                     /* src_mask */
1177          0xfffc,                /* dst_mask */
1178          FALSE),                /* pcrel_offset */
1179
1180   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1181   HOWTO (R_PPC64_TOC16_DS,      /* type */
1182          0,                     /* rightshift */
1183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1184          16,                    /* bitsize */
1185          FALSE,                 /* pc_relative */
1186          0,                     /* bitpos */
1187          complain_overflow_signed, /* complain_on_overflow */
1188          ppc64_elf_toc_reloc,   /* special_function */
1189          "R_PPC64_TOC16_DS",    /* name */
1190          FALSE,                 /* partial_inplace */
1191          0,                     /* src_mask */
1192          0xfffc,                /* dst_mask */
1193          FALSE),                /* pcrel_offset */
1194
1195   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1196   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1197          0,                     /* rightshift */
1198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1199          16,                    /* bitsize */
1200          FALSE,                 /* pc_relative */
1201          0,                     /* bitpos */
1202          complain_overflow_dont, /* complain_on_overflow */
1203          ppc64_elf_toc_reloc,   /* special_function */
1204          "R_PPC64_TOC16_LO_DS", /* name */
1205          FALSE,                 /* partial_inplace */
1206          0,                     /* src_mask */
1207          0xfffc,                /* dst_mask */
1208          FALSE),                /* pcrel_offset */
1209
1210   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1211   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1212   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_signed, /* complain_on_overflow */
1219          ppc64_elf_unhandled_reloc, /* special_function */
1220          "R_PPC64_PLTGOT16_DS", /* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1227   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1228   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1229          0,                     /* rightshift */
1230          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1231          16,                    /* bitsize */
1232          FALSE,                 /* pc_relative */
1233          0,                     /* bitpos */
1234          complain_overflow_dont, /* complain_on_overflow */
1235          ppc64_elf_unhandled_reloc, /* special_function */
1236          "R_PPC64_PLTGOT16_LO_DS",/* name */
1237          FALSE,                 /* partial_inplace */
1238          0,                     /* src_mask */
1239          0xfffc,                /* dst_mask */
1240          FALSE),                /* pcrel_offset */
1241
1242   /* Marker relocs for TLS.  */
1243   HOWTO (R_PPC64_TLS,
1244          0,                     /* rightshift */
1245          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1246          32,                    /* bitsize */
1247          FALSE,                 /* pc_relative */
1248          0,                     /* bitpos */
1249          complain_overflow_dont, /* complain_on_overflow */
1250          bfd_elf_generic_reloc, /* special_function */
1251          "R_PPC64_TLS",         /* name */
1252          FALSE,                 /* partial_inplace */
1253          0,                     /* src_mask */
1254          0,                     /* dst_mask */
1255          FALSE),                /* pcrel_offset */
1256
1257   HOWTO (R_PPC64_TLSGD,
1258          0,                     /* rightshift */
1259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1260          32,                    /* bitsize */
1261          FALSE,                 /* pc_relative */
1262          0,                     /* bitpos */
1263          complain_overflow_dont, /* complain_on_overflow */
1264          bfd_elf_generic_reloc, /* special_function */
1265          "R_PPC64_TLSGD",       /* name */
1266          FALSE,                 /* partial_inplace */
1267          0,                     /* src_mask */
1268          0,                     /* dst_mask */
1269          FALSE),                /* pcrel_offset */
1270
1271   HOWTO (R_PPC64_TLSLD,
1272          0,                     /* rightshift */
1273          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1274          32,                    /* bitsize */
1275          FALSE,                 /* pc_relative */
1276          0,                     /* bitpos */
1277          complain_overflow_dont, /* complain_on_overflow */
1278          bfd_elf_generic_reloc, /* special_function */
1279          "R_PPC64_TLSLD",       /* name */
1280          FALSE,                 /* partial_inplace */
1281          0,                     /* src_mask */
1282          0,                     /* dst_mask */
1283          FALSE),                /* pcrel_offset */
1284
1285   HOWTO (R_PPC64_TOCSAVE,
1286          0,                     /* rightshift */
1287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1288          32,                    /* bitsize */
1289          FALSE,                 /* pc_relative */
1290          0,                     /* bitpos */
1291          complain_overflow_dont, /* complain_on_overflow */
1292          bfd_elf_generic_reloc, /* special_function */
1293          "R_PPC64_TOCSAVE",     /* name */
1294          FALSE,                 /* partial_inplace */
1295          0,                     /* src_mask */
1296          0,                     /* dst_mask */
1297          FALSE),                /* pcrel_offset */
1298
1299   /* Computes the load module index of the load module that contains the
1300      definition of its TLS sym.  */
1301   HOWTO (R_PPC64_DTPMOD64,
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_DTPMOD64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* Computes a dtv-relative displacement, the difference between the value
1316      of sym+add and the base address of the thread-local storage block that
1317      contains the definition of sym, minus 0x8000.  */
1318   HOWTO (R_PPC64_DTPREL64,
1319          0,                     /* rightshift */
1320          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1321          64,                    /* bitsize */
1322          FALSE,                 /* pc_relative */
1323          0,                     /* bitpos */
1324          complain_overflow_dont, /* complain_on_overflow */
1325          ppc64_elf_unhandled_reloc, /* special_function */
1326          "R_PPC64_DTPREL64",    /* name */
1327          FALSE,                 /* partial_inplace */
1328          0,                     /* src_mask */
1329          ONES (64),             /* dst_mask */
1330          FALSE),                /* pcrel_offset */
1331
1332   /* A 16 bit dtprel reloc.  */
1333   HOWTO (R_PPC64_DTPREL16,
1334          0,                     /* rightshift */
1335          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1336          16,                    /* bitsize */
1337          FALSE,                 /* pc_relative */
1338          0,                     /* bitpos */
1339          complain_overflow_signed, /* complain_on_overflow */
1340          ppc64_elf_unhandled_reloc, /* special_function */
1341          "R_PPC64_DTPREL16",    /* name */
1342          FALSE,                 /* partial_inplace */
1343          0,                     /* src_mask */
1344          0xffff,                /* dst_mask */
1345          FALSE),                /* pcrel_offset */
1346
1347   /* Like DTPREL16, but no overflow.  */
1348   HOWTO (R_PPC64_DTPREL16_LO,
1349          0,                     /* rightshift */
1350          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1351          16,                    /* bitsize */
1352          FALSE,                 /* pc_relative */
1353          0,                     /* bitpos */
1354          complain_overflow_dont, /* complain_on_overflow */
1355          ppc64_elf_unhandled_reloc, /* special_function */
1356          "R_PPC64_DTPREL16_LO", /* name */
1357          FALSE,                 /* partial_inplace */
1358          0,                     /* src_mask */
1359          0xffff,                /* dst_mask */
1360          FALSE),                /* pcrel_offset */
1361
1362   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1363   HOWTO (R_PPC64_DTPREL16_HI,
1364          16,                    /* rightshift */
1365          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1366          16,                    /* bitsize */
1367          FALSE,                 /* pc_relative */
1368          0,                     /* bitpos */
1369          complain_overflow_dont, /* complain_on_overflow */
1370          ppc64_elf_unhandled_reloc, /* special_function */
1371          "R_PPC64_DTPREL16_HI", /* name */
1372          FALSE,                 /* partial_inplace */
1373          0,                     /* src_mask */
1374          0xffff,                /* dst_mask */
1375          FALSE),                /* pcrel_offset */
1376
1377   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1378   HOWTO (R_PPC64_DTPREL16_HA,
1379          16,                    /* rightshift */
1380          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1381          16,                    /* bitsize */
1382          FALSE,                 /* pc_relative */
1383          0,                     /* bitpos */
1384          complain_overflow_dont, /* complain_on_overflow */
1385          ppc64_elf_unhandled_reloc, /* special_function */
1386          "R_PPC64_DTPREL16_HA", /* name */
1387          FALSE,                 /* partial_inplace */
1388          0,                     /* src_mask */
1389          0xffff,                /* dst_mask */
1390          FALSE),                /* pcrel_offset */
1391
1392   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1393   HOWTO (R_PPC64_DTPREL16_HIGHER,
1394          32,                    /* rightshift */
1395          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1396          16,                    /* bitsize */
1397          FALSE,                 /* pc_relative */
1398          0,                     /* bitpos */
1399          complain_overflow_dont, /* complain_on_overflow */
1400          ppc64_elf_unhandled_reloc, /* special_function */
1401          "R_PPC64_DTPREL16_HIGHER", /* name */
1402          FALSE,                 /* partial_inplace */
1403          0,                     /* src_mask */
1404          0xffff,                /* dst_mask */
1405          FALSE),                /* pcrel_offset */
1406
1407   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1408   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1409          32,                    /* rightshift */
1410          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1411          16,                    /* bitsize */
1412          FALSE,                 /* pc_relative */
1413          0,                     /* bitpos */
1414          complain_overflow_dont, /* complain_on_overflow */
1415          ppc64_elf_unhandled_reloc, /* special_function */
1416          "R_PPC64_DTPREL16_HIGHERA", /* name */
1417          FALSE,                 /* partial_inplace */
1418          0,                     /* src_mask */
1419          0xffff,                /* dst_mask */
1420          FALSE),                /* pcrel_offset */
1421
1422   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1423   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1424          48,                    /* rightshift */
1425          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1426          16,                    /* bitsize */
1427          FALSE,                 /* pc_relative */
1428          0,                     /* bitpos */
1429          complain_overflow_dont, /* complain_on_overflow */
1430          ppc64_elf_unhandled_reloc, /* special_function */
1431          "R_PPC64_DTPREL16_HIGHEST", /* name */
1432          FALSE,                 /* partial_inplace */
1433          0,                     /* src_mask */
1434          0xffff,                /* dst_mask */
1435          FALSE),                /* pcrel_offset */
1436
1437   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1438   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1439          48,                    /* rightshift */
1440          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1441          16,                    /* bitsize */
1442          FALSE,                 /* pc_relative */
1443          0,                     /* bitpos */
1444          complain_overflow_dont, /* complain_on_overflow */
1445          ppc64_elf_unhandled_reloc, /* special_function */
1446          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1447          FALSE,                 /* partial_inplace */
1448          0,                     /* src_mask */
1449          0xffff,                /* dst_mask */
1450          FALSE),                /* pcrel_offset */
1451
1452   /* Like DTPREL16, but for insns with a DS field.  */
1453   HOWTO (R_PPC64_DTPREL16_DS,
1454          0,                     /* rightshift */
1455          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1456          16,                    /* bitsize */
1457          FALSE,                 /* pc_relative */
1458          0,                     /* bitpos */
1459          complain_overflow_signed, /* complain_on_overflow */
1460          ppc64_elf_unhandled_reloc, /* special_function */
1461          "R_PPC64_DTPREL16_DS", /* name */
1462          FALSE,                 /* partial_inplace */
1463          0,                     /* src_mask */
1464          0xfffc,                /* dst_mask */
1465          FALSE),                /* pcrel_offset */
1466
1467   /* Like DTPREL16_DS, but no overflow.  */
1468   HOWTO (R_PPC64_DTPREL16_LO_DS,
1469          0,                     /* rightshift */
1470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1471          16,                    /* bitsize */
1472          FALSE,                 /* pc_relative */
1473          0,                     /* bitpos */
1474          complain_overflow_dont, /* complain_on_overflow */
1475          ppc64_elf_unhandled_reloc, /* special_function */
1476          "R_PPC64_DTPREL16_LO_DS", /* name */
1477          FALSE,                 /* partial_inplace */
1478          0,                     /* src_mask */
1479          0xfffc,                /* dst_mask */
1480          FALSE),                /* pcrel_offset */
1481
1482   /* Computes a tp-relative displacement, the difference between the value of
1483      sym+add and the value of the thread pointer (r13).  */
1484   HOWTO (R_PPC64_TPREL64,
1485          0,                     /* rightshift */
1486          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          64,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_TPREL64",     /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          ONES (64),             /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* A 16 bit tprel reloc.  */
1499   HOWTO (R_PPC64_TPREL16,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_TPREL16",     /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xffff,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like TPREL16, but no overflow.  */
1514   HOWTO (R_PPC64_TPREL16_LO,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_TPREL16_LO",  /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xffff,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1529   HOWTO (R_PPC64_TPREL16_HI,
1530          16,                    /* rightshift */
1531          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1532          16,                    /* bitsize */
1533          FALSE,                 /* pc_relative */
1534          0,                     /* bitpos */
1535          complain_overflow_dont, /* complain_on_overflow */
1536          ppc64_elf_unhandled_reloc, /* special_function */
1537          "R_PPC64_TPREL16_HI",  /* name */
1538          FALSE,                 /* partial_inplace */
1539          0,                     /* src_mask */
1540          0xffff,                /* dst_mask */
1541          FALSE),                /* pcrel_offset */
1542
1543   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1544   HOWTO (R_PPC64_TPREL16_HA,
1545          16,                    /* rightshift */
1546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1547          16,                    /* bitsize */
1548          FALSE,                 /* pc_relative */
1549          0,                     /* bitpos */
1550          complain_overflow_dont, /* complain_on_overflow */
1551          ppc64_elf_unhandled_reloc, /* special_function */
1552          "R_PPC64_TPREL16_HA",  /* name */
1553          FALSE,                 /* partial_inplace */
1554          0,                     /* src_mask */
1555          0xffff,                /* dst_mask */
1556          FALSE),                /* pcrel_offset */
1557
1558   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1559   HOWTO (R_PPC64_TPREL16_HIGHER,
1560          32,                    /* rightshift */
1561          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1562          16,                    /* bitsize */
1563          FALSE,                 /* pc_relative */
1564          0,                     /* bitpos */
1565          complain_overflow_dont, /* complain_on_overflow */
1566          ppc64_elf_unhandled_reloc, /* special_function */
1567          "R_PPC64_TPREL16_HIGHER",      /* name */
1568          FALSE,                 /* partial_inplace */
1569          0,                     /* src_mask */
1570          0xffff,                /* dst_mask */
1571          FALSE),                /* pcrel_offset */
1572
1573   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1574   HOWTO (R_PPC64_TPREL16_HIGHERA,
1575          32,                    /* rightshift */
1576          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1577          16,                    /* bitsize */
1578          FALSE,                 /* pc_relative */
1579          0,                     /* bitpos */
1580          complain_overflow_dont, /* complain_on_overflow */
1581          ppc64_elf_unhandled_reloc, /* special_function */
1582          "R_PPC64_TPREL16_HIGHERA", /* name */
1583          FALSE,                 /* partial_inplace */
1584          0,                     /* src_mask */
1585          0xffff,                /* dst_mask */
1586          FALSE),                /* pcrel_offset */
1587
1588   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1589   HOWTO (R_PPC64_TPREL16_HIGHEST,
1590          48,                    /* rightshift */
1591          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1592          16,                    /* bitsize */
1593          FALSE,                 /* pc_relative */
1594          0,                     /* bitpos */
1595          complain_overflow_dont, /* complain_on_overflow */
1596          ppc64_elf_unhandled_reloc, /* special_function */
1597          "R_PPC64_TPREL16_HIGHEST", /* name */
1598          FALSE,                 /* partial_inplace */
1599          0,                     /* src_mask */
1600          0xffff,                /* dst_mask */
1601          FALSE),                /* pcrel_offset */
1602
1603   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1604   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1605          48,                    /* rightshift */
1606          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1607          16,                    /* bitsize */
1608          FALSE,                 /* pc_relative */
1609          0,                     /* bitpos */
1610          complain_overflow_dont, /* complain_on_overflow */
1611          ppc64_elf_unhandled_reloc, /* special_function */
1612          "R_PPC64_TPREL16_HIGHESTA", /* name */
1613          FALSE,                 /* partial_inplace */
1614          0,                     /* src_mask */
1615          0xffff,                /* dst_mask */
1616          FALSE),                /* pcrel_offset */
1617
1618   /* Like TPREL16, but for insns with a DS field.  */
1619   HOWTO (R_PPC64_TPREL16_DS,
1620          0,                     /* rightshift */
1621          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1622          16,                    /* bitsize */
1623          FALSE,                 /* pc_relative */
1624          0,                     /* bitpos */
1625          complain_overflow_signed, /* complain_on_overflow */
1626          ppc64_elf_unhandled_reloc, /* special_function */
1627          "R_PPC64_TPREL16_DS",  /* name */
1628          FALSE,                 /* partial_inplace */
1629          0,                     /* src_mask */
1630          0xfffc,                /* dst_mask */
1631          FALSE),                /* pcrel_offset */
1632
1633   /* Like TPREL16_DS, but no overflow.  */
1634   HOWTO (R_PPC64_TPREL16_LO_DS,
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_dont, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_TPREL16_LO_DS", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xfffc,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1649      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1650      to the first entry relative to the TOC base (r2).  */
1651   HOWTO (R_PPC64_GOT_TLSGD16,
1652          0,                     /* rightshift */
1653          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1654          16,                    /* bitsize */
1655          FALSE,                 /* pc_relative */
1656          0,                     /* bitpos */
1657          complain_overflow_signed, /* complain_on_overflow */
1658          ppc64_elf_unhandled_reloc, /* special_function */
1659          "R_PPC64_GOT_TLSGD16", /* name */
1660          FALSE,                 /* partial_inplace */
1661          0,                     /* src_mask */
1662          0xffff,                /* dst_mask */
1663          FALSE),                /* pcrel_offset */
1664
1665   /* Like GOT_TLSGD16, but no overflow.  */
1666   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1667          0,                     /* rightshift */
1668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1669          16,                    /* bitsize */
1670          FALSE,                 /* pc_relative */
1671          0,                     /* bitpos */
1672          complain_overflow_dont, /* complain_on_overflow */
1673          ppc64_elf_unhandled_reloc, /* special_function */
1674          "R_PPC64_GOT_TLSGD16_LO", /* name */
1675          FALSE,                 /* partial_inplace */
1676          0,                     /* src_mask */
1677          0xffff,                /* dst_mask */
1678          FALSE),                /* pcrel_offset */
1679
1680   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1681   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1682          16,                    /* rightshift */
1683          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1684          16,                    /* bitsize */
1685          FALSE,                 /* pc_relative */
1686          0,                     /* bitpos */
1687          complain_overflow_dont, /* complain_on_overflow */
1688          ppc64_elf_unhandled_reloc, /* special_function */
1689          "R_PPC64_GOT_TLSGD16_HI", /* name */
1690          FALSE,                 /* partial_inplace */
1691          0,                     /* src_mask */
1692          0xffff,                /* dst_mask */
1693          FALSE),                /* pcrel_offset */
1694
1695   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1696   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1697          16,                    /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_dont, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSGD16_HA", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1711      with values (sym+add)@dtpmod and zero, and computes the offset to the
1712      first entry relative to the TOC base (r2).  */
1713   HOWTO (R_PPC64_GOT_TLSLD16,
1714          0,                     /* rightshift */
1715          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1716          16,                    /* bitsize */
1717          FALSE,                 /* pc_relative */
1718          0,                     /* bitpos */
1719          complain_overflow_signed, /* complain_on_overflow */
1720          ppc64_elf_unhandled_reloc, /* special_function */
1721          "R_PPC64_GOT_TLSLD16", /* name */
1722          FALSE,                 /* partial_inplace */
1723          0,                     /* src_mask */
1724          0xffff,                /* dst_mask */
1725          FALSE),                /* pcrel_offset */
1726
1727   /* Like GOT_TLSLD16, but no overflow.  */
1728   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1729          0,                     /* rightshift */
1730          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1731          16,                    /* bitsize */
1732          FALSE,                 /* pc_relative */
1733          0,                     /* bitpos */
1734          complain_overflow_dont, /* complain_on_overflow */
1735          ppc64_elf_unhandled_reloc, /* special_function */
1736          "R_PPC64_GOT_TLSLD16_LO", /* name */
1737          FALSE,                 /* partial_inplace */
1738          0,                     /* src_mask */
1739          0xffff,                /* dst_mask */
1740          FALSE),                /* pcrel_offset */
1741
1742   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1743   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1744          16,                    /* rightshift */
1745          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1746          16,                    /* bitsize */
1747          FALSE,                 /* pc_relative */
1748          0,                     /* bitpos */
1749          complain_overflow_dont, /* complain_on_overflow */
1750          ppc64_elf_unhandled_reloc, /* special_function */
1751          "R_PPC64_GOT_TLSLD16_HI", /* name */
1752          FALSE,                 /* partial_inplace */
1753          0,                     /* src_mask */
1754          0xffff,                /* dst_mask */
1755          FALSE),                /* pcrel_offset */
1756
1757   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1758   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1759          16,                    /* rightshift */
1760          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1761          16,                    /* bitsize */
1762          FALSE,                 /* pc_relative */
1763          0,                     /* bitpos */
1764          complain_overflow_dont, /* complain_on_overflow */
1765          ppc64_elf_unhandled_reloc, /* special_function */
1766          "R_PPC64_GOT_TLSLD16_HA", /* name */
1767          FALSE,                 /* partial_inplace */
1768          0,                     /* src_mask */
1769          0xffff,                /* dst_mask */
1770          FALSE),                /* pcrel_offset */
1771
1772   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1773      the offset to the entry relative to the TOC base (r2).  */
1774   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_signed, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_DTPREL16_DS", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xfffc,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_DTPREL16_DS, but no overflow.  */
1789   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1790          0,                     /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_dont, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xfffc,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1804   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_dont, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_DTPREL16_HI", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1819   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1820          16,                    /* rightshift */
1821          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1822          16,                    /* bitsize */
1823          FALSE,                 /* pc_relative */
1824          0,                     /* bitpos */
1825          complain_overflow_dont, /* complain_on_overflow */
1826          ppc64_elf_unhandled_reloc, /* special_function */
1827          "R_PPC64_GOT_DTPREL16_HA", /* name */
1828          FALSE,                 /* partial_inplace */
1829          0,                     /* src_mask */
1830          0xffff,                /* dst_mask */
1831          FALSE),                /* pcrel_offset */
1832
1833   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1834      offset to the entry relative to the TOC base (r2).  */
1835   HOWTO (R_PPC64_GOT_TPREL16_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_signed, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_TPREL16_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_TPREL16_DS, but no overflow.  */
1850   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1851          0,                     /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_dont, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xfffc,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1865   HOWTO (R_PPC64_GOT_TPREL16_HI,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_dont, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_TPREL16_HI", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1880   HOWTO (R_PPC64_GOT_TPREL16_HA,
1881          16,                    /* rightshift */
1882          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1883          16,                    /* bitsize */
1884          FALSE,                 /* pc_relative */
1885          0,                     /* bitpos */
1886          complain_overflow_dont, /* complain_on_overflow */
1887          ppc64_elf_unhandled_reloc, /* special_function */
1888          "R_PPC64_GOT_TPREL16_HA", /* name */
1889          FALSE,                 /* partial_inplace */
1890          0,                     /* src_mask */
1891          0xffff,                /* dst_mask */
1892          FALSE),                /* pcrel_offset */
1893
1894   HOWTO (R_PPC64_JMP_IREL,      /* type */
1895          0,                     /* rightshift */
1896          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1897          0,                     /* bitsize */
1898          FALSE,                 /* pc_relative */
1899          0,                     /* bitpos */
1900          complain_overflow_dont, /* complain_on_overflow */
1901          ppc64_elf_unhandled_reloc, /* special_function */
1902          "R_PPC64_JMP_IREL",    /* name */
1903          FALSE,                 /* partial_inplace */
1904          0,                     /* src_mask */
1905          0,                     /* dst_mask */
1906          FALSE),                /* pcrel_offset */
1907
1908   HOWTO (R_PPC64_IRELATIVE,     /* type */
1909          0,                     /* rightshift */
1910          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1911          64,                    /* bitsize */
1912          FALSE,                 /* pc_relative */
1913          0,                     /* bitpos */
1914          complain_overflow_dont, /* complain_on_overflow */
1915          bfd_elf_generic_reloc, /* special_function */
1916          "R_PPC64_IRELATIVE",   /* name */
1917          FALSE,                 /* partial_inplace */
1918          0,                     /* src_mask */
1919          ONES (64),             /* dst_mask */
1920          FALSE),                /* pcrel_offset */
1921
1922   /* A 16 bit relative relocation.  */
1923   HOWTO (R_PPC64_REL16,         /* type */
1924          0,                     /* rightshift */
1925          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1926          16,                    /* bitsize */
1927          TRUE,                  /* pc_relative */
1928          0,                     /* bitpos */
1929          complain_overflow_bitfield, /* complain_on_overflow */
1930          bfd_elf_generic_reloc, /* special_function */
1931          "R_PPC64_REL16",       /* name */
1932          FALSE,                 /* partial_inplace */
1933          0,                     /* src_mask */
1934          0xffff,                /* dst_mask */
1935          TRUE),                 /* pcrel_offset */
1936
1937   /* A 16 bit relative relocation without overflow.  */
1938   HOWTO (R_PPC64_REL16_LO,      /* type */
1939          0,                     /* rightshift */
1940          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1941          16,                    /* bitsize */
1942          TRUE,                  /* pc_relative */
1943          0,                     /* bitpos */
1944          complain_overflow_dont,/* complain_on_overflow */
1945          bfd_elf_generic_reloc, /* special_function */
1946          "R_PPC64_REL16_LO",    /* name */
1947          FALSE,                 /* partial_inplace */
1948          0,                     /* src_mask */
1949          0xffff,                /* dst_mask */
1950          TRUE),                 /* pcrel_offset */
1951
1952   /* The high order 16 bits of a relative address.  */
1953   HOWTO (R_PPC64_REL16_HI,      /* type */
1954          16,                    /* rightshift */
1955          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1956          16,                    /* bitsize */
1957          TRUE,                  /* pc_relative */
1958          0,                     /* bitpos */
1959          complain_overflow_dont, /* complain_on_overflow */
1960          bfd_elf_generic_reloc, /* special_function */
1961          "R_PPC64_REL16_HI",    /* name */
1962          FALSE,                 /* partial_inplace */
1963          0,                     /* src_mask */
1964          0xffff,                /* dst_mask */
1965          TRUE),                 /* pcrel_offset */
1966
1967   /* The high order 16 bits of a relative address, plus 1 if the contents of
1968      the low 16 bits, treated as a signed number, is negative.  */
1969   HOWTO (R_PPC64_REL16_HA,      /* type */
1970          16,                    /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_dont, /* complain_on_overflow */
1976          ppc64_elf_ha_reloc,    /* special_function */
1977          "R_PPC64_REL16_HA",    /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* GNU extension to record C++ vtable hierarchy.  */
1984   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1985          0,                     /* rightshift */
1986          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          0,                     /* bitsize */
1988          FALSE,                 /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont, /* complain_on_overflow */
1991          NULL,                  /* special_function */
1992          "R_PPC64_GNU_VTINHERIT", /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0,                     /* dst_mask */
1996          FALSE),                /* pcrel_offset */
1997
1998   /* GNU extension to record C++ vtable member usage.  */
1999   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2000          0,                     /* rightshift */
2001          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          0,                     /* bitsize */
2003          FALSE,                 /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_dont, /* complain_on_overflow */
2006          NULL,                  /* special_function */
2007          "R_PPC64_GNU_VTENTRY", /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0,                     /* dst_mask */
2011          FALSE),                /* pcrel_offset */
2012 };
2013
2014 \f
2015 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2016    be done.  */
2017
2018 static void
2019 ppc_howto_init (void)
2020 {
2021   unsigned int i, type;
2022
2023   for (i = 0;
2024        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2025        i++)
2026     {
2027       type = ppc64_elf_howto_raw[i].type;
2028       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2029                           / sizeof (ppc64_elf_howto_table[0])));
2030       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2031     }
2032 }
2033
2034 static reloc_howto_type *
2035 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2036                              bfd_reloc_code_real_type code)
2037 {
2038   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2039
2040   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2041     /* Initialize howto table if needed.  */
2042     ppc_howto_init ();
2043
2044   switch (code)
2045     {
2046     default:
2047       return NULL;
2048
2049     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2050       break;
2051     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2052       break;
2053     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2054       break;
2055     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2056       break;
2057     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2058       break;
2059     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2060       break;
2061     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2062       break;
2063     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2064       break;
2065     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2066       break;
2067     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2068       break;
2069     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2070       break;
2071     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2072       break;
2073     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2074       break;
2075     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2076       break;
2077     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2078       break;
2079     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2080       break;
2081     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2082       break;
2083     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2084       break;
2085     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2086       break;
2087     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2088       break;
2089     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2090       break;
2091     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2092       break;
2093     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2094       break;
2095     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2096       break;
2097     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2098       break;
2099     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2100       break;
2101     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2102       break;
2103     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2104       break;
2105     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2106       break;
2107     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2108       break;
2109     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2110       break;
2111     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2112       break;
2113     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2114       break;
2115     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2116       break;
2117     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2118       break;
2119     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2120       break;
2121     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2122       break;
2123     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2124       break;
2125     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2126       break;
2127     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2128       break;
2129     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2130       break;
2131     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2132       break;
2133     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2134       break;
2135     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2136       break;
2137     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2138       break;
2139     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2140       break;
2141     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2142       break;
2143     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2144       break;
2145     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2146       break;
2147     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2148       break;
2149     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2150       break;
2151     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2152       break;
2153     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2154       break;
2155     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2156       break;
2157     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2158       break;
2159     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2160       break;
2161     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2162       break;
2163     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2164       break;
2165     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2166       break;
2167     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2168       break;
2169     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2170       break;
2171     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2172       break;
2173     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2174       break;
2175     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2176       break;
2177     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2178       break;
2179     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2180       break;
2181     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2182       break;
2183     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2184       break;
2185     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2186       break;
2187     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2188       break;
2189     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2190       break;
2191     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2192       break;
2193     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2194       break;
2195     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2196       break;
2197     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2198       break;
2199     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2200       break;
2201     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2204       break;
2205     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2206       break;
2207     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2208       break;
2209     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2210       break;
2211     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2212       break;
2213     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2214       break;
2215     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2216       break;
2217     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2218       break;
2219     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2220       break;
2221     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2222       break;
2223     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2224       break;
2225     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2226       break;
2227     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2228       break;
2229     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2230       break;
2231     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2232       break;
2233     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2234       break;
2235     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2236       break;
2237     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2238       break;
2239     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2240       break;
2241     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2242       break;
2243     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2244       break;
2245     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2246       break;
2247     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2248       break;
2249     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2250       break;
2251     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2252       break;
2253     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2254       break;
2255     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2256       break;
2257     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2258       break;
2259     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2260       break;
2261     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2262       break;
2263     }
2264
2265   return ppc64_elf_howto_table[r];
2266 };
2267
2268 static reloc_howto_type *
2269 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2270                              const char *r_name)
2271 {
2272   unsigned int i;
2273
2274   for (i = 0;
2275        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2276        i++)
2277     if (ppc64_elf_howto_raw[i].name != NULL
2278         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2279       return &ppc64_elf_howto_raw[i];
2280
2281   return NULL;
2282 }
2283
2284 /* Set the howto pointer for a PowerPC ELF reloc.  */
2285
2286 static void
2287 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2288                          Elf_Internal_Rela *dst)
2289 {
2290   unsigned int type;
2291
2292   /* Initialize howto table if needed.  */
2293   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2294     ppc_howto_init ();
2295
2296   type = ELF64_R_TYPE (dst->r_info);
2297   if (type >= (sizeof (ppc64_elf_howto_table)
2298                / sizeof (ppc64_elf_howto_table[0])))
2299     {
2300       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2301                              abfd, (int) type);
2302       type = R_PPC64_NONE;
2303     }
2304   cache_ptr->howto = ppc64_elf_howto_table[type];
2305 }
2306
2307 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2308
2309 static bfd_reloc_status_type
2310 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2311                     void *data, asection *input_section,
2312                     bfd *output_bfd, char **error_message)
2313 {
2314   /* If this is a relocatable link (output_bfd test tells us), just
2315      call the generic function.  Any adjustment will be done at final
2316      link time.  */
2317   if (output_bfd != NULL)
2318     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2319                                   input_section, output_bfd, error_message);
2320
2321   /* Adjust the addend for sign extension of the low 16 bits.
2322      We won't actually be using the low 16 bits, so trashing them
2323      doesn't matter.  */
2324   reloc_entry->addend += 0x8000;
2325   return bfd_reloc_continue;
2326 }
2327
2328 static bfd_reloc_status_type
2329 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2330                         void *data, asection *input_section,
2331                         bfd *output_bfd, char **error_message)
2332 {
2333   if (output_bfd != NULL)
2334     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2335                                   input_section, output_bfd, error_message);
2336
2337   if (strcmp (symbol->section->name, ".opd") == 0
2338       && (symbol->section->owner->flags & DYNAMIC) == 0)
2339     {
2340       bfd_vma dest = opd_entry_value (symbol->section,
2341                                       symbol->value + reloc_entry->addend,
2342                                       NULL, NULL);
2343       if (dest != (bfd_vma) -1)
2344         reloc_entry->addend = dest - (symbol->value
2345                                       + symbol->section->output_section->vma
2346                                       + symbol->section->output_offset);
2347     }
2348   return bfd_reloc_continue;
2349 }
2350
2351 static bfd_reloc_status_type
2352 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2353                          void *data, asection *input_section,
2354                          bfd *output_bfd, char **error_message)
2355 {
2356   long insn;
2357   enum elf_ppc64_reloc_type r_type;
2358   bfd_size_type octets;
2359   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2360   bfd_boolean is_power4 = FALSE;
2361
2362   /* If this is a relocatable link (output_bfd test tells us), just
2363      call the generic function.  Any adjustment will be done at final
2364      link time.  */
2365   if (output_bfd != NULL)
2366     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2367                                   input_section, output_bfd, error_message);
2368
2369   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2370   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2371   insn &= ~(0x01 << 21);
2372   r_type = reloc_entry->howto->type;
2373   if (r_type == R_PPC64_ADDR14_BRTAKEN
2374       || r_type == R_PPC64_REL14_BRTAKEN)
2375     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2376
2377   if (is_power4)
2378     {
2379       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2380          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2381          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2382       if ((insn & (0x14 << 21)) == (0x04 << 21))
2383         insn |= 0x02 << 21;
2384       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2385         insn |= 0x08 << 21;
2386       else
2387         goto out;
2388     }
2389   else
2390     {
2391       bfd_vma target = 0;
2392       bfd_vma from;
2393
2394       if (!bfd_is_com_section (symbol->section))
2395         target = symbol->value;
2396       target += symbol->section->output_section->vma;
2397       target += symbol->section->output_offset;
2398       target += reloc_entry->addend;
2399
2400       from = (reloc_entry->address
2401               + input_section->output_offset
2402               + input_section->output_section->vma);
2403
2404       /* Invert 'y' bit if not the default.  */
2405       if ((bfd_signed_vma) (target - from) < 0)
2406         insn ^= 0x01 << 21;
2407     }
2408   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2409  out:
2410   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2411                                  input_section, output_bfd, error_message);
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_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   return bfd_reloc_continue;
2429 }
2430
2431 static bfd_reloc_status_type
2432 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2433                             void *data, asection *input_section,
2434                             bfd *output_bfd, char **error_message)
2435 {
2436   /* If this is a relocatable link (output_bfd test tells us), just
2437      call the generic function.  Any adjustment will be done at final
2438      link time.  */
2439   if (output_bfd != NULL)
2440     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2441                                   input_section, output_bfd, error_message);
2442
2443   /* Subtract the symbol section base address.  */
2444   reloc_entry->addend -= symbol->section->output_section->vma;
2445
2446   /* Adjust the addend for sign extension of the low 16 bits.  */
2447   reloc_entry->addend += 0x8000;
2448   return bfd_reloc_continue;
2449 }
2450
2451 static bfd_reloc_status_type
2452 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453                      void *data, asection *input_section,
2454                      bfd *output_bfd, char **error_message)
2455 {
2456   bfd_vma TOCstart;
2457
2458   /* If this is a relocatable link (output_bfd test tells us), just
2459      call the generic function.  Any adjustment will be done at final
2460      link time.  */
2461   if (output_bfd != NULL)
2462     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2463                                   input_section, output_bfd, error_message);
2464
2465   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2466   if (TOCstart == 0)
2467     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2468
2469   /* Subtract the TOC base address.  */
2470   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2471   return bfd_reloc_continue;
2472 }
2473
2474 static bfd_reloc_status_type
2475 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2476                         void *data, asection *input_section,
2477                         bfd *output_bfd, char **error_message)
2478 {
2479   bfd_vma TOCstart;
2480
2481   /* If this is a relocatable link (output_bfd test tells us), just
2482      call the generic function.  Any adjustment will be done at final
2483      link time.  */
2484   if (output_bfd != NULL)
2485     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2486                                   input_section, output_bfd, error_message);
2487
2488   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2489   if (TOCstart == 0)
2490     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2491
2492   /* Subtract the TOC base address.  */
2493   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2494
2495   /* Adjust the addend for sign extension of the low 16 bits.  */
2496   reloc_entry->addend += 0x8000;
2497   return bfd_reloc_continue;
2498 }
2499
2500 static bfd_reloc_status_type
2501 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2502                        void *data, asection *input_section,
2503                        bfd *output_bfd, char **error_message)
2504 {
2505   bfd_vma TOCstart;
2506   bfd_size_type octets;
2507
2508   /* If this is a relocatable link (output_bfd test tells us), just
2509      call the generic function.  Any adjustment will be done at final
2510      link time.  */
2511   if (output_bfd != NULL)
2512     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2513                                   input_section, output_bfd, error_message);
2514
2515   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2516   if (TOCstart == 0)
2517     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2518
2519   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2520   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2521   return bfd_reloc_ok;
2522 }
2523
2524 static bfd_reloc_status_type
2525 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526                            void *data, asection *input_section,
2527                            bfd *output_bfd, char **error_message)
2528 {
2529   /* If this is a relocatable link (output_bfd test tells us), just
2530      call the generic function.  Any adjustment will be done at final
2531      link time.  */
2532   if (output_bfd != NULL)
2533     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2534                                   input_section, output_bfd, error_message);
2535
2536   if (error_message != NULL)
2537     {
2538       static char buf[60];
2539       sprintf (buf, "generic linker can't handle %s",
2540                reloc_entry->howto->name);
2541       *error_message = buf;
2542     }
2543   return bfd_reloc_dangerous;
2544 }
2545
2546 /* Track GOT entries needed for a given symbol.  We might need more
2547    than one got entry per symbol.  */
2548 struct got_entry
2549 {
2550   struct got_entry *next;
2551
2552   /* The symbol addend that we'll be placing in the GOT.  */
2553   bfd_vma addend;
2554
2555   /* Unlike other ELF targets, we use separate GOT entries for the same
2556      symbol referenced from different input files.  This is to support
2557      automatic multiple TOC/GOT sections, where the TOC base can vary
2558      from one input file to another.  After partitioning into TOC groups
2559      we merge entries within the group.
2560
2561      Point to the BFD owning this GOT entry.  */
2562   bfd *owner;
2563
2564   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2565      TLS_TPREL or TLS_DTPREL for tls entries.  */
2566   unsigned char tls_type;
2567
2568   /* Non-zero if got.ent points to real entry.  */
2569   unsigned char is_indirect;
2570
2571   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2572   union
2573     {
2574       bfd_signed_vma refcount;
2575       bfd_vma offset;
2576       struct got_entry *ent;
2577     } got;
2578 };
2579
2580 /* The same for PLT.  */
2581 struct plt_entry
2582 {
2583   struct plt_entry *next;
2584
2585   bfd_vma addend;
2586
2587   union
2588     {
2589       bfd_signed_vma refcount;
2590       bfd_vma offset;
2591     } plt;
2592 };
2593
2594 struct ppc64_elf_obj_tdata
2595 {
2596   struct elf_obj_tdata elf;
2597
2598   /* Shortcuts to dynamic linker sections.  */
2599   asection *got;
2600   asection *relgot;
2601
2602   /* Used during garbage collection.  We attach global symbols defined
2603      on removed .opd entries to this section so that the sym is removed.  */
2604   asection *deleted_section;
2605
2606   /* TLS local dynamic got entry handling.  Support for multiple GOT
2607      sections means we potentially need one of these for each input bfd.  */
2608   struct got_entry tlsld_got;
2609
2610   /* A copy of relocs before they are modified for --emit-relocs.  */
2611   Elf_Internal_Rela *opd_relocs;
2612
2613   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2614      the reloc to be in the range -32768 to 32767.  */
2615   unsigned int has_small_toc_reloc : 1;
2616
2617   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2618      instruction not one we handle.  */
2619   unsigned int unexpected_toc_insn : 1;
2620 };
2621
2622 #define ppc64_elf_tdata(bfd) \
2623   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2624
2625 #define ppc64_tlsld_got(bfd) \
2626   (&ppc64_elf_tdata (bfd)->tlsld_got)
2627
2628 #define is_ppc64_elf(bfd) \
2629   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2630    && elf_object_id (bfd) == PPC64_ELF_DATA)
2631
2632 /* Override the generic function because we store some extras.  */
2633
2634 static bfd_boolean
2635 ppc64_elf_mkobject (bfd *abfd)
2636 {
2637   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2638                                   PPC64_ELF_DATA);
2639 }
2640
2641 /* Fix bad default arch selected for a 64 bit input bfd when the
2642    default is 32 bit.  */
2643
2644 static bfd_boolean
2645 ppc64_elf_object_p (bfd *abfd)
2646 {
2647   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2648     {
2649       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2650
2651       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2652         {
2653           /* Relies on arch after 32 bit default being 64 bit default.  */
2654           abfd->arch_info = abfd->arch_info->next;
2655           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2656         }
2657     }
2658   return TRUE;
2659 }
2660
2661 /* Support for core dump NOTE sections.  */
2662
2663 static bfd_boolean
2664 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2665 {
2666   size_t offset, size;
2667
2668   if (note->descsz != 504)
2669     return FALSE;
2670
2671   /* pr_cursig */
2672   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2673
2674   /* pr_pid */
2675   elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2676
2677   /* pr_reg */
2678   offset = 112;
2679   size = 384;
2680
2681   /* Make a ".reg/999" section.  */
2682   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2683                                           size, note->descpos + offset);
2684 }
2685
2686 static bfd_boolean
2687 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2688 {
2689   if (note->descsz != 136)
2690     return FALSE;
2691
2692   elf_tdata (abfd)->core_pid
2693     = bfd_get_32 (abfd, note->descdata + 24);
2694   elf_tdata (abfd)->core_program
2695     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2696   elf_tdata (abfd)->core_command
2697     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2698
2699   return TRUE;
2700 }
2701
2702 static char *
2703 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2704                            ...)
2705 {
2706   switch (note_type)
2707     {
2708     default:
2709       return NULL;
2710
2711     case NT_PRPSINFO:
2712       {
2713         char data[136];
2714         va_list ap;
2715
2716         va_start (ap, note_type);
2717         memset (data, 0, 40);
2718         strncpy (data + 40, va_arg (ap, const char *), 16);
2719         strncpy (data + 56, va_arg (ap, const char *), 80);
2720         va_end (ap);
2721         return elfcore_write_note (abfd, buf, bufsiz,
2722                                    "CORE", note_type, data, sizeof (data));
2723       }
2724
2725     case NT_PRSTATUS:
2726       {
2727         char data[504];
2728         va_list ap;
2729         long pid;
2730         int cursig;
2731         const void *greg;
2732
2733         va_start (ap, note_type);
2734         memset (data, 0, 112);
2735         pid = va_arg (ap, long);
2736         bfd_put_32 (abfd, pid, data + 32);
2737         cursig = va_arg (ap, int);
2738         bfd_put_16 (abfd, cursig, data + 12);
2739         greg = va_arg (ap, const void *);
2740         memcpy (data + 112, greg, 384);
2741         memset (data + 496, 0, 8);
2742         va_end (ap);
2743         return elfcore_write_note (abfd, buf, bufsiz,
2744                                    "CORE", note_type, data, sizeof (data));
2745       }
2746     }
2747 }
2748
2749 /* Add extra PPC sections.  */
2750
2751 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2752 {
2753   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2754   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2755   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2756   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2757   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2758   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2759   { NULL,                     0,  0, 0,            0 }
2760 };
2761
2762 enum _ppc64_sec_type {
2763   sec_normal = 0,
2764   sec_opd = 1,
2765   sec_toc = 2
2766 };
2767
2768 struct _ppc64_elf_section_data
2769 {
2770   struct bfd_elf_section_data elf;
2771
2772   union
2773   {
2774     /* An array with one entry for each opd function descriptor.  */
2775     struct _opd_sec_data
2776     {
2777       /* Points to the function code section for local opd entries.  */
2778       asection **func_sec;
2779
2780       /* After editing .opd, adjust references to opd local syms.  */
2781       long *adjust;
2782     } opd;
2783
2784     /* An array for toc sections, indexed by offset/8.  */
2785     struct _toc_sec_data
2786     {
2787       /* Specifies the relocation symbol index used at a given toc offset.  */
2788       unsigned *symndx;
2789
2790       /* And the relocation addend.  */
2791       bfd_vma *add;
2792     } toc;
2793   } u;
2794
2795   enum _ppc64_sec_type sec_type:2;
2796
2797   /* Flag set when small branches are detected.  Used to
2798      select suitable defaults for the stub group size.  */
2799   unsigned int has_14bit_branch:1;
2800 };
2801
2802 #define ppc64_elf_section_data(sec) \
2803   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2804
2805 static bfd_boolean
2806 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2807 {
2808   if (!sec->used_by_bfd)
2809     {
2810       struct _ppc64_elf_section_data *sdata;
2811       bfd_size_type amt = sizeof (*sdata);
2812
2813       sdata = bfd_zalloc (abfd, amt);
2814       if (sdata == NULL)
2815         return FALSE;
2816       sec->used_by_bfd = sdata;
2817     }
2818
2819   return _bfd_elf_new_section_hook (abfd, sec);
2820 }
2821
2822 static struct _opd_sec_data *
2823 get_opd_info (asection * sec)
2824 {
2825   if (sec != NULL
2826       && ppc64_elf_section_data (sec) != NULL
2827       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2828     return &ppc64_elf_section_data (sec)->u.opd;
2829   return NULL;
2830 }
2831 \f
2832 /* Parameters for the qsort hook.  */
2833 static bfd_boolean synthetic_relocatable;
2834
2835 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2836
2837 static int
2838 compare_symbols (const void *ap, const void *bp)
2839 {
2840   const asymbol *a = * (const asymbol **) ap;
2841   const asymbol *b = * (const asymbol **) bp;
2842
2843   /* Section symbols first.  */
2844   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2845     return -1;
2846   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2847     return 1;
2848
2849   /* then .opd symbols.  */
2850   if (strcmp (a->section->name, ".opd") == 0
2851       && strcmp (b->section->name, ".opd") != 0)
2852     return -1;
2853   if (strcmp (a->section->name, ".opd") != 0
2854       && strcmp (b->section->name, ".opd") == 0)
2855     return 1;
2856
2857   /* then other code symbols.  */
2858   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2859       == (SEC_CODE | SEC_ALLOC)
2860       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2861          != (SEC_CODE | SEC_ALLOC))
2862     return -1;
2863
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 (synthetic_relocatable)
2871     {
2872       if (a->section->id < b->section->id)
2873         return -1;
2874
2875       if (a->section->id > b->section->id)
2876         return 1;
2877     }
2878
2879   if (a->value + a->section->vma < b->value + b->section->vma)
2880     return -1;
2881
2882   if (a->value + a->section->vma > b->value + b->section->vma)
2883     return 1;
2884
2885   /* For syms with the same value, prefer strong dynamic global function
2886      syms over other syms.  */
2887   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2888     return -1;
2889
2890   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2891     return 1;
2892
2893   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2894     return -1;
2895
2896   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2897     return 1;
2898
2899   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2900     return -1;
2901
2902   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2903     return 1;
2904
2905   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2906     return -1;
2907
2908   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2909     return 1;
2910
2911   return 0;
2912 }
2913
2914 /* Search SYMS for a symbol of the given VALUE.  */
2915
2916 static asymbol *
2917 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2918 {
2919   long mid;
2920
2921   if (id == -1)
2922     {
2923       while (lo < hi)
2924         {
2925           mid = (lo + hi) >> 1;
2926           if (syms[mid]->value + syms[mid]->section->vma < value)
2927             lo = mid + 1;
2928           else if (syms[mid]->value + syms[mid]->section->vma > value)
2929             hi = mid;
2930           else
2931             return syms[mid];
2932         }
2933     }
2934   else
2935     {
2936       while (lo < hi)
2937         {
2938           mid = (lo + hi) >> 1;
2939           if (syms[mid]->section->id < id)
2940             lo = mid + 1;
2941           else if (syms[mid]->section->id > id)
2942             hi = mid;
2943           else if (syms[mid]->value < value)
2944             lo = mid + 1;
2945           else if (syms[mid]->value > value)
2946             hi = mid;
2947           else
2948             return syms[mid];
2949         }
2950     }
2951   return NULL;
2952 }
2953
2954 static bfd_boolean
2955 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2956 {
2957   bfd_vma vma = *(bfd_vma *) ptr;
2958   return ((section->flags & SEC_ALLOC) != 0
2959           && section->vma <= vma
2960           && vma < section->vma + section->size);
2961 }
2962
2963 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2964    entry syms.  Also generate @plt symbols for the glink branch table.  */
2965
2966 static long
2967 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2968                                 long static_count, asymbol **static_syms,
2969                                 long dyn_count, asymbol **dyn_syms,
2970                                 asymbol **ret)
2971 {
2972   asymbol *s;
2973   long i;
2974   long count;
2975   char *names;
2976   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2977   asection *opd;
2978   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2979   asymbol **syms;
2980
2981   *ret = NULL;
2982
2983   opd = bfd_get_section_by_name (abfd, ".opd");
2984   if (opd == NULL)
2985     return 0;
2986
2987   symcount = static_count;
2988   if (!relocatable)
2989     symcount += dyn_count;
2990   if (symcount == 0)
2991     return 0;
2992
2993   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2994   if (syms == NULL)
2995     return -1;
2996
2997   if (!relocatable && static_count != 0 && dyn_count != 0)
2998     {
2999       /* Use both symbol tables.  */
3000       memcpy (syms, static_syms, static_count * sizeof (*syms));
3001       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3002     }
3003   else if (!relocatable && static_count == 0)
3004     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3005   else
3006     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3007
3008   synthetic_relocatable = relocatable;
3009   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3010
3011   if (!relocatable && symcount > 1)
3012     {
3013       long j;
3014       /* Trim duplicate syms, since we may have merged the normal and
3015          dynamic symbols.  Actually, we only care about syms that have
3016          different values, so trim any with the same value.  */
3017       for (i = 1, j = 1; i < symcount; ++i)
3018         if (syms[i - 1]->value + syms[i - 1]->section->vma
3019             != syms[i]->value + syms[i]->section->vma)
3020           syms[j++] = syms[i];
3021       symcount = j;
3022     }
3023
3024   i = 0;
3025   if (strcmp (syms[i]->section->name, ".opd") == 0)
3026     ++i;
3027   codesecsym = i;
3028
3029   for (; i < symcount; ++i)
3030     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3031          != (SEC_CODE | SEC_ALLOC))
3032         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3033       break;
3034   codesecsymend = i;
3035
3036   for (; i < symcount; ++i)
3037     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3038       break;
3039   secsymend = i;
3040
3041   for (; i < symcount; ++i)
3042     if (strcmp (syms[i]->section->name, ".opd") != 0)
3043       break;
3044   opdsymend = i;
3045
3046   for (; i < symcount; ++i)
3047     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048         != (SEC_CODE | SEC_ALLOC))
3049       break;
3050   symcount = i;
3051
3052   count = 0;
3053
3054   if (relocatable)
3055     {
3056       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3057       arelent *r;
3058       size_t size;
3059       long relcount;
3060
3061       if (opdsymend == secsymend)
3062         goto done;
3063
3064       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3065       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3066       if (relcount == 0)
3067         goto done;
3068
3069       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3070         {
3071           count = -1;
3072           goto done;
3073         }
3074
3075       size = 0;
3076       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3077         {
3078           asymbol *sym;
3079
3080           while (r < opd->relocation + relcount
3081                  && r->address < syms[i]->value + opd->vma)
3082             ++r;
3083
3084           if (r == opd->relocation + relcount)
3085             break;
3086
3087           if (r->address != syms[i]->value + opd->vma)
3088             continue;
3089
3090           if (r->howto->type != R_PPC64_ADDR64)
3091             continue;
3092
3093           sym = *r->sym_ptr_ptr;
3094           if (!sym_exists_at (syms, opdsymend, symcount,
3095                               sym->section->id, sym->value + r->addend))
3096             {
3097               ++count;
3098               size += sizeof (asymbol);
3099               size += strlen (syms[i]->name) + 2;
3100             }
3101         }
3102
3103       s = *ret = bfd_malloc (size);
3104       if (s == NULL)
3105         {
3106           count = -1;
3107           goto done;
3108         }
3109
3110       names = (char *) (s + count);
3111
3112       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3113         {
3114           asymbol *sym;
3115
3116           while (r < opd->relocation + relcount
3117                  && r->address < syms[i]->value + opd->vma)
3118             ++r;
3119
3120           if (r == opd->relocation + relcount)
3121             break;
3122
3123           if (r->address != syms[i]->value + opd->vma)
3124             continue;
3125
3126           if (r->howto->type != R_PPC64_ADDR64)
3127             continue;
3128
3129           sym = *r->sym_ptr_ptr;
3130           if (!sym_exists_at (syms, opdsymend, symcount,
3131                               sym->section->id, sym->value + r->addend))
3132             {
3133               size_t len;
3134
3135               *s = *syms[i];
3136               s->flags |= BSF_SYNTHETIC;
3137               s->section = sym->section;
3138               s->value = sym->value + r->addend;
3139               s->name = names;
3140               *names++ = '.';
3141               len = strlen (syms[i]->name);
3142               memcpy (names, syms[i]->name, len + 1);
3143               names += len + 1;
3144               /* Have udata.p point back to the original symbol this
3145                  synthetic symbol was derived from.  */
3146               s->udata.p = syms[i];
3147               s++;
3148             }
3149         }
3150     }
3151   else
3152     {
3153       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3154       bfd_byte *contents;
3155       size_t size;
3156       long plt_count = 0;
3157       bfd_vma glink_vma = 0, resolv_vma = 0;
3158       asection *dynamic, *glink = NULL, *relplt = NULL;
3159       arelent *p;
3160
3161       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3162         {
3163           if (contents)
3164             {
3165             free_contents_and_exit:
3166               free (contents);
3167             }
3168           count = -1;
3169           goto done;
3170         }
3171
3172       size = 0;
3173       for (i = secsymend; i < opdsymend; ++i)
3174         {
3175           bfd_vma ent;
3176
3177           /* Ignore bogus symbols.  */
3178           if (syms[i]->value > opd->size - 8)
3179             continue;
3180
3181           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3182           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3183             {
3184               ++count;
3185               size += sizeof (asymbol);
3186               size += strlen (syms[i]->name) + 2;
3187             }
3188         }
3189
3190       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3191       if (dyn_count != 0
3192           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3193         {
3194           bfd_byte *dynbuf, *extdyn, *extdynend;
3195           size_t extdynsize;
3196           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3197
3198           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3199             goto free_contents_and_exit;
3200
3201           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3202           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3203
3204           extdyn = dynbuf;
3205           extdynend = extdyn + dynamic->size;
3206           for (; extdyn < extdynend; extdyn += extdynsize)
3207             {
3208               Elf_Internal_Dyn dyn;
3209               (*swap_dyn_in) (abfd, extdyn, &dyn);
3210
3211               if (dyn.d_tag == DT_NULL)
3212                 break;
3213
3214               if (dyn.d_tag == DT_PPC64_GLINK)
3215                 {
3216                   /* The first glink stub starts at offset 32; see comment in
3217                      ppc64_elf_finish_dynamic_sections. */
3218                   glink_vma = dyn.d_un.d_val + 32;
3219                   /* The .glink section usually does not survive the final
3220                      link; search for the section (usually .text) where the
3221                      glink stubs now reside.  */
3222                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3223                                                 &glink_vma);
3224                   break;
3225                 }
3226             }
3227
3228           free (dynbuf);
3229         }
3230
3231       if (glink != NULL)
3232         {
3233           /* Determine __glink trampoline by reading the relative branch
3234              from the first glink stub.  */
3235           bfd_byte buf[4];
3236           if (bfd_get_section_contents (abfd, glink, buf,
3237                                         glink_vma + 4 - glink->vma, 4))
3238             {
3239               unsigned int insn = bfd_get_32 (abfd, buf);
3240               insn ^= B_DOT;
3241               if ((insn & ~0x3fffffc) == 0)
3242                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3243             }
3244
3245           if (resolv_vma)
3246             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3247
3248           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3249           if (relplt != NULL)
3250             {
3251               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3252               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3253                 goto free_contents_and_exit;
3254
3255               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3256               size += plt_count * sizeof (asymbol);
3257
3258               p = relplt->relocation;
3259               for (i = 0; i < plt_count; i++, p++)
3260                 {
3261                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3262                   if (p->addend != 0)
3263                     size += sizeof ("+0x") - 1 + 16;
3264                 }
3265             }
3266         }
3267
3268       s = *ret = bfd_malloc (size);
3269       if (s == NULL)
3270         goto free_contents_and_exit;
3271
3272       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3273
3274       for (i = secsymend; i < opdsymend; ++i)
3275         {
3276           bfd_vma ent;
3277
3278           if (syms[i]->value > opd->size - 8)
3279             continue;
3280
3281           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3282           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3283             {
3284               long lo, hi;
3285               size_t len;
3286               asection *sec = abfd->sections;
3287
3288               *s = *syms[i];
3289               lo = codesecsym;
3290               hi = codesecsymend;
3291               while (lo < hi)
3292                 {
3293                   long mid = (lo + hi) >> 1;
3294                   if (syms[mid]->section->vma < ent)
3295                     lo = mid + 1;
3296                   else if (syms[mid]->section->vma > ent)
3297                     hi = mid;
3298                   else
3299                     {
3300                       sec = syms[mid]->section;
3301                       break;
3302                     }
3303                 }
3304
3305               if (lo >= hi && lo > codesecsym)
3306                 sec = syms[lo - 1]->section;
3307
3308               for (; sec != NULL; sec = sec->next)
3309                 {
3310                   if (sec->vma > ent)
3311                     break;
3312                   /* SEC_LOAD may not be set if SEC is from a separate debug
3313                      info file.  */
3314                   if ((sec->flags & SEC_ALLOC) == 0)
3315                     break;
3316                   if ((sec->flags & SEC_CODE) != 0)
3317                     s->section = sec;
3318                 }
3319               s->flags |= BSF_SYNTHETIC;
3320               s->value = ent - s->section->vma;
3321               s->name = names;
3322               *names++ = '.';
3323               len = strlen (syms[i]->name);
3324               memcpy (names, syms[i]->name, len + 1);
3325               names += len + 1;
3326               /* Have udata.p point back to the original symbol this
3327                  synthetic symbol was derived from.  */
3328               s->udata.p = syms[i];
3329               s++;
3330             }
3331         }
3332       free (contents);
3333
3334       if (glink != NULL && relplt != NULL)
3335         {
3336           if (resolv_vma)
3337             {
3338               /* Add a symbol for the main glink trampoline.  */
3339               memset (s, 0, sizeof *s);
3340               s->the_bfd = abfd;
3341               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3342               s->section = glink;
3343               s->value = resolv_vma - glink->vma;
3344               s->name = names;
3345               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3346               names += sizeof ("__glink_PLTresolve");
3347               s++;
3348               count++;
3349             }
3350
3351           /* FIXME: It would be very much nicer to put sym@plt on the
3352              stub rather than on the glink branch table entry.  The
3353              objdump disassembler would then use a sensible symbol
3354              name on plt calls.  The difficulty in doing so is
3355              a) finding the stubs, and,
3356              b) matching stubs against plt entries, and,
3357              c) there can be multiple stubs for a given plt entry.
3358
3359              Solving (a) could be done by code scanning, but older
3360              ppc64 binaries used different stubs to current code.
3361              (b) is the tricky one since you need to known the toc
3362              pointer for at least one function that uses a pic stub to
3363              be able to calculate the plt address referenced.
3364              (c) means gdb would need to set multiple breakpoints (or
3365              find the glink branch itself) when setting breakpoints
3366              for pending shared library loads.  */
3367           p = relplt->relocation;
3368           for (i = 0; i < plt_count; i++, p++)
3369             {
3370               size_t len;
3371
3372               *s = **p->sym_ptr_ptr;
3373               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3374                  we are defining a symbol, ensure one of them is set.  */
3375               if ((s->flags & BSF_LOCAL) == 0)
3376                 s->flags |= BSF_GLOBAL;
3377               s->flags |= BSF_SYNTHETIC;
3378               s->section = glink;
3379               s->value = glink_vma - glink->vma;
3380               s->name = names;
3381               s->udata.p = NULL;
3382               len = strlen ((*p->sym_ptr_ptr)->name);
3383               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3384               names += len;
3385               if (p->addend != 0)
3386                 {
3387                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3388                   names += sizeof ("+0x") - 1;
3389                   bfd_sprintf_vma (abfd, names, p->addend);
3390                   names += strlen (names);
3391                 }
3392               memcpy (names, "@plt", sizeof ("@plt"));
3393               names += sizeof ("@plt");
3394               s++;
3395               glink_vma += 8;
3396               if (i >= 0x8000)
3397                 glink_vma += 4;
3398             }
3399           count += plt_count;
3400         }
3401     }
3402
3403  done:
3404   free (syms);
3405   return count;
3406 }
3407 \f
3408 /* The following functions are specific to the ELF linker, while
3409    functions above are used generally.  Those named ppc64_elf_* are
3410    called by the main ELF linker code.  They appear in this file more
3411    or less in the order in which they are called.  eg.
3412    ppc64_elf_check_relocs is called early in the link process,
3413    ppc64_elf_finish_dynamic_sections is one of the last functions
3414    called.
3415
3416    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3417    functions have both a function code symbol and a function descriptor
3418    symbol.  A call to foo in a relocatable object file looks like:
3419
3420    .            .text
3421    .    x:
3422    .            bl      .foo
3423    .            nop
3424
3425    The function definition in another object file might be:
3426
3427    .            .section .opd
3428    .    foo:    .quad   .foo
3429    .            .quad   .TOC.@tocbase
3430    .            .quad   0
3431    .
3432    .            .text
3433    .    .foo:   blr
3434
3435    When the linker resolves the call during a static link, the branch
3436    unsurprisingly just goes to .foo and the .opd information is unused.
3437    If the function definition is in a shared library, things are a little
3438    different:  The call goes via a plt call stub, the opd information gets
3439    copied to the plt, and the linker patches the nop.
3440
3441    .    x:
3442    .            bl      .foo_stub
3443    .            ld      2,40(1)
3444    .
3445    .
3446    .    .foo_stub:
3447    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3448    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3449    .            std     2,40(1)                 # this is the general idea
3450    .            ld      11,0(12)
3451    .            ld      2,8(12)
3452    .            mtctr   11
3453    .            ld      11,16(12)
3454    .            bctr
3455    .
3456    .            .section .plt
3457    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3458
3459    The "reloc ()" notation is supposed to indicate that the linker emits
3460    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3461    copying.
3462
3463    What are the difficulties here?  Well, firstly, the relocations
3464    examined by the linker in check_relocs are against the function code
3465    sym .foo, while the dynamic relocation in the plt is emitted against
3466    the function descriptor symbol, foo.  Somewhere along the line, we need
3467    to carefully copy dynamic link information from one symbol to the other.
3468    Secondly, the generic part of the elf linker will make .foo a dynamic
3469    symbol as is normal for most other backends.  We need foo dynamic
3470    instead, at least for an application final link.  However, when
3471    creating a shared library containing foo, we need to have both symbols
3472    dynamic so that references to .foo are satisfied during the early
3473    stages of linking.  Otherwise the linker might decide to pull in a
3474    definition from some other object, eg. a static library.
3475
3476    Update: As of August 2004, we support a new convention.  Function
3477    calls may use the function descriptor symbol, ie. "bl foo".  This
3478    behaves exactly as "bl .foo".  */
3479
3480 /* Of those relocs that might be copied as dynamic relocs, this function
3481    selects those that must be copied when linking a shared library,
3482    even when the symbol is local.  */
3483
3484 static int
3485 must_be_dyn_reloc (struct bfd_link_info *info,
3486                    enum elf_ppc64_reloc_type r_type)
3487 {
3488   switch (r_type)
3489     {
3490     default:
3491       return 1;
3492
3493     case R_PPC64_REL32:
3494     case R_PPC64_REL64:
3495     case R_PPC64_REL30:
3496       return 0;
3497
3498     case R_PPC64_TPREL16:
3499     case R_PPC64_TPREL16_LO:
3500     case R_PPC64_TPREL16_HI:
3501     case R_PPC64_TPREL16_HA:
3502     case R_PPC64_TPREL16_DS:
3503     case R_PPC64_TPREL16_LO_DS:
3504     case R_PPC64_TPREL16_HIGHER:
3505     case R_PPC64_TPREL16_HIGHERA:
3506     case R_PPC64_TPREL16_HIGHEST:
3507     case R_PPC64_TPREL16_HIGHESTA:
3508     case R_PPC64_TPREL64:
3509       return !info->executable;
3510     }
3511 }
3512
3513 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3514    copying dynamic variables from a shared lib into an app's dynbss
3515    section, and instead use a dynamic relocation to point into the
3516    shared lib.  With code that gcc generates, it's vital that this be
3517    enabled;  In the PowerPC64 ABI, the address of a function is actually
3518    the address of a function descriptor, which resides in the .opd
3519    section.  gcc uses the descriptor directly rather than going via the
3520    GOT as some other ABI's do, which means that initialized function
3521    pointers must reference the descriptor.  Thus, a function pointer
3522    initialized to the address of a function in a shared library will
3523    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3524    redefines the function descriptor symbol to point to the copy.  This
3525    presents a problem as a plt entry for that function is also
3526    initialized from the function descriptor symbol and the copy reloc
3527    may not be initialized first.  */
3528 #define ELIMINATE_COPY_RELOCS 1
3529
3530 /* Section name for stubs is the associated section name plus this
3531    string.  */
3532 #define STUB_SUFFIX ".stub"
3533
3534 /* Linker stubs.
3535    ppc_stub_long_branch:
3536    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3537    destination, but a 24 bit branch in a stub section will reach.
3538    .    b       dest
3539
3540    ppc_stub_plt_branch:
3541    Similar to the above, but a 24 bit branch in the stub section won't
3542    reach its destination.
3543    .    addis   %r12,%r2,xxx@toc@ha
3544    .    ld      %r11,xxx@toc@l(%r12)
3545    .    mtctr   %r11
3546    .    bctr
3547
3548    ppc_stub_plt_call:
3549    Used to call a function in a shared library.  If it so happens that
3550    the plt entry referenced crosses a 64k boundary, then an extra
3551    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3552    .    addis   %r12,%r2,xxx@toc@ha
3553    .    std     %r2,40(%r1)
3554    .    ld      %r11,xxx+0@toc@l(%r12)
3555    .    mtctr   %r11
3556    .    ld      %r2,xxx+8@toc@l(%r12)
3557    .    ld      %r11,xxx+16@toc@l(%r12)
3558    .    bctr
3559
3560    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3561    code to adjust the value and save r2 to support multiple toc sections.
3562    A ppc_stub_long_branch with an r2 offset looks like:
3563    .    std     %r2,40(%r1)
3564    .    addis   %r2,%r2,off@ha
3565    .    addi    %r2,%r2,off@l
3566    .    b       dest
3567
3568    A ppc_stub_plt_branch with an r2 offset looks like:
3569    .    std     %r2,40(%r1)
3570    .    addis   %r12,%r2,xxx@toc@ha
3571    .    ld      %r11,xxx@toc@l(%r12)
3572    .    addis   %r2,%r2,off@ha
3573    .    addi    %r2,%r2,off@l
3574    .    mtctr   %r11
3575    .    bctr
3576
3577    In cases where the "addis" instruction would add zero, the "addis" is
3578    omitted and following instructions modified slightly in some cases.
3579 */
3580
3581 enum ppc_stub_type {
3582   ppc_stub_none,
3583   ppc_stub_long_branch,
3584   ppc_stub_long_branch_r2off,
3585   ppc_stub_plt_branch,
3586   ppc_stub_plt_branch_r2off,
3587   ppc_stub_plt_call
3588 };
3589
3590 struct ppc_stub_hash_entry {
3591
3592   /* Base hash table entry structure.  */
3593   struct bfd_hash_entry root;
3594
3595   enum ppc_stub_type stub_type;
3596
3597   /* The stub section.  */
3598   asection *stub_sec;
3599
3600   /* Offset within stub_sec of the beginning of this stub.  */
3601   bfd_vma stub_offset;
3602
3603   /* Given the symbol's value and its section we can determine its final
3604      value when building the stubs (so the stub knows where to jump.  */
3605   bfd_vma target_value;
3606   asection *target_section;
3607
3608   /* The symbol table entry, if any, that this was derived from.  */
3609   struct ppc_link_hash_entry *h;
3610   struct plt_entry *plt_ent;
3611
3612   /* And the reloc addend that this was derived from.  */
3613   bfd_vma addend;
3614
3615   /* Where this stub is being called from, or, in the case of combined
3616      stub sections, the first input section in the group.  */
3617   asection *id_sec;
3618 };
3619
3620 struct ppc_branch_hash_entry {
3621
3622   /* Base hash table entry structure.  */
3623   struct bfd_hash_entry root;
3624
3625   /* Offset within branch lookup table.  */
3626   unsigned int offset;
3627
3628   /* Generation marker.  */
3629   unsigned int iter;
3630 };
3631
3632 struct ppc_link_hash_entry
3633 {
3634   struct elf_link_hash_entry elf;
3635
3636   union {
3637     /* A pointer to the most recently used stub hash entry against this
3638        symbol.  */
3639     struct ppc_stub_hash_entry *stub_cache;
3640
3641     /* A pointer to the next symbol starting with a '.'  */
3642     struct ppc_link_hash_entry *next_dot_sym;
3643   } u;
3644
3645   /* Track dynamic relocs copied for this symbol.  */
3646   struct elf_dyn_relocs *dyn_relocs;
3647
3648   /* Link between function code and descriptor symbols.  */
3649   struct ppc_link_hash_entry *oh;
3650
3651   /* Flag function code and descriptor symbols.  */
3652   unsigned int is_func:1;
3653   unsigned int is_func_descriptor:1;
3654   unsigned int fake:1;
3655
3656   /* Whether global opd/toc sym has been adjusted or not.
3657      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3658      should be set for all globals defined in any opd/toc section.  */
3659   unsigned int adjust_done:1;
3660
3661   /* Set if we twiddled this symbol to weak at some stage.  */
3662   unsigned int was_undefined:1;
3663
3664   /* Contexts in which symbol is used in the GOT (or TOC).
3665      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3666      corresponding relocs are encountered during check_relocs.
3667      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3668      indicate the corresponding GOT entry type is not needed.
3669      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3670      a TPREL one.  We use a separate flag rather than setting TPREL
3671      just for convenience in distinguishing the two cases.  */
3672 #define TLS_GD           1      /* GD reloc. */
3673 #define TLS_LD           2      /* LD reloc. */
3674 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3675 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3676 #define TLS_TLS         16      /* Any TLS reloc.  */
3677 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3678 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3679 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3680   unsigned char tls_mask;
3681 };
3682
3683 /* ppc64 ELF linker hash table.  */
3684
3685 struct ppc_link_hash_table
3686 {
3687   struct elf_link_hash_table elf;
3688
3689   /* The stub hash table.  */
3690   struct bfd_hash_table stub_hash_table;
3691
3692   /* Another hash table for plt_branch stubs.  */
3693   struct bfd_hash_table branch_hash_table;
3694
3695   /* Hash table for function prologue tocsave.  */
3696   htab_t tocsave_htab;
3697
3698   /* Linker stub bfd.  */
3699   bfd *stub_bfd;
3700
3701   /* Linker call-backs.  */
3702   asection * (*add_stub_section) (const char *, asection *);
3703   void (*layout_sections_again) (void);
3704
3705   /* Array to keep track of which stub sections have been created, and
3706      information on stub grouping.  */
3707   struct map_stub {
3708     /* This is the section to which stubs in the group will be attached.  */
3709     asection *link_sec;
3710     /* The stub section.  */
3711     asection *stub_sec;
3712     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3713     bfd_vma toc_off;
3714   } *stub_group;
3715
3716   /* Temp used when calculating TOC pointers.  */
3717   bfd_vma toc_curr;
3718   bfd *toc_bfd;
3719   asection *toc_first_sec;
3720
3721   /* Highest input section id.  */
3722   int top_id;
3723
3724   /* Highest output section index.  */
3725   int top_index;
3726
3727   /* Used when adding symbols.  */
3728   struct ppc_link_hash_entry *dot_syms;
3729
3730   /* List of input sections for each output section.  */
3731   asection **input_list;
3732
3733   /* Short-cuts to get to dynamic linker sections.  */
3734   asection *got;
3735   asection *plt;
3736   asection *relplt;
3737   asection *iplt;
3738   asection *reliplt;
3739   asection *dynbss;
3740   asection *relbss;
3741   asection *glink;
3742   asection *sfpr;
3743   asection *brlt;
3744   asection *relbrlt;
3745   asection *glink_eh_frame;
3746
3747   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3748   struct ppc_link_hash_entry *tls_get_addr;
3749   struct ppc_link_hash_entry *tls_get_addr_fd;
3750
3751   /* The size of reliplt used by got entry relocs.  */
3752   bfd_size_type got_reli_size;
3753
3754   /* Statistics.  */
3755   unsigned long stub_count[ppc_stub_plt_call];
3756
3757   /* Number of stubs against global syms.  */
3758   unsigned long stub_globals;
3759
3760   /* Set if PLT call stubs should load r11.  */
3761   unsigned int plt_static_chain:1;
3762
3763   /* Set if we should emit symbols for stubs.  */
3764   unsigned int emit_stub_syms:1;
3765
3766   /* Set if __tls_get_addr optimization should not be done.  */
3767   unsigned int no_tls_get_addr_opt:1;
3768
3769   /* Support for multiple toc sections.  */
3770   unsigned int do_multi_toc:1;
3771   unsigned int multi_toc_needed:1;
3772   unsigned int second_toc_pass:1;
3773   unsigned int do_toc_opt:1;
3774
3775   /* Set on error.  */
3776   unsigned int stub_error:1;
3777
3778   /* Temp used by ppc64_elf_process_dot_syms.  */
3779   unsigned int twiddled_syms:1;
3780
3781   /* Incremented every time we size stubs.  */
3782   unsigned int stub_iteration;
3783
3784   /* Small local sym cache.  */
3785   struct sym_cache sym_cache;
3786 };
3787
3788 /* Rename some of the generic section flags to better document how they
3789    are used here.  */
3790
3791 /* Nonzero if this section has TLS related relocations.  */
3792 #define has_tls_reloc sec_flg0
3793
3794 /* Nonzero if this section has a call to __tls_get_addr.  */
3795 #define has_tls_get_addr_call sec_flg1
3796
3797 /* Nonzero if this section has any toc or got relocs.  */
3798 #define has_toc_reloc sec_flg2
3799
3800 /* Nonzero if this section has a call to another section that uses
3801    the toc or got.  */
3802 #define makes_toc_func_call sec_flg3
3803
3804 /* Recursion protection when determining above flag.  */
3805 #define call_check_in_progress sec_flg4
3806 #define call_check_done sec_flg5
3807
3808 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3809
3810 #define ppc_hash_table(p) \
3811   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3812   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3813
3814 #define ppc_stub_hash_lookup(table, string, create, copy) \
3815   ((struct ppc_stub_hash_entry *) \
3816    bfd_hash_lookup ((table), (string), (create), (copy)))
3817
3818 #define ppc_branch_hash_lookup(table, string, create, copy) \
3819   ((struct ppc_branch_hash_entry *) \
3820    bfd_hash_lookup ((table), (string), (create), (copy)))
3821
3822 /* Create an entry in the stub hash table.  */
3823
3824 static struct bfd_hash_entry *
3825 stub_hash_newfunc (struct bfd_hash_entry *entry,
3826                    struct bfd_hash_table *table,
3827                    const char *string)
3828 {
3829   /* Allocate the structure if it has not already been allocated by a
3830      subclass.  */
3831   if (entry == NULL)
3832     {
3833       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3834       if (entry == NULL)
3835         return entry;
3836     }
3837
3838   /* Call the allocation method of the superclass.  */
3839   entry = bfd_hash_newfunc (entry, table, string);
3840   if (entry != NULL)
3841     {
3842       struct ppc_stub_hash_entry *eh;
3843
3844       /* Initialize the local fields.  */
3845       eh = (struct ppc_stub_hash_entry *) entry;
3846       eh->stub_type = ppc_stub_none;
3847       eh->stub_sec = NULL;
3848       eh->stub_offset = 0;
3849       eh->target_value = 0;
3850       eh->target_section = NULL;
3851       eh->h = NULL;
3852       eh->id_sec = NULL;
3853     }
3854
3855   return entry;
3856 }
3857
3858 /* Create an entry in the branch hash table.  */
3859
3860 static struct bfd_hash_entry *
3861 branch_hash_newfunc (struct bfd_hash_entry *entry,
3862                      struct bfd_hash_table *table,
3863                      const char *string)
3864 {
3865   /* Allocate the structure if it has not already been allocated by a
3866      subclass.  */
3867   if (entry == NULL)
3868     {
3869       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3870       if (entry == NULL)
3871         return entry;
3872     }
3873
3874   /* Call the allocation method of the superclass.  */
3875   entry = bfd_hash_newfunc (entry, table, string);
3876   if (entry != NULL)
3877     {
3878       struct ppc_branch_hash_entry *eh;
3879
3880       /* Initialize the local fields.  */
3881       eh = (struct ppc_branch_hash_entry *) entry;
3882       eh->offset = 0;
3883       eh->iter = 0;
3884     }
3885
3886   return entry;
3887 }
3888
3889 /* Create an entry in a ppc64 ELF linker hash table.  */
3890
3891 static struct bfd_hash_entry *
3892 link_hash_newfunc (struct bfd_hash_entry *entry,
3893                    struct bfd_hash_table *table,
3894                    const char *string)
3895 {
3896   /* Allocate the structure if it has not already been allocated by a
3897      subclass.  */
3898   if (entry == NULL)
3899     {
3900       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3901       if (entry == NULL)
3902         return entry;
3903     }
3904
3905   /* Call the allocation method of the superclass.  */
3906   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3907   if (entry != NULL)
3908     {
3909       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3910
3911       memset (&eh->u.stub_cache, 0,
3912               (sizeof (struct ppc_link_hash_entry)
3913                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3914
3915       /* When making function calls, old ABI code references function entry
3916          points (dot symbols), while new ABI code references the function
3917          descriptor symbol.  We need to make any combination of reference and
3918          definition work together, without breaking archive linking.
3919
3920          For a defined function "foo" and an undefined call to "bar":
3921          An old object defines "foo" and ".foo", references ".bar" (possibly
3922          "bar" too).
3923          A new object defines "foo" and references "bar".
3924
3925          A new object thus has no problem with its undefined symbols being
3926          satisfied by definitions in an old object.  On the other hand, the
3927          old object won't have ".bar" satisfied by a new object.
3928
3929          Keep a list of newly added dot-symbols.  */
3930
3931       if (string[0] == '.')
3932         {
3933           struct ppc_link_hash_table *htab;
3934
3935           htab = (struct ppc_link_hash_table *) table;
3936           eh->u.next_dot_sym = htab->dot_syms;
3937           htab->dot_syms = eh;
3938         }
3939     }
3940
3941   return entry;
3942 }
3943
3944 struct tocsave_entry {
3945   asection *sec;
3946   bfd_vma offset;
3947 };
3948
3949 static hashval_t
3950 tocsave_htab_hash (const void *p)
3951 {
3952   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3953   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
3954 }
3955
3956 static int
3957 tocsave_htab_eq (const void *p1, const void *p2)
3958 {
3959   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3960   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3961   return e1->sec == e2->sec && e1->offset == e2->offset;
3962 }
3963
3964 /* Create a ppc64 ELF linker hash table.  */
3965
3966 static struct bfd_link_hash_table *
3967 ppc64_elf_link_hash_table_create (bfd *abfd)
3968 {
3969   struct ppc_link_hash_table *htab;
3970   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3971
3972   htab = bfd_zmalloc (amt);
3973   if (htab == NULL)
3974     return NULL;
3975
3976   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3977                                       sizeof (struct ppc_link_hash_entry),
3978                                       PPC64_ELF_DATA))
3979     {
3980       free (htab);
3981       return NULL;
3982     }
3983
3984   /* Init the stub hash table too.  */
3985   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3986                             sizeof (struct ppc_stub_hash_entry)))
3987     return NULL;
3988
3989   /* And the branch hash table.  */
3990   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3991                             sizeof (struct ppc_branch_hash_entry)))
3992     return NULL;
3993
3994   htab->tocsave_htab = htab_try_create (1024,
3995                                         tocsave_htab_hash,
3996                                         tocsave_htab_eq,
3997                                         NULL);
3998   if (htab->tocsave_htab == NULL)
3999     return NULL;
4000
4001   /* Initializing two fields of the union is just cosmetic.  We really
4002      only care about glist, but when compiled on a 32-bit host the
4003      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4004      debugger inspection of these fields look nicer.  */
4005   htab->elf.init_got_refcount.refcount = 0;
4006   htab->elf.init_got_refcount.glist = NULL;
4007   htab->elf.init_plt_refcount.refcount = 0;
4008   htab->elf.init_plt_refcount.glist = NULL;
4009   htab->elf.init_got_offset.offset = 0;
4010   htab->elf.init_got_offset.glist = NULL;
4011   htab->elf.init_plt_offset.offset = 0;
4012   htab->elf.init_plt_offset.glist = NULL;
4013
4014   return &htab->elf.root;
4015 }
4016
4017 /* Free the derived linker hash table.  */
4018
4019 static void
4020 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4021 {
4022   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4023
4024   bfd_hash_table_free (&htab->stub_hash_table);
4025   bfd_hash_table_free (&htab->branch_hash_table);
4026   if (htab->tocsave_htab)
4027     htab_delete (htab->tocsave_htab);
4028   _bfd_generic_link_hash_table_free (hash);
4029 }
4030
4031 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4032
4033 void
4034 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4035 {
4036   struct ppc_link_hash_table *htab;
4037
4038   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4039
4040 /* Always hook our dynamic sections into the first bfd, which is the
4041    linker created stub bfd.  This ensures that the GOT header is at
4042    the start of the output TOC section.  */
4043   htab = ppc_hash_table (info);
4044   if (htab == NULL)
4045     return;
4046   htab->stub_bfd = abfd;
4047   htab->elf.dynobj = abfd;
4048 }
4049
4050 /* Build a name for an entry in the stub hash table.  */
4051
4052 static char *
4053 ppc_stub_name (const asection *input_section,
4054                const asection *sym_sec,
4055                const struct ppc_link_hash_entry *h,
4056                const Elf_Internal_Rela *rel)
4057 {
4058   char *stub_name;
4059   bfd_size_type len;
4060
4061   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4062      offsets from a sym as a branch target?  In fact, we could
4063      probably assume the addend is always zero.  */
4064   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4065
4066   if (h)
4067     {
4068       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4069       stub_name = bfd_malloc (len);
4070       if (stub_name == NULL)
4071         return stub_name;
4072
4073       sprintf (stub_name, "%08x.%s+%x",
4074                input_section->id & 0xffffffff,
4075                h->elf.root.root.string,
4076                (int) rel->r_addend & 0xffffffff);
4077     }
4078   else
4079     {
4080       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4081       stub_name = bfd_malloc (len);
4082       if (stub_name == NULL)
4083         return stub_name;
4084
4085       sprintf (stub_name, "%08x.%x:%x+%x",
4086                input_section->id & 0xffffffff,
4087                sym_sec->id & 0xffffffff,
4088                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4089                (int) rel->r_addend & 0xffffffff);
4090     }
4091   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4092     stub_name[len - 2] = 0;
4093   return stub_name;
4094 }
4095
4096 /* Look up an entry in the stub hash.  Stub entries are cached because
4097    creating the stub name takes a bit of time.  */
4098
4099 static struct ppc_stub_hash_entry *
4100 ppc_get_stub_entry (const asection *input_section,
4101                     const asection *sym_sec,
4102                     struct ppc_link_hash_entry *h,
4103                     const Elf_Internal_Rela *rel,
4104                     struct ppc_link_hash_table *htab)
4105 {
4106   struct ppc_stub_hash_entry *stub_entry;
4107   const asection *id_sec;
4108
4109   /* If this input section is part of a group of sections sharing one
4110      stub section, then use the id of the first section in the group.
4111      Stub names need to include a section id, as there may well be
4112      more than one stub used to reach say, printf, and we need to
4113      distinguish between them.  */
4114   id_sec = htab->stub_group[input_section->id].link_sec;
4115
4116   if (h != NULL && h->u.stub_cache != NULL
4117       && h->u.stub_cache->h == h
4118       && h->u.stub_cache->id_sec == id_sec)
4119     {
4120       stub_entry = h->u.stub_cache;
4121     }
4122   else
4123     {
4124       char *stub_name;
4125
4126       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4127       if (stub_name == NULL)
4128         return NULL;
4129
4130       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4131                                          stub_name, FALSE, FALSE);
4132       if (h != NULL)
4133         h->u.stub_cache = stub_entry;
4134
4135       free (stub_name);
4136     }
4137
4138   return stub_entry;
4139 }
4140
4141 /* Add a new stub entry to the stub hash.  Not all fields of the new
4142    stub entry are initialised.  */
4143
4144 static struct ppc_stub_hash_entry *
4145 ppc_add_stub (const char *stub_name,
4146               asection *section,
4147               struct bfd_link_info *info)
4148 {
4149   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4150   asection *link_sec;
4151   asection *stub_sec;
4152   struct ppc_stub_hash_entry *stub_entry;
4153
4154   link_sec = htab->stub_group[section->id].link_sec;
4155   stub_sec = htab->stub_group[section->id].stub_sec;
4156   if (stub_sec == NULL)
4157     {
4158       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4159       if (stub_sec == NULL)
4160         {
4161           size_t namelen;
4162           bfd_size_type len;
4163           char *s_name;
4164
4165           namelen = strlen (link_sec->name);
4166           len = namelen + sizeof (STUB_SUFFIX);
4167           s_name = bfd_alloc (htab->stub_bfd, len);
4168           if (s_name == NULL)
4169             return NULL;
4170
4171           memcpy (s_name, link_sec->name, namelen);
4172           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4173           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4174           if (stub_sec == NULL)
4175             return NULL;
4176           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4177         }
4178       htab->stub_group[section->id].stub_sec = stub_sec;
4179     }
4180
4181   /* Enter this entry into the linker stub hash table.  */
4182   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4183                                      TRUE, FALSE);
4184   if (stub_entry == NULL)
4185     {
4186       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4187                               section->owner, stub_name);
4188       return NULL;
4189     }
4190
4191   stub_entry->stub_sec = stub_sec;
4192   stub_entry->stub_offset = 0;
4193   stub_entry->id_sec = link_sec;
4194   return stub_entry;
4195 }
4196
4197 /* Create sections for linker generated code.  */
4198
4199 static bfd_boolean
4200 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4201 {
4202   struct ppc_link_hash_table *htab;
4203   flagword flags;
4204
4205   htab = ppc_hash_table (info);
4206   if (htab == NULL)
4207     return FALSE;
4208
4209   /* Create .sfpr for code to save and restore fp regs.  */
4210   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4211            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4212   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4213                                                    flags);
4214   if (htab->sfpr == NULL
4215       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4216     return FALSE;
4217
4218   /* Create .glink for lazy dynamic linking support.  */
4219   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4220                                                     flags);
4221   if (htab->glink == NULL
4222       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4223     return FALSE;
4224
4225   if (!info->no_ld_generated_unwind_info)
4226     {
4227       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4228                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4229       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4230                                                                  ".eh_frame",
4231                                                                  flags);
4232       if (htab->glink_eh_frame == NULL
4233           || !bfd_set_section_alignment (abfd, htab->glink_eh_frame, 2))
4234         return FALSE;
4235     }
4236
4237   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4238   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4239   if (htab->iplt == NULL
4240       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4241     return FALSE;
4242
4243   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4244            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4246                                                       ".rela.iplt",
4247                                                       flags);
4248   if (htab->reliplt == NULL
4249       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4250     return FALSE;
4251
4252   /* Create branch lookup table for plt_branch stubs.  */
4253   flags = (SEC_ALLOC | SEC_LOAD
4254            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4255   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4256                                                    flags);
4257   if (htab->brlt == NULL
4258       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4259     return FALSE;
4260
4261   if (!info->shared)
4262     return TRUE;
4263
4264   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4265            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4266   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4267                                                       ".rela.branch_lt",
4268                                                       flags);
4269   if (htab->relbrlt == NULL
4270       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4271     return FALSE;
4272
4273   return TRUE;
4274 }
4275
4276 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4277    not already done.  */
4278
4279 static bfd_boolean
4280 create_got_section (bfd *abfd, struct bfd_link_info *info)
4281 {
4282   asection *got, *relgot;
4283   flagword flags;
4284   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4285
4286   if (!is_ppc64_elf (abfd))
4287     return FALSE;
4288   if (htab == NULL)
4289     return FALSE;
4290
4291   if (!htab->got)
4292     {
4293       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4294         return FALSE;
4295
4296       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4297       if (!htab->got)
4298         abort ();
4299     }
4300
4301   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4302            | SEC_LINKER_CREATED);
4303
4304   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4305   if (!got
4306       || !bfd_set_section_alignment (abfd, got, 3))
4307     return FALSE;
4308
4309   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4310                                                flags | SEC_READONLY);
4311   if (!relgot
4312       || ! bfd_set_section_alignment (abfd, relgot, 3))
4313     return FALSE;
4314
4315   ppc64_elf_tdata (abfd)->got = got;
4316   ppc64_elf_tdata (abfd)->relgot = relgot;
4317   return TRUE;
4318 }
4319
4320 /* Create the dynamic sections, and set up shortcuts.  */
4321
4322 static bfd_boolean
4323 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4324 {
4325   struct ppc_link_hash_table *htab;
4326
4327   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4328     return FALSE;
4329
4330   htab = ppc_hash_table (info);
4331   if (htab == NULL)
4332     return FALSE;
4333
4334   if (!htab->got)
4335     htab->got = bfd_get_section_by_name (dynobj, ".got");
4336   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4337   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4338   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4339   if (!info->shared)
4340     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4341
4342   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4343       || (!info->shared && !htab->relbss))
4344     abort ();
4345
4346   return TRUE;
4347 }
4348
4349 /* Follow indirect and warning symbol links.  */
4350
4351 static inline struct bfd_link_hash_entry *
4352 follow_link (struct bfd_link_hash_entry *h)
4353 {
4354   while (h->type == bfd_link_hash_indirect
4355          || h->type == bfd_link_hash_warning)
4356     h = h->u.i.link;
4357   return h;
4358 }
4359
4360 static inline struct elf_link_hash_entry *
4361 elf_follow_link (struct elf_link_hash_entry *h)
4362 {
4363   return (struct elf_link_hash_entry *) follow_link (&h->root);
4364 }
4365
4366 static inline struct ppc_link_hash_entry *
4367 ppc_follow_link (struct ppc_link_hash_entry *h)
4368 {
4369   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4370 }
4371
4372 /* Merge PLT info on FROM with that on TO.  */
4373
4374 static void
4375 move_plt_plist (struct ppc_link_hash_entry *from,
4376                 struct ppc_link_hash_entry *to)
4377 {
4378   if (from->elf.plt.plist != NULL)
4379     {
4380       if (to->elf.plt.plist != NULL)
4381         {
4382           struct plt_entry **entp;
4383           struct plt_entry *ent;
4384
4385           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4386             {
4387               struct plt_entry *dent;
4388
4389               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4390                 if (dent->addend == ent->addend)
4391                   {
4392                     dent->plt.refcount += ent->plt.refcount;
4393                     *entp = ent->next;
4394                     break;
4395                   }
4396               if (dent == NULL)
4397                 entp = &ent->next;
4398             }
4399           *entp = to->elf.plt.plist;
4400         }
4401
4402       to->elf.plt.plist = from->elf.plt.plist;
4403       from->elf.plt.plist = NULL;
4404     }
4405 }
4406
4407 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4408
4409 static void
4410 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4411                                 struct elf_link_hash_entry *dir,
4412                                 struct elf_link_hash_entry *ind)
4413 {
4414   struct ppc_link_hash_entry *edir, *eind;
4415
4416   edir = (struct ppc_link_hash_entry *) dir;
4417   eind = (struct ppc_link_hash_entry *) ind;
4418
4419   edir->is_func |= eind->is_func;
4420   edir->is_func_descriptor |= eind->is_func_descriptor;
4421   edir->tls_mask |= eind->tls_mask;
4422   if (eind->oh != NULL)
4423     edir->oh = ppc_follow_link (eind->oh);
4424
4425   /* If called to transfer flags for a weakdef during processing
4426      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4427      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4428   if (!(ELIMINATE_COPY_RELOCS
4429         && eind->elf.root.type != bfd_link_hash_indirect
4430         && edir->elf.dynamic_adjusted))
4431     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4432
4433   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4434   edir->elf.ref_regular |= eind->elf.ref_regular;
4435   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4436   edir->elf.needs_plt |= eind->elf.needs_plt;
4437
4438   /* If we were called to copy over info for a weak sym, that's all.  */
4439   if (eind->elf.root.type != bfd_link_hash_indirect)
4440     return;
4441
4442   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4443   if (eind->dyn_relocs != NULL)
4444     {
4445       if (edir->dyn_relocs != NULL)
4446         {
4447           struct elf_dyn_relocs **pp;
4448           struct elf_dyn_relocs *p;
4449
4450           /* Add reloc counts against the indirect sym to the direct sym
4451              list.  Merge any entries against the same section.  */
4452           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4453             {
4454               struct elf_dyn_relocs *q;
4455
4456               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4457                 if (q->sec == p->sec)
4458                   {
4459                     q->pc_count += p->pc_count;
4460                     q->count += p->count;
4461                     *pp = p->next;
4462                     break;
4463                   }
4464               if (q == NULL)
4465                 pp = &p->next;
4466             }
4467           *pp = edir->dyn_relocs;
4468         }
4469
4470       edir->dyn_relocs = eind->dyn_relocs;
4471       eind->dyn_relocs = NULL;
4472     }
4473
4474   /* Copy over got entries that we may have already seen to the
4475      symbol which just became indirect.  */
4476   if (eind->elf.got.glist != NULL)
4477     {
4478       if (edir->elf.got.glist != NULL)
4479         {
4480           struct got_entry **entp;
4481           struct got_entry *ent;
4482
4483           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4484             {
4485               struct got_entry *dent;
4486
4487               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4488                 if (dent->addend == ent->addend
4489                     && dent->owner == ent->owner
4490                     && dent->tls_type == ent->tls_type)
4491                   {
4492                     dent->got.refcount += ent->got.refcount;
4493                     *entp = ent->next;
4494                     break;
4495                   }
4496               if (dent == NULL)
4497                 entp = &ent->next;
4498             }
4499           *entp = edir->elf.got.glist;
4500         }
4501
4502       edir->elf.got.glist = eind->elf.got.glist;
4503       eind->elf.got.glist = NULL;
4504     }
4505
4506   /* And plt entries.  */
4507   move_plt_plist (eind, edir);
4508
4509   if (eind->elf.dynindx != -1)
4510     {
4511       if (edir->elf.dynindx != -1)
4512         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4513                                 edir->elf.dynstr_index);
4514       edir->elf.dynindx = eind->elf.dynindx;
4515       edir->elf.dynstr_index = eind->elf.dynstr_index;
4516       eind->elf.dynindx = -1;
4517       eind->elf.dynstr_index = 0;
4518     }
4519 }
4520
4521 /* Find the function descriptor hash entry from the given function code
4522    hash entry FH.  Link the entries via their OH fields.  */
4523
4524 static struct ppc_link_hash_entry *
4525 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4526 {
4527   struct ppc_link_hash_entry *fdh = fh->oh;
4528
4529   if (fdh == NULL)
4530     {
4531       const char *fd_name = fh->elf.root.root.string + 1;
4532
4533       fdh = (struct ppc_link_hash_entry *)
4534         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4535       if (fdh == NULL)
4536         return fdh;
4537
4538       fdh->is_func_descriptor = 1;
4539       fdh->oh = fh;
4540       fh->is_func = 1;
4541       fh->oh = fdh;
4542     }
4543
4544   return ppc_follow_link (fdh);
4545 }
4546
4547 /* Make a fake function descriptor sym for the code sym FH.  */
4548
4549 static struct ppc_link_hash_entry *
4550 make_fdh (struct bfd_link_info *info,
4551           struct ppc_link_hash_entry *fh)
4552 {
4553   bfd *abfd;
4554   asymbol *newsym;
4555   struct bfd_link_hash_entry *bh;
4556   struct ppc_link_hash_entry *fdh;
4557
4558   abfd = fh->elf.root.u.undef.abfd;
4559   newsym = bfd_make_empty_symbol (abfd);
4560   newsym->name = fh->elf.root.root.string + 1;
4561   newsym->section = bfd_und_section_ptr;
4562   newsym->value = 0;
4563   newsym->flags = BSF_WEAK;
4564
4565   bh = NULL;
4566   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4567                                          newsym->flags, newsym->section,
4568                                          newsym->value, NULL, FALSE, FALSE,
4569                                          &bh))
4570     return NULL;
4571
4572   fdh = (struct ppc_link_hash_entry *) bh;
4573   fdh->elf.non_elf = 0;
4574   fdh->fake = 1;
4575   fdh->is_func_descriptor = 1;
4576   fdh->oh = fh;
4577   fh->is_func = 1;
4578   fh->oh = fdh;
4579   return fdh;
4580 }
4581
4582 /* Fix function descriptor symbols defined in .opd sections to be
4583    function type.  */
4584
4585 static bfd_boolean
4586 ppc64_elf_add_symbol_hook (bfd *ibfd,
4587                            struct bfd_link_info *info,
4588                            Elf_Internal_Sym *isym,
4589                            const char **name ATTRIBUTE_UNUSED,
4590                            flagword *flags ATTRIBUTE_UNUSED,
4591                            asection **sec,
4592                            bfd_vma *value ATTRIBUTE_UNUSED)
4593 {
4594   if ((ibfd->flags & DYNAMIC) == 0
4595       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4596     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4597
4598   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4599     {
4600       if ((ibfd->flags & DYNAMIC) == 0)
4601         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4602     }
4603   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4604     ;
4605   else if (*sec != NULL
4606            && strcmp ((*sec)->name, ".opd") == 0)
4607     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4608
4609   return TRUE;
4610 }
4611
4612 /* This function makes an old ABI object reference to ".bar" cause the
4613    inclusion of a new ABI object archive that defines "bar".
4614    NAME is a symbol defined in an archive.  Return a symbol in the hash
4615    table that might be satisfied by the archive symbols.  */
4616
4617 static struct elf_link_hash_entry *
4618 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4619                                  struct bfd_link_info *info,
4620                                  const char *name)
4621 {
4622   struct elf_link_hash_entry *h;
4623   char *dot_name;
4624   size_t len;
4625
4626   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4627   if (h != NULL
4628       /* Don't return this sym if it is a fake function descriptor
4629          created by add_symbol_adjust.  */
4630       && !(h->root.type == bfd_link_hash_undefweak
4631            && ((struct ppc_link_hash_entry *) h)->fake))
4632     return h;
4633
4634   if (name[0] == '.')
4635     return h;
4636
4637   len = strlen (name);
4638   dot_name = bfd_alloc (abfd, len + 2);
4639   if (dot_name == NULL)
4640     return (struct elf_link_hash_entry *) 0 - 1;
4641   dot_name[0] = '.';
4642   memcpy (dot_name + 1, name, len + 1);
4643   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4644   bfd_release (abfd, dot_name);
4645   return h;
4646 }
4647
4648 /* This function satisfies all old ABI object references to ".bar" if a
4649    new ABI object defines "bar".  Well, at least, undefined dot symbols
4650    are made weak.  This stops later archive searches from including an
4651    object if we already have a function descriptor definition.  It also
4652    prevents the linker complaining about undefined symbols.
4653    We also check and correct mismatched symbol visibility here.  The
4654    most restrictive visibility of the function descriptor and the
4655    function entry symbol is used.  */
4656
4657 static bfd_boolean
4658 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4659 {
4660   struct ppc_link_hash_table *htab;
4661   struct ppc_link_hash_entry *fdh;
4662
4663   if (eh->elf.root.type == bfd_link_hash_indirect)
4664     return TRUE;
4665
4666   if (eh->elf.root.type == bfd_link_hash_warning)
4667     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4668
4669   if (eh->elf.root.root.string[0] != '.')
4670     abort ();
4671
4672   htab = ppc_hash_table (info);
4673   if (htab == NULL)
4674     return FALSE;
4675
4676   fdh = lookup_fdh (eh, htab);
4677   if (fdh == NULL)
4678     {
4679       if (!info->relocatable
4680           && (eh->elf.root.type == bfd_link_hash_undefined
4681               || eh->elf.root.type == bfd_link_hash_undefweak)
4682           && eh->elf.ref_regular)
4683         {
4684           /* Make an undefweak function descriptor sym, which is enough to
4685              pull in an --as-needed shared lib, but won't cause link
4686              errors.  Archives are handled elsewhere.  */
4687           fdh = make_fdh (info, eh);
4688           if (fdh == NULL)
4689             return FALSE;
4690           fdh->elf.ref_regular = 1;
4691         }
4692     }
4693   else
4694     {
4695       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4696       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4697       if (entry_vis < descr_vis)
4698         fdh->elf.other += entry_vis - descr_vis;
4699       else if (entry_vis > descr_vis)
4700         eh->elf.other += descr_vis - entry_vis;
4701
4702       if ((fdh->elf.root.type == bfd_link_hash_defined
4703            || fdh->elf.root.type == bfd_link_hash_defweak)
4704           && eh->elf.root.type == bfd_link_hash_undefined)
4705         {
4706           eh->elf.root.type = bfd_link_hash_undefweak;
4707           eh->was_undefined = 1;
4708           htab->twiddled_syms = 1;
4709         }
4710     }
4711
4712   return TRUE;
4713 }
4714
4715 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4716
4717 static bfd_boolean
4718 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4719 {
4720   struct ppc_link_hash_table *htab;
4721   struct ppc_link_hash_entry **p, *eh;
4722
4723   if (!is_ppc64_elf (info->output_bfd))
4724     return TRUE;
4725   htab = ppc_hash_table (info);
4726   if (htab == NULL)
4727     return FALSE;
4728
4729   if (is_ppc64_elf (ibfd))
4730     {
4731       p = &htab->dot_syms;
4732       while ((eh = *p) != NULL)
4733         {
4734           *p = NULL;
4735           if (!add_symbol_adjust (eh, info))
4736             return FALSE;
4737           p = &eh->u.next_dot_sym;
4738         }
4739     }
4740
4741   /* Clear the list for non-ppc64 input files.  */
4742   p = &htab->dot_syms;
4743   while ((eh = *p) != NULL)
4744     {
4745       *p = NULL;
4746       p = &eh->u.next_dot_sym;
4747     }
4748
4749   /* We need to fix the undefs list for any syms we have twiddled to
4750      undef_weak.  */
4751   if (htab->twiddled_syms)
4752     {
4753       bfd_link_repair_undef_list (&htab->elf.root);
4754       htab->twiddled_syms = 0;
4755     }
4756   return TRUE;
4757 }
4758
4759 /* Undo hash table changes when an --as-needed input file is determined
4760    not to be needed.  */
4761
4762 static bfd_boolean
4763 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4764                              struct bfd_link_info *info)
4765 {
4766   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4767
4768   if (htab == NULL)
4769     return FALSE;
4770
4771   htab->dot_syms = NULL;
4772   return TRUE;
4773 }
4774
4775 /* If --just-symbols against a final linked binary, then assume we need
4776    toc adjusting stubs when calling functions defined there.  */
4777
4778 static void
4779 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4780 {
4781   if ((sec->flags & SEC_CODE) != 0
4782       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4783       && is_ppc64_elf (sec->owner))
4784     {
4785       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4786       if (got != NULL
4787           && got->size >= elf_backend_got_header_size
4788           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4789         sec->has_toc_reloc = 1;
4790     }
4791   _bfd_elf_link_just_syms (sec, info);
4792 }
4793
4794 static struct plt_entry **
4795 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4796                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4797 {
4798   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4799   struct plt_entry **local_plt;
4800   unsigned char *local_got_tls_masks;
4801
4802   if (local_got_ents == NULL)
4803     {
4804       bfd_size_type size = symtab_hdr->sh_info;
4805
4806       size *= (sizeof (*local_got_ents)
4807                + sizeof (*local_plt)
4808                + sizeof (*local_got_tls_masks));
4809       local_got_ents = bfd_zalloc (abfd, size);
4810       if (local_got_ents == NULL)
4811         return NULL;
4812       elf_local_got_ents (abfd) = local_got_ents;
4813     }
4814
4815   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4816     {
4817       struct got_entry *ent;
4818
4819       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4820         if (ent->addend == r_addend
4821             && ent->owner == abfd
4822             && ent->tls_type == tls_type)
4823           break;
4824       if (ent == NULL)
4825         {
4826           bfd_size_type amt = sizeof (*ent);
4827           ent = bfd_alloc (abfd, amt);
4828           if (ent == NULL)
4829             return FALSE;
4830           ent->next = local_got_ents[r_symndx];
4831           ent->addend = r_addend;
4832           ent->owner = abfd;
4833           ent->tls_type = tls_type;
4834           ent->is_indirect = FALSE;
4835           ent->got.refcount = 0;
4836           local_got_ents[r_symndx] = ent;
4837         }
4838       ent->got.refcount += 1;
4839     }
4840
4841   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4842   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4843   local_got_tls_masks[r_symndx] |= tls_type;
4844
4845   return local_plt + r_symndx;
4846 }
4847
4848 static bfd_boolean
4849 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4850 {
4851   struct plt_entry *ent;
4852
4853   for (ent = *plist; ent != NULL; ent = ent->next)
4854     if (ent->addend == addend)
4855       break;
4856   if (ent == NULL)
4857     {
4858       bfd_size_type amt = sizeof (*ent);
4859       ent = bfd_alloc (abfd, amt);
4860       if (ent == NULL)
4861         return FALSE;
4862       ent->next = *plist;
4863       ent->addend = addend;
4864       ent->plt.refcount = 0;
4865       *plist = ent;
4866     }
4867   ent->plt.refcount += 1;
4868   return TRUE;
4869 }
4870
4871 static bfd_boolean
4872 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4873 {
4874   return (r_type == R_PPC64_REL24
4875           || r_type == R_PPC64_REL14
4876           || r_type == R_PPC64_REL14_BRTAKEN
4877           || r_type == R_PPC64_REL14_BRNTAKEN
4878           || r_type == R_PPC64_ADDR24
4879           || r_type == R_PPC64_ADDR14
4880           || r_type == R_PPC64_ADDR14_BRTAKEN
4881           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4882 }
4883
4884 /* Look through the relocs for a section during the first phase, and
4885    calculate needed space in the global offset table, procedure
4886    linkage table, and dynamic reloc sections.  */
4887
4888 static bfd_boolean
4889 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4890                         asection *sec, const Elf_Internal_Rela *relocs)
4891 {
4892   struct ppc_link_hash_table *htab;
4893   Elf_Internal_Shdr *symtab_hdr;
4894   struct elf_link_hash_entry **sym_hashes;
4895   const Elf_Internal_Rela *rel;
4896   const Elf_Internal_Rela *rel_end;
4897   asection *sreloc;
4898   asection **opd_sym_map;
4899   struct elf_link_hash_entry *tga, *dottga;
4900
4901   if (info->relocatable)
4902     return TRUE;
4903
4904   /* Don't do anything special with non-loaded, non-alloced sections.
4905      In particular, any relocs in such sections should not affect GOT
4906      and PLT reference counting (ie. we don't allow them to create GOT
4907      or PLT entries), there's no possibility or desire to optimize TLS
4908      relocs, and there's not much point in propagating relocs to shared
4909      libs that the dynamic linker won't relocate.  */
4910   if ((sec->flags & SEC_ALLOC) == 0)
4911     return TRUE;
4912
4913   BFD_ASSERT (is_ppc64_elf (abfd));
4914
4915   htab = ppc_hash_table (info);
4916   if (htab == NULL)
4917     return FALSE;
4918
4919   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4920                               FALSE, FALSE, TRUE);
4921   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4922                                  FALSE, FALSE, TRUE);
4923   symtab_hdr = &elf_symtab_hdr (abfd);
4924   sym_hashes = elf_sym_hashes (abfd);
4925   sreloc = NULL;
4926   opd_sym_map = NULL;
4927   if (strcmp (sec->name, ".opd") == 0)
4928     {
4929       /* Garbage collection needs some extra help with .opd sections.
4930          We don't want to necessarily keep everything referenced by
4931          relocs in .opd, as that would keep all functions.  Instead,
4932          if we reference an .opd symbol (a function descriptor), we
4933          want to keep the function code symbol's section.  This is
4934          easy for global symbols, but for local syms we need to keep
4935          information about the associated function section.  */
4936       bfd_size_type amt;
4937
4938       amt = sec->size * sizeof (*opd_sym_map) / 8;
4939       opd_sym_map = bfd_zalloc (abfd, amt);
4940       if (opd_sym_map == NULL)
4941         return FALSE;
4942       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4943       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4944       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4945     }
4946
4947   if (htab->sfpr == NULL
4948       && !create_linkage_sections (htab->elf.dynobj, info))
4949     return FALSE;
4950
4951   rel_end = relocs + sec->reloc_count;
4952   for (rel = relocs; rel < rel_end; rel++)
4953     {
4954       unsigned long r_symndx;
4955       struct elf_link_hash_entry *h;
4956       enum elf_ppc64_reloc_type r_type;
4957       int tls_type;
4958       struct _ppc64_elf_section_data *ppc64_sec;
4959       struct plt_entry **ifunc;
4960
4961       r_symndx = ELF64_R_SYM (rel->r_info);
4962       if (r_symndx < symtab_hdr->sh_info)
4963         h = NULL;
4964       else
4965         {
4966           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4967           h = elf_follow_link (h);
4968         }
4969
4970       tls_type = 0;
4971       ifunc = NULL;
4972       if (h != NULL)
4973         {
4974           if (h->type == STT_GNU_IFUNC)
4975             {
4976               h->needs_plt = 1;
4977               ifunc = &h->plt.plist;
4978             }
4979         }
4980       else
4981         {
4982           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4983                                                           abfd, r_symndx);
4984           if (isym == NULL)
4985             return FALSE;
4986
4987           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4988             {
4989               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4990                                              rel->r_addend, PLT_IFUNC);
4991               if (ifunc == NULL)
4992                 return FALSE;
4993             }
4994         }
4995       r_type = ELF64_R_TYPE (rel->r_info);
4996       if (is_branch_reloc (r_type))
4997         {
4998           if (h != NULL && (h == tga || h == dottga))
4999             {
5000               if (rel != relocs
5001                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5002                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5003                 /* We have a new-style __tls_get_addr call with a marker
5004                    reloc.  */
5005                 ;
5006               else
5007                 /* Mark this section as having an old-style call.  */
5008                 sec->has_tls_get_addr_call = 1;
5009             }
5010
5011           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5012           if (ifunc != NULL
5013               && !update_plt_info (abfd, ifunc, rel->r_addend))
5014             return FALSE;
5015         }
5016
5017       switch (r_type)
5018         {
5019         case R_PPC64_TLSGD:
5020         case R_PPC64_TLSLD:
5021           /* These special tls relocs tie a call to __tls_get_addr with
5022              its parameter symbol.  */
5023           break;
5024
5025         case R_PPC64_GOT_TLSLD16:
5026         case R_PPC64_GOT_TLSLD16_LO:
5027         case R_PPC64_GOT_TLSLD16_HI:
5028         case R_PPC64_GOT_TLSLD16_HA:
5029           tls_type = TLS_TLS | TLS_LD;
5030           goto dogottls;
5031
5032         case R_PPC64_GOT_TLSGD16:
5033         case R_PPC64_GOT_TLSGD16_LO:
5034         case R_PPC64_GOT_TLSGD16_HI:
5035         case R_PPC64_GOT_TLSGD16_HA:
5036           tls_type = TLS_TLS | TLS_GD;
5037           goto dogottls;
5038
5039         case R_PPC64_GOT_TPREL16_DS:
5040         case R_PPC64_GOT_TPREL16_LO_DS:
5041         case R_PPC64_GOT_TPREL16_HI:
5042         case R_PPC64_GOT_TPREL16_HA:
5043           if (!info->executable)
5044             info->flags |= DF_STATIC_TLS;
5045           tls_type = TLS_TLS | TLS_TPREL;
5046           goto dogottls;
5047
5048         case R_PPC64_GOT_DTPREL16_DS:
5049         case R_PPC64_GOT_DTPREL16_LO_DS:
5050         case R_PPC64_GOT_DTPREL16_HI:
5051         case R_PPC64_GOT_DTPREL16_HA:
5052           tls_type = TLS_TLS | TLS_DTPREL;
5053         dogottls:
5054           sec->has_tls_reloc = 1;
5055           /* Fall thru */
5056
5057         case R_PPC64_GOT16:
5058         case R_PPC64_GOT16_DS:
5059         case R_PPC64_GOT16_HA:
5060         case R_PPC64_GOT16_HI:
5061         case R_PPC64_GOT16_LO:
5062         case R_PPC64_GOT16_LO_DS:
5063           /* This symbol requires a global offset table entry.  */
5064           sec->has_toc_reloc = 1;
5065           if (r_type == R_PPC64_GOT_TLSLD16
5066               || r_type == R_PPC64_GOT_TLSGD16
5067               || r_type == R_PPC64_GOT_TPREL16_DS
5068               || r_type == R_PPC64_GOT_DTPREL16_DS
5069               || r_type == R_PPC64_GOT16
5070               || r_type == R_PPC64_GOT16_DS)
5071             {
5072               htab->do_multi_toc = 1;
5073               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5074             }
5075
5076           if (ppc64_elf_tdata (abfd)->got == NULL
5077               && !create_got_section (abfd, info))
5078             return FALSE;
5079
5080           if (h != NULL)
5081             {
5082               struct ppc_link_hash_entry *eh;
5083               struct got_entry *ent;
5084
5085               eh = (struct ppc_link_hash_entry *) h;
5086               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5087                 if (ent->addend == rel->r_addend
5088                     && ent->owner == abfd
5089                     && ent->tls_type == tls_type)
5090                   break;
5091               if (ent == NULL)
5092                 {
5093                   bfd_size_type amt = sizeof (*ent);
5094                   ent = bfd_alloc (abfd, amt);
5095                   if (ent == NULL)
5096                     return FALSE;
5097                   ent->next = eh->elf.got.glist;
5098                   ent->addend = rel->r_addend;
5099                   ent->owner = abfd;
5100                   ent->tls_type = tls_type;
5101                   ent->is_indirect = FALSE;
5102                   ent->got.refcount = 0;
5103                   eh->elf.got.glist = ent;
5104                 }
5105               ent->got.refcount += 1;
5106               eh->tls_mask |= tls_type;
5107             }
5108           else
5109             /* This is a global offset table entry for a local symbol.  */
5110             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5111                                         rel->r_addend, tls_type))
5112               return FALSE;
5113           break;
5114
5115         case R_PPC64_PLT16_HA:
5116         case R_PPC64_PLT16_HI:
5117         case R_PPC64_PLT16_LO:
5118         case R_PPC64_PLT32:
5119         case R_PPC64_PLT64:
5120           /* This symbol requires a procedure linkage table entry.  We
5121              actually build the entry in adjust_dynamic_symbol,
5122              because this might be a case of linking PIC code without
5123              linking in any dynamic objects, in which case we don't
5124              need to generate a procedure linkage table after all.  */
5125           if (h == NULL)
5126             {
5127               /* It does not make sense to have a procedure linkage
5128                  table entry for a local symbol.  */
5129               bfd_set_error (bfd_error_bad_value);
5130               return FALSE;
5131             }
5132           else
5133             {
5134               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5135                 return FALSE;
5136               h->needs_plt = 1;
5137               if (h->root.root.string[0] == '.'
5138                   && h->root.root.string[1] != '\0')
5139                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5140             }
5141           break;
5142
5143           /* The following relocations don't need to propagate the
5144              relocation if linking a shared object since they are
5145              section relative.  */
5146         case R_PPC64_SECTOFF:
5147         case R_PPC64_SECTOFF_LO:
5148         case R_PPC64_SECTOFF_HI:
5149         case R_PPC64_SECTOFF_HA:
5150         case R_PPC64_SECTOFF_DS:
5151         case R_PPC64_SECTOFF_LO_DS:
5152         case R_PPC64_DTPREL16:
5153         case R_PPC64_DTPREL16_LO:
5154         case R_PPC64_DTPREL16_HI:
5155         case R_PPC64_DTPREL16_HA:
5156         case R_PPC64_DTPREL16_DS:
5157         case R_PPC64_DTPREL16_LO_DS:
5158         case R_PPC64_DTPREL16_HIGHER:
5159         case R_PPC64_DTPREL16_HIGHERA:
5160         case R_PPC64_DTPREL16_HIGHEST:
5161         case R_PPC64_DTPREL16_HIGHESTA:
5162           break;
5163
5164           /* Nor do these.  */
5165         case R_PPC64_REL16:
5166         case R_PPC64_REL16_LO:
5167         case R_PPC64_REL16_HI:
5168         case R_PPC64_REL16_HA:
5169           break;
5170
5171         case R_PPC64_TOC16:
5172         case R_PPC64_TOC16_DS:
5173           htab->do_multi_toc = 1;
5174           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5175         case R_PPC64_TOC16_LO:
5176         case R_PPC64_TOC16_HI:
5177         case R_PPC64_TOC16_HA:
5178         case R_PPC64_TOC16_LO_DS:
5179           sec->has_toc_reloc = 1;
5180           break;
5181
5182           /* This relocation describes the C++ object vtable hierarchy.
5183              Reconstruct it for later use during GC.  */
5184         case R_PPC64_GNU_VTINHERIT:
5185           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5186             return FALSE;
5187           break;
5188
5189           /* This relocation describes which C++ vtable entries are actually
5190              used.  Record for later use during GC.  */
5191         case R_PPC64_GNU_VTENTRY:
5192           BFD_ASSERT (h != NULL);
5193           if (h != NULL
5194               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5195             return FALSE;
5196           break;
5197
5198         case R_PPC64_REL14:
5199         case R_PPC64_REL14_BRTAKEN:
5200         case R_PPC64_REL14_BRNTAKEN:
5201           {
5202             asection *dest = NULL;
5203
5204             /* Heuristic: If jumping outside our section, chances are
5205                we are going to need a stub.  */
5206             if (h != NULL)
5207               {
5208                 /* If the sym is weak it may be overridden later, so
5209                    don't assume we know where a weak sym lives.  */
5210                 if (h->root.type == bfd_link_hash_defined)
5211                   dest = h->root.u.def.section;
5212               }
5213             else
5214               {
5215                 Elf_Internal_Sym *isym;
5216
5217                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5218                                               abfd, r_symndx);
5219                 if (isym == NULL)
5220                   return FALSE;
5221
5222                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5223               }
5224
5225             if (dest != sec)
5226               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5227           }
5228           /* Fall through.  */
5229
5230         case R_PPC64_REL24:
5231           if (h != NULL && ifunc == NULL)
5232             {
5233               /* We may need a .plt entry if the function this reloc
5234                  refers to is in a shared lib.  */
5235               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5236                 return FALSE;
5237               h->needs_plt = 1;
5238               if (h->root.root.string[0] == '.'
5239                   && h->root.root.string[1] != '\0')
5240                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5241               if (h == tga || h == dottga)
5242                 sec->has_tls_reloc = 1;
5243             }
5244           break;
5245
5246         case R_PPC64_TPREL64:
5247           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5248           if (!info->executable)
5249             info->flags |= DF_STATIC_TLS;
5250           goto dotlstoc;
5251
5252         case R_PPC64_DTPMOD64:
5253           if (rel + 1 < rel_end
5254               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5255               && rel[1].r_offset == rel->r_offset + 8)
5256             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5257           else
5258             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5259           goto dotlstoc;
5260
5261         case R_PPC64_DTPREL64:
5262           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5263           if (rel != relocs
5264               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5265               && rel[-1].r_offset == rel->r_offset - 8)
5266             /* This is the second reloc of a dtpmod, dtprel pair.
5267                Don't mark with TLS_DTPREL.  */
5268             goto dodyn;
5269
5270         dotlstoc:
5271           sec->has_tls_reloc = 1;
5272           if (h != NULL)
5273             {
5274               struct ppc_link_hash_entry *eh;
5275               eh = (struct ppc_link_hash_entry *) h;
5276               eh->tls_mask |= tls_type;
5277             }
5278           else
5279             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5280                                         rel->r_addend, tls_type))
5281               return FALSE;
5282
5283           ppc64_sec = ppc64_elf_section_data (sec);
5284           if (ppc64_sec->sec_type != sec_toc)
5285             {
5286               bfd_size_type amt;
5287
5288               /* One extra to simplify get_tls_mask.  */
5289               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5290               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5291               if (ppc64_sec->u.toc.symndx == NULL)
5292                 return FALSE;
5293               amt = sec->size * sizeof (bfd_vma) / 8;
5294               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5295               if (ppc64_sec->u.toc.add == NULL)
5296                 return FALSE;
5297               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5298               ppc64_sec->sec_type = sec_toc;
5299             }
5300           BFD_ASSERT (rel->r_offset % 8 == 0);
5301           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5302           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5303
5304           /* Mark the second slot of a GD or LD entry.
5305              -1 to indicate GD and -2 to indicate LD.  */
5306           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5307             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5308           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5309             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5310           goto dodyn;
5311
5312         case R_PPC64_TPREL16:
5313         case R_PPC64_TPREL16_LO:
5314         case R_PPC64_TPREL16_HI:
5315         case R_PPC64_TPREL16_HA:
5316         case R_PPC64_TPREL16_DS:
5317         case R_PPC64_TPREL16_LO_DS:
5318         case R_PPC64_TPREL16_HIGHER:
5319         case R_PPC64_TPREL16_HIGHERA:
5320         case R_PPC64_TPREL16_HIGHEST:
5321         case R_PPC64_TPREL16_HIGHESTA:
5322           if (info->shared)
5323             {
5324               if (!info->executable)
5325                 info->flags |= DF_STATIC_TLS;
5326               goto dodyn;
5327             }
5328           break;
5329
5330         case R_PPC64_ADDR64:
5331           if (opd_sym_map != NULL
5332               && rel + 1 < rel_end
5333               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5334             {
5335               if (h != NULL)
5336                 {
5337                   if (h->root.root.string[0] == '.'
5338                       && h->root.root.string[1] != 0
5339                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5340                     ;
5341                   else
5342                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5343                 }
5344               else
5345                 {
5346                   asection *s;
5347                   Elf_Internal_Sym *isym;
5348
5349                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5350                                                 abfd, r_symndx);
5351                   if (isym == NULL)
5352                     return FALSE;
5353
5354                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5355                   if (s != NULL && s != sec)
5356                     opd_sym_map[rel->r_offset / 8] = s;
5357                 }
5358             }
5359           /* Fall through.  */
5360
5361         case R_PPC64_REL30:
5362         case R_PPC64_REL32:
5363         case R_PPC64_REL64:
5364         case R_PPC64_ADDR14:
5365         case R_PPC64_ADDR14_BRNTAKEN:
5366         case R_PPC64_ADDR14_BRTAKEN:
5367         case R_PPC64_ADDR16:
5368         case R_PPC64_ADDR16_DS:
5369         case R_PPC64_ADDR16_HA:
5370         case R_PPC64_ADDR16_HI:
5371         case R_PPC64_ADDR16_HIGHER:
5372         case R_PPC64_ADDR16_HIGHERA:
5373         case R_PPC64_ADDR16_HIGHEST:
5374         case R_PPC64_ADDR16_HIGHESTA:
5375         case R_PPC64_ADDR16_LO:
5376         case R_PPC64_ADDR16_LO_DS:
5377         case R_PPC64_ADDR24:
5378         case R_PPC64_ADDR32:
5379         case R_PPC64_UADDR16:
5380         case R_PPC64_UADDR32:
5381         case R_PPC64_UADDR64:
5382         case R_PPC64_TOC:
5383           if (h != NULL && !info->shared)
5384             /* We may need a copy reloc.  */
5385             h->non_got_ref = 1;
5386
5387           /* Don't propagate .opd relocs.  */
5388           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5389             break;
5390
5391           /* If we are creating a shared library, and this is a reloc
5392              against a global symbol, or a non PC relative reloc
5393              against a local symbol, then we need to copy the reloc
5394              into the shared library.  However, if we are linking with
5395              -Bsymbolic, we do not need to copy a reloc against a
5396              global symbol which is defined in an object we are
5397              including in the link (i.e., DEF_REGULAR is set).  At
5398              this point we have not seen all the input files, so it is
5399              possible that DEF_REGULAR is not set now but will be set
5400              later (it is never cleared).  In case of a weak definition,
5401              DEF_REGULAR may be cleared later by a strong definition in
5402              a shared library.  We account for that possibility below by
5403              storing information in the dyn_relocs field of the hash
5404              table entry.  A similar situation occurs when creating
5405              shared libraries and symbol visibility changes render the
5406              symbol local.
5407
5408              If on the other hand, we are creating an executable, we
5409              may need to keep relocations for symbols satisfied by a
5410              dynamic library if we manage to avoid copy relocs for the
5411              symbol.  */
5412         dodyn:
5413           if ((info->shared
5414                && (must_be_dyn_reloc (info, r_type)
5415                    || (h != NULL
5416                        && (! info->symbolic
5417                            || h->root.type == bfd_link_hash_defweak
5418                            || !h->def_regular))))
5419               || (ELIMINATE_COPY_RELOCS
5420                   && !info->shared
5421                   && h != NULL
5422                   && (h->root.type == bfd_link_hash_defweak
5423                       || !h->def_regular))
5424               || (!info->shared
5425                   && ifunc != NULL))
5426             {
5427               struct elf_dyn_relocs *p;
5428               struct elf_dyn_relocs **head;
5429
5430               /* We must copy these reloc types into the output file.
5431                  Create a reloc section in dynobj and make room for
5432                  this reloc.  */
5433               if (sreloc == NULL)
5434                 {
5435                   sreloc = _bfd_elf_make_dynamic_reloc_section
5436                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5437
5438                   if (sreloc == NULL)
5439                     return FALSE;
5440                 }
5441
5442               /* If this is a global symbol, we count the number of
5443                  relocations we need for this symbol.  */
5444               if (h != NULL)
5445                 {
5446                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5447                 }
5448               else
5449                 {
5450                   /* Track dynamic relocs needed for local syms too.
5451                      We really need local syms available to do this
5452                      easily.  Oh well.  */
5453                   asection *s;
5454                   void *vpp;
5455                   Elf_Internal_Sym *isym;
5456
5457                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5458                                                 abfd, r_symndx);
5459                   if (isym == NULL)
5460                     return FALSE;
5461
5462                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5463                   if (s == NULL)
5464                     s = sec;
5465
5466                   vpp = &elf_section_data (s)->local_dynrel;
5467                   head = (struct elf_dyn_relocs **) vpp;
5468                 }
5469
5470               p = *head;
5471               if (p == NULL || p->sec != sec)
5472                 {
5473                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5474                   if (p == NULL)
5475                     return FALSE;
5476                   p->next = *head;
5477                   *head = p;
5478                   p->sec = sec;
5479                   p->count = 0;
5480                   p->pc_count = 0;
5481                 }
5482
5483               p->count += 1;
5484               if (!must_be_dyn_reloc (info, r_type))
5485                 p->pc_count += 1;
5486             }
5487           break;
5488
5489         default:
5490           break;
5491         }
5492     }
5493
5494   return TRUE;
5495 }
5496
5497 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5498    of the code entry point, and its section.  */
5499
5500 static bfd_vma
5501 opd_entry_value (asection *opd_sec,
5502                  bfd_vma offset,
5503                  asection **code_sec,
5504                  bfd_vma *code_off)
5505 {
5506   bfd *opd_bfd = opd_sec->owner;
5507   Elf_Internal_Rela *relocs;
5508   Elf_Internal_Rela *lo, *hi, *look;
5509   bfd_vma val;
5510
5511   /* No relocs implies we are linking a --just-symbols object.  */
5512   if (opd_sec->reloc_count == 0)
5513     {
5514       char buf[8];
5515
5516       if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5517         return (bfd_vma) -1;
5518
5519       val = bfd_get_64 (opd_bfd, buf);
5520       if (code_sec != NULL)
5521         {
5522           asection *sec, *likely = NULL;
5523           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5524             if (sec->vma <= val
5525                 && (sec->flags & SEC_LOAD) != 0
5526                 && (sec->flags & SEC_ALLOC) != 0)
5527               likely = sec;
5528           if (likely != NULL)
5529             {
5530               *code_sec = likely;
5531               if (code_off != NULL)
5532                 *code_off = val - likely->vma;
5533             }
5534         }
5535       return val;
5536     }
5537
5538   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5539
5540   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5541   if (relocs == NULL)
5542     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5543
5544   /* Go find the opd reloc at the sym address.  */
5545   lo = relocs;
5546   BFD_ASSERT (lo != NULL);
5547   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5548   val = (bfd_vma) -1;
5549   while (lo < hi)
5550     {
5551       look = lo + (hi - lo) / 2;
5552       if (look->r_offset < offset)
5553         lo = look + 1;
5554       else if (look->r_offset > offset)
5555         hi = look;
5556       else
5557         {
5558           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5559
5560           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5561               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5562             {
5563               unsigned long symndx = ELF64_R_SYM (look->r_info);
5564               asection *sec;
5565
5566               if (symndx < symtab_hdr->sh_info)
5567                 {
5568                   Elf_Internal_Sym *sym;
5569
5570                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5571                   if (sym == NULL)
5572                     {
5573                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5574                                                   symtab_hdr->sh_info,
5575                                                   0, NULL, NULL, NULL);
5576                       if (sym == NULL)
5577                         break;
5578                       symtab_hdr->contents = (bfd_byte *) sym;
5579                     }
5580
5581                   sym += symndx;
5582                   val = sym->st_value;
5583                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5584                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5585                 }
5586               else
5587                 {
5588                   struct elf_link_hash_entry **sym_hashes;
5589                   struct elf_link_hash_entry *rh;
5590
5591                   sym_hashes = elf_sym_hashes (opd_bfd);
5592                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5593                   rh = elf_follow_link (rh);
5594                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5595                               || rh->root.type == bfd_link_hash_defweak);
5596                   val = rh->root.u.def.value;
5597                   sec = rh->root.u.def.section;
5598                 }
5599               val += look->r_addend;
5600               if (code_off != NULL)
5601                 *code_off = val;
5602               if (code_sec != NULL)
5603                 *code_sec = sec;
5604               if (sec != NULL && sec->output_section != NULL)
5605                 val += sec->output_section->vma + sec->output_offset;
5606             }
5607           break;
5608         }
5609     }
5610
5611   return val;
5612 }
5613
5614 /* Return true if symbol is defined in a regular object file.  */
5615
5616 static bfd_boolean
5617 is_static_defined (struct elf_link_hash_entry *h)
5618 {
5619   return ((h->root.type == bfd_link_hash_defined
5620            || h->root.type == bfd_link_hash_defweak)
5621           && h->root.u.def.section != NULL
5622           && h->root.u.def.section->output_section != NULL);
5623 }
5624
5625 /* If FDH is a function descriptor symbol, return the associated code
5626    entry symbol if it is defined.  Return NULL otherwise.  */
5627
5628 static struct ppc_link_hash_entry *
5629 defined_code_entry (struct ppc_link_hash_entry *fdh)
5630 {
5631   if (fdh->is_func_descriptor)
5632     {
5633       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5634       if (fh->elf.root.type == bfd_link_hash_defined
5635           || fh->elf.root.type == bfd_link_hash_defweak)
5636         return fh;
5637     }
5638   return NULL;
5639 }
5640
5641 /* If FH is a function code entry symbol, return the associated
5642    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5643
5644 static struct ppc_link_hash_entry *
5645 defined_func_desc (struct ppc_link_hash_entry *fh)
5646 {
5647   if (fh->oh != NULL
5648       && fh->oh->is_func_descriptor)
5649     {
5650       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5651       if (fdh->elf.root.type == bfd_link_hash_defined
5652           || fdh->elf.root.type == bfd_link_hash_defweak)
5653         return fdh;
5654     }
5655   return NULL;
5656 }
5657
5658 /* Mark all our entry sym sections, both opd and code section.  */
5659
5660 static void
5661 ppc64_elf_gc_keep (struct bfd_link_info *info)
5662 {
5663   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5664   struct bfd_sym_chain *sym;
5665
5666   if (htab == NULL)
5667     return;
5668
5669   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5670     {
5671       struct ppc_link_hash_entry *eh, *fh;
5672       asection *sec;
5673
5674       eh = (struct ppc_link_hash_entry *)
5675         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5676       if (eh == NULL)
5677         continue;
5678       if (eh->elf.root.type != bfd_link_hash_defined
5679           && eh->elf.root.type != bfd_link_hash_defweak)
5680         continue;
5681
5682       fh = defined_code_entry (eh);
5683       if (fh != NULL)
5684         {
5685           sec = fh->elf.root.u.def.section;
5686           sec->flags |= SEC_KEEP;
5687         }
5688       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5689                && opd_entry_value (eh->elf.root.u.def.section,
5690                                    eh->elf.root.u.def.value,
5691                                    &sec, NULL) != (bfd_vma) -1)
5692         sec->flags |= SEC_KEEP;
5693
5694       sec = eh->elf.root.u.def.section;
5695       sec->flags |= SEC_KEEP;
5696     }
5697 }
5698
5699 /* Mark sections containing dynamically referenced symbols.  When
5700    building shared libraries, we must assume that any visible symbol is
5701    referenced.  */
5702
5703 static bfd_boolean
5704 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5705 {
5706   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5707   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5708   struct ppc_link_hash_entry *fdh;
5709
5710   /* Dynamic linking info is on the func descriptor sym.  */
5711   fdh = defined_func_desc (eh);
5712   if (fdh != NULL)
5713     eh = fdh;
5714
5715   if ((eh->elf.root.type == bfd_link_hash_defined
5716        || eh->elf.root.type == bfd_link_hash_defweak)
5717       && (eh->elf.ref_dynamic
5718           || (!info->executable
5719               && eh->elf.def_regular
5720               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5721               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5722               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5723                   || !bfd_hide_sym_by_version (info->version_info,
5724                                                eh->elf.root.root.string)))))
5725     {
5726       asection *code_sec;
5727       struct ppc_link_hash_entry *fh;
5728
5729       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5730
5731       /* Function descriptor syms cause the associated
5732          function code sym section to be marked.  */
5733       fh = defined_code_entry (eh);
5734       if (fh != NULL)
5735         {
5736           code_sec = fh->elf.root.u.def.section;
5737           code_sec->flags |= SEC_KEEP;
5738         }
5739       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5740                && opd_entry_value (eh->elf.root.u.def.section,
5741                                    eh->elf.root.u.def.value,
5742                                    &code_sec, NULL) != (bfd_vma) -1)
5743         code_sec->flags |= SEC_KEEP;
5744     }
5745
5746   return TRUE;
5747 }
5748
5749 /* Return the section that should be marked against GC for a given
5750    relocation.  */
5751
5752 static asection *
5753 ppc64_elf_gc_mark_hook (asection *sec,
5754                         struct bfd_link_info *info,
5755                         Elf_Internal_Rela *rel,
5756                         struct elf_link_hash_entry *h,
5757                         Elf_Internal_Sym *sym)
5758 {
5759   asection *rsec;
5760
5761   /* Syms return NULL if we're marking .opd, so we avoid marking all
5762      function sections, as all functions are referenced in .opd.  */
5763   rsec = NULL;
5764   if (get_opd_info (sec) != NULL)
5765     return rsec;
5766
5767   if (h != NULL)
5768     {
5769       enum elf_ppc64_reloc_type r_type;
5770       struct ppc_link_hash_entry *eh, *fh, *fdh;
5771
5772       r_type = ELF64_R_TYPE (rel->r_info);
5773       switch (r_type)
5774         {
5775         case R_PPC64_GNU_VTINHERIT:
5776         case R_PPC64_GNU_VTENTRY:
5777           break;
5778
5779         default:
5780           switch (h->root.type)
5781             {
5782             case bfd_link_hash_defined:
5783             case bfd_link_hash_defweak:
5784               eh = (struct ppc_link_hash_entry *) h;
5785               fdh = defined_func_desc (eh);
5786               if (fdh != NULL)
5787                 eh = fdh;
5788
5789               /* Function descriptor syms cause the associated
5790                  function code sym section to be marked.  */
5791               fh = defined_code_entry (eh);
5792               if (fh != NULL)
5793                 {
5794                   /* They also mark their opd section.  */
5795                   eh->elf.root.u.def.section->gc_mark = 1;
5796
5797                   rsec = fh->elf.root.u.def.section;
5798                 }
5799               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5800                        && opd_entry_value (eh->elf.root.u.def.section,
5801                                            eh->elf.root.u.def.value,
5802                                            &rsec, NULL) != (bfd_vma) -1)
5803                 eh->elf.root.u.def.section->gc_mark = 1;
5804               else
5805                 rsec = h->root.u.def.section;
5806               break;
5807
5808             case bfd_link_hash_common:
5809               rsec = h->root.u.c.p->section;
5810               break;
5811
5812             default:
5813               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5814             }
5815         }
5816     }
5817   else
5818     {
5819       struct _opd_sec_data *opd;
5820
5821       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5822       opd = get_opd_info (rsec);
5823       if (opd != NULL && opd->func_sec != NULL)
5824         {
5825           rsec->gc_mark = 1;
5826
5827           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5828         }
5829     }
5830
5831   return rsec;
5832 }
5833
5834 /* Update the .got, .plt. and dynamic reloc reference counts for the
5835    section being removed.  */
5836
5837 static bfd_boolean
5838 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5839                          asection *sec, const Elf_Internal_Rela *relocs)
5840 {
5841   struct ppc_link_hash_table *htab;
5842   Elf_Internal_Shdr *symtab_hdr;
5843   struct elf_link_hash_entry **sym_hashes;
5844   struct got_entry **local_got_ents;
5845   const Elf_Internal_Rela *rel, *relend;
5846
5847   if (info->relocatable)
5848     return TRUE;
5849
5850   if ((sec->flags & SEC_ALLOC) == 0)
5851     return TRUE;
5852
5853   elf_section_data (sec)->local_dynrel = NULL;
5854
5855   htab = ppc_hash_table (info);
5856   if (htab == NULL)
5857     return FALSE;
5858
5859   symtab_hdr = &elf_symtab_hdr (abfd);
5860   sym_hashes = elf_sym_hashes (abfd);
5861   local_got_ents = elf_local_got_ents (abfd);
5862
5863   relend = relocs + sec->reloc_count;
5864   for (rel = relocs; rel < relend; rel++)
5865     {
5866       unsigned long r_symndx;
5867       enum elf_ppc64_reloc_type r_type;
5868       struct elf_link_hash_entry *h = NULL;
5869       unsigned char tls_type = 0;
5870
5871       r_symndx = ELF64_R_SYM (rel->r_info);
5872       r_type = ELF64_R_TYPE (rel->r_info);
5873       if (r_symndx >= symtab_hdr->sh_info)
5874         {
5875           struct ppc_link_hash_entry *eh;
5876           struct elf_dyn_relocs **pp;
5877           struct elf_dyn_relocs *p;
5878
5879           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5880           h = elf_follow_link (h);
5881           eh = (struct ppc_link_hash_entry *) h;
5882
5883           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5884             if (p->sec == sec)
5885               {
5886                 /* Everything must go for SEC.  */
5887                 *pp = p->next;
5888                 break;
5889               }
5890         }
5891
5892       if (is_branch_reloc (r_type))
5893         {
5894           struct plt_entry **ifunc = NULL;
5895           if (h != NULL)
5896             {
5897               if (h->type == STT_GNU_IFUNC)
5898                 ifunc = &h->plt.plist;
5899             }
5900           else if (local_got_ents != NULL)
5901             {
5902               struct plt_entry **local_plt = (struct plt_entry **)
5903                 (local_got_ents + symtab_hdr->sh_info);
5904               unsigned char *local_got_tls_masks = (unsigned char *)
5905                 (local_plt + symtab_hdr->sh_info);
5906               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5907                 ifunc = local_plt + r_symndx;
5908             }
5909           if (ifunc != NULL)
5910             {
5911               struct plt_entry *ent;
5912
5913               for (ent = *ifunc; ent != NULL; ent = ent->next)
5914                 if (ent->addend == rel->r_addend)
5915                   break;
5916               if (ent == NULL)
5917                 abort ();
5918               if (ent->plt.refcount > 0)
5919                 ent->plt.refcount -= 1;
5920               continue;
5921             }
5922         }
5923
5924       switch (r_type)
5925         {
5926         case R_PPC64_GOT_TLSLD16:
5927         case R_PPC64_GOT_TLSLD16_LO:
5928         case R_PPC64_GOT_TLSLD16_HI:
5929         case R_PPC64_GOT_TLSLD16_HA:
5930           tls_type = TLS_TLS | TLS_LD;
5931           goto dogot;
5932
5933         case R_PPC64_GOT_TLSGD16:
5934         case R_PPC64_GOT_TLSGD16_LO:
5935         case R_PPC64_GOT_TLSGD16_HI:
5936         case R_PPC64_GOT_TLSGD16_HA:
5937           tls_type = TLS_TLS | TLS_GD;
5938           goto dogot;
5939
5940         case R_PPC64_GOT_TPREL16_DS:
5941         case R_PPC64_GOT_TPREL16_LO_DS:
5942         case R_PPC64_GOT_TPREL16_HI:
5943         case R_PPC64_GOT_TPREL16_HA:
5944           tls_type = TLS_TLS | TLS_TPREL;
5945           goto dogot;
5946
5947         case R_PPC64_GOT_DTPREL16_DS:
5948         case R_PPC64_GOT_DTPREL16_LO_DS:
5949         case R_PPC64_GOT_DTPREL16_HI:
5950         case R_PPC64_GOT_DTPREL16_HA:
5951           tls_type = TLS_TLS | TLS_DTPREL;
5952           goto dogot;
5953
5954         case R_PPC64_GOT16:
5955         case R_PPC64_GOT16_DS:
5956         case R_PPC64_GOT16_HA:
5957         case R_PPC64_GOT16_HI:
5958         case R_PPC64_GOT16_LO:
5959         case R_PPC64_GOT16_LO_DS:
5960         dogot:
5961           {
5962             struct got_entry *ent;
5963
5964             if (h != NULL)
5965               ent = h->got.glist;
5966             else
5967               ent = local_got_ents[r_symndx];
5968
5969             for (; ent != NULL; ent = ent->next)
5970               if (ent->addend == rel->r_addend
5971                   && ent->owner == abfd
5972                   && ent->tls_type == tls_type)
5973                 break;
5974             if (ent == NULL)
5975               abort ();
5976             if (ent->got.refcount > 0)
5977               ent->got.refcount -= 1;
5978           }
5979           break;
5980
5981         case R_PPC64_PLT16_HA:
5982         case R_PPC64_PLT16_HI:
5983         case R_PPC64_PLT16_LO:
5984         case R_PPC64_PLT32:
5985         case R_PPC64_PLT64:
5986         case R_PPC64_REL14:
5987         case R_PPC64_REL14_BRNTAKEN:
5988         case R_PPC64_REL14_BRTAKEN:
5989         case R_PPC64_REL24:
5990           if (h != NULL)
5991             {
5992               struct plt_entry *ent;
5993
5994               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5995                 if (ent->addend == rel->r_addend)
5996                   break;
5997               if (ent != NULL && ent->plt.refcount > 0)
5998                 ent->plt.refcount -= 1;
5999             }
6000           break;
6001
6002         default:
6003           break;
6004         }
6005     }
6006   return TRUE;
6007 }
6008
6009 /* The maximum size of .sfpr.  */
6010 #define SFPR_MAX (218*4)
6011
6012 struct sfpr_def_parms
6013 {
6014   const char name[12];
6015   unsigned char lo, hi;
6016   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6017   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6018 };
6019
6020 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6021
6022 static bfd_boolean
6023 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6024 {
6025   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6026   unsigned int i;
6027   size_t len = strlen (parm->name);
6028   bfd_boolean writing = FALSE;
6029   char sym[16];
6030
6031   if (htab == NULL)
6032     return FALSE;
6033
6034   memcpy (sym, parm->name, len);
6035   sym[len + 2] = 0;
6036
6037   for (i = parm->lo; i <= parm->hi; i++)
6038     {
6039       struct elf_link_hash_entry *h;
6040
6041       sym[len + 0] = i / 10 + '0';
6042       sym[len + 1] = i % 10 + '0';
6043       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6044       if (h != NULL
6045           && !h->def_regular)
6046         {
6047           h->root.type = bfd_link_hash_defined;
6048           h->root.u.def.section = htab->sfpr;
6049           h->root.u.def.value = htab->sfpr->size;
6050           h->type = STT_FUNC;
6051           h->def_regular = 1;
6052           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6053           writing = TRUE;
6054           if (htab->sfpr->contents == NULL)
6055             {
6056               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6057               if (htab->sfpr->contents == NULL)
6058                 return FALSE;
6059             }
6060         }
6061       if (writing)
6062         {
6063           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6064           if (i != parm->hi)
6065             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6066           else
6067             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6068           htab->sfpr->size = p - htab->sfpr->contents;
6069         }
6070     }
6071
6072   return TRUE;
6073 }
6074
6075 static bfd_byte *
6076 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6077 {
6078   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6079   return p + 4;
6080 }
6081
6082 static bfd_byte *
6083 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6084 {
6085   p = savegpr0 (abfd, p, r);
6086   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6087   p = p + 4;
6088   bfd_put_32 (abfd, BLR, p);
6089   return p + 4;
6090 }
6091
6092 static bfd_byte *
6093 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6094 {
6095   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6096   return p + 4;
6097 }
6098
6099 static bfd_byte *
6100 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6101 {
6102   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6103   p = p + 4;
6104   p = restgpr0 (abfd, p, r);
6105   bfd_put_32 (abfd, MTLR_R0, p);
6106   p = p + 4;
6107   if (r == 29)
6108     {
6109       p = restgpr0 (abfd, p, 30);
6110       p = restgpr0 (abfd, p, 31);
6111     }
6112   bfd_put_32 (abfd, BLR, p);
6113   return p + 4;
6114 }
6115
6116 static bfd_byte *
6117 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6118 {
6119   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6120   return p + 4;
6121 }
6122
6123 static bfd_byte *
6124 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6125 {
6126   p = savegpr1 (abfd, p, r);
6127   bfd_put_32 (abfd, BLR, p);
6128   return p + 4;
6129 }
6130
6131 static bfd_byte *
6132 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6133 {
6134   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6135   return p + 4;
6136 }
6137
6138 static bfd_byte *
6139 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6140 {
6141   p = restgpr1 (abfd, p, r);
6142   bfd_put_32 (abfd, BLR, p);
6143   return p + 4;
6144 }
6145
6146 static bfd_byte *
6147 savefpr (bfd *abfd, bfd_byte *p, int r)
6148 {
6149   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6150   return p + 4;
6151 }
6152
6153 static bfd_byte *
6154 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6155 {
6156   p = savefpr (abfd, p, r);
6157   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6158   p = p + 4;
6159   bfd_put_32 (abfd, BLR, p);
6160   return p + 4;
6161 }
6162
6163 static bfd_byte *
6164 restfpr (bfd *abfd, bfd_byte *p, int r)
6165 {
6166   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6167   return p + 4;
6168 }
6169
6170 static bfd_byte *
6171 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6172 {
6173   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6174   p = p + 4;
6175   p = restfpr (abfd, p, r);
6176   bfd_put_32 (abfd, MTLR_R0, p);
6177   p = p + 4;
6178   if (r == 29)
6179     {
6180       p = restfpr (abfd, p, 30);
6181       p = restfpr (abfd, p, 31);
6182     }
6183   bfd_put_32 (abfd, BLR, p);
6184   return p + 4;
6185 }
6186
6187 static bfd_byte *
6188 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6189 {
6190   p = savefpr (abfd, p, r);
6191   bfd_put_32 (abfd, BLR, p);
6192   return p + 4;
6193 }
6194
6195 static bfd_byte *
6196 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6197 {
6198   p = restfpr (abfd, p, r);
6199   bfd_put_32 (abfd, BLR, p);
6200   return p + 4;
6201 }
6202
6203 static bfd_byte *
6204 savevr (bfd *abfd, bfd_byte *p, int r)
6205 {
6206   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6207   p = p + 4;
6208   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6209   return p + 4;
6210 }
6211
6212 static bfd_byte *
6213 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6214 {
6215   p = savevr (abfd, p, r);
6216   bfd_put_32 (abfd, BLR, p);
6217   return p + 4;
6218 }
6219
6220 static bfd_byte *
6221 restvr (bfd *abfd, bfd_byte *p, int r)
6222 {
6223   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6224   p = p + 4;
6225   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6226   return p + 4;
6227 }
6228
6229 static bfd_byte *
6230 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6231 {
6232   p = restvr (abfd, p, r);
6233   bfd_put_32 (abfd, BLR, p);
6234   return p + 4;
6235 }
6236
6237 /* Called via elf_link_hash_traverse to transfer dynamic linking
6238    information on function code symbol entries to their corresponding
6239    function descriptor symbol entries.  */
6240
6241 static bfd_boolean
6242 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6243 {
6244   struct bfd_link_info *info;
6245   struct ppc_link_hash_table *htab;
6246   struct plt_entry *ent;
6247   struct ppc_link_hash_entry *fh;
6248   struct ppc_link_hash_entry *fdh;
6249   bfd_boolean force_local;
6250
6251   fh = (struct ppc_link_hash_entry *) h;
6252   if (fh->elf.root.type == bfd_link_hash_indirect)
6253     return TRUE;
6254
6255   info = inf;
6256   htab = ppc_hash_table (info);
6257   if (htab == NULL)
6258     return FALSE;
6259
6260   /* Resolve undefined references to dot-symbols as the value
6261      in the function descriptor, if we have one in a regular object.
6262      This is to satisfy cases like ".quad .foo".  Calls to functions
6263      in dynamic objects are handled elsewhere.  */
6264   if (fh->elf.root.type == bfd_link_hash_undefweak
6265       && fh->was_undefined
6266       && (fdh = defined_func_desc (fh)) != NULL
6267       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6268       && opd_entry_value (fdh->elf.root.u.def.section,
6269                           fdh->elf.root.u.def.value,
6270                           &fh->elf.root.u.def.section,
6271                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6272     {
6273       fh->elf.root.type = fdh->elf.root.type;
6274       fh->elf.forced_local = 1;
6275       fh->elf.def_regular = fdh->elf.def_regular;
6276       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6277     }
6278
6279   /* If this is a function code symbol, transfer dynamic linking
6280      information to the function descriptor symbol.  */
6281   if (!fh->is_func)
6282     return TRUE;
6283
6284   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6285     if (ent->plt.refcount > 0)
6286       break;
6287   if (ent == NULL
6288       || fh->elf.root.root.string[0] != '.'
6289       || fh->elf.root.root.string[1] == '\0')
6290     return TRUE;
6291
6292   /* Find the corresponding function descriptor symbol.  Create it
6293      as undefined if necessary.  */
6294
6295   fdh = lookup_fdh (fh, htab);
6296   if (fdh == NULL
6297       && !info->executable
6298       && (fh->elf.root.type == bfd_link_hash_undefined
6299           || fh->elf.root.type == bfd_link_hash_undefweak))
6300     {
6301       fdh = make_fdh (info, fh);
6302       if (fdh == NULL)
6303         return FALSE;
6304     }
6305
6306   /* Fake function descriptors are made undefweak.  If the function
6307      code symbol is strong undefined, make the fake sym the same.
6308      If the function code symbol is defined, then force the fake
6309      descriptor local;  We can't support overriding of symbols in a
6310      shared library on a fake descriptor.  */
6311
6312   if (fdh != NULL
6313       && fdh->fake
6314       && fdh->elf.root.type == bfd_link_hash_undefweak)
6315     {
6316       if (fh->elf.root.type == bfd_link_hash_undefined)
6317         {
6318           fdh->elf.root.type = bfd_link_hash_undefined;
6319           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6320         }
6321       else if (fh->elf.root.type == bfd_link_hash_defined
6322                || fh->elf.root.type == bfd_link_hash_defweak)
6323         {
6324           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6325         }
6326     }
6327
6328   if (fdh != NULL
6329       && !fdh->elf.forced_local
6330       && (!info->executable
6331           || fdh->elf.def_dynamic
6332           || fdh->elf.ref_dynamic
6333           || (fdh->elf.root.type == bfd_link_hash_undefweak
6334               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6335     {
6336       if (fdh->elf.dynindx == -1)
6337         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6338           return FALSE;
6339       fdh->elf.ref_regular |= fh->elf.ref_regular;
6340       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6341       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6342       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6343       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6344         {
6345           move_plt_plist (fh, fdh);
6346           fdh->elf.needs_plt = 1;
6347         }
6348       fdh->is_func_descriptor = 1;
6349       fdh->oh = fh;
6350       fh->oh = fdh;
6351     }
6352
6353   /* Now that the info is on the function descriptor, clear the
6354      function code sym info.  Any function code syms for which we
6355      don't have a definition in a regular file, we force local.
6356      This prevents a shared library from exporting syms that have
6357      been imported from another library.  Function code syms that
6358      are really in the library we must leave global to prevent the
6359      linker dragging in a definition from a static library.  */
6360   force_local = (!fh->elf.def_regular
6361                  || fdh == NULL
6362                  || !fdh->elf.def_regular
6363                  || fdh->elf.forced_local);
6364   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6365
6366   return TRUE;
6367 }
6368
6369 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6370    this hook to a) provide some gcc support functions, and b) transfer
6371    dynamic linking information gathered so far on function code symbol
6372    entries, to their corresponding function descriptor symbol entries.  */
6373
6374 static bfd_boolean
6375 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6376                             struct bfd_link_info *info)
6377 {
6378   struct ppc_link_hash_table *htab;
6379   unsigned int i;
6380   const struct sfpr_def_parms funcs[] =
6381     {
6382       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6383       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6384       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6385       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6386       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6387       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6388       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6389       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6390       { "._savef", 14, 31, savefpr, savefpr1_tail },
6391       { "._restf", 14, 31, restfpr, restfpr1_tail },
6392       { "_savevr_", 20, 31, savevr, savevr_tail },
6393       { "_restvr_", 20, 31, restvr, restvr_tail }
6394     };
6395
6396   htab = ppc_hash_table (info);
6397   if (htab == NULL)
6398     return FALSE;
6399
6400   if (htab->sfpr == NULL)
6401     /* We don't have any relocs.  */
6402     return TRUE;
6403
6404   /* Provide any missing _save* and _rest* functions.  */
6405   htab->sfpr->size = 0;
6406   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6407     if (!sfpr_define (info, &funcs[i]))
6408       return FALSE;
6409
6410   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6411
6412   if (htab->sfpr->size == 0)
6413     htab->sfpr->flags |= SEC_EXCLUDE;
6414
6415   return TRUE;
6416 }
6417
6418 /* Adjust a symbol defined by a dynamic object and referenced by a
6419    regular object.  The current definition is in some section of the
6420    dynamic object, but we're not including those sections.  We have to
6421    change the definition to something the rest of the link can
6422    understand.  */
6423
6424 static bfd_boolean
6425 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6426                                  struct elf_link_hash_entry *h)
6427 {
6428   struct ppc_link_hash_table *htab;
6429   asection *s;
6430
6431   htab = ppc_hash_table (info);
6432   if (htab == NULL)
6433     return FALSE;
6434
6435   /* Deal with function syms.  */
6436   if (h->type == STT_FUNC
6437       || h->type == STT_GNU_IFUNC
6438       || h->needs_plt)
6439     {
6440       /* Clear procedure linkage table information for any symbol that
6441          won't need a .plt entry.  */
6442       struct plt_entry *ent;
6443       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6444         if (ent->plt.refcount > 0)
6445           break;
6446       if (ent == NULL
6447           || (h->type != STT_GNU_IFUNC
6448               && (SYMBOL_CALLS_LOCAL (info, h)
6449                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6450                       && h->root.type == bfd_link_hash_undefweak))))
6451         {
6452           h->plt.plist = NULL;
6453           h->needs_plt = 0;
6454         }
6455     }
6456   else
6457     h->plt.plist = NULL;
6458
6459   /* If this is a weak symbol, and there is a real definition, the
6460      processor independent code will have arranged for us to see the
6461      real definition first, and we can just use the same value.  */
6462   if (h->u.weakdef != NULL)
6463     {
6464       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6465                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6466       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6467       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6468       if (ELIMINATE_COPY_RELOCS)
6469         h->non_got_ref = h->u.weakdef->non_got_ref;
6470       return TRUE;
6471     }
6472
6473   /* If we are creating a shared library, we must presume that the
6474      only references to the symbol are via the global offset table.
6475      For such cases we need not do anything here; the relocations will
6476      be handled correctly by relocate_section.  */
6477   if (info->shared)
6478     return TRUE;
6479
6480   /* If there are no references to this symbol that do not use the
6481      GOT, we don't need to generate a copy reloc.  */
6482   if (!h->non_got_ref)
6483     return TRUE;
6484
6485   /* Don't generate a copy reloc for symbols defined in the executable.  */
6486   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6487     return TRUE;
6488
6489   if (ELIMINATE_COPY_RELOCS)
6490     {
6491       struct ppc_link_hash_entry * eh;
6492       struct elf_dyn_relocs *p;
6493
6494       eh = (struct ppc_link_hash_entry *) h;
6495       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6496         {
6497           s = p->sec->output_section;
6498           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6499             break;
6500         }
6501
6502       /* If we didn't find any dynamic relocs in read-only sections, then
6503          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6504       if (p == NULL)
6505         {
6506           h->non_got_ref = 0;
6507           return TRUE;
6508         }
6509     }
6510
6511   if (h->plt.plist != NULL)
6512     {
6513       /* We should never get here, but unfortunately there are versions
6514          of gcc out there that improperly (for this ABI) put initialized
6515          function pointers, vtable refs and suchlike in read-only
6516          sections.  Allow them to proceed, but warn that this might
6517          break at runtime.  */
6518       info->callbacks->einfo
6519         (_("%P: copy reloc against `%s' requires lazy plt linking; "
6520            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6521          h->root.root.string);
6522     }
6523
6524   /* This is a reference to a symbol defined by a dynamic object which
6525      is not a function.  */
6526
6527   if (h->size == 0)
6528     {
6529       info->callbacks->einfo (_("%P: dynamic variable `%s' is zero size\n"),
6530                               h->root.root.string);
6531       return TRUE;
6532     }
6533
6534   /* We must allocate the symbol in our .dynbss section, which will
6535      become part of the .bss section of the executable.  There will be
6536      an entry for this symbol in the .dynsym section.  The dynamic
6537      object will contain position independent code, so all references
6538      from the dynamic object to this symbol will go through the global
6539      offset table.  The dynamic linker will use the .dynsym entry to
6540      determine the address it must put in the global offset table, so
6541      both the dynamic object and the regular object will refer to the
6542      same memory location for the variable.  */
6543
6544   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6545      to copy the initial value out of the dynamic object and into the
6546      runtime process image.  We need to remember the offset into the
6547      .rela.bss section we are going to use.  */
6548   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6549     {
6550       htab->relbss->size += sizeof (Elf64_External_Rela);
6551       h->needs_copy = 1;
6552     }
6553
6554   s = htab->dynbss;
6555
6556   return _bfd_elf_adjust_dynamic_copy (h, s);
6557 }
6558
6559 /* If given a function descriptor symbol, hide both the function code
6560    sym and the descriptor.  */
6561 static void
6562 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6563                        struct elf_link_hash_entry *h,
6564                        bfd_boolean force_local)
6565 {
6566   struct ppc_link_hash_entry *eh;
6567   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6568
6569   eh = (struct ppc_link_hash_entry *) h;
6570   if (eh->is_func_descriptor)
6571     {
6572       struct ppc_link_hash_entry *fh = eh->oh;
6573
6574       if (fh == NULL)
6575         {
6576           const char *p, *q;
6577           struct ppc_link_hash_table *htab;
6578           char save;
6579
6580           /* We aren't supposed to use alloca in BFD because on
6581              systems which do not have alloca the version in libiberty
6582              calls xmalloc, which might cause the program to crash
6583              when it runs out of memory.  This function doesn't have a
6584              return status, so there's no way to gracefully return an
6585              error.  So cheat.  We know that string[-1] can be safely
6586              accessed;  It's either a string in an ELF string table,
6587              or allocated in an objalloc structure.  */
6588
6589           p = eh->elf.root.root.string - 1;
6590           save = *p;
6591           *(char *) p = '.';
6592           htab = ppc_hash_table (info);
6593           if (htab == NULL)
6594             return;
6595
6596           fh = (struct ppc_link_hash_entry *)
6597             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6598           *(char *) p = save;
6599
6600           /* Unfortunately, if it so happens that the string we were
6601              looking for was allocated immediately before this string,
6602              then we overwrote the string terminator.  That's the only
6603              reason the lookup should fail.  */
6604           if (fh == NULL)
6605             {
6606               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6607               while (q >= eh->elf.root.root.string && *q == *p)
6608                 --q, --p;
6609               if (q < eh->elf.root.root.string && *p == '.')
6610                 fh = (struct ppc_link_hash_entry *)
6611                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6612             }
6613           if (fh != NULL)
6614             {
6615               eh->oh = fh;
6616               fh->oh = eh;
6617             }
6618         }
6619       if (fh != NULL)
6620         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6621     }
6622 }
6623
6624 static bfd_boolean
6625 get_sym_h (struct elf_link_hash_entry **hp,
6626            Elf_Internal_Sym **symp,
6627            asection **symsecp,
6628            unsigned char **tls_maskp,
6629            Elf_Internal_Sym **locsymsp,
6630            unsigned long r_symndx,
6631            bfd *ibfd)
6632 {
6633   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6634
6635   if (r_symndx >= symtab_hdr->sh_info)
6636     {
6637       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6638       struct elf_link_hash_entry *h;
6639
6640       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6641       h = elf_follow_link (h);
6642
6643       if (hp != NULL)
6644         *hp = h;
6645
6646       if (symp != NULL)
6647         *symp = NULL;
6648
6649       if (symsecp != NULL)
6650         {
6651           asection *symsec = NULL;
6652           if (h->root.type == bfd_link_hash_defined
6653               || h->root.type == bfd_link_hash_defweak)
6654             symsec = h->root.u.def.section;
6655           *symsecp = symsec;
6656         }
6657
6658       if (tls_maskp != NULL)
6659         {
6660           struct ppc_link_hash_entry *eh;
6661
6662           eh = (struct ppc_link_hash_entry *) h;
6663           *tls_maskp = &eh->tls_mask;
6664         }
6665     }
6666   else
6667     {
6668       Elf_Internal_Sym *sym;
6669       Elf_Internal_Sym *locsyms = *locsymsp;
6670
6671       if (locsyms == NULL)
6672         {
6673           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6674           if (locsyms == NULL)
6675             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6676                                             symtab_hdr->sh_info,
6677                                             0, NULL, NULL, NULL);
6678           if (locsyms == NULL)
6679             return FALSE;
6680           *locsymsp = locsyms;
6681         }
6682       sym = locsyms + r_symndx;
6683
6684       if (hp != NULL)
6685         *hp = NULL;
6686
6687       if (symp != NULL)
6688         *symp = sym;
6689
6690       if (symsecp != NULL)
6691         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6692
6693       if (tls_maskp != NULL)
6694         {
6695           struct got_entry **lgot_ents;
6696           unsigned char *tls_mask;
6697
6698           tls_mask = NULL;
6699           lgot_ents = elf_local_got_ents (ibfd);
6700           if (lgot_ents != NULL)
6701             {
6702               struct plt_entry **local_plt = (struct plt_entry **)
6703                 (lgot_ents + symtab_hdr->sh_info);
6704               unsigned char *lgot_masks = (unsigned char *)
6705                 (local_plt + symtab_hdr->sh_info);
6706               tls_mask = &lgot_masks[r_symndx];
6707             }
6708           *tls_maskp = tls_mask;
6709         }
6710     }
6711   return TRUE;
6712 }
6713
6714 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6715    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6716    type suitable for optimization, and 1 otherwise.  */
6717
6718 static int
6719 get_tls_mask (unsigned char **tls_maskp,
6720               unsigned long *toc_symndx,
6721               bfd_vma *toc_addend,
6722               Elf_Internal_Sym **locsymsp,
6723               const Elf_Internal_Rela *rel,
6724               bfd *ibfd)
6725 {
6726   unsigned long r_symndx;
6727   int next_r;
6728   struct elf_link_hash_entry *h;
6729   Elf_Internal_Sym *sym;
6730   asection *sec;
6731   bfd_vma off;
6732
6733   r_symndx = ELF64_R_SYM (rel->r_info);
6734   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6735     return 0;
6736
6737   if ((*tls_maskp != NULL && **tls_maskp != 0)
6738       || sec == NULL
6739       || ppc64_elf_section_data (sec) == NULL
6740       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6741     return 1;
6742
6743   /* Look inside a TOC section too.  */
6744   if (h != NULL)
6745     {
6746       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6747       off = h->root.u.def.value;
6748     }
6749   else
6750     off = sym->st_value;
6751   off += rel->r_addend;
6752   BFD_ASSERT (off % 8 == 0);
6753   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6754   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6755   if (toc_symndx != NULL)
6756     *toc_symndx = r_symndx;
6757   if (toc_addend != NULL)
6758     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6759   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6760     return 0;
6761   if ((h == NULL || is_static_defined (h))
6762       && (next_r == -1 || next_r == -2))
6763     return 1 - next_r;
6764   return 1;
6765 }
6766
6767 /* Find (or create) an entry in the tocsave hash table.  */
6768
6769 static struct tocsave_entry *
6770 tocsave_find (struct ppc_link_hash_table *htab,
6771               enum insert_option insert,
6772               Elf_Internal_Sym **local_syms,
6773               const Elf_Internal_Rela *irela,
6774               bfd *ibfd)
6775 {
6776   unsigned long r_indx;
6777   struct elf_link_hash_entry *h;
6778   Elf_Internal_Sym *sym;
6779   struct tocsave_entry ent, *p;
6780   hashval_t hash;
6781   struct tocsave_entry **slot;
6782
6783   r_indx = ELF64_R_SYM (irela->r_info);
6784   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6785     return NULL;
6786   if (ent.sec == NULL || ent.sec->output_section == NULL)
6787     {
6788       (*_bfd_error_handler)
6789         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6790       return NULL;
6791     }
6792
6793   if (h != NULL)
6794     ent.offset = h->root.u.def.value;
6795   else
6796     ent.offset = sym->st_value;
6797   ent.offset += irela->r_addend;
6798
6799   hash = tocsave_htab_hash (&ent);
6800   slot = ((struct tocsave_entry **)
6801           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6802   if (slot == NULL)
6803     return NULL;
6804
6805   if (*slot == NULL)
6806     {
6807       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6808       if (p == NULL)
6809         return NULL;
6810       *p = ent;
6811       *slot = p;
6812     }
6813   return *slot;
6814 }
6815
6816 /* Adjust all global syms defined in opd sections.  In gcc generated
6817    code for the old ABI, these will already have been done.  */
6818
6819 static bfd_boolean
6820 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6821 {
6822   struct ppc_link_hash_entry *eh;
6823   asection *sym_sec;
6824   struct _opd_sec_data *opd;
6825
6826   if (h->root.type == bfd_link_hash_indirect)
6827     return TRUE;
6828
6829   if (h->root.type != bfd_link_hash_defined
6830       && h->root.type != bfd_link_hash_defweak)
6831     return TRUE;
6832
6833   eh = (struct ppc_link_hash_entry *) h;
6834   if (eh->adjust_done)
6835     return TRUE;
6836
6837   sym_sec = eh->elf.root.u.def.section;
6838   opd = get_opd_info (sym_sec);
6839   if (opd != NULL && opd->adjust != NULL)
6840     {
6841       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6842       if (adjust == -1)
6843         {
6844           /* This entry has been deleted.  */
6845           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6846           if (dsec == NULL)
6847             {
6848               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6849                 if (elf_discarded_section (dsec))
6850                   {
6851                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6852                     break;
6853                   }
6854             }
6855           eh->elf.root.u.def.value = 0;
6856           eh->elf.root.u.def.section = dsec;
6857         }
6858       else
6859         eh->elf.root.u.def.value += adjust;
6860       eh->adjust_done = 1;
6861     }
6862   return TRUE;
6863 }
6864
6865 /* Handles decrementing dynamic reloc counts for the reloc specified by
6866    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6867    have already been determined.  */
6868
6869 static bfd_boolean
6870 dec_dynrel_count (bfd_vma r_info,
6871                   asection *sec,
6872                   struct bfd_link_info *info,
6873                   Elf_Internal_Sym **local_syms,
6874                   struct elf_link_hash_entry *h,
6875                   asection *sym_sec)
6876 {
6877   enum elf_ppc64_reloc_type r_type;
6878   struct elf_dyn_relocs *p;
6879   struct elf_dyn_relocs **pp;
6880
6881   /* Can this reloc be dynamic?  This switch, and later tests here
6882      should be kept in sync with the code in check_relocs.  */
6883   r_type = ELF64_R_TYPE (r_info);
6884   switch (r_type)
6885     {
6886     default:
6887       return TRUE;
6888
6889     case R_PPC64_TPREL16:
6890     case R_PPC64_TPREL16_LO:
6891     case R_PPC64_TPREL16_HI:
6892     case R_PPC64_TPREL16_HA:
6893     case R_PPC64_TPREL16_DS:
6894     case R_PPC64_TPREL16_LO_DS:
6895     case R_PPC64_TPREL16_HIGHER:
6896     case R_PPC64_TPREL16_HIGHERA:
6897     case R_PPC64_TPREL16_HIGHEST:
6898     case R_PPC64_TPREL16_HIGHESTA:
6899       if (!info->shared)
6900         return TRUE;
6901
6902     case R_PPC64_TPREL64:
6903     case R_PPC64_DTPMOD64:
6904     case R_PPC64_DTPREL64:
6905     case R_PPC64_ADDR64:
6906     case R_PPC64_REL30:
6907     case R_PPC64_REL32:
6908     case R_PPC64_REL64:
6909     case R_PPC64_ADDR14:
6910     case R_PPC64_ADDR14_BRNTAKEN:
6911     case R_PPC64_ADDR14_BRTAKEN:
6912     case R_PPC64_ADDR16:
6913     case R_PPC64_ADDR16_DS:
6914     case R_PPC64_ADDR16_HA:
6915     case R_PPC64_ADDR16_HI:
6916     case R_PPC64_ADDR16_HIGHER:
6917     case R_PPC64_ADDR16_HIGHERA:
6918     case R_PPC64_ADDR16_HIGHEST:
6919     case R_PPC64_ADDR16_HIGHESTA:
6920     case R_PPC64_ADDR16_LO:
6921     case R_PPC64_ADDR16_LO_DS:
6922     case R_PPC64_ADDR24:
6923     case R_PPC64_ADDR32:
6924     case R_PPC64_UADDR16:
6925     case R_PPC64_UADDR32:
6926     case R_PPC64_UADDR64:
6927     case R_PPC64_TOC:
6928       break;
6929     }
6930
6931   if (local_syms != NULL)
6932     {
6933       unsigned long r_symndx;
6934       Elf_Internal_Sym *sym;
6935       bfd *ibfd = sec->owner;
6936
6937       r_symndx = ELF64_R_SYM (r_info);
6938       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6939         return FALSE;
6940     }
6941
6942   if ((info->shared
6943        && (must_be_dyn_reloc (info, r_type)
6944            || (h != NULL
6945                && (!info->symbolic
6946                    || h->root.type == bfd_link_hash_defweak
6947                    || !h->def_regular))))
6948       || (ELIMINATE_COPY_RELOCS
6949           && !info->shared
6950           && h != NULL
6951           && (h->root.type == bfd_link_hash_defweak
6952               || !h->def_regular)))
6953     ;
6954   else
6955     return TRUE;
6956
6957   if (h != NULL)
6958     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6959   else
6960     {
6961       if (sym_sec != NULL)
6962         {
6963           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6964           pp = (struct elf_dyn_relocs **) vpp;
6965         }
6966       else
6967         {
6968           void *vpp = &elf_section_data (sec)->local_dynrel;
6969           pp = (struct elf_dyn_relocs **) vpp;
6970         }
6971
6972       /* elf_gc_sweep may have already removed all dyn relocs associated
6973          with local syms for a given section.  Don't report a dynreloc
6974          miscount.  */
6975       if (*pp == NULL)
6976         return TRUE;
6977     }
6978
6979   while ((p = *pp) != NULL)
6980     {
6981       if (p->sec == sec)
6982         {
6983           if (!must_be_dyn_reloc (info, r_type))
6984             p->pc_count -= 1;
6985           p->count -= 1;
6986           if (p->count == 0)
6987             *pp = p->next;
6988           return TRUE;
6989         }
6990       pp = &p->next;
6991     }
6992
6993   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
6994                           sec->owner, sec);
6995   bfd_set_error (bfd_error_bad_value);
6996   return FALSE;
6997 }
6998
6999 /* Remove unused Official Procedure Descriptor entries.  Currently we
7000    only remove those associated with functions in discarded link-once
7001    sections, or weakly defined functions that have been overridden.  It
7002    would be possible to remove many more entries for statically linked
7003    applications.  */
7004
7005 bfd_boolean
7006 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7007 {
7008   bfd *ibfd;
7009   bfd_boolean some_edited = FALSE;
7010   asection *need_pad = NULL;
7011
7012   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7013     {
7014       asection *sec;
7015       Elf_Internal_Rela *relstart, *rel, *relend;
7016       Elf_Internal_Shdr *symtab_hdr;
7017       Elf_Internal_Sym *local_syms;
7018       bfd_vma offset;
7019       struct _opd_sec_data *opd;
7020       bfd_boolean need_edit, add_aux_fields;
7021       bfd_size_type cnt_16b = 0;
7022
7023       if (!is_ppc64_elf (ibfd))
7024         continue;
7025
7026       sec = bfd_get_section_by_name (ibfd, ".opd");
7027       if (sec == NULL || sec->size == 0)
7028         continue;
7029
7030       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
7031         continue;
7032
7033       if (sec->output_section == bfd_abs_section_ptr)
7034         continue;
7035
7036       /* Look through the section relocs.  */
7037       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7038         continue;
7039
7040       local_syms = NULL;
7041       symtab_hdr = &elf_symtab_hdr (ibfd);
7042
7043       /* Read the relocations.  */
7044       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7045                                             info->keep_memory);
7046       if (relstart == NULL)
7047         return FALSE;
7048
7049       /* First run through the relocs to check they are sane, and to
7050          determine whether we need to edit this opd section.  */
7051       need_edit = FALSE;
7052       need_pad = sec;
7053       offset = 0;
7054       relend = relstart + sec->reloc_count;
7055       for (rel = relstart; rel < relend; )
7056         {
7057           enum elf_ppc64_reloc_type r_type;
7058           unsigned long r_symndx;
7059           asection *sym_sec;
7060           struct elf_link_hash_entry *h;
7061           Elf_Internal_Sym *sym;
7062
7063           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7064              only interested in the reloc pointing to a function entry
7065              point.  */
7066           if (rel->r_offset != offset
7067               || rel + 1 >= relend
7068               || (rel + 1)->r_offset != offset + 8)
7069             {
7070               /* If someone messes with .opd alignment then after a
7071                  "ld -r" we might have padding in the middle of .opd.
7072                  Also, there's nothing to prevent someone putting
7073                  something silly in .opd with the assembler.  No .opd
7074                  optimization for them!  */
7075             broken_opd:
7076               (*_bfd_error_handler)
7077                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7078               need_edit = FALSE;
7079               break;
7080             }
7081
7082           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7083               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7084             {
7085               (*_bfd_error_handler)
7086                 (_("%B: unexpected reloc type %u in .opd section"),
7087                  ibfd, r_type);
7088               need_edit = FALSE;
7089               break;
7090             }
7091
7092           r_symndx = ELF64_R_SYM (rel->r_info);
7093           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7094                           r_symndx, ibfd))
7095             goto error_ret;
7096
7097           if (sym_sec == NULL || sym_sec->owner == NULL)
7098             {
7099               const char *sym_name;
7100               if (h != NULL)
7101                 sym_name = h->root.root.string;
7102               else
7103                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7104                                              sym_sec);
7105
7106               (*_bfd_error_handler)
7107                 (_("%B: undefined sym `%s' in .opd section"),
7108                  ibfd, sym_name);
7109               need_edit = FALSE;
7110               break;
7111             }
7112
7113           /* opd entries are always for functions defined in the
7114              current input bfd.  If the symbol isn't defined in the
7115              input bfd, then we won't be using the function in this
7116              bfd;  It must be defined in a linkonce section in another
7117              bfd, or is weak.  It's also possible that we are
7118              discarding the function due to a linker script /DISCARD/,
7119              which we test for via the output_section.  */
7120           if (sym_sec->owner != ibfd
7121               || sym_sec->output_section == bfd_abs_section_ptr)
7122             need_edit = TRUE;
7123
7124           rel += 2;
7125           if (rel == relend
7126               || (rel + 1 == relend && rel->r_offset == offset + 16))
7127             {
7128               if (sec->size == offset + 24)
7129                 {
7130                   need_pad = NULL;
7131                   break;
7132                 }
7133               if (rel == relend && sec->size == offset + 16)
7134                 {
7135                   cnt_16b++;
7136                   break;
7137                 }
7138               goto broken_opd;
7139             }
7140
7141           if (rel->r_offset == offset + 24)
7142             offset += 24;
7143           else if (rel->r_offset != offset + 16)
7144             goto broken_opd;
7145           else if (rel + 1 < relend
7146                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7147                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7148             {
7149               offset += 16;
7150               cnt_16b++;
7151             }
7152           else if (rel + 2 < relend
7153                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7154                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7155             {
7156               offset += 24;
7157               rel += 1;
7158             }
7159           else
7160             goto broken_opd;
7161         }
7162
7163       add_aux_fields = non_overlapping && cnt_16b > 0;
7164
7165       if (need_edit || add_aux_fields)
7166         {
7167           Elf_Internal_Rela *write_rel;
7168           Elf_Internal_Shdr *rel_hdr;
7169           bfd_byte *rptr, *wptr;
7170           bfd_byte *new_contents;
7171           bfd_boolean skip;
7172           long opd_ent_size;
7173           bfd_size_type amt;
7174
7175           new_contents = NULL;
7176           amt = sec->size * sizeof (long) / 8;
7177           opd = &ppc64_elf_section_data (sec)->u.opd;
7178           opd->adjust = bfd_zalloc (sec->owner, amt);
7179           if (opd->adjust == NULL)
7180             return FALSE;
7181           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7182
7183           /* This seems a waste of time as input .opd sections are all
7184              zeros as generated by gcc, but I suppose there's no reason
7185              this will always be so.  We might start putting something in
7186              the third word of .opd entries.  */
7187           if ((sec->flags & SEC_IN_MEMORY) == 0)
7188             {
7189               bfd_byte *loc;
7190               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7191                 {
7192                   if (loc != NULL)
7193                     free (loc);
7194                 error_ret:
7195                   if (local_syms != NULL
7196                       && symtab_hdr->contents != (unsigned char *) local_syms)
7197                     free (local_syms);
7198                   if (elf_section_data (sec)->relocs != relstart)
7199                     free (relstart);
7200                   return FALSE;
7201                 }
7202               sec->contents = loc;
7203               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7204             }
7205
7206           elf_section_data (sec)->relocs = relstart;
7207
7208           new_contents = sec->contents;
7209           if (add_aux_fields)
7210             {
7211               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7212               if (new_contents == NULL)
7213                 return FALSE;
7214               need_pad = FALSE;
7215             }
7216           wptr = new_contents;
7217           rptr = sec->contents;
7218
7219           write_rel = relstart;
7220           skip = FALSE;
7221           offset = 0;
7222           opd_ent_size = 0;
7223           for (rel = relstart; rel < relend; rel++)
7224             {
7225               unsigned long r_symndx;
7226               asection *sym_sec;
7227               struct elf_link_hash_entry *h;
7228               Elf_Internal_Sym *sym;
7229
7230               r_symndx = ELF64_R_SYM (rel->r_info);
7231               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7232                               r_symndx, ibfd))
7233                 goto error_ret;
7234
7235               if (rel->r_offset == offset)
7236                 {
7237                   struct ppc_link_hash_entry *fdh = NULL;
7238
7239                   /* See if the .opd entry is full 24 byte or
7240                      16 byte (with fd_aux entry overlapped with next
7241                      fd_func).  */
7242                   opd_ent_size = 24;
7243                   if ((rel + 2 == relend && sec->size == offset + 16)
7244                       || (rel + 3 < relend
7245                           && rel[2].r_offset == offset + 16
7246                           && rel[3].r_offset == offset + 24
7247                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7248                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7249                     opd_ent_size = 16;
7250
7251                   if (h != NULL
7252                       && h->root.root.string[0] == '.')
7253                     {
7254                       struct ppc_link_hash_table *htab;
7255
7256                       htab = ppc_hash_table (info);
7257                       if (htab != NULL)
7258                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7259                                           htab);
7260                       if (fdh != NULL
7261                           && fdh->elf.root.type != bfd_link_hash_defined
7262                           && fdh->elf.root.type != bfd_link_hash_defweak)
7263                         fdh = NULL;
7264                     }
7265
7266                   skip = (sym_sec->owner != ibfd
7267                           || sym_sec->output_section == bfd_abs_section_ptr);
7268                   if (skip)
7269                     {
7270                       if (fdh != NULL && sym_sec->owner == ibfd)
7271                         {
7272                           /* Arrange for the function descriptor sym
7273                              to be dropped.  */
7274                           fdh->elf.root.u.def.value = 0;
7275                           fdh->elf.root.u.def.section = sym_sec;
7276                         }
7277                       opd->adjust[rel->r_offset / 8] = -1;
7278                     }
7279                   else
7280                     {
7281                       /* We'll be keeping this opd entry.  */
7282
7283                       if (fdh != NULL)
7284                         {
7285                           /* Redefine the function descriptor symbol to
7286                              this location in the opd section.  It is
7287                              necessary to update the value here rather
7288                              than using an array of adjustments as we do
7289                              for local symbols, because various places
7290                              in the generic ELF code use the value
7291                              stored in u.def.value.  */
7292                           fdh->elf.root.u.def.value = wptr - new_contents;
7293                           fdh->adjust_done = 1;
7294                         }
7295
7296                       /* Local syms are a bit tricky.  We could
7297                          tweak them as they can be cached, but
7298                          we'd need to look through the local syms
7299                          for the function descriptor sym which we
7300                          don't have at the moment.  So keep an
7301                          array of adjustments.  */
7302                       opd->adjust[rel->r_offset / 8]
7303                         = (wptr - new_contents) - (rptr - sec->contents);
7304
7305                       if (wptr != rptr)
7306                         memcpy (wptr, rptr, opd_ent_size);
7307                       wptr += opd_ent_size;
7308                       if (add_aux_fields && opd_ent_size == 16)
7309                         {
7310                           memset (wptr, '\0', 8);
7311                           wptr += 8;
7312                         }
7313                     }
7314                   rptr += opd_ent_size;
7315                   offset += opd_ent_size;
7316                 }
7317
7318               if (skip)
7319                 {
7320                   if (!NO_OPD_RELOCS
7321                       && !info->relocatable
7322                       && !dec_dynrel_count (rel->r_info, sec, info,
7323                                             NULL, h, sym_sec))
7324                     goto error_ret;
7325                 }
7326               else
7327                 {
7328                   /* We need to adjust any reloc offsets to point to the
7329                      new opd entries.  While we're at it, we may as well
7330                      remove redundant relocs.  */
7331                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7332                   if (write_rel != rel)
7333                     memcpy (write_rel, rel, sizeof (*rel));
7334                   ++write_rel;
7335                 }
7336             }
7337
7338           sec->size = wptr - new_contents;
7339           sec->reloc_count = write_rel - relstart;
7340           if (add_aux_fields)
7341             {
7342               free (sec->contents);
7343               sec->contents = new_contents;
7344             }
7345
7346           /* Fudge the header size too, as this is used later in
7347              elf_bfd_final_link if we are emitting relocs.  */
7348           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7349           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7350           some_edited = TRUE;
7351         }
7352       else if (elf_section_data (sec)->relocs != relstart)
7353         free (relstart);
7354
7355       if (local_syms != NULL
7356           && symtab_hdr->contents != (unsigned char *) local_syms)
7357         {
7358           if (!info->keep_memory)
7359             free (local_syms);
7360           else
7361             symtab_hdr->contents = (unsigned char *) local_syms;
7362         }
7363     }
7364
7365   if (some_edited)
7366     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7367
7368   /* If we are doing a final link and the last .opd entry is just 16 byte
7369      long, add a 8 byte padding after it.  */
7370   if (need_pad != NULL && !info->relocatable)
7371     {
7372       bfd_byte *p;
7373
7374       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7375         {
7376           BFD_ASSERT (need_pad->size > 0);
7377
7378           p = bfd_malloc (need_pad->size + 8);
7379           if (p == NULL)
7380             return FALSE;
7381
7382           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7383                                           p, 0, need_pad->size))
7384             return FALSE;
7385
7386           need_pad->contents = p;
7387           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7388         }
7389       else
7390         {
7391           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7392           if (p == NULL)
7393             return FALSE;
7394
7395           need_pad->contents = p;
7396         }
7397
7398       memset (need_pad->contents + need_pad->size, 0, 8);
7399       need_pad->size += 8;
7400     }
7401
7402   return TRUE;
7403 }
7404
7405 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7406
7407 asection *
7408 ppc64_elf_tls_setup (struct bfd_link_info *info,
7409                      int no_tls_get_addr_opt,
7410                      int *no_multi_toc)
7411 {
7412   struct ppc_link_hash_table *htab;
7413
7414   htab = ppc_hash_table (info);
7415   if (htab == NULL)
7416     return NULL;
7417
7418   if (*no_multi_toc)
7419     htab->do_multi_toc = 0;
7420   else if (!htab->do_multi_toc)
7421     *no_multi_toc = 1;
7422
7423   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7424                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7425                                               FALSE, FALSE, TRUE));
7426   /* Move dynamic linking info to the function descriptor sym.  */
7427   if (htab->tls_get_addr != NULL)
7428     func_desc_adjust (&htab->tls_get_addr->elf, info);
7429   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7430                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7431                                                  FALSE, FALSE, TRUE));
7432   if (!no_tls_get_addr_opt)
7433     {
7434       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7435
7436       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7437                                   FALSE, FALSE, TRUE);
7438       if (opt != NULL)
7439         func_desc_adjust (opt, info);
7440       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7441                                      FALSE, FALSE, TRUE);
7442       if (opt_fd != NULL
7443           && (opt_fd->root.type == bfd_link_hash_defined
7444               || opt_fd->root.type == bfd_link_hash_defweak))
7445         {
7446           /* If glibc supports an optimized __tls_get_addr call stub,
7447              signalled by the presence of __tls_get_addr_opt, and we'll
7448              be calling __tls_get_addr via a plt call stub, then
7449              make __tls_get_addr point to __tls_get_addr_opt.  */
7450           tga_fd = &htab->tls_get_addr_fd->elf;
7451           if (htab->elf.dynamic_sections_created
7452               && tga_fd != NULL
7453               && (tga_fd->type == STT_FUNC
7454                   || tga_fd->needs_plt)
7455               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7456                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7457                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7458             {
7459               struct plt_entry *ent;
7460
7461               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7462                 if (ent->plt.refcount > 0)
7463                   break;
7464               if (ent != NULL)
7465                 {
7466                   tga_fd->root.type = bfd_link_hash_indirect;
7467                   tga_fd->root.u.i.link = &opt_fd->root;
7468                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7469                   if (opt_fd->dynindx != -1)
7470                     {
7471                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7472                       opt_fd->dynindx = -1;
7473                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7474                                               opt_fd->dynstr_index);
7475                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7476                         return NULL;
7477                     }
7478                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7479                   tga = &htab->tls_get_addr->elf;
7480                   if (opt != NULL && tga != NULL)
7481                     {
7482                       tga->root.type = bfd_link_hash_indirect;
7483                       tga->root.u.i.link = &opt->root;
7484                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7485                       _bfd_elf_link_hash_hide_symbol (info, opt,
7486                                                       tga->forced_local);
7487                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7488                     }
7489                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7490                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7491                   if (htab->tls_get_addr != NULL)
7492                     {
7493                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7494                       htab->tls_get_addr->is_func = 1;
7495                     }
7496                 }
7497             }
7498         }
7499       else
7500         no_tls_get_addr_opt = TRUE;
7501     }
7502   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7503   return _bfd_elf_tls_setup (info->output_bfd, info);
7504 }
7505
7506 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7507    HASH1 or HASH2.  */
7508
7509 static bfd_boolean
7510 branch_reloc_hash_match (const bfd *ibfd,
7511                          const Elf_Internal_Rela *rel,
7512                          const struct ppc_link_hash_entry *hash1,
7513                          const struct ppc_link_hash_entry *hash2)
7514 {
7515   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7516   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7517   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7518
7519   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7520     {
7521       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7522       struct elf_link_hash_entry *h;
7523
7524       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7525       h = elf_follow_link (h);
7526       if (h == &hash1->elf || h == &hash2->elf)
7527         return TRUE;
7528     }
7529   return FALSE;
7530 }
7531
7532 /* Run through all the TLS relocs looking for optimization
7533    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7534    a preliminary section layout so that we know the TLS segment
7535    offsets.  We can't optimize earlier because some optimizations need
7536    to know the tp offset, and we need to optimize before allocating
7537    dynamic relocations.  */
7538
7539 bfd_boolean
7540 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7541 {
7542   bfd *ibfd;
7543   asection *sec;
7544   struct ppc_link_hash_table *htab;
7545   unsigned char *toc_ref;
7546   int pass;
7547
7548   if (info->relocatable || !info->executable)
7549     return TRUE;
7550
7551   htab = ppc_hash_table (info);
7552   if (htab == NULL)
7553     return FALSE;
7554
7555   /* Make two passes over the relocs.  On the first pass, mark toc
7556      entries involved with tls relocs, and check that tls relocs
7557      involved in setting up a tls_get_addr call are indeed followed by
7558      such a call.  If they are not, we can't do any tls optimization.
7559      On the second pass twiddle tls_mask flags to notify
7560      relocate_section that optimization can be done, and adjust got
7561      and plt refcounts.  */
7562   toc_ref = NULL;
7563   for (pass = 0; pass < 2; ++pass)
7564     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7565       {
7566         Elf_Internal_Sym *locsyms = NULL;
7567         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7568
7569         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7570           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7571             {
7572               Elf_Internal_Rela *relstart, *rel, *relend;
7573               bfd_boolean found_tls_get_addr_arg = 0;
7574
7575               /* Read the relocations.  */
7576               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7577                                                     info->keep_memory);
7578               if (relstart == NULL)
7579                 return FALSE;
7580
7581               relend = relstart + sec->reloc_count;
7582               for (rel = relstart; rel < relend; rel++)
7583                 {
7584                   enum elf_ppc64_reloc_type r_type;
7585                   unsigned long r_symndx;
7586                   struct elf_link_hash_entry *h;
7587                   Elf_Internal_Sym *sym;
7588                   asection *sym_sec;
7589                   unsigned char *tls_mask;
7590                   unsigned char tls_set, tls_clear, tls_type = 0;
7591                   bfd_vma value;
7592                   bfd_boolean ok_tprel, is_local;
7593                   long toc_ref_index = 0;
7594                   int expecting_tls_get_addr = 0;
7595                   bfd_boolean ret = FALSE;
7596
7597                   r_symndx = ELF64_R_SYM (rel->r_info);
7598                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7599                                   r_symndx, ibfd))
7600                     {
7601                     err_free_rel:
7602                       if (elf_section_data (sec)->relocs != relstart)
7603                         free (relstart);
7604                       if (toc_ref != NULL)
7605                         free (toc_ref);
7606                       if (locsyms != NULL
7607                           && (elf_symtab_hdr (ibfd).contents
7608                               != (unsigned char *) locsyms))
7609                         free (locsyms);
7610                       return ret;
7611                     }
7612
7613                   if (h != NULL)
7614                     {
7615                       if (h->root.type == bfd_link_hash_defined
7616                           || h->root.type == bfd_link_hash_defweak)
7617                         value = h->root.u.def.value;
7618                       else if (h->root.type == bfd_link_hash_undefweak)
7619                         value = 0;
7620                       else
7621                         {
7622                           found_tls_get_addr_arg = 0;
7623                           continue;
7624                         }
7625                     }
7626                   else
7627                     /* Symbols referenced by TLS relocs must be of type
7628                        STT_TLS.  So no need for .opd local sym adjust.  */
7629                     value = sym->st_value;
7630
7631                   ok_tprel = FALSE;
7632                   is_local = FALSE;
7633                   if (h == NULL
7634                       || !h->def_dynamic)
7635                     {
7636                       is_local = TRUE;
7637                       if (h != NULL
7638                           && h->root.type == bfd_link_hash_undefweak)
7639                         ok_tprel = TRUE;
7640                       else
7641                         {
7642                           value += sym_sec->output_offset;
7643                           value += sym_sec->output_section->vma;
7644                           value -= htab->elf.tls_sec->vma;
7645                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7646                                       < (bfd_vma) 1 << 32);
7647                         }
7648                     }
7649
7650                   r_type = ELF64_R_TYPE (rel->r_info);
7651                   /* If this section has old-style __tls_get_addr calls
7652                      without marker relocs, then check that each
7653                      __tls_get_addr call reloc is preceded by a reloc
7654                      that conceivably belongs to the __tls_get_addr arg
7655                      setup insn.  If we don't find matching arg setup
7656                      relocs, don't do any tls optimization.  */
7657                   if (pass == 0
7658                       && sec->has_tls_get_addr_call
7659                       && h != NULL
7660                       && (h == &htab->tls_get_addr->elf
7661                           || h == &htab->tls_get_addr_fd->elf)
7662                       && !found_tls_get_addr_arg
7663                       && is_branch_reloc (r_type))
7664                     {
7665                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7666                                                 "TLS optimization disabled\n"),
7667                                               ibfd, sec, rel->r_offset);
7668                       ret = TRUE;
7669                       goto err_free_rel;
7670                     }
7671
7672                   found_tls_get_addr_arg = 0;
7673                   switch (r_type)
7674                     {
7675                     case R_PPC64_GOT_TLSLD16:
7676                     case R_PPC64_GOT_TLSLD16_LO:
7677                       expecting_tls_get_addr = 1;
7678                       found_tls_get_addr_arg = 1;
7679                       /* Fall thru */
7680
7681                     case R_PPC64_GOT_TLSLD16_HI:
7682                     case R_PPC64_GOT_TLSLD16_HA:
7683                       /* These relocs should never be against a symbol
7684                          defined in a shared lib.  Leave them alone if
7685                          that turns out to be the case.  */
7686                       if (!is_local)
7687                         continue;
7688
7689                       /* LD -> LE */
7690                       tls_set = 0;
7691                       tls_clear = TLS_LD;
7692                       tls_type = TLS_TLS | TLS_LD;
7693                       break;
7694
7695                     case R_PPC64_GOT_TLSGD16:
7696                     case R_PPC64_GOT_TLSGD16_LO:
7697                       expecting_tls_get_addr = 1;
7698                       found_tls_get_addr_arg = 1;
7699                       /* Fall thru */
7700
7701                     case R_PPC64_GOT_TLSGD16_HI:
7702                     case R_PPC64_GOT_TLSGD16_HA:
7703                       if (ok_tprel)
7704                         /* GD -> LE */
7705                         tls_set = 0;
7706                       else
7707                         /* GD -> IE */
7708                         tls_set = TLS_TLS | TLS_TPRELGD;
7709                       tls_clear = TLS_GD;
7710                       tls_type = TLS_TLS | TLS_GD;
7711                       break;
7712
7713                     case R_PPC64_GOT_TPREL16_DS:
7714                     case R_PPC64_GOT_TPREL16_LO_DS:
7715                     case R_PPC64_GOT_TPREL16_HI:
7716                     case R_PPC64_GOT_TPREL16_HA:
7717                       if (ok_tprel)
7718                         {
7719                           /* IE -> LE */
7720                           tls_set = 0;
7721                           tls_clear = TLS_TPREL;
7722                           tls_type = TLS_TLS | TLS_TPREL;
7723                           break;
7724                         }
7725                       continue;
7726
7727                     case R_PPC64_TLSGD:
7728                     case R_PPC64_TLSLD:
7729                       found_tls_get_addr_arg = 1;
7730                       /* Fall thru */
7731
7732                     case R_PPC64_TLS:
7733                     case R_PPC64_TOC16:
7734                     case R_PPC64_TOC16_LO:
7735                       if (sym_sec == NULL || sym_sec != toc)
7736                         continue;
7737
7738                       /* Mark this toc entry as referenced by a TLS
7739                          code sequence.  We can do that now in the
7740                          case of R_PPC64_TLS, and after checking for
7741                          tls_get_addr for the TOC16 relocs.  */
7742                       if (toc_ref == NULL)
7743                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7744                       if (toc_ref == NULL)
7745                         goto err_free_rel;
7746
7747                       if (h != NULL)
7748                         value = h->root.u.def.value;
7749                       else
7750                         value = sym->st_value;
7751                       value += rel->r_addend;
7752                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7753                       toc_ref_index = (value + toc->output_offset) / 8;
7754                       if (r_type == R_PPC64_TLS
7755                           || r_type == R_PPC64_TLSGD
7756                           || r_type == R_PPC64_TLSLD)
7757                         {
7758                           toc_ref[toc_ref_index] = 1;
7759                           continue;
7760                         }
7761
7762                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7763                         continue;
7764
7765                       tls_set = 0;
7766                       tls_clear = 0;
7767                       expecting_tls_get_addr = 2;
7768                       break;
7769
7770                     case R_PPC64_TPREL64:
7771                       if (pass == 0
7772                           || sec != toc
7773                           || toc_ref == NULL
7774                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7775                         continue;
7776                       if (ok_tprel)
7777                         {
7778                           /* IE -> LE */
7779                           tls_set = TLS_EXPLICIT;
7780                           tls_clear = TLS_TPREL;
7781                           break;
7782                         }
7783                       continue;
7784
7785                     case R_PPC64_DTPMOD64:
7786                       if (pass == 0
7787                           || sec != toc
7788                           || toc_ref == NULL
7789                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7790                         continue;
7791                       if (rel + 1 < relend
7792                           && (rel[1].r_info
7793                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7794                           && rel[1].r_offset == rel->r_offset + 8)
7795                         {
7796                           if (ok_tprel)
7797                             /* GD -> LE */
7798                             tls_set = TLS_EXPLICIT | TLS_GD;
7799                           else
7800                             /* GD -> IE */
7801                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7802                           tls_clear = TLS_GD;
7803                         }
7804                       else
7805                         {
7806                           if (!is_local)
7807                             continue;
7808
7809                           /* LD -> LE */
7810                           tls_set = TLS_EXPLICIT;
7811                           tls_clear = TLS_LD;
7812                         }
7813                       break;
7814
7815                     default:
7816                       continue;
7817                     }
7818
7819                   if (pass == 0)
7820                     {
7821                       if (!expecting_tls_get_addr
7822                           || !sec->has_tls_get_addr_call)
7823                         continue;
7824
7825                       if (rel + 1 < relend
7826                           && branch_reloc_hash_match (ibfd, rel + 1,
7827                                                       htab->tls_get_addr,
7828                                                       htab->tls_get_addr_fd))
7829                         {
7830                           if (expecting_tls_get_addr == 2)
7831                             {
7832                               /* Check for toc tls entries.  */
7833                               unsigned char *toc_tls;
7834                               int retval;
7835
7836                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7837                                                      &locsyms,
7838                                                      rel, ibfd);
7839                               if (retval == 0)
7840                                 goto err_free_rel;
7841                               if (toc_tls != NULL)
7842                                 {
7843                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7844                                     found_tls_get_addr_arg = 1;
7845                                   if (retval > 1)
7846                                     toc_ref[toc_ref_index] = 1;
7847                                 }
7848                             }
7849                           continue;
7850                         }
7851
7852                       if (expecting_tls_get_addr != 1)
7853                         continue;
7854
7855                       /* Uh oh, we didn't find the expected call.  We
7856                          could just mark this symbol to exclude it
7857                          from tls optimization but it's safer to skip
7858                          the entire optimization.  */
7859                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
7860                                                 "TLS optimization disabled\n"),
7861                                               ibfd, sec, rel->r_offset);
7862                       ret = TRUE;
7863                       goto err_free_rel;
7864                     }
7865
7866                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7867                     {
7868                       struct plt_entry *ent;
7869                       for (ent = htab->tls_get_addr->elf.plt.plist;
7870                            ent != NULL;
7871                            ent = ent->next)
7872                         if (ent->addend == 0)
7873                           {
7874                             if (ent->plt.refcount > 0)
7875                               {
7876                                 ent->plt.refcount -= 1;
7877                                 expecting_tls_get_addr = 0;
7878                               }
7879                             break;
7880                           }
7881                     }
7882
7883                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7884                     {
7885                       struct plt_entry *ent;
7886                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7887                            ent != NULL;
7888                            ent = ent->next)
7889                         if (ent->addend == 0)
7890                           {
7891                             if (ent->plt.refcount > 0)
7892                               ent->plt.refcount -= 1;
7893                             break;
7894                           }
7895                     }
7896
7897                   if (tls_clear == 0)
7898                     continue;
7899
7900                   if ((tls_set & TLS_EXPLICIT) == 0)
7901                     {
7902                       struct got_entry *ent;
7903
7904                       /* Adjust got entry for this reloc.  */
7905                       if (h != NULL)
7906                         ent = h->got.glist;
7907                       else
7908                         ent = elf_local_got_ents (ibfd)[r_symndx];
7909
7910                       for (; ent != NULL; ent = ent->next)
7911                         if (ent->addend == rel->r_addend
7912                             && ent->owner == ibfd
7913                             && ent->tls_type == tls_type)
7914                           break;
7915                       if (ent == NULL)
7916                         abort ();
7917
7918                       if (tls_set == 0)
7919                         {
7920                           /* We managed to get rid of a got entry.  */
7921                           if (ent->got.refcount > 0)
7922                             ent->got.refcount -= 1;
7923                         }
7924                     }
7925                   else
7926                     {
7927                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7928                          we'll lose one or two dyn relocs.  */
7929                       if (!dec_dynrel_count (rel->r_info, sec, info,
7930                                              NULL, h, sym_sec))
7931                         return FALSE;
7932
7933                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7934                         {
7935                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7936                                                  NULL, h, sym_sec))
7937                             return FALSE;
7938                         }
7939                     }
7940
7941                   *tls_mask |= tls_set;
7942                   *tls_mask &= ~tls_clear;
7943                 }
7944
7945               if (elf_section_data (sec)->relocs != relstart)
7946                 free (relstart);
7947             }
7948
7949         if (locsyms != NULL
7950             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7951           {
7952             if (!info->keep_memory)
7953               free (locsyms);
7954             else
7955               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7956           }
7957       }
7958
7959   if (toc_ref != NULL)
7960     free (toc_ref);
7961   return TRUE;
7962 }
7963
7964 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7965    the values of any global symbols in a toc section that has been
7966    edited.  Globals in toc sections should be a rarity, so this function
7967    sets a flag if any are found in toc sections other than the one just
7968    edited, so that futher hash table traversals can be avoided.  */
7969
7970 struct adjust_toc_info
7971 {
7972   asection *toc;
7973   unsigned long *skip;
7974   bfd_boolean global_toc_syms;
7975 };
7976
7977 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7978
7979 static bfd_boolean
7980 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7981 {
7982   struct ppc_link_hash_entry *eh;
7983   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7984   unsigned long i;
7985
7986   if (h->root.type != bfd_link_hash_defined
7987       && h->root.type != bfd_link_hash_defweak)
7988     return TRUE;
7989
7990   eh = (struct ppc_link_hash_entry *) h;
7991   if (eh->adjust_done)
7992     return TRUE;
7993
7994   if (eh->elf.root.u.def.section == toc_inf->toc)
7995     {
7996       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
7997         i = toc_inf->toc->rawsize >> 3;
7998       else
7999         i = eh->elf.root.u.def.value >> 3;
8000
8001       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8002         {
8003           (*_bfd_error_handler)
8004             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8005           do
8006             ++i;
8007           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8008           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8009         }
8010
8011       eh->elf.root.u.def.value -= toc_inf->skip[i];
8012       eh->adjust_done = 1;
8013     }
8014   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8015     toc_inf->global_toc_syms = TRUE;
8016
8017   return TRUE;
8018 }
8019
8020 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8021
8022 static bfd_boolean
8023 ok_lo_toc_insn (unsigned int insn)
8024 {
8025   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8026           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8027           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8028           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8029           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8030           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8031           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8032           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8033           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8034           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8035           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8036           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8037           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8038           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8039           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8040               && (insn & 3) != 1)
8041           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8042               && ((insn & 3) == 0 || (insn & 3) == 3))
8043           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8044 }
8045
8046 /* Examine all relocs referencing .toc sections in order to remove
8047    unused .toc entries.  */
8048
8049 bfd_boolean
8050 ppc64_elf_edit_toc (struct bfd_link_info *info)
8051 {
8052   bfd *ibfd;
8053   struct adjust_toc_info toc_inf;
8054   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8055
8056   htab->do_toc_opt = 1;
8057   toc_inf.global_toc_syms = TRUE;
8058   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8059     {
8060       asection *toc, *sec;
8061       Elf_Internal_Shdr *symtab_hdr;
8062       Elf_Internal_Sym *local_syms;
8063       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8064       unsigned long *skip, *drop;
8065       unsigned char *used;
8066       unsigned char *keep, last, some_unused;
8067
8068       if (!is_ppc64_elf (ibfd))
8069         continue;
8070
8071       toc = bfd_get_section_by_name (ibfd, ".toc");
8072       if (toc == NULL
8073           || toc->size == 0
8074           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
8075           || elf_discarded_section (toc))
8076         continue;
8077
8078       toc_relocs = NULL;
8079       local_syms = NULL;
8080       symtab_hdr = &elf_symtab_hdr (ibfd);
8081
8082       /* Look at sections dropped from the final link.  */
8083       skip = NULL;
8084       relstart = NULL;
8085       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8086         {
8087           if (sec->reloc_count == 0
8088               || !elf_discarded_section (sec)
8089               || get_opd_info (sec)
8090               || (sec->flags & SEC_ALLOC) == 0
8091               || (sec->flags & SEC_DEBUGGING) != 0)
8092             continue;
8093
8094           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8095           if (relstart == NULL)
8096             goto error_ret;
8097
8098           /* Run through the relocs to see which toc entries might be
8099              unused.  */
8100           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8101             {
8102               enum elf_ppc64_reloc_type r_type;
8103               unsigned long r_symndx;
8104               asection *sym_sec;
8105               struct elf_link_hash_entry *h;
8106               Elf_Internal_Sym *sym;
8107               bfd_vma val;
8108
8109               r_type = ELF64_R_TYPE (rel->r_info);
8110               switch (r_type)
8111                 {
8112                 default:
8113                   continue;
8114
8115                 case R_PPC64_TOC16:
8116                 case R_PPC64_TOC16_LO:
8117                 case R_PPC64_TOC16_HI:
8118                 case R_PPC64_TOC16_HA:
8119                 case R_PPC64_TOC16_DS:
8120                 case R_PPC64_TOC16_LO_DS:
8121                   break;
8122                 }
8123
8124               r_symndx = ELF64_R_SYM (rel->r_info);
8125               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8126                               r_symndx, ibfd))
8127                 goto error_ret;
8128
8129               if (sym_sec != toc)
8130                 continue;
8131
8132               if (h != NULL)
8133                 val = h->root.u.def.value;
8134               else
8135                 val = sym->st_value;
8136               val += rel->r_addend;
8137
8138               if (val >= toc->size)
8139                 continue;
8140
8141               /* Anything in the toc ought to be aligned to 8 bytes.
8142                  If not, don't mark as unused.  */
8143               if (val & 7)
8144                 continue;
8145
8146               if (skip == NULL)
8147                 {
8148                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8149                   if (skip == NULL)
8150                     goto error_ret;
8151                 }
8152
8153               skip[val >> 3] = ref_from_discarded;
8154             }
8155
8156           if (elf_section_data (sec)->relocs != relstart)
8157             free (relstart);
8158         }
8159
8160       /* For largetoc loads of address constants, we can convert
8161          .  addis rx,2,addr@got@ha
8162          .  ld ry,addr@got@l(rx)
8163          to
8164          .  addis rx,2,addr@toc@ha
8165          .  addi ry,rx,addr@toc@l
8166          when addr is within 2G of the toc pointer.  This then means
8167          that the word storing "addr" in the toc is no longer needed.  */
8168
8169       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8170           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8171           && toc->reloc_count != 0)
8172         {
8173           /* Read toc relocs.  */
8174           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8175                                                   info->keep_memory);
8176           if (toc_relocs == NULL)
8177             goto error_ret;
8178
8179           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8180             {
8181               enum elf_ppc64_reloc_type r_type;
8182               unsigned long r_symndx;
8183               asection *sym_sec;
8184               struct elf_link_hash_entry *h;
8185               Elf_Internal_Sym *sym;
8186               bfd_vma val, addr;
8187
8188               r_type = ELF64_R_TYPE (rel->r_info);
8189               if (r_type != R_PPC64_ADDR64)
8190                 continue;
8191
8192               r_symndx = ELF64_R_SYM (rel->r_info);
8193               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8194                               r_symndx, ibfd))
8195                 goto error_ret;
8196
8197               if (sym_sec == NULL
8198                   || elf_discarded_section (sym_sec))
8199                 continue;
8200
8201               if (!SYMBOL_CALLS_LOCAL (info, h))
8202                 continue;
8203
8204               if (h != NULL)
8205                 {
8206                   if (h->type == STT_GNU_IFUNC)
8207                     continue;
8208                   val = h->root.u.def.value;
8209                 }
8210               else
8211                 {
8212                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8213                     continue;
8214                   val = sym->st_value;
8215                 }
8216               val += rel->r_addend;
8217               val += sym_sec->output_section->vma + sym_sec->output_offset;
8218
8219               /* We don't yet know the exact toc pointer value, but we
8220                  know it will be somewhere in the toc section.  Don't
8221                  optimize if the difference from any possible toc
8222                  pointer is outside [ff..f80008000, 7fff7fff].  */
8223               addr = toc->output_section->vma + TOC_BASE_OFF;
8224               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8225                 continue;
8226
8227               addr = toc->output_section->vma + toc->output_section->rawsize;
8228               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8229                 continue;
8230
8231               if (skip == NULL)
8232                 {
8233                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8234                   if (skip == NULL)
8235                     goto error_ret;
8236                 }
8237
8238               skip[rel->r_offset >> 3]
8239                 |= can_optimize | ((rel - toc_relocs) << 2);
8240             }
8241         }
8242
8243       if (skip == NULL)
8244         continue;
8245
8246       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8247       if (used == NULL)
8248         {
8249         error_ret:
8250           if (local_syms != NULL
8251               && symtab_hdr->contents != (unsigned char *) local_syms)
8252             free (local_syms);
8253           if (sec != NULL
8254               && relstart != NULL
8255               && elf_section_data (sec)->relocs != relstart)
8256             free (relstart);
8257           if (toc_relocs != NULL
8258               && elf_section_data (toc)->relocs != toc_relocs)
8259             free (toc_relocs);
8260           if (skip != NULL)
8261             free (skip);
8262           return FALSE;
8263         }
8264
8265       /* Now check all kept sections that might reference the toc.
8266          Check the toc itself last.  */
8267       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8268                   : ibfd->sections);
8269            sec != NULL;
8270            sec = (sec == toc ? NULL
8271                   : sec->next == NULL ? toc
8272                   : sec->next == toc && toc->next ? toc->next
8273                   : sec->next))
8274         {
8275           int repeat;
8276
8277           if (sec->reloc_count == 0
8278               || elf_discarded_section (sec)
8279               || get_opd_info (sec)
8280               || (sec->flags & SEC_ALLOC) == 0
8281               || (sec->flags & SEC_DEBUGGING) != 0)
8282             continue;
8283
8284           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8285                                                 info->keep_memory);
8286           if (relstart == NULL)
8287             goto error_ret;
8288
8289           /* Mark toc entries referenced as used.  */
8290           repeat = 0;
8291           do
8292             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8293               {
8294                 enum elf_ppc64_reloc_type r_type;
8295                 unsigned long r_symndx;
8296                 asection *sym_sec;
8297                 struct elf_link_hash_entry *h;
8298                 Elf_Internal_Sym *sym;
8299                 bfd_vma val;
8300                 enum {no_check, check_lo, check_ha} insn_check;
8301
8302                 r_type = ELF64_R_TYPE (rel->r_info);
8303                 switch (r_type)
8304                   {
8305                   default:
8306                     insn_check = no_check;
8307                     break;
8308
8309                   case R_PPC64_GOT_TLSLD16_HA:
8310                   case R_PPC64_GOT_TLSGD16_HA:
8311                   case R_PPC64_GOT_TPREL16_HA:
8312                   case R_PPC64_GOT_DTPREL16_HA:
8313                   case R_PPC64_GOT16_HA:
8314                   case R_PPC64_TOC16_HA:
8315                     insn_check = check_ha;
8316                     break;
8317
8318                   case R_PPC64_GOT_TLSLD16_LO:
8319                   case R_PPC64_GOT_TLSGD16_LO:
8320                   case R_PPC64_GOT_TPREL16_LO_DS:
8321                   case R_PPC64_GOT_DTPREL16_LO_DS:
8322                   case R_PPC64_GOT16_LO:
8323                   case R_PPC64_GOT16_LO_DS:
8324                   case R_PPC64_TOC16_LO:
8325                   case R_PPC64_TOC16_LO_DS:
8326                     insn_check = check_lo;
8327                     break;
8328                   }
8329
8330                 if (insn_check != no_check)
8331                   {
8332                     bfd_vma off = rel->r_offset & ~3;
8333                     unsigned char buf[4];
8334                     unsigned int insn;
8335
8336                     if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8337                       {
8338                         free (used);
8339                         goto error_ret;
8340                       }
8341                     insn = bfd_get_32 (ibfd, buf);
8342                     if (insn_check == check_lo
8343                         ? !ok_lo_toc_insn (insn)
8344                         : ((insn & ((0x3f << 26) | 0x1f << 16))
8345                            != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8346                       {
8347                         char str[12];
8348
8349                         ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8350                         sprintf (str, "%#08x", insn);
8351                         info->callbacks->einfo
8352                           (_("%P: %H: toc optimization is not supported for"
8353                              " %s instruction.\n"),
8354                            ibfd, sec, rel->r_offset & ~3, str);
8355                       }
8356                   }
8357
8358                 switch (r_type)
8359                   {
8360                   case R_PPC64_TOC16:
8361                   case R_PPC64_TOC16_LO:
8362                   case R_PPC64_TOC16_HI:
8363                   case R_PPC64_TOC16_HA:
8364                   case R_PPC64_TOC16_DS:
8365                   case R_PPC64_TOC16_LO_DS:
8366                     /* In case we're taking addresses of toc entries.  */
8367                   case R_PPC64_ADDR64:
8368                     break;
8369
8370                   default:
8371                     continue;
8372                   }
8373
8374                 r_symndx = ELF64_R_SYM (rel->r_info);
8375                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8376                                 r_symndx, ibfd))
8377                   {
8378                     free (used);
8379                     goto error_ret;
8380                   }
8381
8382                 if (sym_sec != toc)
8383                   continue;
8384
8385                 if (h != NULL)
8386                   val = h->root.u.def.value;
8387                 else
8388                   val = sym->st_value;
8389                 val += rel->r_addend;
8390
8391                 if (val >= toc->size)
8392                   continue;
8393
8394                 if ((skip[val >> 3] & can_optimize) != 0)
8395                   {
8396                     bfd_vma off;
8397                     unsigned char opc;
8398
8399                     switch (r_type)
8400                       {
8401                       case R_PPC64_TOC16_HA:
8402                         break;
8403
8404                       case R_PPC64_TOC16_LO_DS:
8405                         off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8406                         if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8407                           {
8408                             free (used);
8409                             goto error_ret;
8410                           }
8411                         if ((opc & (0x3f << 2)) == (58u << 2))
8412                           break;
8413                         /* Fall thru */
8414
8415                       default:
8416                         /* Wrong sort of reloc, or not a ld.  We may
8417                            as well clear ref_from_discarded too.  */
8418                         skip[val >> 3] = 0;
8419                       }
8420                   }
8421
8422                 /* For the toc section, we only mark as used if
8423                    this entry itself isn't unused.  */
8424                 if (sec == toc
8425                     && !used[val >> 3]
8426                     && (used[rel->r_offset >> 3]
8427                         || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8428                   /* Do all the relocs again, to catch reference
8429                      chains.  */
8430                   repeat = 1;
8431
8432                 used[val >> 3] = 1;
8433               }
8434           while (repeat);
8435
8436           if (elf_section_data (sec)->relocs != relstart)
8437             free (relstart);
8438         }
8439
8440       /* Merge the used and skip arrays.  Assume that TOC
8441          doublewords not appearing as either used or unused belong
8442          to to an entry more than one doubleword in size.  */
8443       for (drop = skip, keep = used, last = 0, some_unused = 0;
8444            drop < skip + (toc->size + 7) / 8;
8445            ++drop, ++keep)
8446         {
8447           if (*keep)
8448             {
8449               *drop &= ~ref_from_discarded;
8450               if ((*drop & can_optimize) != 0)
8451                 some_unused = 1;
8452               last = 0;
8453             }
8454           else if ((*drop & ref_from_discarded) != 0)
8455             {
8456               some_unused = 1;
8457               last = ref_from_discarded;
8458             }
8459           else
8460             *drop = last;
8461         }
8462
8463       free (used);
8464
8465       if (some_unused)
8466         {
8467           bfd_byte *contents, *src;
8468           unsigned long off;
8469           Elf_Internal_Sym *sym;
8470           bfd_boolean local_toc_syms = FALSE;
8471
8472           /* Shuffle the toc contents, and at the same time convert the
8473              skip array from booleans into offsets.  */
8474           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8475             goto error_ret;
8476
8477           elf_section_data (toc)->this_hdr.contents = contents;
8478
8479           for (src = contents, off = 0, drop = skip;
8480                src < contents + toc->size;
8481                src += 8, ++drop)
8482             {
8483               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8484                 off += 8;
8485               else if (off != 0)
8486                 {
8487                   *drop = off;
8488                   memcpy (src - off, src, 8);
8489                 }
8490             }
8491           *drop = off;
8492           toc->rawsize = toc->size;
8493           toc->size = src - contents - off;
8494
8495           /* Adjust addends for relocs against the toc section sym,
8496              and optimize any accesses we can.  */
8497           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8498             {
8499               if (sec->reloc_count == 0
8500                   || elf_discarded_section (sec))
8501                 continue;
8502
8503               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8504                                                     info->keep_memory);
8505               if (relstart == NULL)
8506                 goto error_ret;
8507
8508               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8509                 {
8510                   enum elf_ppc64_reloc_type r_type;
8511                   unsigned long r_symndx;
8512                   asection *sym_sec;
8513                   struct elf_link_hash_entry *h;
8514                   bfd_vma val;
8515
8516                   r_type = ELF64_R_TYPE (rel->r_info);
8517                   switch (r_type)
8518                     {
8519                     default:
8520                       continue;
8521
8522                     case R_PPC64_TOC16:
8523                     case R_PPC64_TOC16_LO:
8524                     case R_PPC64_TOC16_HI:
8525                     case R_PPC64_TOC16_HA:
8526                     case R_PPC64_TOC16_DS:
8527                     case R_PPC64_TOC16_LO_DS:
8528                     case R_PPC64_ADDR64:
8529                       break;
8530                     }
8531
8532                   r_symndx = ELF64_R_SYM (rel->r_info);
8533                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8534                                   r_symndx, ibfd))
8535                     goto error_ret;
8536
8537                   if (sym_sec != toc)
8538                     continue;
8539
8540                   if (h != NULL)
8541                     val = h->root.u.def.value;
8542                   else
8543                     {
8544                       val = sym->st_value;
8545                       if (val != 0)
8546                         local_toc_syms = TRUE;
8547                     }
8548
8549                   val += rel->r_addend;
8550
8551                   if (val > toc->rawsize)
8552                     val = toc->rawsize;
8553                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8554                     continue;
8555                   else if ((skip[val >> 3] & can_optimize) != 0)
8556                     {
8557                       Elf_Internal_Rela *tocrel
8558                         = toc_relocs + (skip[val >> 3] >> 2);
8559                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8560
8561                       switch (r_type)
8562                         {
8563                         case R_PPC64_TOC16_HA:
8564                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8565                           break;
8566
8567                         case R_PPC64_TOC16_LO_DS:
8568                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8569                           break;
8570
8571                         default:
8572                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8573                             ppc_howto_init ();
8574                           info->callbacks->einfo
8575                             (_("%P: %H: %s relocation references "
8576                                "optimized away TOC entry\n"),
8577                              ibfd, sec, rel->r_offset,
8578                              ppc64_elf_howto_table[r_type]->name);
8579                           bfd_set_error (bfd_error_bad_value);
8580                           goto error_ret;
8581                         }
8582                       rel->r_addend = tocrel->r_addend;
8583                       elf_section_data (sec)->relocs = relstart;
8584                       continue;
8585                     }
8586
8587                   if (h != NULL || sym->st_value != 0)
8588                     continue;
8589
8590                   rel->r_addend -= skip[val >> 3];
8591                   elf_section_data (sec)->relocs = relstart;
8592                 }
8593
8594               if (elf_section_data (sec)->relocs != relstart)
8595                 free (relstart);
8596             }
8597
8598           /* We shouldn't have local or global symbols defined in the TOC,
8599              but handle them anyway.  */
8600           if (local_syms != NULL)
8601             for (sym = local_syms;
8602                  sym < local_syms + symtab_hdr->sh_info;
8603                  ++sym)
8604               if (sym->st_value != 0
8605                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8606                 {
8607                   unsigned long i;
8608
8609                   if (sym->st_value > toc->rawsize)
8610                     i = toc->rawsize >> 3;
8611                   else
8612                     i = sym->st_value >> 3;
8613
8614                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8615                     {
8616                       if (local_toc_syms)
8617                         (*_bfd_error_handler)
8618                           (_("%s defined on removed toc entry"),
8619                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8620                       do
8621                         ++i;
8622                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8623                       sym->st_value = (bfd_vma) i << 3;
8624                     }
8625
8626                   sym->st_value -= skip[i];
8627                   symtab_hdr->contents = (unsigned char *) local_syms;
8628                 }
8629
8630           /* Adjust any global syms defined in this toc input section.  */
8631           if (toc_inf.global_toc_syms)
8632             {
8633               toc_inf.toc = toc;
8634               toc_inf.skip = skip;
8635               toc_inf.global_toc_syms = FALSE;
8636               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8637                                       &toc_inf);
8638             }
8639
8640           if (toc->reloc_count != 0)
8641             {
8642               Elf_Internal_Shdr *rel_hdr;
8643               Elf_Internal_Rela *wrel;
8644               bfd_size_type sz;
8645
8646               /* Remove unused toc relocs, and adjust those we keep.  */
8647               if (toc_relocs == NULL)
8648                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8649                                                         info->keep_memory);
8650               if (toc_relocs == NULL)
8651                 goto error_ret;
8652
8653               wrel = toc_relocs;
8654               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8655                 if ((skip[rel->r_offset >> 3]
8656                      & (ref_from_discarded | can_optimize)) == 0)
8657                   {
8658                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8659                     wrel->r_info = rel->r_info;
8660                     wrel->r_addend = rel->r_addend;
8661                     ++wrel;
8662                   }
8663                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8664                                             &local_syms, NULL, NULL))
8665                   goto error_ret;
8666
8667               elf_section_data (toc)->relocs = toc_relocs;
8668               toc->reloc_count = wrel - toc_relocs;
8669               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8670               sz = rel_hdr->sh_entsize;
8671               rel_hdr->sh_size = toc->reloc_count * sz;
8672             }
8673         }
8674       else if (toc_relocs != NULL
8675                && elf_section_data (toc)->relocs != toc_relocs)
8676         free (toc_relocs);
8677
8678       if (local_syms != NULL
8679           && symtab_hdr->contents != (unsigned char *) local_syms)
8680         {
8681           if (!info->keep_memory)
8682             free (local_syms);
8683           else
8684             symtab_hdr->contents = (unsigned char *) local_syms;
8685         }
8686       free (skip);
8687     }
8688
8689   return TRUE;
8690 }
8691
8692 /* Return true iff input section I references the TOC using
8693    instructions limited to +/-32k offsets.  */
8694
8695 bfd_boolean
8696 ppc64_elf_has_small_toc_reloc (asection *i)
8697 {
8698   return (is_ppc64_elf (i->owner)
8699           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8700 }
8701
8702 /* Allocate space for one GOT entry.  */
8703
8704 static void
8705 allocate_got (struct elf_link_hash_entry *h,
8706               struct bfd_link_info *info,
8707               struct got_entry *gent)
8708 {
8709   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8710   bfd_boolean dyn;
8711   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8712   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8713                  ? 16 : 8);
8714   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8715                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8716   asection *got = ppc64_elf_tdata (gent->owner)->got;
8717
8718   gent->got.offset = got->size;
8719   got->size += entsize;
8720
8721   dyn = htab->elf.dynamic_sections_created;
8722   if ((info->shared
8723        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8724             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8725                 || h->root.type != bfd_link_hash_undefweak))
8726     {
8727       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8728       relgot->size += rentsize;
8729     }
8730   else if (h->type == STT_GNU_IFUNC)
8731     {
8732       asection *relgot = htab->reliplt;
8733       relgot->size += rentsize;
8734       htab->got_reli_size += rentsize;
8735     }
8736 }
8737
8738 /* This function merges got entries in the same toc group.  */
8739
8740 static void
8741 merge_got_entries (struct got_entry **pent)
8742 {
8743   struct got_entry *ent, *ent2;
8744
8745   for (ent = *pent; ent != NULL; ent = ent->next)
8746     if (!ent->is_indirect)
8747       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8748         if (!ent2->is_indirect
8749             && ent2->addend == ent->addend
8750             && ent2->tls_type == ent->tls_type
8751             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8752           {
8753             ent2->is_indirect = TRUE;
8754             ent2->got.ent = ent;
8755           }
8756 }
8757
8758 /* Allocate space in .plt, .got and associated reloc sections for
8759    dynamic relocs.  */
8760
8761 static bfd_boolean
8762 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8763 {
8764   struct bfd_link_info *info;
8765   struct ppc_link_hash_table *htab;
8766   asection *s;
8767   struct ppc_link_hash_entry *eh;
8768   struct elf_dyn_relocs *p;
8769   struct got_entry **pgent, *gent;
8770
8771   if (h->root.type == bfd_link_hash_indirect)
8772     return TRUE;
8773
8774   info = (struct bfd_link_info *) inf;
8775   htab = ppc_hash_table (info);
8776   if (htab == NULL)
8777     return FALSE;
8778
8779   if ((htab->elf.dynamic_sections_created
8780        && h->dynindx != -1
8781        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8782       || h->type == STT_GNU_IFUNC)
8783     {
8784       struct plt_entry *pent;
8785       bfd_boolean doneone = FALSE;
8786       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8787         if (pent->plt.refcount > 0)
8788           {
8789             if (!htab->elf.dynamic_sections_created
8790                 || h->dynindx == -1)
8791               {
8792                 s = htab->iplt;
8793                 pent->plt.offset = s->size;
8794                 s->size += PLT_ENTRY_SIZE;
8795                 s = htab->reliplt;
8796               }
8797             else
8798               {
8799                 /* If this is the first .plt entry, make room for the special
8800                    first entry.  */
8801                 s = htab->plt;
8802                 if (s->size == 0)
8803                   s->size += PLT_INITIAL_ENTRY_SIZE;
8804
8805                 pent->plt.offset = s->size;
8806
8807                 /* Make room for this entry.  */
8808                 s->size += PLT_ENTRY_SIZE;
8809
8810                 /* Make room for the .glink code.  */
8811                 s = htab->glink;
8812                 if (s->size == 0)
8813                   s->size += GLINK_CALL_STUB_SIZE;
8814                 /* We need bigger stubs past index 32767.  */
8815                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8816                   s->size += 4;
8817                 s->size += 2*4;
8818
8819                 /* We also need to make an entry in the .rela.plt section.  */
8820                 s = htab->relplt;
8821               }
8822             s->size += sizeof (Elf64_External_Rela);
8823             doneone = TRUE;
8824           }
8825         else
8826           pent->plt.offset = (bfd_vma) -1;
8827       if (!doneone)
8828         {
8829           h->plt.plist = NULL;
8830           h->needs_plt = 0;
8831         }
8832     }
8833   else
8834     {
8835       h->plt.plist = NULL;
8836       h->needs_plt = 0;
8837     }
8838
8839   eh = (struct ppc_link_hash_entry *) h;
8840   /* Run through the TLS GD got entries first if we're changing them
8841      to TPREL.  */
8842   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8843     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8844       if (gent->got.refcount > 0
8845           && (gent->tls_type & TLS_GD) != 0)
8846         {
8847           /* This was a GD entry that has been converted to TPREL.  If
8848              there happens to be a TPREL entry we can use that one.  */
8849           struct got_entry *ent;
8850           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8851             if (ent->got.refcount > 0
8852                 && (ent->tls_type & TLS_TPREL) != 0
8853                 && ent->addend == gent->addend
8854                 && ent->owner == gent->owner)
8855               {
8856                 gent->got.refcount = 0;
8857                 break;
8858               }
8859
8860           /* If not, then we'll be using our own TPREL entry.  */
8861           if (gent->got.refcount != 0)
8862             gent->tls_type = TLS_TLS | TLS_TPREL;
8863         }
8864
8865   /* Remove any list entry that won't generate a word in the GOT before
8866      we call merge_got_entries.  Otherwise we risk merging to empty
8867      entries.  */
8868   pgent = &h->got.glist;
8869   while ((gent = *pgent) != NULL)
8870     if (gent->got.refcount > 0)
8871       {
8872         if ((gent->tls_type & TLS_LD) != 0
8873             && !h->def_dynamic)
8874           {
8875             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8876             *pgent = gent->next;
8877           }
8878         else
8879           pgent = &gent->next;
8880       }
8881     else
8882       *pgent = gent->next;
8883
8884   if (!htab->do_multi_toc)
8885     merge_got_entries (&h->got.glist);
8886
8887   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8888     if (!gent->is_indirect)
8889       {
8890         /* Make sure this symbol is output as a dynamic symbol.
8891            Undefined weak syms won't yet be marked as dynamic,
8892            nor will all TLS symbols.  */
8893         if (h->dynindx == -1
8894             && !h->forced_local
8895             && h->type != STT_GNU_IFUNC
8896             && htab->elf.dynamic_sections_created)
8897           {
8898             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8899               return FALSE;
8900           }
8901
8902         if (!is_ppc64_elf (gent->owner))
8903           abort ();
8904
8905         allocate_got (h, info, gent);
8906       }
8907
8908   if (eh->dyn_relocs == NULL
8909       || (!htab->elf.dynamic_sections_created
8910           && h->type != STT_GNU_IFUNC))
8911     return TRUE;
8912
8913   /* In the shared -Bsymbolic case, discard space allocated for
8914      dynamic pc-relative relocs against symbols which turn out to be
8915      defined in regular objects.  For the normal shared case, discard
8916      space for relocs that have become local due to symbol visibility
8917      changes.  */
8918
8919   if (info->shared)
8920     {
8921       /* Relocs that use pc_count are those that appear on a call insn,
8922          or certain REL relocs (see must_be_dyn_reloc) that can be
8923          generated via assembly.  We want calls to protected symbols to
8924          resolve directly to the function rather than going via the plt.
8925          If people want function pointer comparisons to work as expected
8926          then they should avoid writing weird assembly.  */
8927       if (SYMBOL_CALLS_LOCAL (info, h))
8928         {
8929           struct elf_dyn_relocs **pp;
8930
8931           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8932             {
8933               p->count -= p->pc_count;
8934               p->pc_count = 0;
8935               if (p->count == 0)
8936                 *pp = p->next;
8937               else
8938                 pp = &p->next;
8939             }
8940         }
8941
8942       /* Also discard relocs on undefined weak syms with non-default
8943          visibility.  */
8944       if (eh->dyn_relocs != NULL
8945           && h->root.type == bfd_link_hash_undefweak)
8946         {
8947           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8948             eh->dyn_relocs = NULL;
8949
8950           /* Make sure this symbol is output as a dynamic symbol.
8951              Undefined weak syms won't yet be marked as dynamic.  */
8952           else if (h->dynindx == -1
8953                    && !h->forced_local)
8954             {
8955               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8956                 return FALSE;
8957             }
8958         }
8959     }
8960   else if (h->type == STT_GNU_IFUNC)
8961     {
8962       if (!h->non_got_ref)
8963         eh->dyn_relocs = NULL;
8964     }
8965   else if (ELIMINATE_COPY_RELOCS)
8966     {
8967       /* For the non-shared case, discard space for relocs against
8968          symbols which turn out to need copy relocs or are not
8969          dynamic.  */
8970
8971       if (!h->non_got_ref
8972           && !h->def_regular)
8973         {
8974           /* Make sure this symbol is output as a dynamic symbol.
8975              Undefined weak syms won't yet be marked as dynamic.  */
8976           if (h->dynindx == -1
8977               && !h->forced_local)
8978             {
8979               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8980                 return FALSE;
8981             }
8982
8983           /* If that succeeded, we know we'll be keeping all the
8984              relocs.  */
8985           if (h->dynindx != -1)
8986             goto keep;
8987         }
8988
8989       eh->dyn_relocs = NULL;
8990
8991     keep: ;
8992     }
8993
8994   /* Finally, allocate space.  */
8995   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8996     {
8997       asection *sreloc = elf_section_data (p->sec)->sreloc;
8998       if (!htab->elf.dynamic_sections_created)
8999         sreloc = htab->reliplt;
9000       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9001     }
9002
9003   return TRUE;
9004 }
9005
9006 /* Find any dynamic relocs that apply to read-only sections.  */
9007
9008 static bfd_boolean
9009 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9010 {
9011   struct ppc_link_hash_entry *eh;
9012   struct elf_dyn_relocs *p;
9013
9014   eh = (struct ppc_link_hash_entry *) h;
9015   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9016     {
9017       asection *s = p->sec->output_section;
9018
9019       if (s != NULL && (s->flags & SEC_READONLY) != 0)
9020         {
9021           struct bfd_link_info *info = inf;
9022
9023           info->flags |= DF_TEXTREL;
9024
9025           /* Not an error, just cut short the traversal.  */
9026           return FALSE;
9027         }
9028     }
9029   return TRUE;
9030 }
9031
9032 /* Set the sizes of the dynamic sections.  */
9033
9034 static bfd_boolean
9035 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9036                                  struct bfd_link_info *info)
9037 {
9038   struct ppc_link_hash_table *htab;
9039   bfd *dynobj;
9040   asection *s;
9041   bfd_boolean relocs;
9042   bfd *ibfd;
9043   struct got_entry *first_tlsld;
9044
9045   htab = ppc_hash_table (info);
9046   if (htab == NULL)
9047     return FALSE;
9048
9049   dynobj = htab->elf.dynobj;
9050   if (dynobj == NULL)
9051     abort ();
9052
9053   if (htab->elf.dynamic_sections_created)
9054     {
9055       /* Set the contents of the .interp section to the interpreter.  */
9056       if (info->executable)
9057         {
9058           s = bfd_get_section_by_name (dynobj, ".interp");
9059           if (s == NULL)
9060             abort ();
9061           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9062           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9063         }
9064     }
9065
9066   /* Set up .got offsets for local syms, and space for local dynamic
9067      relocs.  */
9068   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9069     {
9070       struct got_entry **lgot_ents;
9071       struct got_entry **end_lgot_ents;
9072       struct plt_entry **local_plt;
9073       struct plt_entry **end_local_plt;
9074       unsigned char *lgot_masks;
9075       bfd_size_type locsymcount;
9076       Elf_Internal_Shdr *symtab_hdr;
9077       asection *srel;
9078
9079       if (!is_ppc64_elf (ibfd))
9080         continue;
9081
9082       for (s = ibfd->sections; s != NULL; s = s->next)
9083         {
9084           struct elf_dyn_relocs *p;
9085
9086           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9087             {
9088               if (!bfd_is_abs_section (p->sec)
9089                   && bfd_is_abs_section (p->sec->output_section))
9090                 {
9091                   /* Input section has been discarded, either because
9092                      it is a copy of a linkonce section or due to
9093                      linker script /DISCARD/, so we'll be discarding
9094                      the relocs too.  */
9095                 }
9096               else if (p->count != 0)
9097                 {
9098                   srel = elf_section_data (p->sec)->sreloc;
9099                   if (!htab->elf.dynamic_sections_created)
9100                     srel = htab->reliplt;
9101                   srel->size += p->count * sizeof (Elf64_External_Rela);
9102                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9103                     info->flags |= DF_TEXTREL;
9104                 }
9105             }
9106         }
9107
9108       lgot_ents = elf_local_got_ents (ibfd);
9109       if (!lgot_ents)
9110         continue;
9111
9112       symtab_hdr = &elf_symtab_hdr (ibfd);
9113       locsymcount = symtab_hdr->sh_info;
9114       end_lgot_ents = lgot_ents + locsymcount;
9115       local_plt = (struct plt_entry **) end_lgot_ents;
9116       end_local_plt = local_plt + locsymcount;
9117       lgot_masks = (unsigned char *) end_local_plt;
9118       s = ppc64_elf_tdata (ibfd)->got;
9119       srel = ppc64_elf_tdata (ibfd)->relgot;
9120       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9121         {
9122           struct got_entry **pent, *ent;
9123
9124           pent = lgot_ents;
9125           while ((ent = *pent) != NULL)
9126             if (ent->got.refcount > 0)
9127               {
9128                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9129                   {
9130                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9131                     *pent = ent->next;
9132                   }
9133                 else
9134                   {
9135                     unsigned int num = 1;
9136                     ent->got.offset = s->size;
9137                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9138                       num = 2;
9139                     s->size += num * 8;
9140                     if (info->shared)
9141                       srel->size += num * sizeof (Elf64_External_Rela);
9142                     else if ((*lgot_masks & PLT_IFUNC) != 0)
9143                       {
9144                         htab->reliplt->size
9145                           += num * sizeof (Elf64_External_Rela);
9146                         htab->got_reli_size
9147                           += num * sizeof (Elf64_External_Rela);
9148                       }
9149                     pent = &ent->next;
9150                   }
9151               }
9152             else
9153               *pent = ent->next;
9154         }
9155
9156       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9157       for (; local_plt < end_local_plt; ++local_plt)
9158         {
9159           struct plt_entry *ent;
9160
9161           for (ent = *local_plt; ent != NULL; ent = ent->next)
9162             if (ent->plt.refcount > 0)
9163               {
9164                 s = htab->iplt;
9165                 ent->plt.offset = s->size;
9166                 s->size += PLT_ENTRY_SIZE;
9167
9168                 htab->reliplt->size += sizeof (Elf64_External_Rela);
9169               }
9170             else
9171               ent->plt.offset = (bfd_vma) -1;
9172         }
9173     }
9174
9175   /* Allocate global sym .plt and .got entries, and space for global
9176      sym dynamic relocs.  */
9177   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9178
9179   first_tlsld = NULL;
9180   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9181     {
9182       struct got_entry *ent;
9183
9184       if (!is_ppc64_elf (ibfd))
9185         continue;
9186
9187       ent = ppc64_tlsld_got (ibfd);
9188       if (ent->got.refcount > 0)
9189         {
9190           if (!htab->do_multi_toc && first_tlsld != NULL)
9191             {
9192               ent->is_indirect = TRUE;
9193               ent->got.ent = first_tlsld;
9194             }
9195           else
9196             {
9197               if (first_tlsld == NULL)
9198                 first_tlsld = ent;
9199               s = ppc64_elf_tdata (ibfd)->got;
9200               ent->got.offset = s->size;
9201               ent->owner = ibfd;
9202               s->size += 16;
9203               if (info->shared)
9204                 {
9205                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9206                   srel->size += sizeof (Elf64_External_Rela);
9207                 }
9208             }
9209         }
9210       else
9211         ent->got.offset = (bfd_vma) -1;
9212     }
9213
9214   /* We now have determined the sizes of the various dynamic sections.
9215      Allocate memory for them.  */
9216   relocs = FALSE;
9217   for (s = dynobj->sections; s != NULL; s = s->next)
9218     {
9219       if ((s->flags & SEC_LINKER_CREATED) == 0)
9220         continue;
9221
9222       if (s == htab->brlt || s == htab->relbrlt)
9223         /* These haven't been allocated yet;  don't strip.  */
9224         continue;
9225       else if (s == htab->got
9226                || s == htab->plt
9227                || s == htab->iplt
9228                || s == htab->glink
9229                || s == htab->dynbss)
9230         {
9231           /* Strip this section if we don't need it; see the
9232              comment below.  */
9233         }
9234       else if (s == htab->glink_eh_frame)
9235         {
9236           if (!bfd_is_abs_section (s->output_section))
9237             /* Not sized yet.  */
9238             continue;
9239         }
9240       else if (CONST_STRNEQ (s->name, ".rela"))
9241         {
9242           if (s->size != 0)
9243             {
9244               if (s != htab->relplt)
9245                 relocs = TRUE;
9246
9247               /* We use the reloc_count field as a counter if we need
9248                  to copy relocs into the output file.  */
9249               s->reloc_count = 0;
9250             }
9251         }
9252       else
9253         {
9254           /* It's not one of our sections, so don't allocate space.  */
9255           continue;
9256         }
9257
9258       if (s->size == 0)
9259         {
9260           /* If we don't need this section, strip it from the
9261              output file.  This is mostly to handle .rela.bss and
9262              .rela.plt.  We must create both sections in
9263              create_dynamic_sections, because they must be created
9264              before the linker maps input sections to output
9265              sections.  The linker does that before
9266              adjust_dynamic_symbol is called, and it is that
9267              function which decides whether anything needs to go
9268              into these sections.  */
9269           s->flags |= SEC_EXCLUDE;
9270           continue;
9271         }
9272
9273       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9274         continue;
9275
9276       /* Allocate memory for the section contents.  We use bfd_zalloc
9277          here in case unused entries are not reclaimed before the
9278          section's contents are written out.  This should not happen,
9279          but this way if it does we get a R_PPC64_NONE reloc in .rela
9280          sections instead of garbage.
9281          We also rely on the section contents being zero when writing
9282          the GOT.  */
9283       s->contents = bfd_zalloc (dynobj, s->size);
9284       if (s->contents == NULL)
9285         return FALSE;
9286     }
9287
9288   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9289     {
9290       if (!is_ppc64_elf (ibfd))
9291         continue;
9292
9293       s = ppc64_elf_tdata (ibfd)->got;
9294       if (s != NULL && s != htab->got)
9295         {
9296           if (s->size == 0)
9297             s->flags |= SEC_EXCLUDE;
9298           else
9299             {
9300               s->contents = bfd_zalloc (ibfd, s->size);
9301               if (s->contents == NULL)
9302                 return FALSE;
9303             }
9304         }
9305       s = ppc64_elf_tdata (ibfd)->relgot;
9306       if (s != NULL)
9307         {
9308           if (s->size == 0)
9309             s->flags |= SEC_EXCLUDE;
9310           else
9311             {
9312               s->contents = bfd_zalloc (ibfd, s->size);
9313               if (s->contents == NULL)
9314                 return FALSE;
9315               relocs = TRUE;
9316               s->reloc_count = 0;
9317             }
9318         }
9319     }
9320
9321   if (htab->elf.dynamic_sections_created)
9322     {
9323       /* Add some entries to the .dynamic section.  We fill in the
9324          values later, in ppc64_elf_finish_dynamic_sections, but we
9325          must add the entries now so that we get the correct size for
9326          the .dynamic section.  The DT_DEBUG entry is filled in by the
9327          dynamic linker and used by the debugger.  */
9328 #define add_dynamic_entry(TAG, VAL) \
9329   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9330
9331       if (info->executable)
9332         {
9333           if (!add_dynamic_entry (DT_DEBUG, 0))
9334             return FALSE;
9335         }
9336
9337       if (htab->plt != NULL && htab->plt->size != 0)
9338         {
9339           if (!add_dynamic_entry (DT_PLTGOT, 0)
9340               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9341               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9342               || !add_dynamic_entry (DT_JMPREL, 0)
9343               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9344             return FALSE;
9345         }
9346
9347       if (NO_OPD_RELOCS)
9348         {
9349           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9350               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9351             return FALSE;
9352         }
9353
9354       if (!htab->no_tls_get_addr_opt
9355           && htab->tls_get_addr_fd != NULL
9356           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9357           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9358         return FALSE;
9359
9360       if (relocs)
9361         {
9362           if (!add_dynamic_entry (DT_RELA, 0)
9363               || !add_dynamic_entry (DT_RELASZ, 0)
9364               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9365             return FALSE;
9366
9367           /* If any dynamic relocs apply to a read-only section,
9368              then we need a DT_TEXTREL entry.  */
9369           if ((info->flags & DF_TEXTREL) == 0)
9370             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9371
9372           if ((info->flags & DF_TEXTREL) != 0)
9373             {
9374               if (!add_dynamic_entry (DT_TEXTREL, 0))
9375                 return FALSE;
9376             }
9377         }
9378     }
9379 #undef add_dynamic_entry
9380
9381   return TRUE;
9382 }
9383
9384 /* Determine the type of stub needed, if any, for a call.  */
9385
9386 static inline enum ppc_stub_type
9387 ppc_type_of_stub (asection *input_sec,
9388                   const Elf_Internal_Rela *rel,
9389                   struct ppc_link_hash_entry **hash,
9390                   struct plt_entry **plt_ent,
9391                   bfd_vma destination)
9392 {
9393   struct ppc_link_hash_entry *h = *hash;
9394   bfd_vma location;
9395   bfd_vma branch_offset;
9396   bfd_vma max_branch_offset;
9397   enum elf_ppc64_reloc_type r_type;
9398
9399   if (h != NULL)
9400     {
9401       struct plt_entry *ent;
9402       struct ppc_link_hash_entry *fdh = h;
9403       if (h->oh != NULL
9404           && h->oh->is_func_descriptor)
9405         {
9406           fdh = ppc_follow_link (h->oh);
9407           *hash = fdh;
9408         }
9409
9410       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9411         if (ent->addend == rel->r_addend
9412             && ent->plt.offset != (bfd_vma) -1)
9413           {
9414             *plt_ent = ent;
9415             return ppc_stub_plt_call;
9416           }
9417
9418       /* Here, we know we don't have a plt entry.  If we don't have a
9419          either a defined function descriptor or a defined entry symbol
9420          in a regular object file, then it is pointless trying to make
9421          any other type of stub.  */
9422       if (!is_static_defined (&fdh->elf)
9423           && !is_static_defined (&h->elf))
9424         return ppc_stub_none;
9425     }
9426   else if (elf_local_got_ents (input_sec->owner) != NULL)
9427     {
9428       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9429       struct plt_entry **local_plt = (struct plt_entry **)
9430         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9431       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9432
9433       if (local_plt[r_symndx] != NULL)
9434         {
9435           struct plt_entry *ent;
9436
9437           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9438             if (ent->addend == rel->r_addend
9439                 && ent->plt.offset != (bfd_vma) -1)
9440               {
9441                 *plt_ent = ent;
9442                 return ppc_stub_plt_call;
9443               }
9444         }
9445     }
9446
9447   /* Determine where the call point is.  */
9448   location = (input_sec->output_offset
9449               + input_sec->output_section->vma
9450               + rel->r_offset);
9451
9452   branch_offset = destination - location;
9453   r_type = ELF64_R_TYPE (rel->r_info);
9454
9455   /* Determine if a long branch stub is needed.  */
9456   max_branch_offset = 1 << 25;
9457   if (r_type != R_PPC64_REL24)
9458     max_branch_offset = 1 << 15;
9459
9460   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9461     /* We need a stub.  Figure out whether a long_branch or plt_branch
9462        is needed later.  */
9463     return ppc_stub_long_branch;
9464
9465   return ppc_stub_none;
9466 }
9467
9468 /* Build a .plt call stub.  */
9469
9470 static inline bfd_byte *
9471 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r,
9472                 bfd_boolean plt_static_chain)
9473 {
9474 #define PPC_LO(v) ((v) & 0xffff)
9475 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9476 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9477
9478   if (PPC_HA (offset) != 0)
9479     {
9480       if (r != NULL)
9481         {
9482           r[0].r_offset += 4;
9483           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9484           r[1].r_offset = r[0].r_offset + 4;
9485           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9486           r[1].r_addend = r[0].r_addend;
9487           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9488             {
9489               r[2].r_offset = r[1].r_offset + 4;
9490               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9491               r[2].r_addend = r[0].r_addend;
9492             }
9493           else
9494             {
9495               r[2].r_offset = r[1].r_offset + 8;
9496               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9497               r[2].r_addend = r[0].r_addend + 8;
9498               if (plt_static_chain)
9499                 {
9500                   r[3].r_offset = r[2].r_offset + 4;
9501                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9502                   r[3].r_addend = r[0].r_addend + 16;
9503                 }
9504             }
9505         }
9506       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9507       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9508       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9509       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9510         {
9511           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9512           offset = 0;
9513         }
9514       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9515       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9516       if (plt_static_chain)
9517         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9518       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9519     }
9520   else
9521     {
9522       if (r != NULL)
9523         {
9524           r[0].r_offset += 4;
9525           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9526           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9527             {
9528               r[1].r_offset = r[0].r_offset + 4;
9529               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9530               r[1].r_addend = r[0].r_addend;
9531             }
9532           else
9533             {
9534               r[1].r_offset = r[0].r_offset + 8;
9535               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9536               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9537               if (plt_static_chain)
9538                 {
9539                   r[2].r_offset = r[1].r_offset + 4;
9540                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9541                   r[2].r_addend = r[0].r_addend + 8;
9542                 }
9543             }
9544         }
9545       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9546       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9547       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9548         {
9549           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9550           offset = 0;
9551         }
9552       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9553       if (plt_static_chain)
9554         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9555       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9556       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9557     }
9558   return p;
9559 }
9560
9561 /* Build a special .plt call stub for __tls_get_addr.  */
9562
9563 #define LD_R11_0R3      0xe9630000
9564 #define LD_R12_0R3      0xe9830000
9565 #define MR_R0_R3        0x7c601b78
9566 #define CMPDI_R11_0     0x2c2b0000
9567 #define ADD_R3_R12_R13  0x7c6c6a14
9568 #define BEQLR           0x4d820020
9569 #define MR_R3_R0        0x7c030378
9570 #define MFLR_R11        0x7d6802a6
9571 #define STD_R11_0R1     0xf9610000
9572 #define BCTRL           0x4e800421
9573 #define LD_R11_0R1      0xe9610000
9574 #define LD_R2_0R1       0xe8410000
9575 #define MTLR_R11        0x7d6803a6
9576
9577 static inline bfd_byte *
9578 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9579                          Elf_Internal_Rela *r, bfd_boolean plt_static_chain)
9580 {
9581   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9582   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9583   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9584   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9585   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9586   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9587   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9588   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9589   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9590
9591   if (r != NULL)
9592     r[0].r_offset += 9 * 4;
9593   p = build_plt_stub (obfd, p, offset, r, plt_static_chain);
9594   bfd_put_32 (obfd, BCTRL, p - 4);
9595
9596   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9597   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9598   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9599   bfd_put_32 (obfd, BLR, p),                    p += 4;
9600
9601   return p;
9602 }
9603
9604 static Elf_Internal_Rela *
9605 get_relocs (asection *sec, int count)
9606 {
9607   Elf_Internal_Rela *relocs;
9608   struct bfd_elf_section_data *elfsec_data;
9609
9610   elfsec_data = elf_section_data (sec);
9611   relocs = elfsec_data->relocs;
9612   if (relocs == NULL)
9613     {
9614       bfd_size_type relsize;
9615       relsize = sec->reloc_count * sizeof (*relocs);
9616       relocs = bfd_alloc (sec->owner, relsize);
9617       if (relocs == NULL)
9618         return NULL;
9619       elfsec_data->relocs = relocs;
9620       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9621                                           sizeof (Elf_Internal_Shdr));
9622       if (elfsec_data->rela.hdr == NULL)
9623         return NULL;
9624       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9625                                         * sizeof (Elf64_External_Rela));
9626       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9627       sec->reloc_count = 0;
9628     }
9629   relocs += sec->reloc_count;
9630   sec->reloc_count += count;
9631   return relocs;
9632 }
9633
9634 static bfd_vma
9635 get_r2off (struct bfd_link_info *info,
9636            struct ppc_stub_hash_entry *stub_entry)
9637 {
9638   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9639   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9640
9641   if (r2off == 0)
9642     {
9643       /* Support linking -R objects.  Get the toc pointer from the
9644          opd entry.  */
9645       char buf[8];
9646       asection *opd = stub_entry->h->elf.root.u.def.section;
9647       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9648
9649       if (strcmp (opd->name, ".opd") != 0
9650           || opd->reloc_count != 0)
9651         {
9652           info->callbacks->einfo (_("%P: cannot find opd entry toc for %s\n"),
9653                                   stub_entry->h->elf.root.root.string);
9654           bfd_set_error (bfd_error_bad_value);
9655           return 0;
9656         }
9657       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9658         return 0;
9659       r2off = bfd_get_64 (opd->owner, buf);
9660       r2off -= elf_gp (info->output_bfd);
9661     }
9662   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9663   return r2off;
9664 }
9665
9666 static bfd_boolean
9667 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9668 {
9669   struct ppc_stub_hash_entry *stub_entry;
9670   struct ppc_branch_hash_entry *br_entry;
9671   struct bfd_link_info *info;
9672   struct ppc_link_hash_table *htab;
9673   bfd_byte *loc;
9674   bfd_byte *p;
9675   bfd_vma dest, off;
9676   int size;
9677   Elf_Internal_Rela *r;
9678   asection *plt;
9679
9680   /* Massage our args to the form they really have.  */
9681   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9682   info = in_arg;
9683
9684   htab = ppc_hash_table (info);
9685   if (htab == NULL)
9686     return FALSE;
9687
9688   /* Make a note of the offset within the stubs for this entry.  */
9689   stub_entry->stub_offset = stub_entry->stub_sec->size;
9690   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9691
9692   htab->stub_count[stub_entry->stub_type - 1] += 1;
9693   switch (stub_entry->stub_type)
9694     {
9695     case ppc_stub_long_branch:
9696     case ppc_stub_long_branch_r2off:
9697       /* Branches are relative.  This is where we are going to.  */
9698       off = dest = (stub_entry->target_value
9699                     + stub_entry->target_section->output_offset
9700                     + stub_entry->target_section->output_section->vma);
9701
9702       /* And this is where we are coming from.  */
9703       off -= (stub_entry->stub_offset
9704               + stub_entry->stub_sec->output_offset
9705               + stub_entry->stub_sec->output_section->vma);
9706
9707       size = 4;
9708       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9709         {
9710           bfd_vma r2off = get_r2off (info, stub_entry);
9711
9712           if (r2off == 0)
9713             {
9714               htab->stub_error = TRUE;
9715               return FALSE;
9716             }
9717           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9718           loc += 4;
9719           size = 12;
9720           if (PPC_HA (r2off) != 0)
9721             {
9722               size = 16;
9723               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9724               loc += 4;
9725             }
9726           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9727           loc += 4;
9728           off -= size - 4;
9729         }
9730       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9731
9732       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9733         {
9734           info->callbacks->einfo (_("%P: long branch stub `%s' offset overflow\n"),
9735                                   stub_entry->root.string);
9736           htab->stub_error = TRUE;
9737           return FALSE;
9738         }
9739
9740       if (info->emitrelocations)
9741         {
9742           r = get_relocs (stub_entry->stub_sec, 1);
9743           if (r == NULL)
9744             return FALSE;
9745           r->r_offset = loc - stub_entry->stub_sec->contents;
9746           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9747           r->r_addend = dest;
9748           if (stub_entry->h != NULL)
9749             {
9750               struct elf_link_hash_entry **hashes;
9751               unsigned long symndx;
9752               struct ppc_link_hash_entry *h;
9753
9754               hashes = elf_sym_hashes (htab->stub_bfd);
9755               if (hashes == NULL)
9756                 {
9757                   bfd_size_type hsize;
9758
9759                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9760                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9761                   if (hashes == NULL)
9762                     return FALSE;
9763                   elf_sym_hashes (htab->stub_bfd) = hashes;
9764                   htab->stub_globals = 1;
9765                 }
9766               symndx = htab->stub_globals++;
9767               h = stub_entry->h;
9768               hashes[symndx] = &h->elf;
9769               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9770               if (h->oh != NULL && h->oh->is_func)
9771                 h = ppc_follow_link (h->oh);
9772               if (h->elf.root.u.def.section != stub_entry->target_section)
9773                 /* H is an opd symbol.  The addend must be zero.  */
9774                 r->r_addend = 0;
9775               else
9776                 {
9777                   off = (h->elf.root.u.def.value
9778                          + h->elf.root.u.def.section->output_offset
9779                          + h->elf.root.u.def.section->output_section->vma);
9780                   r->r_addend -= off;
9781                 }
9782             }
9783         }
9784       break;
9785
9786     case ppc_stub_plt_branch:
9787     case ppc_stub_plt_branch_r2off:
9788       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9789                                          stub_entry->root.string + 9,
9790                                          FALSE, FALSE);
9791       if (br_entry == NULL)
9792         {
9793           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
9794                                   stub_entry->root.string);
9795           htab->stub_error = TRUE;
9796           return FALSE;
9797         }
9798
9799       dest = (stub_entry->target_value
9800               + stub_entry->target_section->output_offset
9801               + stub_entry->target_section->output_section->vma);
9802
9803       bfd_put_64 (htab->brlt->owner, dest,
9804                   htab->brlt->contents + br_entry->offset);
9805
9806       if (br_entry->iter == htab->stub_iteration)
9807         {
9808           br_entry->iter = 0;
9809
9810           if (htab->relbrlt != NULL)
9811             {
9812               /* Create a reloc for the branch lookup table entry.  */
9813               Elf_Internal_Rela rela;
9814               bfd_byte *rl;
9815
9816               rela.r_offset = (br_entry->offset
9817                                + htab->brlt->output_offset
9818                                + htab->brlt->output_section->vma);
9819               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9820               rela.r_addend = dest;
9821
9822               rl = htab->relbrlt->contents;
9823               rl += (htab->relbrlt->reloc_count++
9824                      * sizeof (Elf64_External_Rela));
9825               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9826             }
9827           else if (info->emitrelocations)
9828             {
9829               r = get_relocs (htab->brlt, 1);
9830               if (r == NULL)
9831                 return FALSE;
9832               /* brlt, being SEC_LINKER_CREATED does not go through the
9833                  normal reloc processing.  Symbols and offsets are not
9834                  translated from input file to output file form, so
9835                  set up the offset per the output file.  */
9836               r->r_offset = (br_entry->offset
9837                              + htab->brlt->output_offset
9838                              + htab->brlt->output_section->vma);
9839               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9840               r->r_addend = dest;
9841             }
9842         }
9843
9844       dest = (br_entry->offset
9845               + htab->brlt->output_offset
9846               + htab->brlt->output_section->vma);
9847
9848       off = (dest
9849              - elf_gp (htab->brlt->output_section->owner)
9850              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9851
9852       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9853         {
9854           info->callbacks->einfo
9855             (_("%P: linkage table error against `%s'\n"),
9856              stub_entry->root.string);
9857           bfd_set_error (bfd_error_bad_value);
9858           htab->stub_error = TRUE;
9859           return FALSE;
9860         }
9861
9862       if (info->emitrelocations)
9863         {
9864           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9865           if (r == NULL)
9866             return FALSE;
9867           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9868           if (bfd_big_endian (info->output_bfd))
9869             r[0].r_offset += 2;
9870           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9871             r[0].r_offset += 4;
9872           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9873           r[0].r_addend = dest;
9874           if (PPC_HA (off) != 0)
9875             {
9876               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9877               r[1].r_offset = r[0].r_offset + 4;
9878               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9879               r[1].r_addend = r[0].r_addend;
9880             }
9881         }
9882
9883       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9884         {
9885           if (PPC_HA (off) != 0)
9886             {
9887               size = 16;
9888               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9889               loc += 4;
9890               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9891             }
9892           else
9893             {
9894               size = 12;
9895               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9896             }
9897         }
9898       else
9899         {
9900           bfd_vma r2off = get_r2off (info, stub_entry);
9901
9902           if (r2off == 0)
9903             {
9904               htab->stub_error = TRUE;
9905               return FALSE;
9906             }
9907
9908           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9909           loc += 4;
9910           size = 20;
9911           if (PPC_HA (off) != 0)
9912             {
9913               size += 4;
9914               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9915               loc += 4;
9916               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9917               loc += 4;
9918             }
9919           else
9920             {
9921               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9922               loc += 4;
9923             }
9924
9925           if (PPC_HA (r2off) != 0)
9926             {
9927               size += 4;
9928               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9929               loc += 4;
9930             }
9931           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9932         }
9933       loc += 4;
9934       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9935       loc += 4;
9936       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9937       break;
9938
9939     case ppc_stub_plt_call:
9940       if (stub_entry->h != NULL
9941           && stub_entry->h->is_func_descriptor
9942           && stub_entry->h->oh != NULL)
9943         {
9944           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9945
9946           /* If the old-ABI "dot-symbol" is undefined make it weak so
9947              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9948              FIXME: We used to define the symbol on one of the call
9949              stubs instead, which is why we test symbol section id
9950              against htab->top_id in various places.  Likely all
9951              these checks could now disappear.  */
9952           if (fh->elf.root.type == bfd_link_hash_undefined)
9953             fh->elf.root.type = bfd_link_hash_undefweak;
9954           /* Stop undo_symbol_twiddle changing it back to undefined.  */
9955           fh->was_undefined = 0;
9956         }
9957
9958       /* Now build the stub.  */
9959       dest = stub_entry->plt_ent->plt.offset & ~1;
9960       if (dest >= (bfd_vma) -2)
9961         abort ();
9962
9963       plt = htab->plt;
9964       if (!htab->elf.dynamic_sections_created
9965           || stub_entry->h == NULL
9966           || stub_entry->h->elf.dynindx == -1)
9967         plt = htab->iplt;
9968
9969       dest += plt->output_offset + plt->output_section->vma;
9970
9971       if (stub_entry->h == NULL
9972           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9973         {
9974           Elf_Internal_Rela rela;
9975           bfd_byte *rl;
9976
9977           rela.r_offset = dest;
9978           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9979           rela.r_addend = (stub_entry->target_value
9980                            + stub_entry->target_section->output_offset
9981                            + stub_entry->target_section->output_section->vma);
9982
9983           rl = (htab->reliplt->contents
9984                 + (htab->reliplt->reloc_count++
9985                    * sizeof (Elf64_External_Rela)));
9986           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9987           stub_entry->plt_ent->plt.offset |= 1;
9988         }
9989
9990       off = (dest
9991              - elf_gp (plt->output_section->owner)
9992              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9993
9994       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9995         {
9996           info->callbacks->einfo
9997             (_("%P: linkage table error against `%s'\n"),
9998              stub_entry->h != NULL
9999              ? stub_entry->h->elf.root.root.string
10000              : "<local sym>");
10001           bfd_set_error (bfd_error_bad_value);
10002           htab->stub_error = TRUE;
10003           return FALSE;
10004         }
10005
10006       r = NULL;
10007       if (info->emitrelocations)
10008         {
10009           r = get_relocs (stub_entry->stub_sec,
10010                           (2
10011                            + (PPC_HA (off) != 0)
10012                            + (htab->plt_static_chain
10013                               && PPC_HA (off + 16) == PPC_HA (off))));
10014           if (r == NULL)
10015             return FALSE;
10016           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10017           if (bfd_big_endian (info->output_bfd))
10018             r[0].r_offset += 2;
10019           r[0].r_addend = dest;
10020         }
10021       if (stub_entry->h != NULL
10022           && (stub_entry->h == htab->tls_get_addr_fd
10023               || stub_entry->h == htab->tls_get_addr)
10024           && !htab->no_tls_get_addr_opt)
10025         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r,
10026                                      htab->plt_static_chain);
10027       else
10028         p = build_plt_stub (htab->stub_bfd, loc, off, r,
10029                             htab->plt_static_chain);
10030       size = p - loc;
10031       break;
10032
10033     default:
10034       BFD_FAIL ();
10035       return FALSE;
10036     }
10037
10038   stub_entry->stub_sec->size += size;
10039
10040   if (htab->emit_stub_syms)
10041     {
10042       struct elf_link_hash_entry *h;
10043       size_t len1, len2;
10044       char *name;
10045       const char *const stub_str[] = { "long_branch",
10046                                        "long_branch_r2off",
10047                                        "plt_branch",
10048                                        "plt_branch_r2off",
10049                                        "plt_call" };
10050
10051       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10052       len2 = strlen (stub_entry->root.string);
10053       name = bfd_malloc (len1 + len2 + 2);
10054       if (name == NULL)
10055         return FALSE;
10056       memcpy (name, stub_entry->root.string, 9);
10057       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10058       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10059       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10060       if (h == NULL)
10061         return FALSE;
10062       if (h->root.type == bfd_link_hash_new)
10063         {
10064           h->root.type = bfd_link_hash_defined;
10065           h->root.u.def.section = stub_entry->stub_sec;
10066           h->root.u.def.value = stub_entry->stub_offset;
10067           h->ref_regular = 1;
10068           h->def_regular = 1;
10069           h->ref_regular_nonweak = 1;
10070           h->forced_local = 1;
10071           h->non_elf = 0;
10072         }
10073     }
10074
10075   return TRUE;
10076 }
10077
10078 /* As above, but don't actually build the stub.  Just bump offset so
10079    we know stub section sizes, and select plt_branch stubs where
10080    long_branch stubs won't do.  */
10081
10082 static bfd_boolean
10083 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10084 {
10085   struct ppc_stub_hash_entry *stub_entry;
10086   struct bfd_link_info *info;
10087   struct ppc_link_hash_table *htab;
10088   bfd_vma off;
10089   int size;
10090
10091   /* Massage our args to the form they really have.  */
10092   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10093   info = in_arg;
10094
10095   htab = ppc_hash_table (info);
10096   if (htab == NULL)
10097     return FALSE;
10098
10099   if (stub_entry->stub_type == ppc_stub_plt_call)
10100     {
10101       asection *plt;
10102       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10103       if (off >= (bfd_vma) -2)
10104         abort ();
10105       plt = htab->plt;
10106       if (!htab->elf.dynamic_sections_created
10107           || stub_entry->h == NULL
10108           || stub_entry->h->elf.dynindx == -1)
10109         plt = htab->iplt;
10110       off += (plt->output_offset
10111               + plt->output_section->vma
10112               - elf_gp (plt->output_section->owner)
10113               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10114
10115       size = PLT_CALL_STUB_SIZE;
10116       if (!htab->plt_static_chain)
10117         size -= 4;
10118       if (PPC_HA (off) == 0)
10119         size -= 4;
10120       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10121         size += 4;
10122       if (stub_entry->h != NULL
10123           && (stub_entry->h == htab->tls_get_addr_fd
10124               || stub_entry->h == htab->tls_get_addr)
10125           && !htab->no_tls_get_addr_opt)
10126         size += 13 * 4;
10127       if (info->emitrelocations)
10128         {
10129           stub_entry->stub_sec->reloc_count
10130             += (2
10131                 + (PPC_HA (off) != 0)
10132                 + (htab->plt_static_chain
10133                    && PPC_HA (off + 16) == PPC_HA (off)));
10134           stub_entry->stub_sec->flags |= SEC_RELOC;
10135         }
10136     }
10137   else
10138     {
10139       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10140          variants.  */
10141       bfd_vma r2off = 0;
10142
10143       off = (stub_entry->target_value
10144              + stub_entry->target_section->output_offset
10145              + stub_entry->target_section->output_section->vma);
10146       off -= (stub_entry->stub_sec->size
10147               + stub_entry->stub_sec->output_offset
10148               + stub_entry->stub_sec->output_section->vma);
10149
10150       /* Reset the stub type from the plt variant in case we now
10151          can reach with a shorter stub.  */
10152       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10153         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10154
10155       size = 4;
10156       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10157         {
10158           r2off = get_r2off (info, stub_entry);
10159           if (r2off == 0)
10160             {
10161               htab->stub_error = TRUE;
10162               return FALSE;
10163             }
10164           size = 12;
10165           if (PPC_HA (r2off) != 0)
10166             size = 16;
10167           off -= size - 4;
10168         }
10169
10170       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
10171       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10172         {
10173           struct ppc_branch_hash_entry *br_entry;
10174
10175           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10176                                              stub_entry->root.string + 9,
10177                                              TRUE, FALSE);
10178           if (br_entry == NULL)
10179             {
10180               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10181                                       stub_entry->root.string);
10182               htab->stub_error = TRUE;
10183               return FALSE;
10184             }
10185
10186           if (br_entry->iter != htab->stub_iteration)
10187             {
10188               br_entry->iter = htab->stub_iteration;
10189               br_entry->offset = htab->brlt->size;
10190               htab->brlt->size += 8;
10191
10192               if (htab->relbrlt != NULL)
10193                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10194               else if (info->emitrelocations)
10195                 {
10196                   htab->brlt->reloc_count += 1;
10197                   htab->brlt->flags |= SEC_RELOC;
10198                 }
10199             }
10200
10201           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10202           off = (br_entry->offset
10203                  + htab->brlt->output_offset
10204                  + htab->brlt->output_section->vma
10205                  - elf_gp (htab->brlt->output_section->owner)
10206                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10207
10208           if (info->emitrelocations)
10209             {
10210               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10211               stub_entry->stub_sec->flags |= SEC_RELOC;
10212             }
10213
10214           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10215             {
10216               size = 12;
10217               if (PPC_HA (off) != 0)
10218                 size = 16;
10219             }
10220           else
10221             {
10222               size = 20;
10223               if (PPC_HA (off) != 0)
10224                 size += 4;
10225
10226               if (PPC_HA (r2off) != 0)
10227                 size += 4;
10228             }
10229         }
10230       else if (info->emitrelocations)
10231         {
10232           stub_entry->stub_sec->reloc_count += 1;
10233           stub_entry->stub_sec->flags |= SEC_RELOC;
10234         }
10235     }
10236
10237   stub_entry->stub_sec->size += size;
10238   return TRUE;
10239 }
10240
10241 /* Set up various things so that we can make a list of input sections
10242    for each output section included in the link.  Returns -1 on error,
10243    0 when no stubs will be needed, and 1 on success.  */
10244
10245 int
10246 ppc64_elf_setup_section_lists
10247   (struct bfd_link_info *info,
10248    asection *(*add_stub_section) (const char *, asection *),
10249    void (*layout_sections_again) (void))
10250 {
10251   bfd *input_bfd;
10252   int top_id, top_index, id;
10253   asection *section;
10254   asection **input_list;
10255   bfd_size_type amt;
10256   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10257
10258   if (htab == NULL)
10259     return -1;
10260   /* Stash our params away.  */
10261   htab->add_stub_section = add_stub_section;
10262   htab->layout_sections_again = layout_sections_again;
10263
10264   if (htab->brlt == NULL)
10265     return 0;
10266
10267   /* Find the top input section id.  */
10268   for (input_bfd = info->input_bfds, top_id = 3;
10269        input_bfd != NULL;
10270        input_bfd = input_bfd->link_next)
10271     {
10272       for (section = input_bfd->sections;
10273            section != NULL;
10274            section = section->next)
10275         {
10276           if (top_id < section->id)
10277             top_id = section->id;
10278         }
10279     }
10280
10281   htab->top_id = top_id;
10282   amt = sizeof (struct map_stub) * (top_id + 1);
10283   htab->stub_group = bfd_zmalloc (amt);
10284   if (htab->stub_group == NULL)
10285     return -1;
10286
10287   /* Set toc_off for com, und, abs and ind sections.  */
10288   for (id = 0; id < 3; id++)
10289     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10290
10291   /* We can't use output_bfd->section_count here to find the top output
10292      section index as some sections may have been removed, and
10293      strip_excluded_output_sections doesn't renumber the indices.  */
10294   for (section = info->output_bfd->sections, top_index = 0;
10295        section != NULL;
10296        section = section->next)
10297     {
10298       if (top_index < section->index)
10299         top_index = section->index;
10300     }
10301
10302   htab->top_index = top_index;
10303   amt = sizeof (asection *) * (top_index + 1);
10304   input_list = bfd_zmalloc (amt);
10305   htab->input_list = input_list;
10306   if (input_list == NULL)
10307     return -1;
10308
10309   return 1;
10310 }
10311
10312 /* Set up for first pass at multitoc partitioning.  */
10313
10314 void
10315 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10316 {
10317   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10318
10319   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10320   htab->toc_curr = elf_gp (info->output_bfd);
10321   htab->toc_bfd = NULL;
10322   htab->toc_first_sec = NULL;
10323 }
10324
10325 /* The linker repeatedly calls this function for each TOC input section
10326    and linker generated GOT section.  Group input bfds such that the toc
10327    within a group is less than 64k in size.  */
10328
10329 bfd_boolean
10330 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10331 {
10332   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10333   bfd_vma addr, off, limit;
10334
10335   if (htab == NULL)
10336     return FALSE;
10337
10338   if (!htab->second_toc_pass)
10339     {
10340       /* Keep track of the first .toc or .got section for this input bfd.  */
10341       if (htab->toc_bfd != isec->owner)
10342         {
10343           htab->toc_bfd = isec->owner;
10344           htab->toc_first_sec = isec;
10345         }
10346
10347       addr = isec->output_offset + isec->output_section->vma;
10348       off = addr - htab->toc_curr;
10349       limit = 0x80008000;
10350       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10351         limit = 0x10000;
10352       if (off + isec->size > limit)
10353         {
10354           addr = (htab->toc_first_sec->output_offset
10355                   + htab->toc_first_sec->output_section->vma);
10356           htab->toc_curr = addr;
10357         }
10358
10359       /* toc_curr is the base address of this toc group.  Set elf_gp
10360          for the input section to be the offset relative to the
10361          output toc base plus 0x8000.  Making the input elf_gp an
10362          offset allows us to move the toc as a whole without
10363          recalculating input elf_gp.  */
10364       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10365       off += TOC_BASE_OFF;
10366
10367       /* Die if someone uses a linker script that doesn't keep input
10368          file .toc and .got together.  */
10369       if (elf_gp (isec->owner) != 0
10370           && elf_gp (isec->owner) != off)
10371         return FALSE;
10372
10373       elf_gp (isec->owner) = off;
10374       return TRUE;
10375     }
10376
10377   /* During the second pass toc_first_sec points to the start of
10378      a toc group, and toc_curr is used to track the old elf_gp.
10379      We use toc_bfd to ensure we only look at each bfd once.  */
10380   if (htab->toc_bfd == isec->owner)
10381     return TRUE;
10382   htab->toc_bfd = isec->owner;
10383
10384   if (htab->toc_first_sec == NULL
10385       || htab->toc_curr != elf_gp (isec->owner))
10386     {
10387       htab->toc_curr = elf_gp (isec->owner);
10388       htab->toc_first_sec = isec;
10389     }
10390   addr = (htab->toc_first_sec->output_offset
10391           + htab->toc_first_sec->output_section->vma);
10392   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10393   elf_gp (isec->owner) = off;
10394
10395   return TRUE;
10396 }
10397
10398 /* Called via elf_link_hash_traverse to merge GOT entries for global
10399    symbol H.  */
10400
10401 static bfd_boolean
10402 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10403 {
10404   if (h->root.type == bfd_link_hash_indirect)
10405     return TRUE;
10406
10407   merge_got_entries (&h->got.glist);
10408
10409   return TRUE;
10410 }
10411
10412 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10413    symbol H.  */
10414
10415 static bfd_boolean
10416 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10417 {
10418   struct got_entry *gent;
10419
10420   if (h->root.type == bfd_link_hash_indirect)
10421     return TRUE;
10422
10423   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10424     if (!gent->is_indirect)
10425       allocate_got (h, (struct bfd_link_info *) inf, gent);
10426   return TRUE;
10427 }
10428
10429 /* Called on the first multitoc pass after the last call to
10430    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10431    entries.  */
10432
10433 bfd_boolean
10434 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10435 {
10436   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10437   struct bfd *ibfd, *ibfd2;
10438   bfd_boolean done_something;
10439
10440   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10441
10442   if (!htab->do_multi_toc)
10443     return FALSE;
10444
10445   /* Merge global sym got entries within a toc group.  */
10446   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10447
10448   /* And tlsld_got.  */
10449   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10450     {
10451       struct got_entry *ent, *ent2;
10452
10453       if (!is_ppc64_elf (ibfd))
10454         continue;
10455
10456       ent = ppc64_tlsld_got (ibfd);
10457       if (!ent->is_indirect
10458           && ent->got.offset != (bfd_vma) -1)
10459         {
10460           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10461             {
10462               if (!is_ppc64_elf (ibfd2))
10463                 continue;
10464
10465               ent2 = ppc64_tlsld_got (ibfd2);
10466               if (!ent2->is_indirect
10467                   && ent2->got.offset != (bfd_vma) -1
10468                   && elf_gp (ibfd2) == elf_gp (ibfd))
10469                 {
10470                   ent2->is_indirect = TRUE;
10471                   ent2->got.ent = ent;
10472                 }
10473             }
10474         }
10475     }
10476
10477   /* Zap sizes of got sections.  */
10478   htab->reliplt->rawsize = htab->reliplt->size;
10479   htab->reliplt->size -= htab->got_reli_size;
10480   htab->got_reli_size = 0;
10481
10482   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10483     {
10484       asection *got, *relgot;
10485
10486       if (!is_ppc64_elf (ibfd))
10487         continue;
10488
10489       got = ppc64_elf_tdata (ibfd)->got;
10490       if (got != NULL)
10491         {
10492           got->rawsize = got->size;
10493           got->size = 0;
10494           relgot = ppc64_elf_tdata (ibfd)->relgot;
10495           relgot->rawsize = relgot->size;
10496           relgot->size = 0;
10497         }
10498     }
10499
10500   /* Now reallocate the got, local syms first.  We don't need to
10501      allocate section contents again since we never increase size.  */
10502   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10503     {
10504       struct got_entry **lgot_ents;
10505       struct got_entry **end_lgot_ents;
10506       struct plt_entry **local_plt;
10507       struct plt_entry **end_local_plt;
10508       unsigned char *lgot_masks;
10509       bfd_size_type locsymcount;
10510       Elf_Internal_Shdr *symtab_hdr;
10511       asection *s, *srel;
10512
10513       if (!is_ppc64_elf (ibfd))
10514         continue;
10515
10516       lgot_ents = elf_local_got_ents (ibfd);
10517       if (!lgot_ents)
10518         continue;
10519
10520       symtab_hdr = &elf_symtab_hdr (ibfd);
10521       locsymcount = symtab_hdr->sh_info;
10522       end_lgot_ents = lgot_ents + locsymcount;
10523       local_plt = (struct plt_entry **) end_lgot_ents;
10524       end_local_plt = local_plt + locsymcount;
10525       lgot_masks = (unsigned char *) end_local_plt;
10526       s = ppc64_elf_tdata (ibfd)->got;
10527       srel = ppc64_elf_tdata (ibfd)->relgot;
10528       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10529         {
10530           struct got_entry *ent;
10531
10532           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10533             {
10534               unsigned int num = 1;
10535               ent->got.offset = s->size;
10536               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10537                 num = 2;
10538               s->size += num * 8;
10539               if (info->shared)
10540                 srel->size += num * sizeof (Elf64_External_Rela);
10541               else if ((*lgot_masks & PLT_IFUNC) != 0)
10542                 {
10543                   htab->reliplt->size
10544                     += num * sizeof (Elf64_External_Rela);
10545                   htab->got_reli_size
10546                     += num * sizeof (Elf64_External_Rela);
10547                 }
10548             }
10549         }
10550     }
10551
10552   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10553
10554   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10555     {
10556       struct got_entry *ent;
10557
10558       if (!is_ppc64_elf (ibfd))
10559         continue;
10560
10561       ent = ppc64_tlsld_got (ibfd);
10562       if (!ent->is_indirect
10563           && ent->got.offset != (bfd_vma) -1)
10564         {
10565           asection *s = ppc64_elf_tdata (ibfd)->got;
10566           ent->got.offset = s->size;
10567           s->size += 16;
10568           if (info->shared)
10569             {
10570               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10571               srel->size += sizeof (Elf64_External_Rela);
10572             }
10573         }
10574     }
10575
10576   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10577   if (!done_something)
10578     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10579       {
10580         asection *got;
10581
10582         if (!is_ppc64_elf (ibfd))
10583           continue;
10584
10585         got = ppc64_elf_tdata (ibfd)->got;
10586         if (got != NULL)
10587           {
10588             done_something = got->rawsize != got->size;
10589             if (done_something)
10590               break;
10591           }
10592       }
10593
10594   if (done_something)
10595     (*htab->layout_sections_again) ();
10596
10597   /* Set up for second pass over toc sections to recalculate elf_gp
10598      on input sections.  */
10599   htab->toc_bfd = NULL;
10600   htab->toc_first_sec = NULL;
10601   htab->second_toc_pass = TRUE;
10602   return done_something;
10603 }
10604
10605 /* Called after second pass of multitoc partitioning.  */
10606
10607 void
10608 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10609 {
10610   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10611
10612   /* After the second pass, toc_curr tracks the TOC offset used
10613      for code sections below in ppc64_elf_next_input_section.  */
10614   htab->toc_curr = TOC_BASE_OFF;
10615 }
10616
10617 /* No toc references were found in ISEC.  If the code in ISEC makes no
10618    calls, then there's no need to use toc adjusting stubs when branching
10619    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10620    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10621    needed, and 2 if a cyclical call-graph was found but no other reason
10622    for a stub was detected.  If called from the top level, a return of
10623    2 means the same as a return of 0.  */
10624
10625 static int
10626 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10627 {
10628   int ret;
10629
10630   /* Mark this section as checked.  */
10631   isec->call_check_done = 1;
10632
10633   /* We know none of our code bearing sections will need toc stubs.  */
10634   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10635     return 0;
10636
10637   if (isec->size == 0)
10638     return 0;
10639
10640   if (isec->output_section == NULL)
10641     return 0;
10642
10643   ret = 0;
10644   if (isec->reloc_count != 0)
10645     {
10646       Elf_Internal_Rela *relstart, *rel;
10647       Elf_Internal_Sym *local_syms;
10648       struct ppc_link_hash_table *htab;
10649
10650       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10651                                             info->keep_memory);
10652       if (relstart == NULL)
10653         return -1;
10654
10655       /* Look for branches to outside of this section.  */
10656       local_syms = NULL;
10657       htab = ppc_hash_table (info);
10658       if (htab == NULL)
10659         return -1;
10660
10661       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10662         {
10663           enum elf_ppc64_reloc_type r_type;
10664           unsigned long r_symndx;
10665           struct elf_link_hash_entry *h;
10666           struct ppc_link_hash_entry *eh;
10667           Elf_Internal_Sym *sym;
10668           asection *sym_sec;
10669           struct _opd_sec_data *opd;
10670           bfd_vma sym_value;
10671           bfd_vma dest;
10672
10673           r_type = ELF64_R_TYPE (rel->r_info);
10674           if (r_type != R_PPC64_REL24
10675               && r_type != R_PPC64_REL14
10676               && r_type != R_PPC64_REL14_BRTAKEN
10677               && r_type != R_PPC64_REL14_BRNTAKEN)
10678             continue;
10679
10680           r_symndx = ELF64_R_SYM (rel->r_info);
10681           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10682                           isec->owner))
10683             {
10684               ret = -1;
10685               break;
10686             }
10687
10688           /* Calls to dynamic lib functions go through a plt call stub
10689              that uses r2.  */
10690           eh = (struct ppc_link_hash_entry *) h;
10691           if (eh != NULL
10692               && (eh->elf.plt.plist != NULL
10693                   || (eh->oh != NULL
10694                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10695             {
10696               ret = 1;
10697               break;
10698             }
10699
10700           if (sym_sec == NULL)
10701             /* Ignore other undefined symbols.  */
10702             continue;
10703
10704           /* Assume branches to other sections not included in the
10705              link need stubs too, to cover -R and absolute syms.  */
10706           if (sym_sec->output_section == NULL)
10707             {
10708               ret = 1;
10709               break;
10710             }
10711
10712           if (h == NULL)
10713             sym_value = sym->st_value;
10714           else
10715             {
10716               if (h->root.type != bfd_link_hash_defined
10717                   && h->root.type != bfd_link_hash_defweak)
10718                 abort ();
10719               sym_value = h->root.u.def.value;
10720             }
10721           sym_value += rel->r_addend;
10722
10723           /* If this branch reloc uses an opd sym, find the code section.  */
10724           opd = get_opd_info (sym_sec);
10725           if (opd != NULL)
10726             {
10727               if (h == NULL && opd->adjust != NULL)
10728                 {
10729                   long adjust;
10730
10731                   adjust = opd->adjust[sym->st_value / 8];
10732                   if (adjust == -1)
10733                     /* Assume deleted functions won't ever be called.  */
10734                     continue;
10735                   sym_value += adjust;
10736                 }
10737
10738               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10739               if (dest == (bfd_vma) -1)
10740                 continue;
10741             }
10742           else
10743             dest = (sym_value
10744                     + sym_sec->output_offset
10745                     + sym_sec->output_section->vma);
10746
10747           /* Ignore branch to self.  */
10748           if (sym_sec == isec)
10749             continue;
10750
10751           /* If the called function uses the toc, we need a stub.  */
10752           if (sym_sec->has_toc_reloc
10753               || sym_sec->makes_toc_func_call)
10754             {
10755               ret = 1;
10756               break;
10757             }
10758
10759           /* Assume any branch that needs a long branch stub might in fact
10760              need a plt_branch stub.  A plt_branch stub uses r2.  */
10761           else if (dest - (isec->output_offset
10762                            + isec->output_section->vma
10763                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10764             {
10765               ret = 1;
10766               break;
10767             }
10768
10769           /* If calling back to a section in the process of being
10770              tested, we can't say for sure that no toc adjusting stubs
10771              are needed, so don't return zero.  */
10772           else if (sym_sec->call_check_in_progress)
10773             ret = 2;
10774
10775           /* Branches to another section that itself doesn't have any TOC
10776              references are OK.  Recursively call ourselves to check.  */
10777           else if (!sym_sec->call_check_done)
10778             {
10779               int recur;
10780
10781               /* Mark current section as indeterminate, so that other
10782                  sections that call back to current won't be marked as
10783                  known.  */
10784               isec->call_check_in_progress = 1;
10785               recur = toc_adjusting_stub_needed (info, sym_sec);
10786               isec->call_check_in_progress = 0;
10787
10788               if (recur != 0)
10789                 {
10790                   ret = recur;
10791                   if (recur != 2)
10792                     break;
10793                 }
10794             }
10795         }
10796
10797       if (local_syms != NULL
10798           && (elf_symtab_hdr (isec->owner).contents
10799               != (unsigned char *) local_syms))
10800         free (local_syms);
10801       if (elf_section_data (isec)->relocs != relstart)
10802         free (relstart);
10803     }
10804
10805   if ((ret & 1) == 0
10806       && isec->map_head.s != NULL
10807       && (strcmp (isec->output_section->name, ".init") == 0
10808           || strcmp (isec->output_section->name, ".fini") == 0))
10809     {
10810       if (isec->map_head.s->has_toc_reloc
10811           || isec->map_head.s->makes_toc_func_call)
10812         ret = 1;
10813       else if (!isec->map_head.s->call_check_done)
10814         {
10815           int recur;
10816           isec->call_check_in_progress = 1;
10817           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10818           isec->call_check_in_progress = 0;
10819           if (recur != 0)
10820             ret = recur;
10821         }
10822     }
10823
10824   if (ret == 1)
10825     isec->makes_toc_func_call = 1;
10826
10827   return ret;
10828 }
10829
10830 /* The linker repeatedly calls this function for each input section,
10831    in the order that input sections are linked into output sections.
10832    Build lists of input sections to determine groupings between which
10833    we may insert linker stubs.  */
10834
10835 bfd_boolean
10836 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10837 {
10838   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10839
10840   if (htab == NULL)
10841     return FALSE;
10842
10843   if ((isec->output_section->flags & SEC_CODE) != 0
10844       && isec->output_section->index <= htab->top_index)
10845     {
10846       asection **list = htab->input_list + isec->output_section->index;
10847       /* Steal the link_sec pointer for our list.  */
10848 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10849       /* This happens to make the list in reverse order,
10850          which is what we want.  */
10851       PREV_SEC (isec) = *list;
10852       *list = isec;
10853     }
10854
10855   if (htab->multi_toc_needed)
10856     {
10857       /* If a code section has a function that uses the TOC then we need
10858          to use the right TOC (obviously).  Also, make sure that .opd gets
10859          the correct TOC value for R_PPC64_TOC relocs that don't have or
10860          can't find their function symbol (shouldn't ever happen now).
10861          Also specially treat .fixup for the linux kernel.  .fixup
10862          contains branches, but only back to the function that hit an
10863          exception.  */
10864       if (isec->has_toc_reloc
10865           || (isec->flags & SEC_CODE) == 0
10866           || strcmp (isec->name, ".fixup") == 0)
10867         {
10868           if (elf_gp (isec->owner) != 0)
10869             htab->toc_curr = elf_gp (isec->owner);
10870         }
10871       else
10872         {
10873           if (!isec->call_check_done
10874               && toc_adjusting_stub_needed (info, isec) < 0)
10875             return FALSE;
10876           /* If we make a local call from this section, ie. a branch
10877              without a following nop, then we have no place to put a
10878              toc restoring insn.  We must use the same toc group as
10879              the callee.
10880              Testing makes_toc_func_call actually tests for *any*
10881              calls to functions that need a good toc pointer.  A more
10882              precise test would be better, as this one will set
10883              incorrect values for pasted .init/.fini fragments.
10884              (Fixed later in check_pasted_section.)  */
10885           if (isec->makes_toc_func_call
10886               && elf_gp (isec->owner) != 0)
10887             htab->toc_curr = elf_gp (isec->owner);
10888         }
10889     }
10890
10891   /* Functions that don't use the TOC can belong in any TOC group.
10892      Use the last TOC base.  */
10893   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10894   return TRUE;
10895 }
10896
10897 /* Check that all .init and .fini sections use the same toc, if they
10898    have toc relocs.  */
10899
10900 static bfd_boolean
10901 check_pasted_section (struct bfd_link_info *info, const char *name)
10902 {
10903   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10904
10905   if (o != NULL)
10906     {
10907       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10908       bfd_vma toc_off = 0;
10909       asection *i;
10910
10911       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10912         if (i->has_toc_reloc)
10913           {
10914             if (toc_off == 0)
10915               toc_off = htab->stub_group[i->id].toc_off;
10916             else if (toc_off != htab->stub_group[i->id].toc_off)
10917               return FALSE;
10918           }
10919
10920       if (toc_off == 0)
10921         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10922           if (i->makes_toc_func_call)
10923             {
10924               toc_off = htab->stub_group[i->id].toc_off;
10925               break;
10926             }
10927
10928       /* Make sure the whole pasted function uses the same toc offset.  */
10929       if (toc_off != 0)
10930         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10931           htab->stub_group[i->id].toc_off = toc_off;
10932     }
10933   return TRUE;
10934 }
10935
10936 bfd_boolean
10937 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10938 {
10939   return (check_pasted_section (info, ".init")
10940           & check_pasted_section (info, ".fini"));
10941 }
10942
10943 /* See whether we can group stub sections together.  Grouping stub
10944    sections may result in fewer stubs.  More importantly, we need to
10945    put all .init* and .fini* stubs at the beginning of the .init or
10946    .fini output sections respectively, because glibc splits the
10947    _init and _fini functions into multiple parts.  Putting a stub in
10948    the middle of a function is not a good idea.  */
10949
10950 static void
10951 group_sections (struct ppc_link_hash_table *htab,
10952                 bfd_size_type stub_group_size,
10953                 bfd_boolean stubs_always_before_branch)
10954 {
10955   asection **list;
10956   bfd_size_type stub14_group_size;
10957   bfd_boolean suppress_size_errors;
10958
10959   suppress_size_errors = FALSE;
10960   stub14_group_size = stub_group_size;
10961   if (stub_group_size == 1)
10962     {
10963       /* Default values.  */
10964       if (stubs_always_before_branch)
10965         {
10966           stub_group_size = 0x1e00000;
10967           stub14_group_size = 0x7800;
10968         }
10969       else
10970         {
10971           stub_group_size = 0x1c00000;
10972           stub14_group_size = 0x7000;
10973         }
10974       suppress_size_errors = TRUE;
10975     }
10976
10977   list = htab->input_list + htab->top_index;
10978   do
10979     {
10980       asection *tail = *list;
10981       while (tail != NULL)
10982         {
10983           asection *curr;
10984           asection *prev;
10985           bfd_size_type total;
10986           bfd_boolean big_sec;
10987           bfd_vma curr_toc;
10988
10989           curr = tail;
10990           total = tail->size;
10991           big_sec = total > (ppc64_elf_section_data (tail) != NULL
10992                              && ppc64_elf_section_data (tail)->has_14bit_branch
10993                              ? stub14_group_size : stub_group_size);
10994           if (big_sec && !suppress_size_errors)
10995             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10996                                      tail->owner, tail);
10997           curr_toc = htab->stub_group[tail->id].toc_off;
10998
10999           while ((prev = PREV_SEC (curr)) != NULL
11000                  && ((total += curr->output_offset - prev->output_offset)
11001                      < (ppc64_elf_section_data (prev) != NULL
11002                         && ppc64_elf_section_data (prev)->has_14bit_branch
11003                         ? stub14_group_size : stub_group_size))
11004                  && htab->stub_group[prev->id].toc_off == curr_toc)
11005             curr = prev;
11006
11007           /* OK, the size from the start of CURR to the end is less
11008              than stub_group_size and thus can be handled by one stub
11009              section.  (or the tail section is itself larger than
11010              stub_group_size, in which case we may be toast.)  We
11011              should really be keeping track of the total size of stubs
11012              added here, as stubs contribute to the final output
11013              section size.  That's a little tricky, and this way will
11014              only break if stubs added make the total size more than
11015              2^25, ie. for the default stub_group_size, if stubs total
11016              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11017           do
11018             {
11019               prev = PREV_SEC (tail);
11020               /* Set up this stub group.  */
11021               htab->stub_group[tail->id].link_sec = curr;
11022             }
11023           while (tail != curr && (tail = prev) != NULL);
11024
11025           /* But wait, there's more!  Input sections up to stub_group_size
11026              bytes before the stub section can be handled by it too.
11027              Don't do this if we have a really large section after the
11028              stubs, as adding more stubs increases the chance that
11029              branches may not reach into the stub section.  */
11030           if (!stubs_always_before_branch && !big_sec)
11031             {
11032               total = 0;
11033               while (prev != NULL
11034                      && ((total += tail->output_offset - prev->output_offset)
11035                          < (ppc64_elf_section_data (prev) != NULL
11036                             && ppc64_elf_section_data (prev)->has_14bit_branch
11037                             ? stub14_group_size : stub_group_size))
11038                      && htab->stub_group[prev->id].toc_off == curr_toc)
11039                 {
11040                   tail = prev;
11041                   prev = PREV_SEC (tail);
11042                   htab->stub_group[tail->id].link_sec = curr;
11043                 }
11044             }
11045           tail = prev;
11046         }
11047     }
11048   while (list-- != htab->input_list);
11049   free (htab->input_list);
11050 #undef PREV_SEC
11051 }
11052
11053 static const unsigned char glink_eh_frame_cie[] =
11054 {
11055   0, 0, 0, 16,                          /* length.  */
11056   0, 0, 0, 0,                           /* id.  */
11057   1,                                    /* CIE version.  */
11058   'z', 'R', 0,                          /* Augmentation string.  */
11059   4,                                    /* Code alignment.  */
11060   0x78,                                 /* Data alignment.  */
11061   65,                                   /* RA reg.  */
11062   1,                                    /* Augmentation size.  */
11063   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11064   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11065 };
11066
11067 /* Stripping output sections is normally done before dynamic section
11068    symbols have been allocated.  This function is called later, and
11069    handles cases like htab->brlt which is mapped to its own output
11070    section.  */
11071
11072 static void
11073 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11074 {
11075   if (isec->size == 0
11076       && isec->output_section->size == 0
11077       && !bfd_section_removed_from_list (info->output_bfd,
11078                                          isec->output_section)
11079       && elf_section_data (isec->output_section)->dynindx == 0)
11080     {
11081       isec->output_section->flags |= SEC_EXCLUDE;
11082       bfd_section_list_remove (info->output_bfd, isec->output_section);
11083       info->output_bfd->section_count--;
11084     }
11085 }
11086
11087 /* Determine and set the size of the stub section for a final link.
11088
11089    The basic idea here is to examine all the relocations looking for
11090    PC-relative calls to a target that is unreachable with a "bl"
11091    instruction.  */
11092
11093 bfd_boolean
11094 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11095                       bfd_boolean plt_static_chain)
11096 {
11097   bfd_size_type stub_group_size;
11098   bfd_boolean stubs_always_before_branch;
11099   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11100
11101   if (htab == NULL)
11102     return FALSE;
11103
11104   htab->plt_static_chain = plt_static_chain;
11105   stubs_always_before_branch = group_size < 0;
11106   if (group_size < 0)
11107     stub_group_size = -group_size;
11108   else
11109     stub_group_size = group_size;
11110
11111   group_sections (htab, stub_group_size, stubs_always_before_branch);
11112
11113   while (1)
11114     {
11115       bfd *input_bfd;
11116       unsigned int bfd_indx;
11117       asection *stub_sec;
11118
11119       htab->stub_iteration += 1;
11120
11121       for (input_bfd = info->input_bfds, bfd_indx = 0;
11122            input_bfd != NULL;
11123            input_bfd = input_bfd->link_next, bfd_indx++)
11124         {
11125           Elf_Internal_Shdr *symtab_hdr;
11126           asection *section;
11127           Elf_Internal_Sym *local_syms = NULL;
11128
11129           if (!is_ppc64_elf (input_bfd))
11130             continue;
11131
11132           /* We'll need the symbol table in a second.  */
11133           symtab_hdr = &elf_symtab_hdr (input_bfd);
11134           if (symtab_hdr->sh_info == 0)
11135             continue;
11136
11137           /* Walk over each section attached to the input bfd.  */
11138           for (section = input_bfd->sections;
11139                section != NULL;
11140                section = section->next)
11141             {
11142               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11143
11144               /* If there aren't any relocs, then there's nothing more
11145                  to do.  */
11146               if ((section->flags & SEC_RELOC) == 0
11147                   || (section->flags & SEC_ALLOC) == 0
11148                   || (section->flags & SEC_LOAD) == 0
11149                   || (section->flags & SEC_CODE) == 0
11150                   || section->reloc_count == 0)
11151                 continue;
11152
11153               /* If this section is a link-once section that will be
11154                  discarded, then don't create any stubs.  */
11155               if (section->output_section == NULL
11156                   || section->output_section->owner != info->output_bfd)
11157                 continue;
11158
11159               /* Get the relocs.  */
11160               internal_relocs
11161                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11162                                              info->keep_memory);
11163               if (internal_relocs == NULL)
11164                 goto error_ret_free_local;
11165
11166               /* Now examine each relocation.  */
11167               irela = internal_relocs;
11168               irelaend = irela + section->reloc_count;
11169               for (; irela < irelaend; irela++)
11170                 {
11171                   enum elf_ppc64_reloc_type r_type;
11172                   unsigned int r_indx;
11173                   enum ppc_stub_type stub_type;
11174                   struct ppc_stub_hash_entry *stub_entry;
11175                   asection *sym_sec, *code_sec;
11176                   bfd_vma sym_value, code_value;
11177                   bfd_vma destination;
11178                   bfd_boolean ok_dest;
11179                   struct ppc_link_hash_entry *hash;
11180                   struct ppc_link_hash_entry *fdh;
11181                   struct elf_link_hash_entry *h;
11182                   Elf_Internal_Sym *sym;
11183                   char *stub_name;
11184                   const asection *id_sec;
11185                   struct _opd_sec_data *opd;
11186                   struct plt_entry *plt_ent;
11187
11188                   r_type = ELF64_R_TYPE (irela->r_info);
11189                   r_indx = ELF64_R_SYM (irela->r_info);
11190
11191                   if (r_type >= R_PPC64_max)
11192                     {
11193                       bfd_set_error (bfd_error_bad_value);
11194                       goto error_ret_free_internal;
11195                     }
11196
11197                   /* Only look for stubs on branch instructions.  */
11198                   if (r_type != R_PPC64_REL24
11199                       && r_type != R_PPC64_REL14
11200                       && r_type != R_PPC64_REL14_BRTAKEN
11201                       && r_type != R_PPC64_REL14_BRNTAKEN)
11202                     continue;
11203
11204                   /* Now determine the call target, its name, value,
11205                      section.  */
11206                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11207                                   r_indx, input_bfd))
11208                     goto error_ret_free_internal;
11209                   hash = (struct ppc_link_hash_entry *) h;
11210
11211                   ok_dest = FALSE;
11212                   fdh = NULL;
11213                   sym_value = 0;
11214                   if (hash == NULL)
11215                     {
11216                       sym_value = sym->st_value;
11217                       ok_dest = TRUE;
11218                     }
11219                   else if (hash->elf.root.type == bfd_link_hash_defined
11220                            || hash->elf.root.type == bfd_link_hash_defweak)
11221                     {
11222                       sym_value = hash->elf.root.u.def.value;
11223                       if (sym_sec->output_section != NULL)
11224                         ok_dest = TRUE;
11225                     }
11226                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11227                            || hash->elf.root.type == bfd_link_hash_undefined)
11228                     {
11229                       /* Recognise an old ABI func code entry sym, and
11230                          use the func descriptor sym instead if it is
11231                          defined.  */
11232                       if (hash->elf.root.root.string[0] == '.'
11233                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11234                         {
11235                           if (fdh->elf.root.type == bfd_link_hash_defined
11236                               || fdh->elf.root.type == bfd_link_hash_defweak)
11237                             {
11238                               sym_sec = fdh->elf.root.u.def.section;
11239                               sym_value = fdh->elf.root.u.def.value;
11240                               if (sym_sec->output_section != NULL)
11241                                 ok_dest = TRUE;
11242                             }
11243                           else
11244                             fdh = NULL;
11245                         }
11246                     }
11247                   else
11248                     {
11249                       bfd_set_error (bfd_error_bad_value);
11250                       goto error_ret_free_internal;
11251                     }
11252
11253                   destination = 0;
11254                   if (ok_dest)
11255                     {
11256                       sym_value += irela->r_addend;
11257                       destination = (sym_value
11258                                      + sym_sec->output_offset
11259                                      + sym_sec->output_section->vma);
11260                     }
11261
11262                   code_sec = sym_sec;
11263                   code_value = sym_value;
11264                   opd = get_opd_info (sym_sec);
11265                   if (opd != NULL)
11266                     {
11267                       bfd_vma dest;
11268
11269                       if (hash == NULL && opd->adjust != NULL)
11270                         {
11271                           long adjust = opd->adjust[sym_value / 8];
11272                           if (adjust == -1)
11273                             continue;
11274                           code_value += adjust;
11275                           sym_value += adjust;
11276                         }
11277                       dest = opd_entry_value (sym_sec, sym_value,
11278                                               &code_sec, &code_value);
11279                       if (dest != (bfd_vma) -1)
11280                         {
11281                           destination = dest;
11282                           if (fdh != NULL)
11283                             {
11284                               /* Fixup old ABI sym to point at code
11285                                  entry.  */
11286                               hash->elf.root.type = bfd_link_hash_defweak;
11287                               hash->elf.root.u.def.section = code_sec;
11288                               hash->elf.root.u.def.value = code_value;
11289                             }
11290                         }
11291                     }
11292
11293                   /* Determine what (if any) linker stub is needed.  */
11294                   plt_ent = NULL;
11295                   stub_type = ppc_type_of_stub (section, irela, &hash,
11296                                                 &plt_ent, destination);
11297
11298                   if (stub_type != ppc_stub_plt_call)
11299                     {
11300                       /* Check whether we need a TOC adjusting stub.
11301                          Since the linker pastes together pieces from
11302                          different object files when creating the
11303                          _init and _fini functions, it may be that a
11304                          call to what looks like a local sym is in
11305                          fact a call needing a TOC adjustment.  */
11306                       if (code_sec != NULL
11307                           && code_sec->output_section != NULL
11308                           && (htab->stub_group[code_sec->id].toc_off
11309                               != htab->stub_group[section->id].toc_off)
11310                           && (code_sec->has_toc_reloc
11311                               || code_sec->makes_toc_func_call))
11312                         stub_type = ppc_stub_long_branch_r2off;
11313                     }
11314
11315                   if (stub_type == ppc_stub_none)
11316                     continue;
11317
11318                   /* __tls_get_addr calls might be eliminated.  */
11319                   if (stub_type != ppc_stub_plt_call
11320                       && hash != NULL
11321                       && (hash == htab->tls_get_addr
11322                           || hash == htab->tls_get_addr_fd)
11323                       && section->has_tls_reloc
11324                       && irela != internal_relocs)
11325                     {
11326                       /* Get tls info.  */
11327                       unsigned char *tls_mask;
11328
11329                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11330                                          irela - 1, input_bfd))
11331                         goto error_ret_free_internal;
11332                       if (*tls_mask != 0)
11333                         continue;
11334                     }
11335
11336                   if (stub_type == ppc_stub_plt_call
11337                       && irela + 1 < irelaend
11338                       && irela[1].r_offset == irela->r_offset + 4
11339                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE
11340                       && !tocsave_find (htab, INSERT,
11341                                         &local_syms, irela + 1, input_bfd))
11342                     goto error_ret_free_internal;
11343
11344                   /* Support for grouping stub sections.  */
11345                   id_sec = htab->stub_group[section->id].link_sec;
11346
11347                   /* Get the name of this stub.  */
11348                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11349                   if (!stub_name)
11350                     goto error_ret_free_internal;
11351
11352                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11353                                                      stub_name, FALSE, FALSE);
11354                   if (stub_entry != NULL)
11355                     {
11356                       /* The proper stub has already been created.  */
11357                       free (stub_name);
11358                       continue;
11359                     }
11360
11361                   stub_entry = ppc_add_stub (stub_name, section, info);
11362                   if (stub_entry == NULL)
11363                     {
11364                       free (stub_name);
11365                     error_ret_free_internal:
11366                       if (elf_section_data (section)->relocs == NULL)
11367                         free (internal_relocs);
11368                     error_ret_free_local:
11369                       if (local_syms != NULL
11370                           && (symtab_hdr->contents
11371                               != (unsigned char *) local_syms))
11372                         free (local_syms);
11373                       return FALSE;
11374                     }
11375
11376                   stub_entry->stub_type = stub_type;
11377                   if (stub_type != ppc_stub_plt_call)
11378                     {
11379                       stub_entry->target_value = code_value;
11380                       stub_entry->target_section = code_sec;
11381                     }
11382                   else
11383                     {
11384                       stub_entry->target_value = sym_value;
11385                       stub_entry->target_section = sym_sec;
11386                     }
11387                   stub_entry->h = hash;
11388                   stub_entry->plt_ent = plt_ent;
11389                   stub_entry->addend = irela->r_addend;
11390
11391                   if (stub_entry->h != NULL)
11392                     htab->stub_globals += 1;
11393                 }
11394
11395               /* We're done with the internal relocs, free them.  */
11396               if (elf_section_data (section)->relocs != internal_relocs)
11397                 free (internal_relocs);
11398             }
11399
11400           if (local_syms != NULL
11401               && symtab_hdr->contents != (unsigned char *) local_syms)
11402             {
11403               if (!info->keep_memory)
11404                 free (local_syms);
11405               else
11406                 symtab_hdr->contents = (unsigned char *) local_syms;
11407             }
11408         }
11409
11410       /* We may have added some stubs.  Find out the new size of the
11411          stub sections.  */
11412       for (stub_sec = htab->stub_bfd->sections;
11413            stub_sec != NULL;
11414            stub_sec = stub_sec->next)
11415         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11416           {
11417             stub_sec->rawsize = stub_sec->size;
11418             stub_sec->size = 0;
11419             stub_sec->reloc_count = 0;
11420             stub_sec->flags &= ~SEC_RELOC;
11421           }
11422
11423       htab->brlt->size = 0;
11424       htab->brlt->reloc_count = 0;
11425       htab->brlt->flags &= ~SEC_RELOC;
11426       if (htab->relbrlt != NULL)
11427         htab->relbrlt->size = 0;
11428
11429       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11430
11431       if (info->emitrelocations
11432           && htab->glink != NULL && htab->glink->size != 0)
11433         {
11434           htab->glink->reloc_count = 1;
11435           htab->glink->flags |= SEC_RELOC;
11436         }
11437
11438       if (htab->glink_eh_frame != NULL
11439           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11440           && (htab->glink_eh_frame->flags & SEC_EXCLUDE) == 0)
11441         {
11442           bfd_size_type size = 0;
11443
11444           for (stub_sec = htab->stub_bfd->sections;
11445                stub_sec != NULL;
11446                stub_sec = stub_sec->next)
11447             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11448               size += 20;
11449           if (htab->glink != NULL && htab->glink->size != 0)
11450             size += 24;
11451           if (size != 0)
11452             size += sizeof (glink_eh_frame_cie);
11453           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11454           htab->glink_eh_frame->size = size;
11455         }
11456
11457       for (stub_sec = htab->stub_bfd->sections;
11458            stub_sec != NULL;
11459            stub_sec = stub_sec->next)
11460         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11461             && stub_sec->rawsize != stub_sec->size)
11462           break;
11463
11464       /* Exit from this loop when no stubs have been added, and no stubs
11465          have changed size.  */
11466       if (stub_sec == NULL
11467           && (htab->glink_eh_frame == NULL
11468               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11469         break;
11470
11471       /* Ask the linker to do its stuff.  */
11472       (*htab->layout_sections_again) ();
11473     }
11474
11475   maybe_strip_output (info, htab->brlt);
11476   if (htab->glink_eh_frame != NULL)
11477     maybe_strip_output (info, htab->glink_eh_frame);
11478
11479   return TRUE;
11480 }
11481
11482 /* Called after we have determined section placement.  If sections
11483    move, we'll be called again.  Provide a value for TOCstart.  */
11484
11485 bfd_vma
11486 ppc64_elf_toc (bfd *obfd)
11487 {
11488   asection *s;
11489   bfd_vma TOCstart;
11490
11491   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11492      order.  The TOC starts where the first of these sections starts.  */
11493   s = bfd_get_section_by_name (obfd, ".got");
11494   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11495     s = bfd_get_section_by_name (obfd, ".toc");
11496   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11497     s = bfd_get_section_by_name (obfd, ".tocbss");
11498   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11499     s = bfd_get_section_by_name (obfd, ".plt");
11500   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11501     {
11502       /* This may happen for
11503          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11504          .toc directive
11505          o  bad linker script
11506          o --gc-sections and empty TOC sections
11507
11508          FIXME: Warn user?  */
11509
11510       /* Look for a likely section.  We probably won't even be
11511          using TOCstart.  */
11512       for (s = obfd->sections; s != NULL; s = s->next)
11513         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11514                          | SEC_EXCLUDE))
11515             == (SEC_ALLOC | SEC_SMALL_DATA))
11516           break;
11517       if (s == NULL)
11518         for (s = obfd->sections; s != NULL; s = s->next)
11519           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11520               == (SEC_ALLOC | SEC_SMALL_DATA))
11521             break;
11522       if (s == NULL)
11523         for (s = obfd->sections; s != NULL; s = s->next)
11524           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11525               == SEC_ALLOC)
11526             break;
11527       if (s == NULL)
11528         for (s = obfd->sections; s != NULL; s = s->next)
11529           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11530             break;
11531     }
11532
11533   TOCstart = 0;
11534   if (s != NULL)
11535     TOCstart = s->output_section->vma + s->output_offset;
11536
11537   return TOCstart;
11538 }
11539
11540 /* Build all the stubs associated with the current output file.
11541    The stubs are kept in a hash table attached to the main linker
11542    hash table.  This function is called via gldelf64ppc_finish.  */
11543
11544 bfd_boolean
11545 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11546                        struct bfd_link_info *info,
11547                        char **stats)
11548 {
11549   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11550   asection *stub_sec;
11551   bfd_byte *p;
11552   int stub_sec_count = 0;
11553
11554   if (htab == NULL)
11555     return FALSE;
11556
11557   htab->emit_stub_syms = emit_stub_syms;
11558
11559   /* Allocate memory to hold the linker stubs.  */
11560   for (stub_sec = htab->stub_bfd->sections;
11561        stub_sec != NULL;
11562        stub_sec = stub_sec->next)
11563     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11564         && stub_sec->size != 0)
11565       {
11566         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11567         if (stub_sec->contents == NULL)
11568           return FALSE;
11569         /* We want to check that built size is the same as calculated
11570            size.  rawsize is a convenient location to use.  */
11571         stub_sec->rawsize = stub_sec->size;
11572         stub_sec->size = 0;
11573       }
11574
11575   if (htab->glink != NULL && htab->glink->size != 0)
11576     {
11577       unsigned int indx;
11578       bfd_vma plt0;
11579
11580       /* Build the .glink plt call stub.  */
11581       if (htab->emit_stub_syms)
11582         {
11583           struct elf_link_hash_entry *h;
11584           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11585                                     TRUE, FALSE, FALSE);
11586           if (h == NULL)
11587             return FALSE;
11588           if (h->root.type == bfd_link_hash_new)
11589             {
11590               h->root.type = bfd_link_hash_defined;
11591               h->root.u.def.section = htab->glink;
11592               h->root.u.def.value = 8;
11593               h->ref_regular = 1;
11594               h->def_regular = 1;
11595               h->ref_regular_nonweak = 1;
11596               h->forced_local = 1;
11597               h->non_elf = 0;
11598             }
11599         }
11600       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11601       if (info->emitrelocations)
11602         {
11603           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11604           if (r == NULL)
11605             return FALSE;
11606           r->r_offset = (htab->glink->output_offset
11607                          + htab->glink->output_section->vma);
11608           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11609           r->r_addend = plt0;
11610         }
11611       p = htab->glink->contents;
11612       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11613       bfd_put_64 (htab->glink->owner, plt0, p);
11614       p += 8;
11615       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11616       p += 4;
11617       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11618       p += 4;
11619       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11620       p += 4;
11621       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11622       p += 4;
11623       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11624       p += 4;
11625       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11626       p += 4;
11627       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11628       p += 4;
11629       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11630       p += 4;
11631       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11632       p += 4;
11633       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11634       p += 4;
11635       bfd_put_32 (htab->glink->owner, BCTR, p);
11636       p += 4;
11637       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11638         {
11639           bfd_put_32 (htab->glink->owner, NOP, p);
11640           p += 4;
11641         }
11642
11643       /* Build the .glink lazy link call stubs.  */
11644       indx = 0;
11645       while (p < htab->glink->contents + htab->glink->size)
11646         {
11647           if (indx < 0x8000)
11648             {
11649               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11650               p += 4;
11651             }
11652           else
11653             {
11654               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11655               p += 4;
11656               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11657               p += 4;
11658             }
11659           bfd_put_32 (htab->glink->owner,
11660                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11661           indx++;
11662           p += 4;
11663         }
11664       htab->glink->rawsize = p - htab->glink->contents;
11665     }
11666
11667   if (htab->brlt->size != 0)
11668     {
11669       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11670                                          htab->brlt->size);
11671       if (htab->brlt->contents == NULL)
11672         return FALSE;
11673     }
11674   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11675     {
11676       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11677                                             htab->relbrlt->size);
11678       if (htab->relbrlt->contents == NULL)
11679         return FALSE;
11680     }
11681
11682   if (htab->glink_eh_frame != NULL
11683       && htab->glink_eh_frame->size != 0)
11684     {
11685       bfd_vma val;
11686
11687       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
11688       if (p == NULL)
11689         return FALSE;
11690       htab->glink_eh_frame->contents = p;
11691
11692       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11693
11694       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
11695       /* CIE length (rewrite in case little-endian).  */
11696       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
11697       p += sizeof (glink_eh_frame_cie);
11698
11699       for (stub_sec = htab->stub_bfd->sections;
11700            stub_sec != NULL;
11701            stub_sec = stub_sec->next)
11702         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11703           {
11704             /* FDE length.  */
11705             bfd_put_32 (htab->elf.dynobj, 16, p);
11706             p += 4;
11707             /* CIE pointer.  */
11708             val = p - htab->glink_eh_frame->contents;
11709             bfd_put_32 (htab->elf.dynobj, val, p);
11710             p += 4;
11711             /* Offset to stub section.  */
11712             val = (stub_sec->output_section->vma
11713                    + stub_sec->output_offset);
11714             val -= (htab->glink_eh_frame->output_section->vma
11715                     + htab->glink_eh_frame->output_offset);
11716             val -= p - htab->glink_eh_frame->contents;
11717             if (val + 0x80000000 > 0xffffffff)
11718               {
11719                 info->callbacks->einfo
11720                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11721                    stub_sec->name);
11722                 return FALSE;
11723               }
11724             bfd_put_32 (htab->elf.dynobj, val, p);
11725             p += 4;
11726             /* stub section size.  */
11727             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
11728             p += 4;
11729             /* Augmentation.  */
11730             p += 1;
11731             /* Pad.  */
11732             p += 3;
11733           }
11734       if (htab->glink != NULL && htab->glink->size != 0)
11735         {
11736           /* FDE length.  */
11737           bfd_put_32 (htab->elf.dynobj, 20, p);
11738           p += 4;
11739           /* CIE pointer.  */
11740           val = p - htab->glink_eh_frame->contents;
11741           bfd_put_32 (htab->elf.dynobj, val, p);
11742           p += 4;
11743           /* Offset to .glink.  */
11744           val = (htab->glink->output_section->vma
11745                  + htab->glink->output_offset
11746                  + 8);
11747           val -= (htab->glink_eh_frame->output_section->vma
11748                   + htab->glink_eh_frame->output_offset);
11749           val -= p - htab->glink_eh_frame->contents;
11750           if (val + 0x80000000 > 0xffffffff)
11751             {
11752               info->callbacks->einfo
11753                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11754                  htab->glink->name);
11755               return FALSE;
11756             }
11757           bfd_put_32 (htab->elf.dynobj, val, p);
11758           p += 4;
11759           /* .glink size.  */
11760           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
11761           p += 4;
11762           /* Augmentation.  */
11763           p += 1;
11764
11765           *p++ = DW_CFA_advance_loc + 1;
11766           *p++ = DW_CFA_register;
11767           *p++ = 65;
11768           *p++ = 12;
11769           *p++ = DW_CFA_advance_loc + 4;
11770           *p++ = DW_CFA_restore_extended;
11771           *p++ = 65;
11772         }
11773       htab->glink_eh_frame->size = p - htab->glink_eh_frame->contents;
11774     }
11775
11776   /* Build the stubs as directed by the stub hash table.  */
11777   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11778
11779   if (htab->relbrlt != NULL)
11780     htab->relbrlt->reloc_count = 0;
11781
11782   for (stub_sec = htab->stub_bfd->sections;
11783        stub_sec != NULL;
11784        stub_sec = stub_sec->next)
11785     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11786       {
11787         stub_sec_count += 1;
11788         if (stub_sec->rawsize != stub_sec->size)
11789           break;
11790       }
11791
11792   if (stub_sec != NULL
11793       || htab->glink->rawsize != htab->glink->size
11794       || (htab->glink_eh_frame != NULL
11795           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
11796     {
11797       htab->stub_error = TRUE;
11798       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
11799     }
11800
11801   if (htab->stub_error)
11802     return FALSE;
11803
11804   if (stats != NULL)
11805     {
11806       *stats = bfd_malloc (500);
11807       if (*stats == NULL)
11808         return FALSE;
11809
11810       sprintf (*stats, _("linker stubs in %u group%s\n"
11811                          "  branch       %lu\n"
11812                          "  toc adjust   %lu\n"
11813                          "  long branch  %lu\n"
11814                          "  long toc adj %lu\n"
11815                          "  plt call     %lu"),
11816                stub_sec_count,
11817                stub_sec_count == 1 ? "" : "s",
11818                htab->stub_count[ppc_stub_long_branch - 1],
11819                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11820                htab->stub_count[ppc_stub_plt_branch - 1],
11821                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11822                htab->stub_count[ppc_stub_plt_call - 1]);
11823     }
11824   return TRUE;
11825 }
11826
11827 /* This function undoes the changes made by add_symbol_adjust.  */
11828
11829 static bfd_boolean
11830 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11831 {
11832   struct ppc_link_hash_entry *eh;
11833
11834   if (h->root.type == bfd_link_hash_indirect)
11835     return TRUE;
11836
11837   eh = (struct ppc_link_hash_entry *) h;
11838   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11839     return TRUE;
11840
11841   eh->elf.root.type = bfd_link_hash_undefined;
11842   return TRUE;
11843 }
11844
11845 void
11846 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11847 {
11848   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11849
11850   if (htab != NULL)
11851     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11852 }
11853
11854 /* What to do when ld finds relocations against symbols defined in
11855    discarded sections.  */
11856
11857 static unsigned int
11858 ppc64_elf_action_discarded (asection *sec)
11859 {
11860   if (strcmp (".opd", sec->name) == 0)
11861     return 0;
11862
11863   if (strcmp (".toc", sec->name) == 0)
11864     return 0;
11865
11866   if (strcmp (".toc1", sec->name) == 0)
11867     return 0;
11868
11869   return _bfd_elf_default_action_discarded (sec);
11870 }
11871
11872 /* The RELOCATE_SECTION function is called by the ELF backend linker
11873    to handle the relocations for a section.
11874
11875    The relocs are always passed as Rela structures; if the section
11876    actually uses Rel structures, the r_addend field will always be
11877    zero.
11878
11879    This function is responsible for adjust the section contents as
11880    necessary, and (if using Rela relocs and generating a
11881    relocatable output file) adjusting the reloc addend as
11882    necessary.
11883
11884    This function does not have to worry about setting the reloc
11885    address or the reloc symbol index.
11886
11887    LOCAL_SYMS is a pointer to the swapped in local symbols.
11888
11889    LOCAL_SECTIONS is an array giving the section in the input file
11890    corresponding to the st_shndx field of each local symbol.
11891
11892    The global hash table entry for the global symbols can be found
11893    via elf_sym_hashes (input_bfd).
11894
11895    When generating relocatable output, this function must handle
11896    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11897    going to be the section symbol corresponding to the output
11898    section, which means that the addend must be adjusted
11899    accordingly.  */
11900
11901 static bfd_boolean
11902 ppc64_elf_relocate_section (bfd *output_bfd,
11903                             struct bfd_link_info *info,
11904                             bfd *input_bfd,
11905                             asection *input_section,
11906                             bfd_byte *contents,
11907                             Elf_Internal_Rela *relocs,
11908                             Elf_Internal_Sym *local_syms,
11909                             asection **local_sections)
11910 {
11911   struct ppc_link_hash_table *htab;
11912   Elf_Internal_Shdr *symtab_hdr;
11913   struct elf_link_hash_entry **sym_hashes;
11914   Elf_Internal_Rela *rel;
11915   Elf_Internal_Rela *relend;
11916   Elf_Internal_Rela outrel;
11917   bfd_byte *loc;
11918   struct got_entry **local_got_ents;
11919   bfd_vma TOCstart;
11920   bfd_boolean ret = TRUE;
11921   bfd_boolean is_opd;
11922   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11923   bfd_boolean is_power4 = FALSE;
11924   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11925
11926   /* Initialize howto table if needed.  */
11927   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11928     ppc_howto_init ();
11929
11930   htab = ppc_hash_table (info);
11931   if (htab == NULL)
11932     return FALSE;
11933
11934   /* Don't relocate stub sections.  */
11935   if (input_section->owner == htab->stub_bfd)
11936     return TRUE;
11937
11938   BFD_ASSERT (is_ppc64_elf (input_bfd));
11939
11940   local_got_ents = elf_local_got_ents (input_bfd);
11941   TOCstart = elf_gp (output_bfd);
11942   symtab_hdr = &elf_symtab_hdr (input_bfd);
11943   sym_hashes = elf_sym_hashes (input_bfd);
11944   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11945
11946   rel = relocs;
11947   relend = relocs + input_section->reloc_count;
11948   for (; rel < relend; rel++)
11949     {
11950       enum elf_ppc64_reloc_type r_type;
11951       bfd_vma addend, orig_addend;
11952       bfd_reloc_status_type r;
11953       Elf_Internal_Sym *sym;
11954       asection *sec;
11955       struct elf_link_hash_entry *h_elf;
11956       struct ppc_link_hash_entry *h;
11957       struct ppc_link_hash_entry *fdh;
11958       const char *sym_name;
11959       unsigned long r_symndx, toc_symndx;
11960       bfd_vma toc_addend;
11961       unsigned char tls_mask, tls_gd, tls_type;
11962       unsigned char sym_type;
11963       bfd_vma relocation;
11964       bfd_boolean unresolved_reloc;
11965       bfd_boolean warned;
11966       unsigned int insn;
11967       unsigned int mask;
11968       struct ppc_stub_hash_entry *stub_entry;
11969       bfd_vma max_br_offset;
11970       bfd_vma from;
11971
11972       r_type = ELF64_R_TYPE (rel->r_info);
11973       r_symndx = ELF64_R_SYM (rel->r_info);
11974
11975       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11976          symbol of the previous ADDR64 reloc.  The symbol gives us the
11977          proper TOC base to use.  */
11978       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11979           && rel != relocs
11980           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11981           && is_opd)
11982         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11983
11984       sym = NULL;
11985       sec = NULL;
11986       h_elf = NULL;
11987       sym_name = NULL;
11988       unresolved_reloc = FALSE;
11989       warned = FALSE;
11990       orig_addend = rel->r_addend;
11991
11992       if (r_symndx < symtab_hdr->sh_info)
11993         {
11994           /* It's a local symbol.  */
11995           struct _opd_sec_data *opd;
11996
11997           sym = local_syms + r_symndx;
11998           sec = local_sections[r_symndx];
11999           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12000           sym_type = ELF64_ST_TYPE (sym->st_info);
12001           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12002           opd = get_opd_info (sec);
12003           if (opd != NULL && opd->adjust != NULL)
12004             {
12005               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12006               if (adjust == -1)
12007                 relocation = 0;
12008               else
12009                 {
12010                   /* If this is a relocation against the opd section sym
12011                      and we have edited .opd, adjust the reloc addend so
12012                      that ld -r and ld --emit-relocs output is correct.
12013                      If it is a reloc against some other .opd symbol,
12014                      then the symbol value will be adjusted later.  */
12015                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12016                     rel->r_addend += adjust;
12017                   else
12018                     relocation += adjust;
12019                 }
12020             }
12021         }
12022       else
12023         {
12024           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12025                                    r_symndx, symtab_hdr, sym_hashes,
12026                                    h_elf, sec, relocation,
12027                                    unresolved_reloc, warned);
12028           sym_name = h_elf->root.root.string;
12029           sym_type = h_elf->type;
12030         }
12031       h = (struct ppc_link_hash_entry *) h_elf;
12032
12033       if (sec != NULL && elf_discarded_section (sec))
12034         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12035                                          rel, relend,
12036                                          ppc64_elf_howto_table[r_type],
12037                                          contents);
12038
12039       if (info->relocatable)
12040         continue;
12041
12042       /* TLS optimizations.  Replace instruction sequences and relocs
12043          based on information we collected in tls_optimize.  We edit
12044          RELOCS so that --emit-relocs will output something sensible
12045          for the final instruction stream.  */
12046       tls_mask = 0;
12047       tls_gd = 0;
12048       toc_symndx = 0;
12049       if (h != NULL)
12050         tls_mask = h->tls_mask;
12051       else if (local_got_ents != NULL)
12052         {
12053           struct plt_entry **local_plt = (struct plt_entry **)
12054             (local_got_ents + symtab_hdr->sh_info);
12055           unsigned char *lgot_masks = (unsigned char *)
12056             (local_plt + symtab_hdr->sh_info);
12057           tls_mask = lgot_masks[r_symndx];
12058         }
12059       if (tls_mask == 0
12060           && (r_type == R_PPC64_TLS
12061               || r_type == R_PPC64_TLSGD
12062               || r_type == R_PPC64_TLSLD))
12063         {
12064           /* Check for toc tls entries.  */
12065           unsigned char *toc_tls;
12066
12067           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12068                              &local_syms, rel, input_bfd))
12069             return FALSE;
12070
12071           if (toc_tls)
12072             tls_mask = *toc_tls;
12073         }
12074
12075       /* Check that tls relocs are used with tls syms, and non-tls
12076          relocs are used with non-tls syms.  */
12077       if (r_symndx != STN_UNDEF
12078           && r_type != R_PPC64_NONE
12079           && (h == NULL
12080               || h->elf.root.type == bfd_link_hash_defined
12081               || h->elf.root.type == bfd_link_hash_defweak)
12082           && (IS_PPC64_TLS_RELOC (r_type)
12083               != (sym_type == STT_TLS
12084                   || (sym_type == STT_SECTION
12085                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12086         {
12087           if (tls_mask != 0
12088               && (r_type == R_PPC64_TLS
12089                   || r_type == R_PPC64_TLSGD
12090                   || r_type == R_PPC64_TLSLD))
12091             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
12092             ;
12093           else
12094             info->callbacks->einfo
12095               (!IS_PPC64_TLS_RELOC (r_type)
12096                ? _("%P: %H: %s used with TLS symbol %s\n")
12097                : _("%P: %H: %s used with non-TLS symbol %s\n"),
12098                input_bfd, input_section, rel->r_offset,
12099                ppc64_elf_howto_table[r_type]->name,
12100                sym_name);
12101         }
12102
12103       /* Ensure reloc mapping code below stays sane.  */
12104       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12105           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12106           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
12107           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12108           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12109           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12110           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
12111           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12112           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12113           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12114         abort ();
12115
12116       switch (r_type)
12117         {
12118         default:
12119           break;
12120
12121         case R_PPC64_LO_DS_OPT:
12122           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12123           if ((insn & (0x3f << 26)) != 58u << 26)
12124             abort ();
12125           insn += (14u << 26) - (58u << 26);
12126           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12127           r_type = R_PPC64_TOC16_LO;
12128           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12129           break;
12130
12131         case R_PPC64_TOC16:
12132         case R_PPC64_TOC16_LO:
12133         case R_PPC64_TOC16_DS:
12134         case R_PPC64_TOC16_LO_DS:
12135           {
12136             /* Check for toc tls entries.  */
12137             unsigned char *toc_tls;
12138             int retval;
12139
12140             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12141                                    &local_syms, rel, input_bfd);
12142             if (retval == 0)
12143               return FALSE;
12144
12145             if (toc_tls)
12146               {
12147                 tls_mask = *toc_tls;
12148                 if (r_type == R_PPC64_TOC16_DS
12149                     || r_type == R_PPC64_TOC16_LO_DS)
12150                   {
12151                     if (tls_mask != 0
12152                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12153                       goto toctprel;
12154                   }
12155                 else
12156                   {
12157                     /* If we found a GD reloc pair, then we might be
12158                        doing a GD->IE transition.  */
12159                     if (retval == 2)
12160                       {
12161                         tls_gd = TLS_TPRELGD;
12162                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12163                           goto tls_ldgd_opt;
12164                       }
12165                     else if (retval == 3)
12166                       {
12167                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12168                           goto tls_ldgd_opt;
12169                       }
12170                   }
12171               }
12172           }
12173           break;
12174
12175         case R_PPC64_GOT_TPREL16_HI:
12176         case R_PPC64_GOT_TPREL16_HA:
12177           if (tls_mask != 0
12178               && (tls_mask & TLS_TPREL) == 0)
12179             {
12180               rel->r_offset -= d_offset;
12181               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12182               r_type = R_PPC64_NONE;
12183               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12184             }
12185           break;
12186
12187         case R_PPC64_GOT_TPREL16_DS:
12188         case R_PPC64_GOT_TPREL16_LO_DS:
12189           if (tls_mask != 0
12190               && (tls_mask & TLS_TPREL) == 0)
12191             {
12192             toctprel:
12193               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12194               insn &= 31 << 21;
12195               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12196               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12197               r_type = R_PPC64_TPREL16_HA;
12198               if (toc_symndx != 0)
12199                 {
12200                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12201                   rel->r_addend = toc_addend;
12202                   /* We changed the symbol.  Start over in order to
12203                      get h, sym, sec etc. right.  */
12204                   rel--;
12205                   continue;
12206                 }
12207               else
12208                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12209             }
12210           break;
12211
12212         case R_PPC64_TLS:
12213           if (tls_mask != 0
12214               && (tls_mask & TLS_TPREL) == 0)
12215             {
12216               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12217               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12218               if (insn == 0)
12219                 abort ();
12220               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12221               /* Was PPC64_TLS which sits on insn boundary, now
12222                  PPC64_TPREL16_LO which is at low-order half-word.  */
12223               rel->r_offset += d_offset;
12224               r_type = R_PPC64_TPREL16_LO;
12225               if (toc_symndx != 0)
12226                 {
12227                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12228                   rel->r_addend = toc_addend;
12229                   /* We changed the symbol.  Start over in order to
12230                      get h, sym, sec etc. right.  */
12231                   rel--;
12232                   continue;
12233                 }
12234               else
12235                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12236             }
12237           break;
12238
12239         case R_PPC64_GOT_TLSGD16_HI:
12240         case R_PPC64_GOT_TLSGD16_HA:
12241           tls_gd = TLS_TPRELGD;
12242           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12243             goto tls_gdld_hi;
12244           break;
12245
12246         case R_PPC64_GOT_TLSLD16_HI:
12247         case R_PPC64_GOT_TLSLD16_HA:
12248           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12249             {
12250             tls_gdld_hi:
12251               if ((tls_mask & tls_gd) != 0)
12252                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12253                           + R_PPC64_GOT_TPREL16_DS);
12254               else
12255                 {
12256                   rel->r_offset -= d_offset;
12257                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12258                   r_type = R_PPC64_NONE;
12259                 }
12260               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12261             }
12262           break;
12263
12264         case R_PPC64_GOT_TLSGD16:
12265         case R_PPC64_GOT_TLSGD16_LO:
12266           tls_gd = TLS_TPRELGD;
12267           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12268             goto tls_ldgd_opt;
12269           break;
12270
12271         case R_PPC64_GOT_TLSLD16:
12272         case R_PPC64_GOT_TLSLD16_LO:
12273           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12274             {
12275               unsigned int insn1, insn2, insn3;
12276               bfd_vma offset;
12277
12278             tls_ldgd_opt:
12279               offset = (bfd_vma) -1;
12280               /* If not using the newer R_PPC64_TLSGD/LD to mark
12281                  __tls_get_addr calls, we must trust that the call
12282                  stays with its arg setup insns, ie. that the next
12283                  reloc is the __tls_get_addr call associated with
12284                  the current reloc.  Edit both insns.  */
12285               if (input_section->has_tls_get_addr_call
12286                   && rel + 1 < relend
12287                   && branch_reloc_hash_match (input_bfd, rel + 1,
12288                                               htab->tls_get_addr,
12289                                               htab->tls_get_addr_fd))
12290                 offset = rel[1].r_offset;
12291               if ((tls_mask & tls_gd) != 0)
12292                 {
12293                   /* IE */
12294                   insn1 = bfd_get_32 (output_bfd,
12295                                       contents + rel->r_offset - d_offset);
12296                   insn1 &= (1 << 26) - (1 << 2);
12297                   insn1 |= 58 << 26;    /* ld */
12298                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12299                   if (offset != (bfd_vma) -1)
12300                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12301                   if ((tls_mask & TLS_EXPLICIT) == 0)
12302                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12303                               + R_PPC64_GOT_TPREL16_DS);
12304                   else
12305                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12306                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12307                 }
12308               else
12309                 {
12310                   /* LE */
12311                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12312                   insn2 = 0x38630000;   /* addi 3,3,0 */
12313                   if (tls_gd == 0)
12314                     {
12315                       /* Was an LD reloc.  */
12316                       if (toc_symndx)
12317                         sec = local_sections[toc_symndx];
12318                       for (r_symndx = 0;
12319                            r_symndx < symtab_hdr->sh_info;
12320                            r_symndx++)
12321                         if (local_sections[r_symndx] == sec)
12322                           break;
12323                       if (r_symndx >= symtab_hdr->sh_info)
12324                         r_symndx = STN_UNDEF;
12325                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12326                       if (r_symndx != STN_UNDEF)
12327                         rel->r_addend -= (local_syms[r_symndx].st_value
12328                                           + sec->output_offset
12329                                           + sec->output_section->vma);
12330                     }
12331                   else if (toc_symndx != 0)
12332                     {
12333                       r_symndx = toc_symndx;
12334                       rel->r_addend = toc_addend;
12335                     }
12336                   r_type = R_PPC64_TPREL16_HA;
12337                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12338                   if (offset != (bfd_vma) -1)
12339                     {
12340                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12341                                                     R_PPC64_TPREL16_LO);
12342                       rel[1].r_offset = offset + d_offset;
12343                       rel[1].r_addend = rel->r_addend;
12344                     }
12345                 }
12346               bfd_put_32 (output_bfd, insn1,
12347                           contents + rel->r_offset - d_offset);
12348               if (offset != (bfd_vma) -1)
12349                 {
12350                   insn3 = bfd_get_32 (output_bfd,
12351                                       contents + offset + 4);
12352                   if (insn3 == NOP
12353                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12354                     {
12355                       rel[1].r_offset += 4;
12356                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12357                       insn2 = NOP;
12358                     }
12359                   bfd_put_32 (output_bfd, insn2, contents + offset);
12360                 }
12361               if ((tls_mask & tls_gd) == 0
12362                   && (tls_gd == 0 || toc_symndx != 0))
12363                 {
12364                   /* We changed the symbol.  Start over in order
12365                      to get h, sym, sec etc. right.  */
12366                   rel--;
12367                   continue;
12368                 }
12369             }
12370           break;
12371
12372         case R_PPC64_TLSGD:
12373           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12374             {
12375               unsigned int insn2, insn3;
12376               bfd_vma offset = rel->r_offset;
12377
12378               if ((tls_mask & TLS_TPRELGD) != 0)
12379                 {
12380                   /* IE */
12381                   r_type = R_PPC64_NONE;
12382                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12383                 }
12384               else
12385                 {
12386                   /* LE */
12387                   if (toc_symndx != 0)
12388                     {
12389                       r_symndx = toc_symndx;
12390                       rel->r_addend = toc_addend;
12391                     }
12392                   r_type = R_PPC64_TPREL16_LO;
12393                   rel->r_offset = offset + d_offset;
12394                   insn2 = 0x38630000;   /* addi 3,3,0 */
12395                 }
12396               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12397               /* Zap the reloc on the _tls_get_addr call too.  */
12398               BFD_ASSERT (offset == rel[1].r_offset);
12399               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12400               insn3 = bfd_get_32 (output_bfd,
12401                                   contents + offset + 4);
12402               if (insn3 == NOP
12403                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12404                 {
12405                   rel->r_offset += 4;
12406                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12407                   insn2 = NOP;
12408                 }
12409               bfd_put_32 (output_bfd, insn2, contents + offset);
12410               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12411                 {
12412                   rel--;
12413                   continue;
12414                 }
12415             }
12416           break;
12417
12418         case R_PPC64_TLSLD:
12419           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12420             {
12421               unsigned int insn2, insn3;
12422               bfd_vma offset = rel->r_offset;
12423
12424               if (toc_symndx)
12425                 sec = local_sections[toc_symndx];
12426               for (r_symndx = 0;
12427                    r_symndx < symtab_hdr->sh_info;
12428                    r_symndx++)
12429                 if (local_sections[r_symndx] == sec)
12430                   break;
12431               if (r_symndx >= symtab_hdr->sh_info)
12432                 r_symndx = STN_UNDEF;
12433               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12434               if (r_symndx != STN_UNDEF)
12435                 rel->r_addend -= (local_syms[r_symndx].st_value
12436                                   + sec->output_offset
12437                                   + sec->output_section->vma);
12438
12439               r_type = R_PPC64_TPREL16_LO;
12440               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12441               rel->r_offset = offset + d_offset;
12442               /* Zap the reloc on the _tls_get_addr call too.  */
12443               BFD_ASSERT (offset == rel[1].r_offset);
12444               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12445               insn2 = 0x38630000;       /* addi 3,3,0 */
12446               insn3 = bfd_get_32 (output_bfd,
12447                                   contents + offset + 4);
12448               if (insn3 == NOP
12449                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12450                 {
12451                   rel->r_offset += 4;
12452                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12453                   insn2 = NOP;
12454                 }
12455               bfd_put_32 (output_bfd, insn2, contents + offset);
12456               rel--;
12457               continue;
12458             }
12459           break;
12460
12461         case R_PPC64_DTPMOD64:
12462           if (rel + 1 < relend
12463               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12464               && rel[1].r_offset == rel->r_offset + 8)
12465             {
12466               if ((tls_mask & TLS_GD) == 0)
12467                 {
12468                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12469                   if ((tls_mask & TLS_TPRELGD) != 0)
12470                     r_type = R_PPC64_TPREL64;
12471                   else
12472                     {
12473                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12474                       r_type = R_PPC64_NONE;
12475                     }
12476                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12477                 }
12478             }
12479           else
12480             {
12481               if ((tls_mask & TLS_LD) == 0)
12482                 {
12483                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12484                   r_type = R_PPC64_NONE;
12485                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12486                 }
12487             }
12488           break;
12489
12490         case R_PPC64_TPREL64:
12491           if ((tls_mask & TLS_TPREL) == 0)
12492             {
12493               r_type = R_PPC64_NONE;
12494               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12495             }
12496           break;
12497         }
12498
12499       /* Handle other relocations that tweak non-addend part of insn.  */
12500       insn = 0;
12501       max_br_offset = 1 << 25;
12502       addend = rel->r_addend;
12503       switch (r_type)
12504         {
12505         default:
12506           break;
12507
12508         case R_PPC64_TOCSAVE:
12509           if (relocation + addend == (rel->r_offset
12510                                       + input_section->output_offset
12511                                       + input_section->output_section->vma)
12512               && tocsave_find (htab, NO_INSERT,
12513                                &local_syms, rel, input_bfd))
12514             {
12515               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12516               if (insn == NOP
12517                   || insn == CROR_151515 || insn == CROR_313131)
12518                 bfd_put_32 (input_bfd, STD_R2_40R1,
12519                             contents + rel->r_offset);
12520             }
12521           break;
12522
12523           /* Branch taken prediction relocations.  */
12524         case R_PPC64_ADDR14_BRTAKEN:
12525         case R_PPC64_REL14_BRTAKEN:
12526           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12527           /* Fall thru.  */
12528
12529           /* Branch not taken prediction relocations.  */
12530         case R_PPC64_ADDR14_BRNTAKEN:
12531         case R_PPC64_REL14_BRNTAKEN:
12532           insn |= bfd_get_32 (output_bfd,
12533                               contents + rel->r_offset) & ~(0x01 << 21);
12534           /* Fall thru.  */
12535
12536         case R_PPC64_REL14:
12537           max_br_offset = 1 << 15;
12538           /* Fall thru.  */
12539
12540         case R_PPC64_REL24:
12541           /* Calls to functions with a different TOC, such as calls to
12542              shared objects, need to alter the TOC pointer.  This is
12543              done using a linkage stub.  A REL24 branching to these
12544              linkage stubs needs to be followed by a nop, as the nop
12545              will be replaced with an instruction to restore the TOC
12546              base pointer.  */
12547           fdh = h;
12548           if (h != NULL
12549               && h->oh != NULL
12550               && h->oh->is_func_descriptor)
12551             fdh = ppc_follow_link (h->oh);
12552           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12553           if (stub_entry != NULL
12554               && (stub_entry->stub_type == ppc_stub_plt_call
12555                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12556                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12557             {
12558               bfd_boolean can_plt_call = FALSE;
12559
12560               if (rel->r_offset + 8 <= input_section->size)
12561                 {
12562                   unsigned long nop;
12563                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12564                   if (nop == NOP
12565                       || nop == CROR_151515 || nop == CROR_313131)
12566                     {
12567                       if (h != NULL
12568                           && (h == htab->tls_get_addr_fd
12569                               || h == htab->tls_get_addr)
12570                           && !htab->no_tls_get_addr_opt)
12571                         {
12572                           /* Special stub used, leave nop alone.  */
12573                         }
12574                       else
12575                         bfd_put_32 (input_bfd, LD_R2_40R1,
12576                                     contents + rel->r_offset + 4);
12577                       can_plt_call = TRUE;
12578                     }
12579                 }
12580
12581               if (!can_plt_call)
12582                 {
12583                   if (stub_entry->stub_type == ppc_stub_plt_call)
12584                     {
12585                       /* If this is a plain branch rather than a branch
12586                          and link, don't require a nop.  However, don't
12587                          allow tail calls in a shared library as they
12588                          will result in r2 being corrupted.  */
12589                       unsigned long br;
12590                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12591                       if (info->executable && (br & 1) == 0)
12592                         can_plt_call = TRUE;
12593                       else
12594                         stub_entry = NULL;
12595                     }
12596                   else if (h != NULL
12597                            && strcmp (h->elf.root.root.string,
12598                                       ".__libc_start_main") == 0)
12599                     {
12600                       /* Allow crt1 branch to go via a toc adjusting stub.  */
12601                       can_plt_call = TRUE;
12602                     }
12603                   else
12604                     {
12605                       if (strcmp (input_section->output_section->name,
12606                                   ".init") == 0
12607                           || strcmp (input_section->output_section->name,
12608                                      ".fini") == 0)
12609                         info->callbacks->einfo
12610                           (_("%P: %H: automatic multiple TOCs "
12611                              "not supported using your crt files; "
12612                              "recompile with -mminimal-toc or upgrade gcc\n"),
12613                            input_bfd, input_section, rel->r_offset);
12614                       else
12615                         info->callbacks->einfo
12616                           (_("%P: %H: sibling call optimization to `%s' "
12617                              "does not allow automatic multiple TOCs; "
12618                              "recompile with -mminimal-toc or "
12619                              "-fno-optimize-sibling-calls, "
12620                              "or make `%s' extern\n"),
12621                            input_bfd, input_section, rel->r_offset,
12622                            sym_name,
12623                            sym_name);
12624                       bfd_set_error (bfd_error_bad_value);
12625                       ret = FALSE;
12626                     }
12627                 }
12628
12629               if (can_plt_call
12630                   && stub_entry->stub_type == ppc_stub_plt_call)
12631                 unresolved_reloc = FALSE;
12632             }
12633
12634           if ((stub_entry == NULL
12635                || stub_entry->stub_type == ppc_stub_long_branch
12636                || stub_entry->stub_type == ppc_stub_plt_branch)
12637               && get_opd_info (sec) != NULL)
12638             {
12639               /* The branch destination is the value of the opd entry. */
12640               bfd_vma off = (relocation + addend
12641                              - sec->output_section->vma
12642                              - sec->output_offset);
12643               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12644               if (dest != (bfd_vma) -1)
12645                 {
12646                   relocation = dest;
12647                   addend = 0;
12648                 }
12649             }
12650
12651           /* If the branch is out of reach we ought to have a long
12652              branch stub.  */
12653           from = (rel->r_offset
12654                   + input_section->output_offset
12655                   + input_section->output_section->vma);
12656
12657           if (stub_entry != NULL
12658               && (stub_entry->stub_type == ppc_stub_long_branch
12659                   || stub_entry->stub_type == ppc_stub_plt_branch)
12660               && (r_type == R_PPC64_ADDR14_BRTAKEN
12661                   || r_type == R_PPC64_ADDR14_BRNTAKEN
12662                   || (relocation + addend - from + max_br_offset
12663                       < 2 * max_br_offset)))
12664             /* Don't use the stub if this branch is in range.  */
12665             stub_entry = NULL;
12666
12667           if (stub_entry != NULL)
12668             {
12669               /* Munge up the value and addend so that we call the stub
12670                  rather than the procedure directly.  */
12671               relocation = (stub_entry->stub_offset
12672                             + stub_entry->stub_sec->output_offset
12673                             + stub_entry->stub_sec->output_section->vma);
12674               addend = 0;
12675
12676               if (stub_entry->stub_type == ppc_stub_plt_call
12677                   && rel + 1 < relend
12678                   && rel[1].r_offset == rel->r_offset + 4
12679                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
12680                 relocation += 4;
12681             }
12682
12683           if (insn != 0)
12684             {
12685               if (is_power4)
12686                 {
12687                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12688                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12689                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12690                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12691                     insn |= 0x02 << 21;
12692                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12693                     insn |= 0x08 << 21;
12694                   else
12695                     break;
12696                 }
12697               else
12698                 {
12699                   /* Invert 'y' bit if not the default.  */
12700                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12701                     insn ^= 0x01 << 21;
12702                 }
12703
12704               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12705             }
12706
12707           /* NOP out calls to undefined weak functions.
12708              We can thus call a weak function without first
12709              checking whether the function is defined.  */
12710           else if (h != NULL
12711                    && h->elf.root.type == bfd_link_hash_undefweak
12712                    && h->elf.dynindx == -1
12713                    && r_type == R_PPC64_REL24
12714                    && relocation == 0
12715                    && addend == 0)
12716             {
12717               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12718               continue;
12719             }
12720           break;
12721         }
12722
12723       /* Set `addend'.  */
12724       tls_type = 0;
12725       switch (r_type)
12726         {
12727         default:
12728           info->callbacks->einfo
12729             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
12730              input_bfd, (int) r_type, sym_name);
12731
12732           bfd_set_error (bfd_error_bad_value);
12733           ret = FALSE;
12734           continue;
12735
12736         case R_PPC64_NONE:
12737         case R_PPC64_TLS:
12738         case R_PPC64_TLSGD:
12739         case R_PPC64_TLSLD:
12740         case R_PPC64_TOCSAVE:
12741         case R_PPC64_GNU_VTINHERIT:
12742         case R_PPC64_GNU_VTENTRY:
12743           continue;
12744
12745           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12746              address in the GOT as relocation value instead of the
12747              symbol's value itself.  Also, create a GOT entry for the
12748              symbol and put the symbol value there.  */
12749         case R_PPC64_GOT_TLSGD16:
12750         case R_PPC64_GOT_TLSGD16_LO:
12751         case R_PPC64_GOT_TLSGD16_HI:
12752         case R_PPC64_GOT_TLSGD16_HA:
12753           tls_type = TLS_TLS | TLS_GD;
12754           goto dogot;
12755
12756         case R_PPC64_GOT_TLSLD16:
12757         case R_PPC64_GOT_TLSLD16_LO:
12758         case R_PPC64_GOT_TLSLD16_HI:
12759         case R_PPC64_GOT_TLSLD16_HA:
12760           tls_type = TLS_TLS | TLS_LD;
12761           goto dogot;
12762
12763         case R_PPC64_GOT_TPREL16_DS:
12764         case R_PPC64_GOT_TPREL16_LO_DS:
12765         case R_PPC64_GOT_TPREL16_HI:
12766         case R_PPC64_GOT_TPREL16_HA:
12767           tls_type = TLS_TLS | TLS_TPREL;
12768           goto dogot;
12769
12770         case R_PPC64_GOT_DTPREL16_DS:
12771         case R_PPC64_GOT_DTPREL16_LO_DS:
12772         case R_PPC64_GOT_DTPREL16_HI:
12773         case R_PPC64_GOT_DTPREL16_HA:
12774           tls_type = TLS_TLS | TLS_DTPREL;
12775           goto dogot;
12776
12777         case R_PPC64_GOT16:
12778         case R_PPC64_GOT16_LO:
12779         case R_PPC64_GOT16_HI:
12780         case R_PPC64_GOT16_HA:
12781         case R_PPC64_GOT16_DS:
12782         case R_PPC64_GOT16_LO_DS:
12783         dogot:
12784           {
12785             /* Relocation is to the entry for this symbol in the global
12786                offset table.  */
12787             asection *got;
12788             bfd_vma *offp;
12789             bfd_vma off;
12790             unsigned long indx = 0;
12791             struct got_entry *ent;
12792
12793             if (tls_type == (TLS_TLS | TLS_LD)
12794                 && (h == NULL
12795                     || !h->elf.def_dynamic))
12796               ent = ppc64_tlsld_got (input_bfd);
12797             else
12798               {
12799
12800                 if (h != NULL)
12801                   {
12802                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12803                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12804                                                           &h->elf)
12805                         || (info->shared
12806                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12807                       /* This is actually a static link, or it is a
12808                          -Bsymbolic link and the symbol is defined
12809                          locally, or the symbol was forced to be local
12810                          because of a version file.  */
12811                       ;
12812                     else
12813                       {
12814                         indx = h->elf.dynindx;
12815                         unresolved_reloc = FALSE;
12816                       }
12817                     ent = h->elf.got.glist;
12818                   }
12819                 else
12820                   {
12821                     if (local_got_ents == NULL)
12822                       abort ();
12823                     ent = local_got_ents[r_symndx];
12824                   }
12825
12826                 for (; ent != NULL; ent = ent->next)
12827                   if (ent->addend == orig_addend
12828                       && ent->owner == input_bfd
12829                       && ent->tls_type == tls_type)
12830                     break;
12831               }
12832
12833             if (ent == NULL)
12834               abort ();
12835             if (ent->is_indirect)
12836               ent = ent->got.ent;
12837             offp = &ent->got.offset;
12838             got = ppc64_elf_tdata (ent->owner)->got;
12839             if (got == NULL)
12840               abort ();
12841
12842             /* The offset must always be a multiple of 8.  We use the
12843                least significant bit to record whether we have already
12844                processed this entry.  */
12845             off = *offp;
12846             if ((off & 1) != 0)
12847               off &= ~1;
12848             else
12849               {
12850                 /* Generate relocs for the dynamic linker, except in
12851                    the case of TLSLD where we'll use one entry per
12852                    module.  */
12853                 asection *relgot;
12854                 bfd_boolean ifunc;
12855
12856                 *offp = off | 1;
12857                 relgot = NULL;
12858                 ifunc = (h != NULL
12859                          ? h->elf.type == STT_GNU_IFUNC
12860                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12861                 if ((info->shared || indx != 0)
12862                     && (h == NULL
12863                         || (tls_type == (TLS_TLS | TLS_LD)
12864                             && !h->elf.def_dynamic)
12865                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12866                         || h->elf.root.type != bfd_link_hash_undefweak))
12867                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12868                 else if (ifunc)
12869                   relgot = htab->reliplt;
12870                 if (relgot != NULL)
12871                   {
12872                     outrel.r_offset = (got->output_section->vma
12873                                        + got->output_offset
12874                                        + off);
12875                     outrel.r_addend = addend;
12876                     if (tls_type & (TLS_LD | TLS_GD))
12877                       {
12878                         outrel.r_addend = 0;
12879                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12880                         if (tls_type == (TLS_TLS | TLS_GD))
12881                           {
12882                             loc = relgot->contents;
12883                             loc += (relgot->reloc_count++
12884                                     * sizeof (Elf64_External_Rela));
12885                             bfd_elf64_swap_reloca_out (output_bfd,
12886                                                        &outrel, loc);
12887                             outrel.r_offset += 8;
12888                             outrel.r_addend = addend;
12889                             outrel.r_info
12890                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12891                           }
12892                       }
12893                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12894                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12895                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12896                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12897                     else if (indx != 0)
12898                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12899                     else
12900                       {
12901                         if (ifunc)
12902                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12903                         else
12904                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12905
12906                         /* Write the .got section contents for the sake
12907                            of prelink.  */
12908                         loc = got->contents + off;
12909                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12910                                     loc);
12911                       }
12912
12913                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12914                       {
12915                         outrel.r_addend += relocation;
12916                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12917                           outrel.r_addend -= htab->elf.tls_sec->vma;
12918                       }
12919                     loc = relgot->contents;
12920                     loc += (relgot->reloc_count++
12921                             * sizeof (Elf64_External_Rela));
12922                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12923                   }
12924
12925                 /* Init the .got section contents here if we're not
12926                    emitting a reloc.  */
12927                 else
12928                   {
12929                     relocation += addend;
12930                     if (tls_type == (TLS_TLS | TLS_LD))
12931                       relocation = 1;
12932                     else if (tls_type != 0)
12933                       {
12934                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12935                         if (tls_type == (TLS_TLS | TLS_TPREL))
12936                           relocation += DTP_OFFSET - TP_OFFSET;
12937
12938                         if (tls_type == (TLS_TLS | TLS_GD))
12939                           {
12940                             bfd_put_64 (output_bfd, relocation,
12941                                         got->contents + off + 8);
12942                             relocation = 1;
12943                           }
12944                       }
12945
12946                     bfd_put_64 (output_bfd, relocation,
12947                                 got->contents + off);
12948                   }
12949               }
12950
12951             if (off >= (bfd_vma) -2)
12952               abort ();
12953
12954             relocation = got->output_section->vma + got->output_offset + off;
12955             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12956           }
12957           break;
12958
12959         case R_PPC64_PLT16_HA:
12960         case R_PPC64_PLT16_HI:
12961         case R_PPC64_PLT16_LO:
12962         case R_PPC64_PLT32:
12963         case R_PPC64_PLT64:
12964           /* Relocation is to the entry for this symbol in the
12965              procedure linkage table.  */
12966
12967           /* Resolve a PLT reloc against a local symbol directly,
12968              without using the procedure linkage table.  */
12969           if (h == NULL)
12970             break;
12971
12972           /* It's possible that we didn't make a PLT entry for this
12973              symbol.  This happens when statically linking PIC code,
12974              or when using -Bsymbolic.  Go find a match if there is a
12975              PLT entry.  */
12976           if (htab->plt != NULL)
12977             {
12978               struct plt_entry *ent;
12979               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12980                 if (ent->addend == orig_addend
12981                     && ent->plt.offset != (bfd_vma) -1)
12982                   {
12983                     relocation = (htab->plt->output_section->vma
12984                                   + htab->plt->output_offset
12985                                   + ent->plt.offset);
12986                     unresolved_reloc = FALSE;
12987                   }
12988             }
12989           break;
12990
12991         case R_PPC64_TOC:
12992           /* Relocation value is TOC base.  */
12993           relocation = TOCstart;
12994           if (r_symndx == STN_UNDEF)
12995             relocation += htab->stub_group[input_section->id].toc_off;
12996           else if (unresolved_reloc)
12997             ;
12998           else if (sec != NULL && sec->id <= htab->top_id)
12999             relocation += htab->stub_group[sec->id].toc_off;
13000           else
13001             unresolved_reloc = TRUE;
13002           goto dodyn;
13003
13004           /* TOC16 relocs.  We want the offset relative to the TOC base,
13005              which is the address of the start of the TOC plus 0x8000.
13006              The TOC consists of sections .got, .toc, .tocbss, and .plt,
13007              in this order.  */
13008         case R_PPC64_TOC16:
13009         case R_PPC64_TOC16_LO:
13010         case R_PPC64_TOC16_HI:
13011         case R_PPC64_TOC16_DS:
13012         case R_PPC64_TOC16_LO_DS:
13013         case R_PPC64_TOC16_HA:
13014           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13015           break;
13016
13017           /* Relocate against the beginning of the section.  */
13018         case R_PPC64_SECTOFF:
13019         case R_PPC64_SECTOFF_LO:
13020         case R_PPC64_SECTOFF_HI:
13021         case R_PPC64_SECTOFF_DS:
13022         case R_PPC64_SECTOFF_LO_DS:
13023         case R_PPC64_SECTOFF_HA:
13024           if (sec != NULL)
13025             addend -= sec->output_section->vma;
13026           break;
13027
13028         case R_PPC64_REL16:
13029         case R_PPC64_REL16_LO:
13030         case R_PPC64_REL16_HI:
13031         case R_PPC64_REL16_HA:
13032           break;
13033
13034         case R_PPC64_REL14:
13035         case R_PPC64_REL14_BRNTAKEN:
13036         case R_PPC64_REL14_BRTAKEN:
13037         case R_PPC64_REL24:
13038           break;
13039
13040         case R_PPC64_TPREL16:
13041         case R_PPC64_TPREL16_LO:
13042         case R_PPC64_TPREL16_HI:
13043         case R_PPC64_TPREL16_HA:
13044         case R_PPC64_TPREL16_DS:
13045         case R_PPC64_TPREL16_LO_DS:
13046         case R_PPC64_TPREL16_HIGHER:
13047         case R_PPC64_TPREL16_HIGHERA:
13048         case R_PPC64_TPREL16_HIGHEST:
13049         case R_PPC64_TPREL16_HIGHESTA:
13050           if (h != NULL
13051               && h->elf.root.type == bfd_link_hash_undefweak
13052               && h->elf.dynindx == -1)
13053             {
13054               /* Make this relocation against an undefined weak symbol
13055                  resolve to zero.  This is really just a tweak, since
13056                  code using weak externs ought to check that they are
13057                  defined before using them.  */
13058               bfd_byte *p = contents + rel->r_offset - d_offset;
13059
13060               insn = bfd_get_32 (output_bfd, p);
13061               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13062               if (insn != 0)
13063                 bfd_put_32 (output_bfd, insn, p);
13064               break;
13065             }
13066           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13067           if (info->shared)
13068             /* The TPREL16 relocs shouldn't really be used in shared
13069                libs as they will result in DT_TEXTREL being set, but
13070                support them anyway.  */
13071             goto dodyn;
13072           break;
13073
13074         case R_PPC64_DTPREL16:
13075         case R_PPC64_DTPREL16_LO:
13076         case R_PPC64_DTPREL16_HI:
13077         case R_PPC64_DTPREL16_HA:
13078         case R_PPC64_DTPREL16_DS:
13079         case R_PPC64_DTPREL16_LO_DS:
13080         case R_PPC64_DTPREL16_HIGHER:
13081         case R_PPC64_DTPREL16_HIGHERA:
13082         case R_PPC64_DTPREL16_HIGHEST:
13083         case R_PPC64_DTPREL16_HIGHESTA:
13084           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13085           break;
13086
13087         case R_PPC64_DTPMOD64:
13088           relocation = 1;
13089           addend = 0;
13090           goto dodyn;
13091
13092         case R_PPC64_TPREL64:
13093           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13094           goto dodyn;
13095
13096         case R_PPC64_DTPREL64:
13097           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13098           /* Fall thru */
13099
13100           /* Relocations that may need to be propagated if this is a
13101              dynamic object.  */
13102         case R_PPC64_REL30:
13103         case R_PPC64_REL32:
13104         case R_PPC64_REL64:
13105         case R_PPC64_ADDR14:
13106         case R_PPC64_ADDR14_BRNTAKEN:
13107         case R_PPC64_ADDR14_BRTAKEN:
13108         case R_PPC64_ADDR16:
13109         case R_PPC64_ADDR16_DS:
13110         case R_PPC64_ADDR16_HA:
13111         case R_PPC64_ADDR16_HI:
13112         case R_PPC64_ADDR16_HIGHER:
13113         case R_PPC64_ADDR16_HIGHERA:
13114         case R_PPC64_ADDR16_HIGHEST:
13115         case R_PPC64_ADDR16_HIGHESTA:
13116         case R_PPC64_ADDR16_LO:
13117         case R_PPC64_ADDR16_LO_DS:
13118         case R_PPC64_ADDR24:
13119         case R_PPC64_ADDR32:
13120         case R_PPC64_ADDR64:
13121         case R_PPC64_UADDR16:
13122         case R_PPC64_UADDR32:
13123         case R_PPC64_UADDR64:
13124         dodyn:
13125           if ((input_section->flags & SEC_ALLOC) == 0)
13126             break;
13127
13128           if (NO_OPD_RELOCS && is_opd)
13129             break;
13130
13131           if ((info->shared
13132                && (h == NULL
13133                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13134                    || h->elf.root.type != bfd_link_hash_undefweak)
13135                && (must_be_dyn_reloc (info, r_type)
13136                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13137               || (ELIMINATE_COPY_RELOCS
13138                   && !info->shared
13139                   && h != NULL
13140                   && h->elf.dynindx != -1
13141                   && !h->elf.non_got_ref
13142                   && !h->elf.def_regular)
13143               || (!info->shared
13144                   && (h != NULL
13145                       ? h->elf.type == STT_GNU_IFUNC
13146                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13147             {
13148               bfd_boolean skip, relocate;
13149               asection *sreloc;
13150               bfd_vma out_off;
13151
13152               /* When generating a dynamic object, these relocations
13153                  are copied into the output file to be resolved at run
13154                  time.  */
13155
13156               skip = FALSE;
13157               relocate = FALSE;
13158
13159               out_off = _bfd_elf_section_offset (output_bfd, info,
13160                                                  input_section, rel->r_offset);
13161               if (out_off == (bfd_vma) -1)
13162                 skip = TRUE;
13163               else if (out_off == (bfd_vma) -2)
13164                 skip = TRUE, relocate = TRUE;
13165               out_off += (input_section->output_section->vma
13166                           + input_section->output_offset);
13167               outrel.r_offset = out_off;
13168               outrel.r_addend = rel->r_addend;
13169
13170               /* Optimize unaligned reloc use.  */
13171               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13172                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13173                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13174               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13175                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13176                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13177               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13178                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13179                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13180
13181               if (skip)
13182                 memset (&outrel, 0, sizeof outrel);
13183               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13184                        && !is_opd
13185                        && r_type != R_PPC64_TOC)
13186                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13187               else
13188                 {
13189                   /* This symbol is local, or marked to become local,
13190                      or this is an opd section reloc which must point
13191                      at a local function.  */
13192                   outrel.r_addend += relocation;
13193                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13194                     {
13195                       if (is_opd && h != NULL)
13196                         {
13197                           /* Lie about opd entries.  This case occurs
13198                              when building shared libraries and we
13199                              reference a function in another shared
13200                              lib.  The same thing happens for a weak
13201                              definition in an application that's
13202                              overridden by a strong definition in a
13203                              shared lib.  (I believe this is a generic
13204                              bug in binutils handling of weak syms.)
13205                              In these cases we won't use the opd
13206                              entry in this lib.  */
13207                           unresolved_reloc = FALSE;
13208                         }
13209                       if (!is_opd
13210                           && r_type == R_PPC64_ADDR64
13211                           && (h != NULL
13212                               ? h->elf.type == STT_GNU_IFUNC
13213                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13214                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13215                       else
13216                         {
13217                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13218
13219                           /* We need to relocate .opd contents for ld.so.
13220                              Prelink also wants simple and consistent rules
13221                              for relocs.  This make all RELATIVE relocs have
13222                              *r_offset equal to r_addend.  */
13223                           relocate = TRUE;
13224                         }
13225                     }
13226                   else
13227                     {
13228                       long indx = 0;
13229
13230                       if (h != NULL
13231                           ? h->elf.type == STT_GNU_IFUNC
13232                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13233                         {
13234                           info->callbacks->einfo
13235                             (_("%P: %H: relocation %s for indirect "
13236                                "function %s unsupported\n"),
13237                              input_bfd, input_section, rel->r_offset,
13238                              ppc64_elf_howto_table[r_type]->name,
13239                              sym_name);
13240                           ret = FALSE;
13241                         }
13242                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13243                         ;
13244                       else if (sec == NULL || sec->owner == NULL)
13245                         {
13246                           bfd_set_error (bfd_error_bad_value);
13247                           return FALSE;
13248                         }
13249                       else
13250                         {
13251                           asection *osec;
13252
13253                           osec = sec->output_section;
13254                           indx = elf_section_data (osec)->dynindx;
13255
13256                           if (indx == 0)
13257                             {
13258                               if ((osec->flags & SEC_READONLY) == 0
13259                                   && htab->elf.data_index_section != NULL)
13260                                 osec = htab->elf.data_index_section;
13261                               else
13262                                 osec = htab->elf.text_index_section;
13263                               indx = elf_section_data (osec)->dynindx;
13264                             }
13265                           BFD_ASSERT (indx != 0);
13266
13267                           /* We are turning this relocation into one
13268                              against a section symbol, so subtract out
13269                              the output section's address but not the
13270                              offset of the input section in the output
13271                              section.  */
13272                           outrel.r_addend -= osec->vma;
13273                         }
13274
13275                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13276                     }
13277                 }
13278
13279               sreloc = elf_section_data (input_section)->sreloc;
13280               if (!htab->elf.dynamic_sections_created)
13281                 sreloc = htab->reliplt;
13282               if (sreloc == NULL)
13283                 abort ();
13284
13285               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13286                   >= sreloc->size)
13287                 abort ();
13288               loc = sreloc->contents;
13289               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13290               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13291
13292               /* If this reloc is against an external symbol, it will
13293                  be computed at runtime, so there's no need to do
13294                  anything now.  However, for the sake of prelink ensure
13295                  that the section contents are a known value.  */
13296               if (! relocate)
13297                 {
13298                   unresolved_reloc = FALSE;
13299                   /* The value chosen here is quite arbitrary as ld.so
13300                      ignores section contents except for the special
13301                      case of .opd where the contents might be accessed
13302                      before relocation.  Choose zero, as that won't
13303                      cause reloc overflow.  */
13304                   relocation = 0;
13305                   addend = 0;
13306                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13307                      to improve backward compatibility with older
13308                      versions of ld.  */
13309                   if (r_type == R_PPC64_ADDR64)
13310                     addend = outrel.r_addend;
13311                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13312                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13313                     addend = (input_section->output_section->vma
13314                               + input_section->output_offset
13315                               + rel->r_offset);
13316                 }
13317             }
13318           break;
13319
13320         case R_PPC64_COPY:
13321         case R_PPC64_GLOB_DAT:
13322         case R_PPC64_JMP_SLOT:
13323         case R_PPC64_JMP_IREL:
13324         case R_PPC64_RELATIVE:
13325           /* We shouldn't ever see these dynamic relocs in relocatable
13326              files.  */
13327           /* Fall through.  */
13328
13329         case R_PPC64_PLTGOT16:
13330         case R_PPC64_PLTGOT16_DS:
13331         case R_PPC64_PLTGOT16_HA:
13332         case R_PPC64_PLTGOT16_HI:
13333         case R_PPC64_PLTGOT16_LO:
13334         case R_PPC64_PLTGOT16_LO_DS:
13335         case R_PPC64_PLTREL32:
13336         case R_PPC64_PLTREL64:
13337           /* These ones haven't been implemented yet.  */
13338
13339           info->callbacks->einfo
13340             (_("%P: %B: relocation %s is not supported for symbol %s\n"),
13341              input_bfd,
13342              ppc64_elf_howto_table[r_type]->name, sym_name);
13343
13344           bfd_set_error (bfd_error_invalid_operation);
13345           ret = FALSE;
13346           continue;
13347         }
13348
13349       /* Multi-instruction sequences that access the TOC can be
13350          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13351          to             nop;           addi rb,r2,x;  */
13352       switch (r_type)
13353         {
13354         default:
13355           break;
13356
13357         case R_PPC64_GOT_TLSLD16_HI:
13358         case R_PPC64_GOT_TLSGD16_HI:
13359         case R_PPC64_GOT_TPREL16_HI:
13360         case R_PPC64_GOT_DTPREL16_HI:
13361         case R_PPC64_GOT16_HI:
13362         case R_PPC64_TOC16_HI:
13363           /* These relocs would only be useful if building up an
13364              offset to later add to r2, perhaps in an indexed
13365              addressing mode instruction.  Don't try to optimize.
13366              Unfortunately, the possibility of someone building up an
13367              offset like this or even with the HA relocs, means that
13368              we need to check the high insn when optimizing the low
13369              insn.  */
13370           break;
13371
13372         case R_PPC64_GOT_TLSLD16_HA:
13373         case R_PPC64_GOT_TLSGD16_HA:
13374         case R_PPC64_GOT_TPREL16_HA:
13375         case R_PPC64_GOT_DTPREL16_HA:
13376         case R_PPC64_GOT16_HA:
13377         case R_PPC64_TOC16_HA:
13378           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13379               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13380             {
13381               bfd_byte *p = contents + (rel->r_offset & ~3);
13382               bfd_put_32 (input_bfd, NOP, p);
13383             }
13384           break;
13385
13386         case R_PPC64_GOT_TLSLD16_LO:
13387         case R_PPC64_GOT_TLSGD16_LO:
13388         case R_PPC64_GOT_TPREL16_LO_DS:
13389         case R_PPC64_GOT_DTPREL16_LO_DS:
13390         case R_PPC64_GOT16_LO:
13391         case R_PPC64_GOT16_LO_DS:
13392         case R_PPC64_TOC16_LO:
13393         case R_PPC64_TOC16_LO_DS:
13394           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13395               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13396             {
13397               bfd_byte *p = contents + (rel->r_offset & ~3);
13398               insn = bfd_get_32 (input_bfd, p);
13399               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13400                 {
13401                   /* Transform addic to addi when we change reg.  */
13402                   insn &= ~((0x3f << 26) | (0x1f << 16));
13403                   insn |= (14u << 26) | (2 << 16);
13404                 }
13405               else
13406                 {
13407                   insn &= ~(0x1f << 16);
13408                   insn |= 2 << 16;
13409                 }
13410               bfd_put_32 (input_bfd, insn, p);
13411             }
13412           break;
13413         }
13414
13415       /* Do any further special processing.  */
13416       switch (r_type)
13417         {
13418         default:
13419           break;
13420
13421         case R_PPC64_ADDR16_HA:
13422         case R_PPC64_REL16_HA:
13423         case R_PPC64_ADDR16_HIGHERA:
13424         case R_PPC64_ADDR16_HIGHESTA:
13425         case R_PPC64_TOC16_HA:
13426         case R_PPC64_SECTOFF_HA:
13427         case R_PPC64_TPREL16_HA:
13428         case R_PPC64_DTPREL16_HA:
13429         case R_PPC64_TPREL16_HIGHER:
13430         case R_PPC64_TPREL16_HIGHERA:
13431         case R_PPC64_TPREL16_HIGHEST:
13432         case R_PPC64_TPREL16_HIGHESTA:
13433         case R_PPC64_DTPREL16_HIGHER:
13434         case R_PPC64_DTPREL16_HIGHERA:
13435         case R_PPC64_DTPREL16_HIGHEST:
13436         case R_PPC64_DTPREL16_HIGHESTA:
13437           /* It's just possible that this symbol is a weak symbol
13438              that's not actually defined anywhere. In that case,
13439              'sec' would be NULL, and we should leave the symbol
13440              alone (it will be set to zero elsewhere in the link).  */
13441           if (sec == NULL)
13442             break;
13443           /* Fall thru */
13444
13445         case R_PPC64_GOT16_HA:
13446         case R_PPC64_PLTGOT16_HA:
13447         case R_PPC64_PLT16_HA:
13448         case R_PPC64_GOT_TLSGD16_HA:
13449         case R_PPC64_GOT_TLSLD16_HA:
13450         case R_PPC64_GOT_TPREL16_HA:
13451         case R_PPC64_GOT_DTPREL16_HA:
13452           /* Add 0x10000 if sign bit in 0:15 is set.
13453              Bits 0:15 are not used.  */
13454           addend += 0x8000;
13455           break;
13456
13457         case R_PPC64_ADDR16_DS:
13458         case R_PPC64_ADDR16_LO_DS:
13459         case R_PPC64_GOT16_DS:
13460         case R_PPC64_GOT16_LO_DS:
13461         case R_PPC64_PLT16_LO_DS:
13462         case R_PPC64_SECTOFF_DS:
13463         case R_PPC64_SECTOFF_LO_DS:
13464         case R_PPC64_TOC16_DS:
13465         case R_PPC64_TOC16_LO_DS:
13466         case R_PPC64_PLTGOT16_DS:
13467         case R_PPC64_PLTGOT16_LO_DS:
13468         case R_PPC64_GOT_TPREL16_DS:
13469         case R_PPC64_GOT_TPREL16_LO_DS:
13470         case R_PPC64_GOT_DTPREL16_DS:
13471         case R_PPC64_GOT_DTPREL16_LO_DS:
13472         case R_PPC64_TPREL16_DS:
13473         case R_PPC64_TPREL16_LO_DS:
13474         case R_PPC64_DTPREL16_DS:
13475         case R_PPC64_DTPREL16_LO_DS:
13476           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13477           mask = 3;
13478           /* If this reloc is against an lq insn, then the value must be
13479              a multiple of 16.  This is somewhat of a hack, but the
13480              "correct" way to do this by defining _DQ forms of all the
13481              _DS relocs bloats all reloc switches in this file.  It
13482              doesn't seem to make much sense to use any of these relocs
13483              in data, so testing the insn should be safe.  */
13484           if ((insn & (0x3f << 26)) == (56u << 26))
13485             mask = 15;
13486           if (((relocation + addend) & mask) != 0)
13487             {
13488               info->callbacks->einfo
13489                 (_("%P: %H: error: %s not a multiple of %u\n"),
13490                  input_bfd, input_section, rel->r_offset,
13491                  ppc64_elf_howto_table[r_type]->name,
13492                  mask + 1);
13493               bfd_set_error (bfd_error_bad_value);
13494               ret = FALSE;
13495               continue;
13496             }
13497           break;
13498         }
13499
13500       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13501          because such sections are not SEC_ALLOC and thus ld.so will
13502          not process them.  */
13503       if (unresolved_reloc
13504           && !((input_section->flags & SEC_DEBUGGING) != 0
13505                && h->elf.def_dynamic)
13506           && _bfd_elf_section_offset (output_bfd, info, input_section,
13507                                       rel->r_offset) != (bfd_vma) -1)
13508         {
13509           info->callbacks->einfo
13510             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
13511              input_bfd, input_section, rel->r_offset,
13512              ppc64_elf_howto_table[(int) r_type]->name,
13513              h->elf.root.root.string);
13514           ret = FALSE;
13515         }
13516
13517       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13518                                     input_bfd,
13519                                     input_section,
13520                                     contents,
13521                                     rel->r_offset,
13522                                     relocation,
13523                                     addend);
13524
13525       if (r != bfd_reloc_ok)
13526         {
13527           if (sym_name == NULL)
13528             sym_name = "(null)";
13529           if (r == bfd_reloc_overflow)
13530             {
13531               if (warned)
13532                 continue;
13533               if (h != NULL
13534                   && h->elf.root.type == bfd_link_hash_undefweak
13535                   && ppc64_elf_howto_table[r_type]->pc_relative)
13536                 {
13537                   /* Assume this is a call protected by other code that
13538                      detects the symbol is undefined.  If this is the case,
13539                      we can safely ignore the overflow.  If not, the
13540                      program is hosed anyway, and a little warning isn't
13541                      going to help.  */
13542
13543                   continue;
13544                 }
13545
13546               if (!((*info->callbacks->reloc_overflow)
13547                     (info, (h ? &h->elf.root : NULL), sym_name,
13548                      ppc64_elf_howto_table[r_type]->name,
13549                      orig_addend, input_bfd, input_section, rel->r_offset)))
13550                 return FALSE;
13551             }
13552           else
13553             {
13554               info->callbacks->einfo
13555                 (_("%P: %H: %s reloc against `%s': error %d\n"),
13556                  input_bfd, input_section, rel->r_offset,
13557                  ppc64_elf_howto_table[r_type]->name,
13558                  sym_name,
13559                  (int) r);
13560               ret = FALSE;
13561             }
13562         }
13563     }
13564
13565   /* If we're emitting relocations, then shortly after this function
13566      returns, reloc offsets and addends for this section will be
13567      adjusted.  Worse, reloc symbol indices will be for the output
13568      file rather than the input.  Save a copy of the relocs for
13569      opd_entry_value.  */
13570   if (is_opd && (info->emitrelocations || info->relocatable))
13571     {
13572       bfd_size_type amt;
13573       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13574       rel = bfd_alloc (input_bfd, amt);
13575       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13576       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13577       if (rel == NULL)
13578         return FALSE;
13579       memcpy (rel, relocs, amt);
13580     }
13581   return ret;
13582 }
13583
13584 /* Adjust the value of any local symbols in opd sections.  */
13585
13586 static int
13587 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13588                               const char *name ATTRIBUTE_UNUSED,
13589                               Elf_Internal_Sym *elfsym,
13590                               asection *input_sec,
13591                               struct elf_link_hash_entry *h)
13592 {
13593   struct _opd_sec_data *opd;
13594   long adjust;
13595   bfd_vma value;
13596
13597   if (h != NULL)
13598     return 1;
13599
13600   opd = get_opd_info (input_sec);
13601   if (opd == NULL || opd->adjust == NULL)
13602     return 1;
13603
13604   value = elfsym->st_value - input_sec->output_offset;
13605   if (!info->relocatable)
13606     value -= input_sec->output_section->vma;
13607
13608   adjust = opd->adjust[value / 8];
13609   if (adjust == -1)
13610     return 2;
13611
13612   elfsym->st_value += adjust;
13613   return 1;
13614 }
13615
13616 /* Finish up dynamic symbol handling.  We set the contents of various
13617    dynamic sections here.  */
13618
13619 static bfd_boolean
13620 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13621                                  struct bfd_link_info *info,
13622                                  struct elf_link_hash_entry *h,
13623                                  Elf_Internal_Sym *sym)
13624 {
13625   struct ppc_link_hash_table *htab;
13626   struct plt_entry *ent;
13627   Elf_Internal_Rela rela;
13628   bfd_byte *loc;
13629
13630   htab = ppc_hash_table (info);
13631   if (htab == NULL)
13632     return FALSE;
13633
13634   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13635     if (ent->plt.offset != (bfd_vma) -1)
13636       {
13637         /* This symbol has an entry in the procedure linkage
13638            table.  Set it up.  */
13639         if (!htab->elf.dynamic_sections_created
13640             || h->dynindx == -1)
13641           {
13642             BFD_ASSERT (h->type == STT_GNU_IFUNC
13643                         && h->def_regular
13644                         && (h->root.type == bfd_link_hash_defined
13645                             || h->root.type == bfd_link_hash_defweak));
13646             rela.r_offset = (htab->iplt->output_section->vma
13647                              + htab->iplt->output_offset
13648                              + ent->plt.offset);
13649             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13650             rela.r_addend = (h->root.u.def.value
13651                              + h->root.u.def.section->output_offset
13652                              + h->root.u.def.section->output_section->vma
13653                              + ent->addend);
13654             loc = (htab->reliplt->contents
13655                    + (htab->reliplt->reloc_count++
13656                       * sizeof (Elf64_External_Rela)));
13657           }
13658         else
13659           {
13660             rela.r_offset = (htab->plt->output_section->vma
13661                              + htab->plt->output_offset
13662                              + ent->plt.offset);
13663             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13664             rela.r_addend = ent->addend;
13665             loc = (htab->relplt->contents
13666                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13667                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13668           }
13669         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13670       }
13671
13672   if (h->needs_copy)
13673     {
13674       /* This symbol needs a copy reloc.  Set it up.  */
13675
13676       if (h->dynindx == -1
13677           || (h->root.type != bfd_link_hash_defined
13678               && h->root.type != bfd_link_hash_defweak)
13679           || htab->relbss == NULL)
13680         abort ();
13681
13682       rela.r_offset = (h->root.u.def.value
13683                        + h->root.u.def.section->output_section->vma
13684                        + h->root.u.def.section->output_offset);
13685       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13686       rela.r_addend = 0;
13687       loc = htab->relbss->contents;
13688       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13689       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13690     }
13691
13692   /* Mark some specially defined symbols as absolute.  */
13693   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13694     sym->st_shndx = SHN_ABS;
13695
13696   return TRUE;
13697 }
13698
13699 /* Used to decide how to sort relocs in an optimal manner for the
13700    dynamic linker, before writing them out.  */
13701
13702 static enum elf_reloc_type_class
13703 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13704 {
13705   enum elf_ppc64_reloc_type r_type;
13706
13707   r_type = ELF64_R_TYPE (rela->r_info);
13708   switch (r_type)
13709     {
13710     case R_PPC64_RELATIVE:
13711       return reloc_class_relative;
13712     case R_PPC64_JMP_SLOT:
13713       return reloc_class_plt;
13714     case R_PPC64_COPY:
13715       return reloc_class_copy;
13716     default:
13717       return reloc_class_normal;
13718     }
13719 }
13720
13721 /* Finish up the dynamic sections.  */
13722
13723 static bfd_boolean
13724 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13725                                    struct bfd_link_info *info)
13726 {
13727   struct ppc_link_hash_table *htab;
13728   bfd *dynobj;
13729   asection *sdyn;
13730
13731   htab = ppc_hash_table (info);
13732   if (htab == NULL)
13733     return FALSE;
13734
13735   dynobj = htab->elf.dynobj;
13736   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13737
13738   if (htab->elf.dynamic_sections_created)
13739     {
13740       Elf64_External_Dyn *dyncon, *dynconend;
13741
13742       if (sdyn == NULL || htab->got == NULL)
13743         abort ();
13744
13745       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13746       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13747       for (; dyncon < dynconend; dyncon++)
13748         {
13749           Elf_Internal_Dyn dyn;
13750           asection *s;
13751
13752           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13753
13754           switch (dyn.d_tag)
13755             {
13756             default:
13757               continue;
13758
13759             case DT_PPC64_GLINK:
13760               s = htab->glink;
13761               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13762               /* We stupidly defined DT_PPC64_GLINK to be the start
13763                  of glink rather than the first entry point, which is
13764                  what ld.so needs, and now have a bigger stub to
13765                  support automatic multiple TOCs.  */
13766               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13767               break;
13768
13769             case DT_PPC64_OPD:
13770               s = bfd_get_section_by_name (output_bfd, ".opd");
13771               if (s == NULL)
13772                 continue;
13773               dyn.d_un.d_ptr = s->vma;
13774               break;
13775
13776             case DT_PPC64_OPDSZ:
13777               s = bfd_get_section_by_name (output_bfd, ".opd");
13778               if (s == NULL)
13779                 continue;
13780               dyn.d_un.d_val = s->size;
13781               break;
13782
13783             case DT_PLTGOT:
13784               s = htab->plt;
13785               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13786               break;
13787
13788             case DT_JMPREL:
13789               s = htab->relplt;
13790               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13791               break;
13792
13793             case DT_PLTRELSZ:
13794               dyn.d_un.d_val = htab->relplt->size;
13795               break;
13796
13797             case DT_RELASZ:
13798               /* Don't count procedure linkage table relocs in the
13799                  overall reloc count.  */
13800               s = htab->relplt;
13801               if (s == NULL)
13802                 continue;
13803               dyn.d_un.d_val -= s->size;
13804               break;
13805
13806             case DT_RELA:
13807               /* We may not be using the standard ELF linker script.
13808                  If .rela.plt is the first .rela section, we adjust
13809                  DT_RELA to not include it.  */
13810               s = htab->relplt;
13811               if (s == NULL)
13812                 continue;
13813               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13814                 continue;
13815               dyn.d_un.d_ptr += s->size;
13816               break;
13817             }
13818
13819           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13820         }
13821     }
13822
13823   if (htab->got != NULL && htab->got->size != 0)
13824     {
13825       /* Fill in the first entry in the global offset table.
13826          We use it to hold the link-time TOCbase.  */
13827       bfd_put_64 (output_bfd,
13828                   elf_gp (output_bfd) + TOC_BASE_OFF,
13829                   htab->got->contents);
13830
13831       /* Set .got entry size.  */
13832       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13833     }
13834
13835   if (htab->plt != NULL && htab->plt->size != 0)
13836     {
13837       /* Set .plt entry size.  */
13838       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13839         = PLT_ENTRY_SIZE;
13840     }
13841
13842   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13843      brlt ourselves if emitrelocations.  */
13844   if (htab->brlt != NULL
13845       && htab->brlt->reloc_count != 0
13846       && !_bfd_elf_link_output_relocs (output_bfd,
13847                                        htab->brlt,
13848                                        elf_section_data (htab->brlt)->rela.hdr,
13849                                        elf_section_data (htab->brlt)->relocs,
13850                                        NULL))
13851     return FALSE;
13852
13853   if (htab->glink != NULL
13854       && htab->glink->reloc_count != 0
13855       && !_bfd_elf_link_output_relocs (output_bfd,
13856                                        htab->glink,
13857                                        elf_section_data (htab->glink)->rela.hdr,
13858                                        elf_section_data (htab->glink)->relocs,
13859                                        NULL))
13860     return FALSE;
13861
13862
13863   if (htab->glink_eh_frame != NULL
13864       && htab->glink_eh_frame->sec_info_type == ELF_INFO_TYPE_EH_FRAME
13865       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
13866                                            htab->glink_eh_frame,
13867                                            htab->glink_eh_frame->contents))
13868     return FALSE;
13869
13870   /* We need to handle writing out multiple GOT sections ourselves,
13871      since we didn't add them to DYNOBJ.  We know dynobj is the first
13872      bfd.  */
13873   while ((dynobj = dynobj->link_next) != NULL)
13874     {
13875       asection *s;
13876
13877       if (!is_ppc64_elf (dynobj))
13878         continue;
13879
13880       s = ppc64_elf_tdata (dynobj)->got;
13881       if (s != NULL
13882           && s->size != 0
13883           && s->output_section != bfd_abs_section_ptr
13884           && !bfd_set_section_contents (output_bfd, s->output_section,
13885                                         s->contents, s->output_offset,
13886                                         s->size))
13887         return FALSE;
13888       s = ppc64_elf_tdata (dynobj)->relgot;
13889       if (s != NULL
13890           && s->size != 0
13891           && s->output_section != bfd_abs_section_ptr
13892           && !bfd_set_section_contents (output_bfd, s->output_section,
13893                                         s->contents, s->output_offset,
13894                                         s->size))
13895         return FALSE;
13896     }
13897
13898   return TRUE;
13899 }
13900
13901 #include "elf64-target.h"