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   /* Computes the load module index of the load module that contains the
1286      definition of its TLS sym.  */
1287   HOWTO (R_PPC64_DTPMOD64,
1288          0,                     /* rightshift */
1289          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1290          64,                    /* bitsize */
1291          FALSE,                 /* pc_relative */
1292          0,                     /* bitpos */
1293          complain_overflow_dont, /* complain_on_overflow */
1294          ppc64_elf_unhandled_reloc, /* special_function */
1295          "R_PPC64_DTPMOD64",    /* name */
1296          FALSE,                 /* partial_inplace */
1297          0,                     /* src_mask */
1298          ONES (64),             /* dst_mask */
1299          FALSE),                /* pcrel_offset */
1300
1301   /* Computes a dtv-relative displacement, the difference between the value
1302      of sym+add and the base address of the thread-local storage block that
1303      contains the definition of sym, minus 0x8000.  */
1304   HOWTO (R_PPC64_DTPREL64,
1305          0,                     /* rightshift */
1306          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1307          64,                    /* bitsize */
1308          FALSE,                 /* pc_relative */
1309          0,                     /* bitpos */
1310          complain_overflow_dont, /* complain_on_overflow */
1311          ppc64_elf_unhandled_reloc, /* special_function */
1312          "R_PPC64_DTPREL64",    /* name */
1313          FALSE,                 /* partial_inplace */
1314          0,                     /* src_mask */
1315          ONES (64),             /* dst_mask */
1316          FALSE),                /* pcrel_offset */
1317
1318   /* A 16 bit dtprel reloc.  */
1319   HOWTO (R_PPC64_DTPREL16,
1320          0,                     /* rightshift */
1321          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1322          16,                    /* bitsize */
1323          FALSE,                 /* pc_relative */
1324          0,                     /* bitpos */
1325          complain_overflow_signed, /* complain_on_overflow */
1326          ppc64_elf_unhandled_reloc, /* special_function */
1327          "R_PPC64_DTPREL16",    /* name */
1328          FALSE,                 /* partial_inplace */
1329          0,                     /* src_mask */
1330          0xffff,                /* dst_mask */
1331          FALSE),                /* pcrel_offset */
1332
1333   /* Like DTPREL16, but no overflow.  */
1334   HOWTO (R_PPC64_DTPREL16_LO,
1335          0,                     /* rightshift */
1336          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1337          16,                    /* bitsize */
1338          FALSE,                 /* pc_relative */
1339          0,                     /* bitpos */
1340          complain_overflow_dont, /* complain_on_overflow */
1341          ppc64_elf_unhandled_reloc, /* special_function */
1342          "R_PPC64_DTPREL16_LO", /* name */
1343          FALSE,                 /* partial_inplace */
1344          0,                     /* src_mask */
1345          0xffff,                /* dst_mask */
1346          FALSE),                /* pcrel_offset */
1347
1348   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1349   HOWTO (R_PPC64_DTPREL16_HI,
1350          16,                    /* rightshift */
1351          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1352          16,                    /* bitsize */
1353          FALSE,                 /* pc_relative */
1354          0,                     /* bitpos */
1355          complain_overflow_dont, /* complain_on_overflow */
1356          ppc64_elf_unhandled_reloc, /* special_function */
1357          "R_PPC64_DTPREL16_HI", /* name */
1358          FALSE,                 /* partial_inplace */
1359          0,                     /* src_mask */
1360          0xffff,                /* dst_mask */
1361          FALSE),                /* pcrel_offset */
1362
1363   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1364   HOWTO (R_PPC64_DTPREL16_HA,
1365          16,                    /* rightshift */
1366          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1367          16,                    /* bitsize */
1368          FALSE,                 /* pc_relative */
1369          0,                     /* bitpos */
1370          complain_overflow_dont, /* complain_on_overflow */
1371          ppc64_elf_unhandled_reloc, /* special_function */
1372          "R_PPC64_DTPREL16_HA", /* name */
1373          FALSE,                 /* partial_inplace */
1374          0,                     /* src_mask */
1375          0xffff,                /* dst_mask */
1376          FALSE),                /* pcrel_offset */
1377
1378   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1379   HOWTO (R_PPC64_DTPREL16_HIGHER,
1380          32,                    /* rightshift */
1381          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1382          16,                    /* bitsize */
1383          FALSE,                 /* pc_relative */
1384          0,                     /* bitpos */
1385          complain_overflow_dont, /* complain_on_overflow */
1386          ppc64_elf_unhandled_reloc, /* special_function */
1387          "R_PPC64_DTPREL16_HIGHER", /* name */
1388          FALSE,                 /* partial_inplace */
1389          0,                     /* src_mask */
1390          0xffff,                /* dst_mask */
1391          FALSE),                /* pcrel_offset */
1392
1393   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1394   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1395          32,                    /* rightshift */
1396          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1397          16,                    /* bitsize */
1398          FALSE,                 /* pc_relative */
1399          0,                     /* bitpos */
1400          complain_overflow_dont, /* complain_on_overflow */
1401          ppc64_elf_unhandled_reloc, /* special_function */
1402          "R_PPC64_DTPREL16_HIGHERA", /* name */
1403          FALSE,                 /* partial_inplace */
1404          0,                     /* src_mask */
1405          0xffff,                /* dst_mask */
1406          FALSE),                /* pcrel_offset */
1407
1408   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1409   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1410          48,                    /* rightshift */
1411          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1412          16,                    /* bitsize */
1413          FALSE,                 /* pc_relative */
1414          0,                     /* bitpos */
1415          complain_overflow_dont, /* complain_on_overflow */
1416          ppc64_elf_unhandled_reloc, /* special_function */
1417          "R_PPC64_DTPREL16_HIGHEST", /* name */
1418          FALSE,                 /* partial_inplace */
1419          0,                     /* src_mask */
1420          0xffff,                /* dst_mask */
1421          FALSE),                /* pcrel_offset */
1422
1423   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1424   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1425          48,                    /* rightshift */
1426          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1427          16,                    /* bitsize */
1428          FALSE,                 /* pc_relative */
1429          0,                     /* bitpos */
1430          complain_overflow_dont, /* complain_on_overflow */
1431          ppc64_elf_unhandled_reloc, /* special_function */
1432          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1433          FALSE,                 /* partial_inplace */
1434          0,                     /* src_mask */
1435          0xffff,                /* dst_mask */
1436          FALSE),                /* pcrel_offset */
1437
1438   /* Like DTPREL16, but for insns with a DS field.  */
1439   HOWTO (R_PPC64_DTPREL16_DS,
1440          0,                     /* rightshift */
1441          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          16,                    /* bitsize */
1443          FALSE,                 /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_signed, /* complain_on_overflow */
1446          ppc64_elf_unhandled_reloc, /* special_function */
1447          "R_PPC64_DTPREL16_DS", /* name */
1448          FALSE,                 /* partial_inplace */
1449          0,                     /* src_mask */
1450          0xfffc,                /* dst_mask */
1451          FALSE),                /* pcrel_offset */
1452
1453   /* Like DTPREL16_DS, but no overflow.  */
1454   HOWTO (R_PPC64_DTPREL16_LO_DS,
1455          0,                     /* rightshift */
1456          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1457          16,                    /* bitsize */
1458          FALSE,                 /* pc_relative */
1459          0,                     /* bitpos */
1460          complain_overflow_dont, /* complain_on_overflow */
1461          ppc64_elf_unhandled_reloc, /* special_function */
1462          "R_PPC64_DTPREL16_LO_DS", /* name */
1463          FALSE,                 /* partial_inplace */
1464          0,                     /* src_mask */
1465          0xfffc,                /* dst_mask */
1466          FALSE),                /* pcrel_offset */
1467
1468   /* Computes a tp-relative displacement, the difference between the value of
1469      sym+add and the value of the thread pointer (r13).  */
1470   HOWTO (R_PPC64_TPREL64,
1471          0,                     /* rightshift */
1472          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1473          64,                    /* bitsize */
1474          FALSE,                 /* pc_relative */
1475          0,                     /* bitpos */
1476          complain_overflow_dont, /* complain_on_overflow */
1477          ppc64_elf_unhandled_reloc, /* special_function */
1478          "R_PPC64_TPREL64",     /* name */
1479          FALSE,                 /* partial_inplace */
1480          0,                     /* src_mask */
1481          ONES (64),             /* dst_mask */
1482          FALSE),                /* pcrel_offset */
1483
1484   /* A 16 bit tprel reloc.  */
1485   HOWTO (R_PPC64_TPREL16,
1486          0,                     /* rightshift */
1487          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1488          16,                    /* bitsize */
1489          FALSE,                 /* pc_relative */
1490          0,                     /* bitpos */
1491          complain_overflow_signed, /* complain_on_overflow */
1492          ppc64_elf_unhandled_reloc, /* special_function */
1493          "R_PPC64_TPREL16",     /* name */
1494          FALSE,                 /* partial_inplace */
1495          0,                     /* src_mask */
1496          0xffff,                /* dst_mask */
1497          FALSE),                /* pcrel_offset */
1498
1499   /* Like TPREL16, but no overflow.  */
1500   HOWTO (R_PPC64_TPREL16_LO,
1501          0,                     /* rightshift */
1502          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1503          16,                    /* bitsize */
1504          FALSE,                 /* pc_relative */
1505          0,                     /* bitpos */
1506          complain_overflow_dont, /* complain_on_overflow */
1507          ppc64_elf_unhandled_reloc, /* special_function */
1508          "R_PPC64_TPREL16_LO",  /* name */
1509          FALSE,                 /* partial_inplace */
1510          0,                     /* src_mask */
1511          0xffff,                /* dst_mask */
1512          FALSE),                /* pcrel_offset */
1513
1514   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1515   HOWTO (R_PPC64_TPREL16_HI,
1516          16,                    /* rightshift */
1517          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1518          16,                    /* bitsize */
1519          FALSE,                 /* pc_relative */
1520          0,                     /* bitpos */
1521          complain_overflow_dont, /* complain_on_overflow */
1522          ppc64_elf_unhandled_reloc, /* special_function */
1523          "R_PPC64_TPREL16_HI",  /* name */
1524          FALSE,                 /* partial_inplace */
1525          0,                     /* src_mask */
1526          0xffff,                /* dst_mask */
1527          FALSE),                /* pcrel_offset */
1528
1529   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1530   HOWTO (R_PPC64_TPREL16_HA,
1531          16,                    /* rightshift */
1532          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1533          16,                    /* bitsize */
1534          FALSE,                 /* pc_relative */
1535          0,                     /* bitpos */
1536          complain_overflow_dont, /* complain_on_overflow */
1537          ppc64_elf_unhandled_reloc, /* special_function */
1538          "R_PPC64_TPREL16_HA",  /* name */
1539          FALSE,                 /* partial_inplace */
1540          0,                     /* src_mask */
1541          0xffff,                /* dst_mask */
1542          FALSE),                /* pcrel_offset */
1543
1544   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1545   HOWTO (R_PPC64_TPREL16_HIGHER,
1546          32,                    /* rightshift */
1547          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1548          16,                    /* bitsize */
1549          FALSE,                 /* pc_relative */
1550          0,                     /* bitpos */
1551          complain_overflow_dont, /* complain_on_overflow */
1552          ppc64_elf_unhandled_reloc, /* special_function */
1553          "R_PPC64_TPREL16_HIGHER",      /* name */
1554          FALSE,                 /* partial_inplace */
1555          0,                     /* src_mask */
1556          0xffff,                /* dst_mask */
1557          FALSE),                /* pcrel_offset */
1558
1559   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1560   HOWTO (R_PPC64_TPREL16_HIGHERA,
1561          32,                    /* rightshift */
1562          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          16,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_dont, /* complain_on_overflow */
1567          ppc64_elf_unhandled_reloc, /* special_function */
1568          "R_PPC64_TPREL16_HIGHERA", /* name */
1569          FALSE,                 /* partial_inplace */
1570          0,                     /* src_mask */
1571          0xffff,                /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1575   HOWTO (R_PPC64_TPREL16_HIGHEST,
1576          48,                    /* rightshift */
1577          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          16,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_dont, /* complain_on_overflow */
1582          ppc64_elf_unhandled_reloc, /* special_function */
1583          "R_PPC64_TPREL16_HIGHEST", /* name */
1584          FALSE,                 /* partial_inplace */
1585          0,                     /* src_mask */
1586          0xffff,                /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1590   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1591          48,                    /* rightshift */
1592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1593          16,                    /* bitsize */
1594          FALSE,                 /* pc_relative */
1595          0,                     /* bitpos */
1596          complain_overflow_dont, /* complain_on_overflow */
1597          ppc64_elf_unhandled_reloc, /* special_function */
1598          "R_PPC64_TPREL16_HIGHESTA", /* name */
1599          FALSE,                 /* partial_inplace */
1600          0,                     /* src_mask */
1601          0xffff,                /* dst_mask */
1602          FALSE),                /* pcrel_offset */
1603
1604   /* Like TPREL16, but for insns with a DS field.  */
1605   HOWTO (R_PPC64_TPREL16_DS,
1606          0,                     /* rightshift */
1607          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1608          16,                    /* bitsize */
1609          FALSE,                 /* pc_relative */
1610          0,                     /* bitpos */
1611          complain_overflow_signed, /* complain_on_overflow */
1612          ppc64_elf_unhandled_reloc, /* special_function */
1613          "R_PPC64_TPREL16_DS",  /* name */
1614          FALSE,                 /* partial_inplace */
1615          0,                     /* src_mask */
1616          0xfffc,                /* dst_mask */
1617          FALSE),                /* pcrel_offset */
1618
1619   /* Like TPREL16_DS, but no overflow.  */
1620   HOWTO (R_PPC64_TPREL16_LO_DS,
1621          0,                     /* rightshift */
1622          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1623          16,                    /* bitsize */
1624          FALSE,                 /* pc_relative */
1625          0,                     /* bitpos */
1626          complain_overflow_dont, /* complain_on_overflow */
1627          ppc64_elf_unhandled_reloc, /* special_function */
1628          "R_PPC64_TPREL16_LO_DS", /* name */
1629          FALSE,                 /* partial_inplace */
1630          0,                     /* src_mask */
1631          0xfffc,                /* dst_mask */
1632          FALSE),                /* pcrel_offset */
1633
1634   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1635      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1636      to the first entry relative to the TOC base (r2).  */
1637   HOWTO (R_PPC64_GOT_TLSGD16,
1638          0,                     /* rightshift */
1639          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1640          16,                    /* bitsize */
1641          FALSE,                 /* pc_relative */
1642          0,                     /* bitpos */
1643          complain_overflow_signed, /* complain_on_overflow */
1644          ppc64_elf_unhandled_reloc, /* special_function */
1645          "R_PPC64_GOT_TLSGD16", /* name */
1646          FALSE,                 /* partial_inplace */
1647          0,                     /* src_mask */
1648          0xffff,                /* dst_mask */
1649          FALSE),                /* pcrel_offset */
1650
1651   /* Like GOT_TLSGD16, but no overflow.  */
1652   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1653          0,                     /* rightshift */
1654          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1655          16,                    /* bitsize */
1656          FALSE,                 /* pc_relative */
1657          0,                     /* bitpos */
1658          complain_overflow_dont, /* complain_on_overflow */
1659          ppc64_elf_unhandled_reloc, /* special_function */
1660          "R_PPC64_GOT_TLSGD16_LO", /* name */
1661          FALSE,                 /* partial_inplace */
1662          0,                     /* src_mask */
1663          0xffff,                /* dst_mask */
1664          FALSE),                /* pcrel_offset */
1665
1666   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1667   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1668          16,                    /* rightshift */
1669          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1670          16,                    /* bitsize */
1671          FALSE,                 /* pc_relative */
1672          0,                     /* bitpos */
1673          complain_overflow_dont, /* complain_on_overflow */
1674          ppc64_elf_unhandled_reloc, /* special_function */
1675          "R_PPC64_GOT_TLSGD16_HI", /* name */
1676          FALSE,                 /* partial_inplace */
1677          0,                     /* src_mask */
1678          0xffff,                /* dst_mask */
1679          FALSE),                /* pcrel_offset */
1680
1681   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1682   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1683          16,                    /* rightshift */
1684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1685          16,                    /* bitsize */
1686          FALSE,                 /* pc_relative */
1687          0,                     /* bitpos */
1688          complain_overflow_dont, /* complain_on_overflow */
1689          ppc64_elf_unhandled_reloc, /* special_function */
1690          "R_PPC64_GOT_TLSGD16_HA", /* name */
1691          FALSE,                 /* partial_inplace */
1692          0,                     /* src_mask */
1693          0xffff,                /* dst_mask */
1694          FALSE),                /* pcrel_offset */
1695
1696   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1697      with values (sym+add)@dtpmod and zero, and computes the offset to the
1698      first entry relative to the TOC base (r2).  */
1699   HOWTO (R_PPC64_GOT_TLSLD16,
1700          0,                     /* rightshift */
1701          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1702          16,                    /* bitsize */
1703          FALSE,                 /* pc_relative */
1704          0,                     /* bitpos */
1705          complain_overflow_signed, /* complain_on_overflow */
1706          ppc64_elf_unhandled_reloc, /* special_function */
1707          "R_PPC64_GOT_TLSLD16", /* name */
1708          FALSE,                 /* partial_inplace */
1709          0,                     /* src_mask */
1710          0xffff,                /* dst_mask */
1711          FALSE),                /* pcrel_offset */
1712
1713   /* Like GOT_TLSLD16, but no overflow.  */
1714   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1715          0,                     /* rightshift */
1716          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1717          16,                    /* bitsize */
1718          FALSE,                 /* pc_relative */
1719          0,                     /* bitpos */
1720          complain_overflow_dont, /* complain_on_overflow */
1721          ppc64_elf_unhandled_reloc, /* special_function */
1722          "R_PPC64_GOT_TLSLD16_LO", /* name */
1723          FALSE,                 /* partial_inplace */
1724          0,                     /* src_mask */
1725          0xffff,                /* dst_mask */
1726          FALSE),                /* pcrel_offset */
1727
1728   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1729   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1730          16,                    /* rightshift */
1731          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1732          16,                    /* bitsize */
1733          FALSE,                 /* pc_relative */
1734          0,                     /* bitpos */
1735          complain_overflow_dont, /* complain_on_overflow */
1736          ppc64_elf_unhandled_reloc, /* special_function */
1737          "R_PPC64_GOT_TLSLD16_HI", /* name */
1738          FALSE,                 /* partial_inplace */
1739          0,                     /* src_mask */
1740          0xffff,                /* dst_mask */
1741          FALSE),                /* pcrel_offset */
1742
1743   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1744   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1745          16,                    /* rightshift */
1746          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1747          16,                    /* bitsize */
1748          FALSE,                 /* pc_relative */
1749          0,                     /* bitpos */
1750          complain_overflow_dont, /* complain_on_overflow */
1751          ppc64_elf_unhandled_reloc, /* special_function */
1752          "R_PPC64_GOT_TLSLD16_HA", /* name */
1753          FALSE,                 /* partial_inplace */
1754          0,                     /* src_mask */
1755          0xffff,                /* dst_mask */
1756          FALSE),                /* pcrel_offset */
1757
1758   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1759      the offset to the entry relative to the TOC base (r2).  */
1760   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1761          0,                     /* rightshift */
1762          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1763          16,                    /* bitsize */
1764          FALSE,                 /* pc_relative */
1765          0,                     /* bitpos */
1766          complain_overflow_signed, /* complain_on_overflow */
1767          ppc64_elf_unhandled_reloc, /* special_function */
1768          "R_PPC64_GOT_DTPREL16_DS", /* name */
1769          FALSE,                 /* partial_inplace */
1770          0,                     /* src_mask */
1771          0xfffc,                /* dst_mask */
1772          FALSE),                /* pcrel_offset */
1773
1774   /* Like GOT_DTPREL16_DS, but no overflow.  */
1775   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1776          0,                     /* rightshift */
1777          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1778          16,                    /* bitsize */
1779          FALSE,                 /* pc_relative */
1780          0,                     /* bitpos */
1781          complain_overflow_dont, /* complain_on_overflow */
1782          ppc64_elf_unhandled_reloc, /* special_function */
1783          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1784          FALSE,                 /* partial_inplace */
1785          0,                     /* src_mask */
1786          0xfffc,                /* dst_mask */
1787          FALSE),                /* pcrel_offset */
1788
1789   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1790   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1791          16,                    /* rightshift */
1792          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1793          16,                    /* bitsize */
1794          FALSE,                 /* pc_relative */
1795          0,                     /* bitpos */
1796          complain_overflow_dont, /* complain_on_overflow */
1797          ppc64_elf_unhandled_reloc, /* special_function */
1798          "R_PPC64_GOT_DTPREL16_HI", /* name */
1799          FALSE,                 /* partial_inplace */
1800          0,                     /* src_mask */
1801          0xffff,                /* dst_mask */
1802          FALSE),                /* pcrel_offset */
1803
1804   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1805   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1806          16,                    /* rightshift */
1807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1808          16,                    /* bitsize */
1809          FALSE,                 /* pc_relative */
1810          0,                     /* bitpos */
1811          complain_overflow_dont, /* complain_on_overflow */
1812          ppc64_elf_unhandled_reloc, /* special_function */
1813          "R_PPC64_GOT_DTPREL16_HA", /* name */
1814          FALSE,                 /* partial_inplace */
1815          0,                     /* src_mask */
1816          0xffff,                /* dst_mask */
1817          FALSE),                /* pcrel_offset */
1818
1819   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1820      offset to the entry relative to the TOC base (r2).  */
1821   HOWTO (R_PPC64_GOT_TPREL16_DS,
1822          0,                     /* rightshift */
1823          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1824          16,                    /* bitsize */
1825          FALSE,                 /* pc_relative */
1826          0,                     /* bitpos */
1827          complain_overflow_signed, /* complain_on_overflow */
1828          ppc64_elf_unhandled_reloc, /* special_function */
1829          "R_PPC64_GOT_TPREL16_DS", /* name */
1830          FALSE,                 /* partial_inplace */
1831          0,                     /* src_mask */
1832          0xfffc,                /* dst_mask */
1833          FALSE),                /* pcrel_offset */
1834
1835   /* Like GOT_TPREL16_DS, but no overflow.  */
1836   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1837          0,                     /* rightshift */
1838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1839          16,                    /* bitsize */
1840          FALSE,                 /* pc_relative */
1841          0,                     /* bitpos */
1842          complain_overflow_dont, /* complain_on_overflow */
1843          ppc64_elf_unhandled_reloc, /* special_function */
1844          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1845          FALSE,                 /* partial_inplace */
1846          0,                     /* src_mask */
1847          0xfffc,                /* dst_mask */
1848          FALSE),                /* pcrel_offset */
1849
1850   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1851   HOWTO (R_PPC64_GOT_TPREL16_HI,
1852          16,                    /* rightshift */
1853          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1854          16,                    /* bitsize */
1855          FALSE,                 /* pc_relative */
1856          0,                     /* bitpos */
1857          complain_overflow_dont, /* complain_on_overflow */
1858          ppc64_elf_unhandled_reloc, /* special_function */
1859          "R_PPC64_GOT_TPREL16_HI", /* name */
1860          FALSE,                 /* partial_inplace */
1861          0,                     /* src_mask */
1862          0xffff,                /* dst_mask */
1863          FALSE),                /* pcrel_offset */
1864
1865   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1866   HOWTO (R_PPC64_GOT_TPREL16_HA,
1867          16,                    /* rightshift */
1868          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1869          16,                    /* bitsize */
1870          FALSE,                 /* pc_relative */
1871          0,                     /* bitpos */
1872          complain_overflow_dont, /* complain_on_overflow */
1873          ppc64_elf_unhandled_reloc, /* special_function */
1874          "R_PPC64_GOT_TPREL16_HA", /* name */
1875          FALSE,                 /* partial_inplace */
1876          0,                     /* src_mask */
1877          0xffff,                /* dst_mask */
1878          FALSE),                /* pcrel_offset */
1879
1880   HOWTO (R_PPC64_JMP_IREL,      /* type */
1881          0,                     /* rightshift */
1882          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1883          0,                     /* 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_JMP_IREL",    /* name */
1889          FALSE,                 /* partial_inplace */
1890          0,                     /* src_mask */
1891          0,                     /* dst_mask */
1892          FALSE),                /* pcrel_offset */
1893
1894   HOWTO (R_PPC64_IRELATIVE,     /* type */
1895          0,                     /* rightshift */
1896          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1897          64,                    /* bitsize */
1898          FALSE,                 /* pc_relative */
1899          0,                     /* bitpos */
1900          complain_overflow_dont, /* complain_on_overflow */
1901          bfd_elf_generic_reloc, /* special_function */
1902          "R_PPC64_IRELATIVE",   /* name */
1903          FALSE,                 /* partial_inplace */
1904          0,                     /* src_mask */
1905          ONES (64),             /* dst_mask */
1906          FALSE),                /* pcrel_offset */
1907
1908   /* A 16 bit relative relocation.  */
1909   HOWTO (R_PPC64_REL16,         /* type */
1910          0,                     /* rightshift */
1911          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1912          16,                    /* bitsize */
1913          TRUE,                  /* pc_relative */
1914          0,                     /* bitpos */
1915          complain_overflow_bitfield, /* complain_on_overflow */
1916          bfd_elf_generic_reloc, /* special_function */
1917          "R_PPC64_REL16",       /* name */
1918          FALSE,                 /* partial_inplace */
1919          0,                     /* src_mask */
1920          0xffff,                /* dst_mask */
1921          TRUE),                 /* pcrel_offset */
1922
1923   /* A 16 bit relative relocation without overflow.  */
1924   HOWTO (R_PPC64_REL16_LO,      /* type */
1925          0,                     /* rightshift */
1926          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1927          16,                    /* bitsize */
1928          TRUE,                  /* pc_relative */
1929          0,                     /* bitpos */
1930          complain_overflow_dont,/* complain_on_overflow */
1931          bfd_elf_generic_reloc, /* special_function */
1932          "R_PPC64_REL16_LO",    /* name */
1933          FALSE,                 /* partial_inplace */
1934          0,                     /* src_mask */
1935          0xffff,                /* dst_mask */
1936          TRUE),                 /* pcrel_offset */
1937
1938   /* The high order 16 bits of a relative address.  */
1939   HOWTO (R_PPC64_REL16_HI,      /* type */
1940          16,                    /* rightshift */
1941          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1942          16,                    /* bitsize */
1943          TRUE,                  /* pc_relative */
1944          0,                     /* bitpos */
1945          complain_overflow_dont, /* complain_on_overflow */
1946          bfd_elf_generic_reloc, /* special_function */
1947          "R_PPC64_REL16_HI",    /* name */
1948          FALSE,                 /* partial_inplace */
1949          0,                     /* src_mask */
1950          0xffff,                /* dst_mask */
1951          TRUE),                 /* pcrel_offset */
1952
1953   /* The high order 16 bits of a relative address, plus 1 if the contents of
1954      the low 16 bits, treated as a signed number, is negative.  */
1955   HOWTO (R_PPC64_REL16_HA,      /* type */
1956          16,                    /* rightshift */
1957          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1958          16,                    /* bitsize */
1959          TRUE,                  /* pc_relative */
1960          0,                     /* bitpos */
1961          complain_overflow_dont, /* complain_on_overflow */
1962          ppc64_elf_ha_reloc,    /* special_function */
1963          "R_PPC64_REL16_HA",    /* name */
1964          FALSE,                 /* partial_inplace */
1965          0,                     /* src_mask */
1966          0xffff,                /* dst_mask */
1967          TRUE),                 /* pcrel_offset */
1968
1969   /* GNU extension to record C++ vtable hierarchy.  */
1970   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1971          0,                     /* rightshift */
1972          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1973          0,                     /* bitsize */
1974          FALSE,                 /* pc_relative */
1975          0,                     /* bitpos */
1976          complain_overflow_dont, /* complain_on_overflow */
1977          NULL,                  /* special_function */
1978          "R_PPC64_GNU_VTINHERIT", /* name */
1979          FALSE,                 /* partial_inplace */
1980          0,                     /* src_mask */
1981          0,                     /* dst_mask */
1982          FALSE),                /* pcrel_offset */
1983
1984   /* GNU extension to record C++ vtable member usage.  */
1985   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1986          0,                     /* rightshift */
1987          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1988          0,                     /* bitsize */
1989          FALSE,                 /* pc_relative */
1990          0,                     /* bitpos */
1991          complain_overflow_dont, /* complain_on_overflow */
1992          NULL,                  /* special_function */
1993          "R_PPC64_GNU_VTENTRY", /* name */
1994          FALSE,                 /* partial_inplace */
1995          0,                     /* src_mask */
1996          0,                     /* dst_mask */
1997          FALSE),                /* pcrel_offset */
1998 };
1999
2000 \f
2001 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2002    be done.  */
2003
2004 static void
2005 ppc_howto_init (void)
2006 {
2007   unsigned int i, type;
2008
2009   for (i = 0;
2010        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2011        i++)
2012     {
2013       type = ppc64_elf_howto_raw[i].type;
2014       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2015                           / sizeof (ppc64_elf_howto_table[0])));
2016       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2017     }
2018 }
2019
2020 static reloc_howto_type *
2021 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2022                              bfd_reloc_code_real_type code)
2023 {
2024   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2025
2026   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2027     /* Initialize howto table if needed.  */
2028     ppc_howto_init ();
2029
2030   switch (code)
2031     {
2032     default:
2033       return NULL;
2034
2035     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2036       break;
2037     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2038       break;
2039     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2040       break;
2041     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2042       break;
2043     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2044       break;
2045     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2046       break;
2047     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2048       break;
2049     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2050       break;
2051     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2052       break;
2053     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2054       break;
2055     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2056       break;
2057     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2058       break;
2059     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2060       break;
2061     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2062       break;
2063     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2064       break;
2065     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2066       break;
2067     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2068       break;
2069     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2070       break;
2071     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2072       break;
2073     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2074       break;
2075     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2076       break;
2077     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2078       break;
2079     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2080       break;
2081     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2082       break;
2083     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2084       break;
2085     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2086       break;
2087     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2088       break;
2089     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2090       break;
2091     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2092       break;
2093     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2094       break;
2095     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2096       break;
2097     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2098       break;
2099     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2100       break;
2101     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2102       break;
2103     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2104       break;
2105     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2106       break;
2107     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2108       break;
2109     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2110       break;
2111     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2112       break;
2113     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2114       break;
2115     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2116       break;
2117     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2118       break;
2119     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2120       break;
2121     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2122       break;
2123     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2124       break;
2125     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2126       break;
2127     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2128       break;
2129     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2130       break;
2131     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2132       break;
2133     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2134       break;
2135     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2136       break;
2137     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2138       break;
2139     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2140       break;
2141     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2142       break;
2143     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2144       break;
2145     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2146       break;
2147     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2148       break;
2149     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2150       break;
2151     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2152       break;
2153     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2154       break;
2155     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2156       break;
2157     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2158       break;
2159     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2160       break;
2161     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2162       break;
2163     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2164       break;
2165     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2166       break;
2167     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2168       break;
2169     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2170       break;
2171     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2172       break;
2173     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2174       break;
2175     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2176       break;
2177     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2178       break;
2179     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2180       break;
2181     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2182       break;
2183     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2184       break;
2185     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2186       break;
2187     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2188       break;
2189     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2190       break;
2191     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2192       break;
2193     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2194       break;
2195     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2196       break;
2197     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2198       break;
2199     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2200       break;
2201     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2204       break;
2205     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2206       break;
2207     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2208       break;
2209     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2210       break;
2211     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2212       break;
2213     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2214       break;
2215     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2216       break;
2217     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2218       break;
2219     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2220       break;
2221     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2222       break;
2223     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2224       break;
2225     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2226       break;
2227     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2228       break;
2229     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2230       break;
2231     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2232       break;
2233     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2234       break;
2235     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2236       break;
2237     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2238       break;
2239     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2240       break;
2241     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2242       break;
2243     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2244       break;
2245     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2246       break;
2247     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2248       break;
2249     }
2250
2251   return ppc64_elf_howto_table[r];
2252 };
2253
2254 static reloc_howto_type *
2255 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2256                              const char *r_name)
2257 {
2258   unsigned int i;
2259
2260   for (i = 0;
2261        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2262        i++)
2263     if (ppc64_elf_howto_raw[i].name != NULL
2264         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2265       return &ppc64_elf_howto_raw[i];
2266
2267   return NULL;
2268 }
2269
2270 /* Set the howto pointer for a PowerPC ELF reloc.  */
2271
2272 static void
2273 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2274                          Elf_Internal_Rela *dst)
2275 {
2276   unsigned int type;
2277
2278   /* Initialize howto table if needed.  */
2279   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2280     ppc_howto_init ();
2281
2282   type = ELF64_R_TYPE (dst->r_info);
2283   if (type >= (sizeof (ppc64_elf_howto_table)
2284                / sizeof (ppc64_elf_howto_table[0])))
2285     {
2286       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2287                              abfd, (int) type);
2288       type = R_PPC64_NONE;
2289     }
2290   cache_ptr->howto = ppc64_elf_howto_table[type];
2291 }
2292
2293 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2294
2295 static bfd_reloc_status_type
2296 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2297                     void *data, asection *input_section,
2298                     bfd *output_bfd, char **error_message)
2299 {
2300   /* If this is a relocatable link (output_bfd test tells us), just
2301      call the generic function.  Any adjustment will be done at final
2302      link time.  */
2303   if (output_bfd != NULL)
2304     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2305                                   input_section, output_bfd, error_message);
2306
2307   /* Adjust the addend for sign extension of the low 16 bits.
2308      We won't actually be using the low 16 bits, so trashing them
2309      doesn't matter.  */
2310   reloc_entry->addend += 0x8000;
2311   return bfd_reloc_continue;
2312 }
2313
2314 static bfd_reloc_status_type
2315 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2316                         void *data, asection *input_section,
2317                         bfd *output_bfd, char **error_message)
2318 {
2319   if (output_bfd != NULL)
2320     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2321                                   input_section, output_bfd, error_message);
2322
2323   if (strcmp (symbol->section->name, ".opd") == 0
2324       && (symbol->section->owner->flags & DYNAMIC) == 0)
2325     {
2326       bfd_vma dest = opd_entry_value (symbol->section,
2327                                       symbol->value + reloc_entry->addend,
2328                                       NULL, NULL);
2329       if (dest != (bfd_vma) -1)
2330         reloc_entry->addend = dest - (symbol->value
2331                                       + symbol->section->output_section->vma
2332                                       + symbol->section->output_offset);
2333     }
2334   return bfd_reloc_continue;
2335 }
2336
2337 static bfd_reloc_status_type
2338 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2339                          void *data, asection *input_section,
2340                          bfd *output_bfd, char **error_message)
2341 {
2342   long insn;
2343   enum elf_ppc64_reloc_type r_type;
2344   bfd_size_type octets;
2345   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2346   bfd_boolean is_power4 = FALSE;
2347
2348   /* If this is a relocatable link (output_bfd test tells us), just
2349      call the generic function.  Any adjustment will be done at final
2350      link time.  */
2351   if (output_bfd != NULL)
2352     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2353                                   input_section, output_bfd, error_message);
2354
2355   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2356   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2357   insn &= ~(0x01 << 21);
2358   r_type = reloc_entry->howto->type;
2359   if (r_type == R_PPC64_ADDR14_BRTAKEN
2360       || r_type == R_PPC64_REL14_BRTAKEN)
2361     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2362
2363   if (is_power4)
2364     {
2365       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2366          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2367          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2368       if ((insn & (0x14 << 21)) == (0x04 << 21))
2369         insn |= 0x02 << 21;
2370       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2371         insn |= 0x08 << 21;
2372       else
2373         goto out;
2374     }
2375   else
2376     {
2377       bfd_vma target = 0;
2378       bfd_vma from;
2379
2380       if (!bfd_is_com_section (symbol->section))
2381         target = symbol->value;
2382       target += symbol->section->output_section->vma;
2383       target += symbol->section->output_offset;
2384       target += reloc_entry->addend;
2385
2386       from = (reloc_entry->address
2387               + input_section->output_offset
2388               + input_section->output_section->vma);
2389
2390       /* Invert 'y' bit if not the default.  */
2391       if ((bfd_signed_vma) (target - from) < 0)
2392         insn ^= 0x01 << 21;
2393     }
2394   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2395  out:
2396   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2397                                  input_section, output_bfd, error_message);
2398 }
2399
2400 static bfd_reloc_status_type
2401 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2402                          void *data, asection *input_section,
2403                          bfd *output_bfd, char **error_message)
2404 {
2405   /* If this is a relocatable link (output_bfd test tells us), just
2406      call the generic function.  Any adjustment will be done at final
2407      link time.  */
2408   if (output_bfd != NULL)
2409     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2410                                   input_section, output_bfd, error_message);
2411
2412   /* Subtract the symbol section base address.  */
2413   reloc_entry->addend -= symbol->section->output_section->vma;
2414   return bfd_reloc_continue;
2415 }
2416
2417 static bfd_reloc_status_type
2418 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2419                             void *data, asection *input_section,
2420                             bfd *output_bfd, char **error_message)
2421 {
2422   /* If this is a relocatable link (output_bfd test tells us), just
2423      call the generic function.  Any adjustment will be done at final
2424      link time.  */
2425   if (output_bfd != NULL)
2426     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2427                                   input_section, output_bfd, error_message);
2428
2429   /* Subtract the symbol section base address.  */
2430   reloc_entry->addend -= symbol->section->output_section->vma;
2431
2432   /* Adjust the addend for sign extension of the low 16 bits.  */
2433   reloc_entry->addend += 0x8000;
2434   return bfd_reloc_continue;
2435 }
2436
2437 static bfd_reloc_status_type
2438 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2439                      void *data, asection *input_section,
2440                      bfd *output_bfd, char **error_message)
2441 {
2442   bfd_vma TOCstart;
2443
2444   /* If this is a relocatable link (output_bfd test tells us), just
2445      call the generic function.  Any adjustment will be done at final
2446      link time.  */
2447   if (output_bfd != NULL)
2448     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2449                                   input_section, output_bfd, error_message);
2450
2451   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2452   if (TOCstart == 0)
2453     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2454
2455   /* Subtract the TOC base address.  */
2456   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2457   return bfd_reloc_continue;
2458 }
2459
2460 static bfd_reloc_status_type
2461 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2462                         void *data, asection *input_section,
2463                         bfd *output_bfd, char **error_message)
2464 {
2465   bfd_vma TOCstart;
2466
2467   /* If this is a relocatable link (output_bfd test tells us), just
2468      call the generic function.  Any adjustment will be done at final
2469      link time.  */
2470   if (output_bfd != NULL)
2471     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2472                                   input_section, output_bfd, error_message);
2473
2474   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2475   if (TOCstart == 0)
2476     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2477
2478   /* Subtract the TOC base address.  */
2479   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2480
2481   /* Adjust the addend for sign extension of the low 16 bits.  */
2482   reloc_entry->addend += 0x8000;
2483   return bfd_reloc_continue;
2484 }
2485
2486 static bfd_reloc_status_type
2487 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2488                        void *data, asection *input_section,
2489                        bfd *output_bfd, char **error_message)
2490 {
2491   bfd_vma TOCstart;
2492   bfd_size_type octets;
2493
2494   /* If this is a relocatable link (output_bfd test tells us), just
2495      call the generic function.  Any adjustment will be done at final
2496      link time.  */
2497   if (output_bfd != NULL)
2498     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2499                                   input_section, output_bfd, error_message);
2500
2501   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2502   if (TOCstart == 0)
2503     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2504
2505   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2506   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2507   return bfd_reloc_ok;
2508 }
2509
2510 static bfd_reloc_status_type
2511 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2512                            void *data, asection *input_section,
2513                            bfd *output_bfd, char **error_message)
2514 {
2515   /* If this is a relocatable link (output_bfd test tells us), just
2516      call the generic function.  Any adjustment will be done at final
2517      link time.  */
2518   if (output_bfd != NULL)
2519     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2520                                   input_section, output_bfd, error_message);
2521
2522   if (error_message != NULL)
2523     {
2524       static char buf[60];
2525       sprintf (buf, "generic linker can't handle %s",
2526                reloc_entry->howto->name);
2527       *error_message = buf;
2528     }
2529   return bfd_reloc_dangerous;
2530 }
2531
2532 /* Track GOT entries needed for a given symbol.  We might need more
2533    than one got entry per symbol.  */
2534 struct got_entry
2535 {
2536   struct got_entry *next;
2537
2538   /* The symbol addend that we'll be placing in the GOT.  */
2539   bfd_vma addend;
2540
2541   /* Unlike other ELF targets, we use separate GOT entries for the same
2542      symbol referenced from different input files.  This is to support
2543      automatic multiple TOC/GOT sections, where the TOC base can vary
2544      from one input file to another.  After partitioning into TOC groups
2545      we merge entries within the group.
2546
2547      Point to the BFD owning this GOT entry.  */
2548   bfd *owner;
2549
2550   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2551      TLS_TPREL or TLS_DTPREL for tls entries.  */
2552   unsigned char tls_type;
2553
2554   /* Non-zero if got.ent points to real entry.  */
2555   unsigned char is_indirect;
2556
2557   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2558   union
2559     {
2560       bfd_signed_vma refcount;
2561       bfd_vma offset;
2562       struct got_entry *ent;
2563     } got;
2564 };
2565
2566 /* The same for PLT.  */
2567 struct plt_entry
2568 {
2569   struct plt_entry *next;
2570
2571   bfd_vma addend;
2572
2573   union
2574     {
2575       bfd_signed_vma refcount;
2576       bfd_vma offset;
2577     } plt;
2578 };
2579
2580 struct ppc64_elf_obj_tdata
2581 {
2582   struct elf_obj_tdata elf;
2583
2584   /* Shortcuts to dynamic linker sections.  */
2585   asection *got;
2586   asection *relgot;
2587
2588   /* Used during garbage collection.  We attach global symbols defined
2589      on removed .opd entries to this section so that the sym is removed.  */
2590   asection *deleted_section;
2591
2592   /* TLS local dynamic got entry handling.  Support for multiple GOT
2593      sections means we potentially need one of these for each input bfd.  */
2594   struct got_entry tlsld_got;
2595
2596   /* A copy of relocs before they are modified for --emit-relocs.  */
2597   Elf_Internal_Rela *opd_relocs;
2598
2599   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2600      the reloc to be in the range -32768 to 32767.  */
2601   unsigned int has_small_toc_reloc;
2602 };
2603
2604 #define ppc64_elf_tdata(bfd) \
2605   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2606
2607 #define ppc64_tlsld_got(bfd) \
2608   (&ppc64_elf_tdata (bfd)->tlsld_got)
2609
2610 #define is_ppc64_elf(bfd) \
2611   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2612    && elf_object_id (bfd) == PPC64_ELF_DATA)
2613
2614 /* Override the generic function because we store some extras.  */
2615
2616 static bfd_boolean
2617 ppc64_elf_mkobject (bfd *abfd)
2618 {
2619   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2620                                   PPC64_ELF_DATA);
2621 }
2622
2623 /* Fix bad default arch selected for a 64 bit input bfd when the
2624    default is 32 bit.  */
2625
2626 static bfd_boolean
2627 ppc64_elf_object_p (bfd *abfd)
2628 {
2629   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2630     {
2631       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2632
2633       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2634         {
2635           /* Relies on arch after 32 bit default being 64 bit default.  */
2636           abfd->arch_info = abfd->arch_info->next;
2637           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2638         }
2639     }
2640   return TRUE;
2641 }
2642
2643 /* Support for core dump NOTE sections.  */
2644
2645 static bfd_boolean
2646 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2647 {
2648   size_t offset, size;
2649
2650   if (note->descsz != 504)
2651     return FALSE;
2652
2653   /* pr_cursig */
2654   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2655
2656   /* pr_pid */
2657   elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2658
2659   /* pr_reg */
2660   offset = 112;
2661   size = 384;
2662
2663   /* Make a ".reg/999" section.  */
2664   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2665                                           size, note->descpos + offset);
2666 }
2667
2668 static bfd_boolean
2669 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2670 {
2671   if (note->descsz != 136)
2672     return FALSE;
2673
2674   elf_tdata (abfd)->core_pid
2675     = bfd_get_32 (abfd, note->descdata + 24);
2676   elf_tdata (abfd)->core_program
2677     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2678   elf_tdata (abfd)->core_command
2679     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2680
2681   return TRUE;
2682 }
2683
2684 static char *
2685 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2686                            ...)
2687 {
2688   switch (note_type)
2689     {
2690     default:
2691       return NULL;
2692
2693     case NT_PRPSINFO:
2694       {
2695         char data[136];
2696         va_list ap;
2697
2698         va_start (ap, note_type);
2699         memset (data, 0, 40);
2700         strncpy (data + 40, va_arg (ap, const char *), 16);
2701         strncpy (data + 56, va_arg (ap, const char *), 80);
2702         va_end (ap);
2703         return elfcore_write_note (abfd, buf, bufsiz,
2704                                    "CORE", note_type, data, sizeof (data));
2705       }
2706
2707     case NT_PRSTATUS:
2708       {
2709         char data[504];
2710         va_list ap;
2711         long pid;
2712         int cursig;
2713         const void *greg;
2714
2715         va_start (ap, note_type);
2716         memset (data, 0, 112);
2717         pid = va_arg (ap, long);
2718         bfd_put_32 (abfd, pid, data + 32);
2719         cursig = va_arg (ap, int);
2720         bfd_put_16 (abfd, cursig, data + 12);
2721         greg = va_arg (ap, const void *);
2722         memcpy (data + 112, greg, 384);
2723         memset (data + 496, 0, 8);
2724         va_end (ap);
2725         return elfcore_write_note (abfd, buf, bufsiz,
2726                                    "CORE", note_type, data, sizeof (data));
2727       }
2728     }
2729 }
2730
2731 /* Add extra PPC sections.  */
2732
2733 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2734 {
2735   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2736   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2737   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2738   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2739   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2740   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2741   { NULL,                     0,  0, 0,            0 }
2742 };
2743
2744 enum _ppc64_sec_type {
2745   sec_normal = 0,
2746   sec_opd = 1,
2747   sec_toc = 2
2748 };
2749
2750 struct _ppc64_elf_section_data
2751 {
2752   struct bfd_elf_section_data elf;
2753
2754   union
2755   {
2756     /* An array with one entry for each opd function descriptor.  */
2757     struct _opd_sec_data
2758     {
2759       /* Points to the function code section for local opd entries.  */
2760       asection **func_sec;
2761
2762       /* After editing .opd, adjust references to opd local syms.  */
2763       long *adjust;
2764     } opd;
2765
2766     /* An array for toc sections, indexed by offset/8.  */
2767     struct _toc_sec_data
2768     {
2769       /* Specifies the relocation symbol index used at a given toc offset.  */
2770       unsigned *symndx;
2771
2772       /* And the relocation addend.  */
2773       bfd_vma *add;
2774     } toc;
2775   } u;
2776
2777   enum _ppc64_sec_type sec_type:2;
2778
2779   /* Flag set when small branches are detected.  Used to
2780      select suitable defaults for the stub group size.  */
2781   unsigned int has_14bit_branch:1;
2782 };
2783
2784 #define ppc64_elf_section_data(sec) \
2785   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2786
2787 static bfd_boolean
2788 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2789 {
2790   if (!sec->used_by_bfd)
2791     {
2792       struct _ppc64_elf_section_data *sdata;
2793       bfd_size_type amt = sizeof (*sdata);
2794
2795       sdata = bfd_zalloc (abfd, amt);
2796       if (sdata == NULL)
2797         return FALSE;
2798       sec->used_by_bfd = sdata;
2799     }
2800
2801   return _bfd_elf_new_section_hook (abfd, sec);
2802 }
2803
2804 static struct _opd_sec_data *
2805 get_opd_info (asection * sec)
2806 {
2807   if (sec != NULL
2808       && ppc64_elf_section_data (sec) != NULL
2809       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2810     return &ppc64_elf_section_data (sec)->u.opd;
2811   return NULL;
2812 }
2813 \f
2814 /* Parameters for the qsort hook.  */
2815 static bfd_boolean synthetic_relocatable;
2816
2817 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2818
2819 static int
2820 compare_symbols (const void *ap, const void *bp)
2821 {
2822   const asymbol *a = * (const asymbol **) ap;
2823   const asymbol *b = * (const asymbol **) bp;
2824
2825   /* Section symbols first.  */
2826   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2827     return -1;
2828   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2829     return 1;
2830
2831   /* then .opd symbols.  */
2832   if (strcmp (a->section->name, ".opd") == 0
2833       && strcmp (b->section->name, ".opd") != 0)
2834     return -1;
2835   if (strcmp (a->section->name, ".opd") != 0
2836       && strcmp (b->section->name, ".opd") == 0)
2837     return 1;
2838
2839   /* then other code symbols.  */
2840   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2841       == (SEC_CODE | SEC_ALLOC)
2842       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2843          != (SEC_CODE | SEC_ALLOC))
2844     return -1;
2845
2846   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2847       != (SEC_CODE | SEC_ALLOC)
2848       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2849          == (SEC_CODE | SEC_ALLOC))
2850     return 1;
2851
2852   if (synthetic_relocatable)
2853     {
2854       if (a->section->id < b->section->id)
2855         return -1;
2856
2857       if (a->section->id > b->section->id)
2858         return 1;
2859     }
2860
2861   if (a->value + a->section->vma < b->value + b->section->vma)
2862     return -1;
2863
2864   if (a->value + a->section->vma > b->value + b->section->vma)
2865     return 1;
2866
2867   /* For syms with the same value, prefer strong dynamic global function
2868      syms over other syms.  */
2869   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2870     return -1;
2871
2872   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2873     return 1;
2874
2875   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2876     return -1;
2877
2878   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2879     return 1;
2880
2881   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2882     return -1;
2883
2884   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2885     return 1;
2886
2887   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2888     return -1;
2889
2890   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2891     return 1;
2892
2893   return 0;
2894 }
2895
2896 /* Search SYMS for a symbol of the given VALUE.  */
2897
2898 static asymbol *
2899 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2900 {
2901   long mid;
2902
2903   if (id == -1)
2904     {
2905       while (lo < hi)
2906         {
2907           mid = (lo + hi) >> 1;
2908           if (syms[mid]->value + syms[mid]->section->vma < value)
2909             lo = mid + 1;
2910           else if (syms[mid]->value + syms[mid]->section->vma > value)
2911             hi = mid;
2912           else
2913             return syms[mid];
2914         }
2915     }
2916   else
2917     {
2918       while (lo < hi)
2919         {
2920           mid = (lo + hi) >> 1;
2921           if (syms[mid]->section->id < id)
2922             lo = mid + 1;
2923           else if (syms[mid]->section->id > id)
2924             hi = mid;
2925           else if (syms[mid]->value < value)
2926             lo = mid + 1;
2927           else if (syms[mid]->value > value)
2928             hi = mid;
2929           else
2930             return syms[mid];
2931         }
2932     }
2933   return NULL;
2934 }
2935
2936 static bfd_boolean
2937 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2938 {
2939   bfd_vma vma = *(bfd_vma *) ptr;
2940   return ((section->flags & SEC_ALLOC) != 0
2941           && section->vma <= vma
2942           && vma < section->vma + section->size);
2943 }
2944
2945 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2946    entry syms.  Also generate @plt symbols for the glink branch table.  */
2947
2948 static long
2949 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2950                                 long static_count, asymbol **static_syms,
2951                                 long dyn_count, asymbol **dyn_syms,
2952                                 asymbol **ret)
2953 {
2954   asymbol *s;
2955   long i;
2956   long count;
2957   char *names;
2958   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2959   asection *opd;
2960   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2961   asymbol **syms;
2962
2963   *ret = NULL;
2964
2965   opd = bfd_get_section_by_name (abfd, ".opd");
2966   if (opd == NULL)
2967     return 0;
2968
2969   symcount = static_count;
2970   if (!relocatable)
2971     symcount += dyn_count;
2972   if (symcount == 0)
2973     return 0;
2974
2975   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2976   if (syms == NULL)
2977     return -1;
2978
2979   if (!relocatable && static_count != 0 && dyn_count != 0)
2980     {
2981       /* Use both symbol tables.  */
2982       memcpy (syms, static_syms, static_count * sizeof (*syms));
2983       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2984     }
2985   else if (!relocatable && static_count == 0)
2986     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2987   else
2988     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2989
2990   synthetic_relocatable = relocatable;
2991   qsort (syms, symcount, sizeof (*syms), compare_symbols);
2992
2993   if (!relocatable && symcount > 1)
2994     {
2995       long j;
2996       /* Trim duplicate syms, since we may have merged the normal and
2997          dynamic symbols.  Actually, we only care about syms that have
2998          different values, so trim any with the same value.  */
2999       for (i = 1, j = 1; i < symcount; ++i)
3000         if (syms[i - 1]->value + syms[i - 1]->section->vma
3001             != syms[i]->value + syms[i]->section->vma)
3002           syms[j++] = syms[i];
3003       symcount = j;
3004     }
3005
3006   i = 0;
3007   if (strcmp (syms[i]->section->name, ".opd") == 0)
3008     ++i;
3009   codesecsym = i;
3010
3011   for (; i < symcount; ++i)
3012     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3013          != (SEC_CODE | SEC_ALLOC))
3014         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3015       break;
3016   codesecsymend = i;
3017
3018   for (; i < symcount; ++i)
3019     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3020       break;
3021   secsymend = i;
3022
3023   for (; i < symcount; ++i)
3024     if (strcmp (syms[i]->section->name, ".opd") != 0)
3025       break;
3026   opdsymend = i;
3027
3028   for (; i < symcount; ++i)
3029     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3030         != (SEC_CODE | SEC_ALLOC))
3031       break;
3032   symcount = i;
3033
3034   count = 0;
3035
3036   if (relocatable)
3037     {
3038       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3039       arelent *r;
3040       size_t size;
3041       long relcount;
3042
3043       if (opdsymend == secsymend)
3044         goto done;
3045
3046       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3047       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3048       if (relcount == 0)
3049         goto done;
3050
3051       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3052         {
3053           count = -1;
3054           goto done;
3055         }
3056
3057       size = 0;
3058       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3059         {
3060           asymbol *sym;
3061
3062           while (r < opd->relocation + relcount
3063                  && r->address < syms[i]->value + opd->vma)
3064             ++r;
3065
3066           if (r == opd->relocation + relcount)
3067             break;
3068
3069           if (r->address != syms[i]->value + opd->vma)
3070             continue;
3071
3072           if (r->howto->type != R_PPC64_ADDR64)
3073             continue;
3074
3075           sym = *r->sym_ptr_ptr;
3076           if (!sym_exists_at (syms, opdsymend, symcount,
3077                               sym->section->id, sym->value + r->addend))
3078             {
3079               ++count;
3080               size += sizeof (asymbol);
3081               size += strlen (syms[i]->name) + 2;
3082             }
3083         }
3084
3085       s = *ret = bfd_malloc (size);
3086       if (s == NULL)
3087         {
3088           count = -1;
3089           goto done;
3090         }
3091
3092       names = (char *) (s + count);
3093
3094       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3095         {
3096           asymbol *sym;
3097
3098           while (r < opd->relocation + relcount
3099                  && r->address < syms[i]->value + opd->vma)
3100             ++r;
3101
3102           if (r == opd->relocation + relcount)
3103             break;
3104
3105           if (r->address != syms[i]->value + opd->vma)
3106             continue;
3107
3108           if (r->howto->type != R_PPC64_ADDR64)
3109             continue;
3110
3111           sym = *r->sym_ptr_ptr;
3112           if (!sym_exists_at (syms, opdsymend, symcount,
3113                               sym->section->id, sym->value + r->addend))
3114             {
3115               size_t len;
3116
3117               *s = *syms[i];
3118               s->flags |= BSF_SYNTHETIC;
3119               s->section = sym->section;
3120               s->value = sym->value + r->addend;
3121               s->name = names;
3122               *names++ = '.';
3123               len = strlen (syms[i]->name);
3124               memcpy (names, syms[i]->name, len + 1);
3125               names += len + 1;
3126               /* Have udata.p point back to the original symbol this
3127                  synthetic symbol was derived from.  */
3128               s->udata.p = syms[i];
3129               s++;
3130             }
3131         }
3132     }
3133   else
3134     {
3135       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3136       bfd_byte *contents;
3137       size_t size;
3138       long plt_count = 0;
3139       bfd_vma glink_vma = 0, resolv_vma = 0;
3140       asection *dynamic, *glink = NULL, *relplt = NULL;
3141       arelent *p;
3142
3143       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3144         {
3145           if (contents)
3146             {
3147             free_contents_and_exit:
3148               free (contents);
3149             }
3150           count = -1;
3151           goto done;
3152         }
3153
3154       size = 0;
3155       for (i = secsymend; i < opdsymend; ++i)
3156         {
3157           bfd_vma ent;
3158
3159           /* Ignore bogus symbols.  */
3160           if (syms[i]->value > opd->size - 8)
3161             continue;
3162
3163           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3164           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3165             {
3166               ++count;
3167               size += sizeof (asymbol);
3168               size += strlen (syms[i]->name) + 2;
3169             }
3170         }
3171
3172       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3173       if (dyn_count != 0
3174           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3175         {
3176           bfd_byte *dynbuf, *extdyn, *extdynend;
3177           size_t extdynsize;
3178           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3179
3180           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3181             goto free_contents_and_exit;
3182
3183           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3184           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3185
3186           extdyn = dynbuf;
3187           extdynend = extdyn + dynamic->size;
3188           for (; extdyn < extdynend; extdyn += extdynsize)
3189             {
3190               Elf_Internal_Dyn dyn;
3191               (*swap_dyn_in) (abfd, extdyn, &dyn);
3192
3193               if (dyn.d_tag == DT_NULL)
3194                 break;
3195
3196               if (dyn.d_tag == DT_PPC64_GLINK)
3197                 {
3198                   /* The first glink stub starts at offset 32; see comment in
3199                      ppc64_elf_finish_dynamic_sections. */
3200                   glink_vma = dyn.d_un.d_val + 32;
3201                   /* The .glink section usually does not survive the final
3202                      link; search for the section (usually .text) where the
3203                      glink stubs now reside.  */
3204                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3205                                                 &glink_vma);
3206                   break;
3207                 }
3208             }
3209
3210           free (dynbuf);
3211         }
3212
3213       if (glink != NULL)
3214         {
3215           /* Determine __glink trampoline by reading the relative branch
3216              from the first glink stub.  */
3217           bfd_byte buf[4];
3218           if (bfd_get_section_contents (abfd, glink, buf,
3219                                         glink_vma + 4 - glink->vma, 4))
3220             {
3221               unsigned int insn = bfd_get_32 (abfd, buf);
3222               insn ^= B_DOT;
3223               if ((insn & ~0x3fffffc) == 0)
3224                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3225             }
3226
3227           if (resolv_vma)
3228             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3229
3230           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3231           if (relplt != NULL)
3232             {
3233               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3234               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3235                 goto free_contents_and_exit;
3236
3237               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3238               size += plt_count * sizeof (asymbol);
3239
3240               p = relplt->relocation;
3241               for (i = 0; i < plt_count; i++, p++)
3242                 {
3243                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3244                   if (p->addend != 0)
3245                     size += sizeof ("+0x") - 1 + 16;
3246                 }
3247             }
3248         }
3249
3250       s = *ret = bfd_malloc (size);
3251       if (s == NULL)
3252         goto free_contents_and_exit;
3253
3254       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3255
3256       for (i = secsymend; i < opdsymend; ++i)
3257         {
3258           bfd_vma ent;
3259
3260           if (syms[i]->value > opd->size - 8)
3261             continue;
3262
3263           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3264           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3265             {
3266               long lo, hi;
3267               size_t len;
3268               asection *sec = abfd->sections;
3269
3270               *s = *syms[i];
3271               lo = codesecsym;
3272               hi = codesecsymend;
3273               while (lo < hi)
3274                 {
3275                   long mid = (lo + hi) >> 1;
3276                   if (syms[mid]->section->vma < ent)
3277                     lo = mid + 1;
3278                   else if (syms[mid]->section->vma > ent)
3279                     hi = mid;
3280                   else
3281                     {
3282                       sec = syms[mid]->section;
3283                       break;
3284                     }
3285                 }
3286
3287               if (lo >= hi && lo > codesecsym)
3288                 sec = syms[lo - 1]->section;
3289
3290               for (; sec != NULL; sec = sec->next)
3291                 {
3292                   if (sec->vma > ent)
3293                     break;
3294                   /* SEC_LOAD may not be set if SEC is from a separate debug
3295                      info file.  */
3296                   if ((sec->flags & SEC_ALLOC) == 0)
3297                     break;
3298                   if ((sec->flags & SEC_CODE) != 0)
3299                     s->section = sec;
3300                 }
3301               s->flags |= BSF_SYNTHETIC;
3302               s->value = ent - s->section->vma;
3303               s->name = names;
3304               *names++ = '.';
3305               len = strlen (syms[i]->name);
3306               memcpy (names, syms[i]->name, len + 1);
3307               names += len + 1;
3308               /* Have udata.p point back to the original symbol this
3309                  synthetic symbol was derived from.  */
3310               s->udata.p = syms[i];
3311               s++;
3312             }
3313         }
3314       free (contents);
3315
3316       if (glink != NULL && relplt != NULL)
3317         {
3318           if (resolv_vma)
3319             {
3320               /* Add a symbol for the main glink trampoline.  */
3321               memset (s, 0, sizeof *s);
3322               s->the_bfd = abfd;
3323               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3324               s->section = glink;
3325               s->value = resolv_vma - glink->vma;
3326               s->name = names;
3327               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3328               names += sizeof ("__glink_PLTresolve");
3329               s++;
3330               count++;
3331             }
3332
3333           /* FIXME: It would be very much nicer to put sym@plt on the
3334              stub rather than on the glink branch table entry.  The
3335              objdump disassembler would then use a sensible symbol
3336              name on plt calls.  The difficulty in doing so is
3337              a) finding the stubs, and,
3338              b) matching stubs against plt entries, and,
3339              c) there can be multiple stubs for a given plt entry.
3340
3341              Solving (a) could be done by code scanning, but older
3342              ppc64 binaries used different stubs to current code.
3343              (b) is the tricky one since you need to known the toc
3344              pointer for at least one function that uses a pic stub to
3345              be able to calculate the plt address referenced.
3346              (c) means gdb would need to set multiple breakpoints (or
3347              find the glink branch itself) when setting breakpoints
3348              for pending shared library loads.  */
3349           p = relplt->relocation;
3350           for (i = 0; i < plt_count; i++, p++)
3351             {
3352               size_t len;
3353
3354               *s = **p->sym_ptr_ptr;
3355               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3356                  we are defining a symbol, ensure one of them is set.  */
3357               if ((s->flags & BSF_LOCAL) == 0)
3358                 s->flags |= BSF_GLOBAL;
3359               s->flags |= BSF_SYNTHETIC;
3360               s->section = glink;
3361               s->value = glink_vma - glink->vma;
3362               s->name = names;
3363               s->udata.p = NULL;
3364               len = strlen ((*p->sym_ptr_ptr)->name);
3365               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3366               names += len;
3367               if (p->addend != 0)
3368                 {
3369                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3370                   names += sizeof ("+0x") - 1;
3371                   bfd_sprintf_vma (abfd, names, p->addend);
3372                   names += strlen (names);
3373                 }
3374               memcpy (names, "@plt", sizeof ("@plt"));
3375               names += sizeof ("@plt");
3376               s++;
3377               glink_vma += 8;
3378               if (i >= 0x8000)
3379                 glink_vma += 4;
3380             }
3381           count += plt_count;
3382         }
3383     }
3384
3385  done:
3386   free (syms);
3387   return count;
3388 }
3389 \f
3390 /* The following functions are specific to the ELF linker, while
3391    functions above are used generally.  Those named ppc64_elf_* are
3392    called by the main ELF linker code.  They appear in this file more
3393    or less in the order in which they are called.  eg.
3394    ppc64_elf_check_relocs is called early in the link process,
3395    ppc64_elf_finish_dynamic_sections is one of the last functions
3396    called.
3397
3398    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3399    functions have both a function code symbol and a function descriptor
3400    symbol.  A call to foo in a relocatable object file looks like:
3401
3402    .            .text
3403    .    x:
3404    .            bl      .foo
3405    .            nop
3406
3407    The function definition in another object file might be:
3408
3409    .            .section .opd
3410    .    foo:    .quad   .foo
3411    .            .quad   .TOC.@tocbase
3412    .            .quad   0
3413    .
3414    .            .text
3415    .    .foo:   blr
3416
3417    When the linker resolves the call during a static link, the branch
3418    unsurprisingly just goes to .foo and the .opd information is unused.
3419    If the function definition is in a shared library, things are a little
3420    different:  The call goes via a plt call stub, the opd information gets
3421    copied to the plt, and the linker patches the nop.
3422
3423    .    x:
3424    .            bl      .foo_stub
3425    .            ld      2,40(1)
3426    .
3427    .
3428    .    .foo_stub:
3429    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3430    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3431    .            std     2,40(1)                 # this is the general idea
3432    .            ld      11,0(12)
3433    .            ld      2,8(12)
3434    .            mtctr   11
3435    .            ld      11,16(12)
3436    .            bctr
3437    .
3438    .            .section .plt
3439    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3440
3441    The "reloc ()" notation is supposed to indicate that the linker emits
3442    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3443    copying.
3444
3445    What are the difficulties here?  Well, firstly, the relocations
3446    examined by the linker in check_relocs are against the function code
3447    sym .foo, while the dynamic relocation in the plt is emitted against
3448    the function descriptor symbol, foo.  Somewhere along the line, we need
3449    to carefully copy dynamic link information from one symbol to the other.
3450    Secondly, the generic part of the elf linker will make .foo a dynamic
3451    symbol as is normal for most other backends.  We need foo dynamic
3452    instead, at least for an application final link.  However, when
3453    creating a shared library containing foo, we need to have both symbols
3454    dynamic so that references to .foo are satisfied during the early
3455    stages of linking.  Otherwise the linker might decide to pull in a
3456    definition from some other object, eg. a static library.
3457
3458    Update: As of August 2004, we support a new convention.  Function
3459    calls may use the function descriptor symbol, ie. "bl foo".  This
3460    behaves exactly as "bl .foo".  */
3461
3462 /* Of those relocs that might be copied as dynamic relocs, this function
3463    selects those that must be copied when linking a shared library,
3464    even when the symbol is local.  */
3465
3466 static int
3467 must_be_dyn_reloc (struct bfd_link_info *info,
3468                    enum elf_ppc64_reloc_type r_type)
3469 {
3470   switch (r_type)
3471     {
3472     default:
3473       return 1;
3474
3475     case R_PPC64_REL32:
3476     case R_PPC64_REL64:
3477     case R_PPC64_REL30:
3478       return 0;
3479
3480     case R_PPC64_TPREL16:
3481     case R_PPC64_TPREL16_LO:
3482     case R_PPC64_TPREL16_HI:
3483     case R_PPC64_TPREL16_HA:
3484     case R_PPC64_TPREL16_DS:
3485     case R_PPC64_TPREL16_LO_DS:
3486     case R_PPC64_TPREL16_HIGHER:
3487     case R_PPC64_TPREL16_HIGHERA:
3488     case R_PPC64_TPREL16_HIGHEST:
3489     case R_PPC64_TPREL16_HIGHESTA:
3490     case R_PPC64_TPREL64:
3491       return !info->executable;
3492     }
3493 }
3494
3495 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3496    copying dynamic variables from a shared lib into an app's dynbss
3497    section, and instead use a dynamic relocation to point into the
3498    shared lib.  With code that gcc generates, it's vital that this be
3499    enabled;  In the PowerPC64 ABI, the address of a function is actually
3500    the address of a function descriptor, which resides in the .opd
3501    section.  gcc uses the descriptor directly rather than going via the
3502    GOT as some other ABI's do, which means that initialized function
3503    pointers must reference the descriptor.  Thus, a function pointer
3504    initialized to the address of a function in a shared library will
3505    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3506    redefines the function descriptor symbol to point to the copy.  This
3507    presents a problem as a plt entry for that function is also
3508    initialized from the function descriptor symbol and the copy reloc
3509    may not be initialized first.  */
3510 #define ELIMINATE_COPY_RELOCS 1
3511
3512 /* Section name for stubs is the associated section name plus this
3513    string.  */
3514 #define STUB_SUFFIX ".stub"
3515
3516 /* Linker stubs.
3517    ppc_stub_long_branch:
3518    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3519    destination, but a 24 bit branch in a stub section will reach.
3520    .    b       dest
3521
3522    ppc_stub_plt_branch:
3523    Similar to the above, but a 24 bit branch in the stub section won't
3524    reach its destination.
3525    .    addis   %r12,%r2,xxx@toc@ha
3526    .    ld      %r11,xxx@toc@l(%r12)
3527    .    mtctr   %r11
3528    .    bctr
3529
3530    ppc_stub_plt_call:
3531    Used to call a function in a shared library.  If it so happens that
3532    the plt entry referenced crosses a 64k boundary, then an extra
3533    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3534    .    addis   %r12,%r2,xxx@toc@ha
3535    .    std     %r2,40(%r1)
3536    .    ld      %r11,xxx+0@toc@l(%r12)
3537    .    mtctr   %r11
3538    .    ld      %r2,xxx+8@toc@l(%r12)
3539    .    ld      %r11,xxx+16@toc@l(%r12)
3540    .    bctr
3541
3542    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3543    code to adjust the value and save r2 to support multiple toc sections.
3544    A ppc_stub_long_branch with an r2 offset looks like:
3545    .    std     %r2,40(%r1)
3546    .    addis   %r2,%r2,off@ha
3547    .    addi    %r2,%r2,off@l
3548    .    b       dest
3549
3550    A ppc_stub_plt_branch with an r2 offset looks like:
3551    .    std     %r2,40(%r1)
3552    .    addis   %r12,%r2,xxx@toc@ha
3553    .    ld      %r11,xxx@toc@l(%r12)
3554    .    addis   %r2,%r2,off@ha
3555    .    addi    %r2,%r2,off@l
3556    .    mtctr   %r11
3557    .    bctr
3558
3559    In cases where the "addis" instruction would add zero, the "addis" is
3560    omitted and following instructions modified slightly in some cases.
3561 */
3562
3563 enum ppc_stub_type {
3564   ppc_stub_none,
3565   ppc_stub_long_branch,
3566   ppc_stub_long_branch_r2off,
3567   ppc_stub_plt_branch,
3568   ppc_stub_plt_branch_r2off,
3569   ppc_stub_plt_call
3570 };
3571
3572 struct ppc_stub_hash_entry {
3573
3574   /* Base hash table entry structure.  */
3575   struct bfd_hash_entry root;
3576
3577   enum ppc_stub_type stub_type;
3578
3579   /* The stub section.  */
3580   asection *stub_sec;
3581
3582   /* Offset within stub_sec of the beginning of this stub.  */
3583   bfd_vma stub_offset;
3584
3585   /* Given the symbol's value and its section we can determine its final
3586      value when building the stubs (so the stub knows where to jump.  */
3587   bfd_vma target_value;
3588   asection *target_section;
3589
3590   /* The symbol table entry, if any, that this was derived from.  */
3591   struct ppc_link_hash_entry *h;
3592   struct plt_entry *plt_ent;
3593
3594   /* And the reloc addend that this was derived from.  */
3595   bfd_vma addend;
3596
3597   /* Where this stub is being called from, or, in the case of combined
3598      stub sections, the first input section in the group.  */
3599   asection *id_sec;
3600 };
3601
3602 struct ppc_branch_hash_entry {
3603
3604   /* Base hash table entry structure.  */
3605   struct bfd_hash_entry root;
3606
3607   /* Offset within branch lookup table.  */
3608   unsigned int offset;
3609
3610   /* Generation marker.  */
3611   unsigned int iter;
3612 };
3613
3614 struct ppc_link_hash_entry
3615 {
3616   struct elf_link_hash_entry elf;
3617
3618   union {
3619     /* A pointer to the most recently used stub hash entry against this
3620        symbol.  */
3621     struct ppc_stub_hash_entry *stub_cache;
3622
3623     /* A pointer to the next symbol starting with a '.'  */
3624     struct ppc_link_hash_entry *next_dot_sym;
3625   } u;
3626
3627   /* Track dynamic relocs copied for this symbol.  */
3628   struct elf_dyn_relocs *dyn_relocs;
3629
3630   /* Link between function code and descriptor symbols.  */
3631   struct ppc_link_hash_entry *oh;
3632
3633   /* Flag function code and descriptor symbols.  */
3634   unsigned int is_func:1;
3635   unsigned int is_func_descriptor:1;
3636   unsigned int fake:1;
3637
3638   /* Whether global opd/toc sym has been adjusted or not.
3639      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3640      should be set for all globals defined in any opd/toc section.  */
3641   unsigned int adjust_done:1;
3642
3643   /* Set if we twiddled this symbol to weak at some stage.  */
3644   unsigned int was_undefined:1;
3645
3646   /* Contexts in which symbol is used in the GOT (or TOC).
3647      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3648      corresponding relocs are encountered during check_relocs.
3649      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3650      indicate the corresponding GOT entry type is not needed.
3651      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3652      a TPREL one.  We use a separate flag rather than setting TPREL
3653      just for convenience in distinguishing the two cases.  */
3654 #define TLS_GD           1      /* GD reloc. */
3655 #define TLS_LD           2      /* LD reloc. */
3656 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3657 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3658 #define TLS_TLS         16      /* Any TLS reloc.  */
3659 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3660 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3661 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3662   unsigned char tls_mask;
3663 };
3664
3665 /* ppc64 ELF linker hash table.  */
3666
3667 struct ppc_link_hash_table
3668 {
3669   struct elf_link_hash_table elf;
3670
3671   /* The stub hash table.  */
3672   struct bfd_hash_table stub_hash_table;
3673
3674   /* Another hash table for plt_branch stubs.  */
3675   struct bfd_hash_table branch_hash_table;
3676
3677   /* Linker stub bfd.  */
3678   bfd *stub_bfd;
3679
3680   /* Linker call-backs.  */
3681   asection * (*add_stub_section) (const char *, asection *);
3682   void (*layout_sections_again) (void);
3683
3684   /* Array to keep track of which stub sections have been created, and
3685      information on stub grouping.  */
3686   struct map_stub {
3687     /* This is the section to which stubs in the group will be attached.  */
3688     asection *link_sec;
3689     /* The stub section.  */
3690     asection *stub_sec;
3691     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3692     bfd_vma toc_off;
3693   } *stub_group;
3694
3695   /* Temp used when calculating TOC pointers.  */
3696   bfd_vma toc_curr;
3697   bfd *toc_bfd;
3698   asection *toc_first_sec;
3699
3700   /* Highest input section id.  */
3701   int top_id;
3702
3703   /* Highest output section index.  */
3704   int top_index;
3705
3706   /* Used when adding symbols.  */
3707   struct ppc_link_hash_entry *dot_syms;
3708
3709   /* List of input sections for each output section.  */
3710   asection **input_list;
3711
3712   /* Short-cuts to get to dynamic linker sections.  */
3713   asection *got;
3714   asection *plt;
3715   asection *relplt;
3716   asection *iplt;
3717   asection *reliplt;
3718   asection *dynbss;
3719   asection *relbss;
3720   asection *glink;
3721   asection *sfpr;
3722   asection *brlt;
3723   asection *relbrlt;
3724   asection *glink_eh_frame;
3725
3726   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3727   struct ppc_link_hash_entry *tls_get_addr;
3728   struct ppc_link_hash_entry *tls_get_addr_fd;
3729
3730   /* The size of reliplt used by got entry relocs.  */
3731   bfd_size_type got_reli_size;
3732
3733   /* Statistics.  */
3734   unsigned long stub_count[ppc_stub_plt_call];
3735
3736   /* Number of stubs against global syms.  */
3737   unsigned long stub_globals;
3738
3739   /* Set if PLT call stubs should load r11.  */
3740   unsigned int plt_static_chain:1;
3741
3742   /* Set if we should emit symbols for stubs.  */
3743   unsigned int emit_stub_syms:1;
3744
3745   /* Set if __tls_get_addr optimization should not be done.  */
3746   unsigned int no_tls_get_addr_opt:1;
3747
3748   /* Support for multiple toc sections.  */
3749   unsigned int do_multi_toc:1;
3750   unsigned int multi_toc_needed:1;
3751   unsigned int second_toc_pass:1;
3752   unsigned int do_toc_opt:1;
3753
3754   /* Set on error.  */
3755   unsigned int stub_error:1;
3756
3757   /* Temp used by ppc64_elf_process_dot_syms.  */
3758   unsigned int twiddled_syms:1;
3759
3760   /* Incremented every time we size stubs.  */
3761   unsigned int stub_iteration;
3762
3763   /* Small local sym cache.  */
3764   struct sym_cache sym_cache;
3765 };
3766
3767 /* Rename some of the generic section flags to better document how they
3768    are used here.  */
3769
3770 /* Nonzero if this section has TLS related relocations.  */
3771 #define has_tls_reloc sec_flg0
3772
3773 /* Nonzero if this section has a call to __tls_get_addr.  */
3774 #define has_tls_get_addr_call sec_flg1
3775
3776 /* Nonzero if this section has any toc or got relocs.  */
3777 #define has_toc_reloc sec_flg2
3778
3779 /* Nonzero if this section has a call to another section that uses
3780    the toc or got.  */
3781 #define makes_toc_func_call sec_flg3
3782
3783 /* Recursion protection when determining above flag.  */
3784 #define call_check_in_progress sec_flg4
3785 #define call_check_done sec_flg5
3786
3787 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3788
3789 #define ppc_hash_table(p) \
3790   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3791   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3792
3793 #define ppc_stub_hash_lookup(table, string, create, copy) \
3794   ((struct ppc_stub_hash_entry *) \
3795    bfd_hash_lookup ((table), (string), (create), (copy)))
3796
3797 #define ppc_branch_hash_lookup(table, string, create, copy) \
3798   ((struct ppc_branch_hash_entry *) \
3799    bfd_hash_lookup ((table), (string), (create), (copy)))
3800
3801 /* Create an entry in the stub hash table.  */
3802
3803 static struct bfd_hash_entry *
3804 stub_hash_newfunc (struct bfd_hash_entry *entry,
3805                    struct bfd_hash_table *table,
3806                    const char *string)
3807 {
3808   /* Allocate the structure if it has not already been allocated by a
3809      subclass.  */
3810   if (entry == NULL)
3811     {
3812       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3813       if (entry == NULL)
3814         return entry;
3815     }
3816
3817   /* Call the allocation method of the superclass.  */
3818   entry = bfd_hash_newfunc (entry, table, string);
3819   if (entry != NULL)
3820     {
3821       struct ppc_stub_hash_entry *eh;
3822
3823       /* Initialize the local fields.  */
3824       eh = (struct ppc_stub_hash_entry *) entry;
3825       eh->stub_type = ppc_stub_none;
3826       eh->stub_sec = NULL;
3827       eh->stub_offset = 0;
3828       eh->target_value = 0;
3829       eh->target_section = NULL;
3830       eh->h = NULL;
3831       eh->id_sec = NULL;
3832     }
3833
3834   return entry;
3835 }
3836
3837 /* Create an entry in the branch hash table.  */
3838
3839 static struct bfd_hash_entry *
3840 branch_hash_newfunc (struct bfd_hash_entry *entry,
3841                      struct bfd_hash_table *table,
3842                      const char *string)
3843 {
3844   /* Allocate the structure if it has not already been allocated by a
3845      subclass.  */
3846   if (entry == NULL)
3847     {
3848       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3849       if (entry == NULL)
3850         return entry;
3851     }
3852
3853   /* Call the allocation method of the superclass.  */
3854   entry = bfd_hash_newfunc (entry, table, string);
3855   if (entry != NULL)
3856     {
3857       struct ppc_branch_hash_entry *eh;
3858
3859       /* Initialize the local fields.  */
3860       eh = (struct ppc_branch_hash_entry *) entry;
3861       eh->offset = 0;
3862       eh->iter = 0;
3863     }
3864
3865   return entry;
3866 }
3867
3868 /* Create an entry in a ppc64 ELF linker hash table.  */
3869
3870 static struct bfd_hash_entry *
3871 link_hash_newfunc (struct bfd_hash_entry *entry,
3872                    struct bfd_hash_table *table,
3873                    const char *string)
3874 {
3875   /* Allocate the structure if it has not already been allocated by a
3876      subclass.  */
3877   if (entry == NULL)
3878     {
3879       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3880       if (entry == NULL)
3881         return entry;
3882     }
3883
3884   /* Call the allocation method of the superclass.  */
3885   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3886   if (entry != NULL)
3887     {
3888       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3889
3890       memset (&eh->u.stub_cache, 0,
3891               (sizeof (struct ppc_link_hash_entry)
3892                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3893
3894       /* When making function calls, old ABI code references function entry
3895          points (dot symbols), while new ABI code references the function
3896          descriptor symbol.  We need to make any combination of reference and
3897          definition work together, without breaking archive linking.
3898
3899          For a defined function "foo" and an undefined call to "bar":
3900          An old object defines "foo" and ".foo", references ".bar" (possibly
3901          "bar" too).
3902          A new object defines "foo" and references "bar".
3903
3904          A new object thus has no problem with its undefined symbols being
3905          satisfied by definitions in an old object.  On the other hand, the
3906          old object won't have ".bar" satisfied by a new object.
3907
3908          Keep a list of newly added dot-symbols.  */
3909
3910       if (string[0] == '.')
3911         {
3912           struct ppc_link_hash_table *htab;
3913
3914           htab = (struct ppc_link_hash_table *) table;
3915           eh->u.next_dot_sym = htab->dot_syms;
3916           htab->dot_syms = eh;
3917         }
3918     }
3919
3920   return entry;
3921 }
3922
3923 /* Create a ppc64 ELF linker hash table.  */
3924
3925 static struct bfd_link_hash_table *
3926 ppc64_elf_link_hash_table_create (bfd *abfd)
3927 {
3928   struct ppc_link_hash_table *htab;
3929   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3930
3931   htab = bfd_zmalloc (amt);
3932   if (htab == NULL)
3933     return NULL;
3934
3935   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3936                                       sizeof (struct ppc_link_hash_entry),
3937                                       PPC64_ELF_DATA))
3938     {
3939       free (htab);
3940       return NULL;
3941     }
3942
3943   /* Init the stub hash table too.  */
3944   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3945                             sizeof (struct ppc_stub_hash_entry)))
3946     return NULL;
3947
3948   /* And the branch hash table.  */
3949   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3950                             sizeof (struct ppc_branch_hash_entry)))
3951     return NULL;
3952
3953   /* Initializing two fields of the union is just cosmetic.  We really
3954      only care about glist, but when compiled on a 32-bit host the
3955      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3956      debugger inspection of these fields look nicer.  */
3957   htab->elf.init_got_refcount.refcount = 0;
3958   htab->elf.init_got_refcount.glist = NULL;
3959   htab->elf.init_plt_refcount.refcount = 0;
3960   htab->elf.init_plt_refcount.glist = NULL;
3961   htab->elf.init_got_offset.offset = 0;
3962   htab->elf.init_got_offset.glist = NULL;
3963   htab->elf.init_plt_offset.offset = 0;
3964   htab->elf.init_plt_offset.glist = NULL;
3965
3966   return &htab->elf.root;
3967 }
3968
3969 /* Free the derived linker hash table.  */
3970
3971 static void
3972 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3973 {
3974   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3975
3976   bfd_hash_table_free (&ret->stub_hash_table);
3977   bfd_hash_table_free (&ret->branch_hash_table);
3978   _bfd_generic_link_hash_table_free (hash);
3979 }
3980
3981 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
3982
3983 void
3984 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3985 {
3986   struct ppc_link_hash_table *htab;
3987
3988   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3989
3990 /* Always hook our dynamic sections into the first bfd, which is the
3991    linker created stub bfd.  This ensures that the GOT header is at
3992    the start of the output TOC section.  */
3993   htab = ppc_hash_table (info);
3994   if (htab == NULL)
3995     return;
3996   htab->stub_bfd = abfd;
3997   htab->elf.dynobj = abfd;
3998 }
3999
4000 /* Build a name for an entry in the stub hash table.  */
4001
4002 static char *
4003 ppc_stub_name (const asection *input_section,
4004                const asection *sym_sec,
4005                const struct ppc_link_hash_entry *h,
4006                const Elf_Internal_Rela *rel)
4007 {
4008   char *stub_name;
4009   bfd_size_type len;
4010
4011   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4012      offsets from a sym as a branch target?  In fact, we could
4013      probably assume the addend is always zero.  */
4014   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4015
4016   if (h)
4017     {
4018       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4019       stub_name = bfd_malloc (len);
4020       if (stub_name == NULL)
4021         return stub_name;
4022
4023       sprintf (stub_name, "%08x.%s+%x",
4024                input_section->id & 0xffffffff,
4025                h->elf.root.root.string,
4026                (int) rel->r_addend & 0xffffffff);
4027     }
4028   else
4029     {
4030       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4031       stub_name = bfd_malloc (len);
4032       if (stub_name == NULL)
4033         return stub_name;
4034
4035       sprintf (stub_name, "%08x.%x:%x+%x",
4036                input_section->id & 0xffffffff,
4037                sym_sec->id & 0xffffffff,
4038                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4039                (int) rel->r_addend & 0xffffffff);
4040     }
4041   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4042     stub_name[len - 2] = 0;
4043   return stub_name;
4044 }
4045
4046 /* Look up an entry in the stub hash.  Stub entries are cached because
4047    creating the stub name takes a bit of time.  */
4048
4049 static struct ppc_stub_hash_entry *
4050 ppc_get_stub_entry (const asection *input_section,
4051                     const asection *sym_sec,
4052                     struct ppc_link_hash_entry *h,
4053                     const Elf_Internal_Rela *rel,
4054                     struct ppc_link_hash_table *htab)
4055 {
4056   struct ppc_stub_hash_entry *stub_entry;
4057   const asection *id_sec;
4058
4059   /* If this input section is part of a group of sections sharing one
4060      stub section, then use the id of the first section in the group.
4061      Stub names need to include a section id, as there may well be
4062      more than one stub used to reach say, printf, and we need to
4063      distinguish between them.  */
4064   id_sec = htab->stub_group[input_section->id].link_sec;
4065
4066   if (h != NULL && h->u.stub_cache != NULL
4067       && h->u.stub_cache->h == h
4068       && h->u.stub_cache->id_sec == id_sec)
4069     {
4070       stub_entry = h->u.stub_cache;
4071     }
4072   else
4073     {
4074       char *stub_name;
4075
4076       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4077       if (stub_name == NULL)
4078         return NULL;
4079
4080       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4081                                          stub_name, FALSE, FALSE);
4082       if (h != NULL)
4083         h->u.stub_cache = stub_entry;
4084
4085       free (stub_name);
4086     }
4087
4088   return stub_entry;
4089 }
4090
4091 /* Add a new stub entry to the stub hash.  Not all fields of the new
4092    stub entry are initialised.  */
4093
4094 static struct ppc_stub_hash_entry *
4095 ppc_add_stub (const char *stub_name,
4096               asection *section,
4097               struct bfd_link_info *info)
4098 {
4099   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4100   asection *link_sec;
4101   asection *stub_sec;
4102   struct ppc_stub_hash_entry *stub_entry;
4103
4104   link_sec = htab->stub_group[section->id].link_sec;
4105   stub_sec = htab->stub_group[section->id].stub_sec;
4106   if (stub_sec == NULL)
4107     {
4108       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4109       if (stub_sec == NULL)
4110         {
4111           size_t namelen;
4112           bfd_size_type len;
4113           char *s_name;
4114
4115           namelen = strlen (link_sec->name);
4116           len = namelen + sizeof (STUB_SUFFIX);
4117           s_name = bfd_alloc (htab->stub_bfd, len);
4118           if (s_name == NULL)
4119             return NULL;
4120
4121           memcpy (s_name, link_sec->name, namelen);
4122           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4123           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4124           if (stub_sec == NULL)
4125             return NULL;
4126           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4127         }
4128       htab->stub_group[section->id].stub_sec = stub_sec;
4129     }
4130
4131   /* Enter this entry into the linker stub hash table.  */
4132   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4133                                      TRUE, FALSE);
4134   if (stub_entry == NULL)
4135     {
4136       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4137                               section->owner, stub_name);
4138       return NULL;
4139     }
4140
4141   stub_entry->stub_sec = stub_sec;
4142   stub_entry->stub_offset = 0;
4143   stub_entry->id_sec = link_sec;
4144   return stub_entry;
4145 }
4146
4147 /* Create sections for linker generated code.  */
4148
4149 static bfd_boolean
4150 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4151 {
4152   struct ppc_link_hash_table *htab;
4153   flagword flags;
4154
4155   htab = ppc_hash_table (info);
4156   if (htab == NULL)
4157     return FALSE;
4158
4159   /* Create .sfpr for code to save and restore fp regs.  */
4160   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4161            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4162   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4163                                                    flags);
4164   if (htab->sfpr == NULL
4165       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4166     return FALSE;
4167
4168   /* Create .glink for lazy dynamic linking support.  */
4169   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4170                                                     flags);
4171   if (htab->glink == NULL
4172       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4173     return FALSE;
4174
4175   if (!info->no_ld_generated_unwind_info)
4176     {
4177       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4178                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4179       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4180                                                                  ".eh_frame",
4181                                                                  flags);
4182       if (htab->glink_eh_frame == NULL
4183           || !bfd_set_section_alignment (abfd, htab->glink_eh_frame, 2))
4184         return FALSE;
4185     }
4186
4187   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4188   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4189   if (htab->iplt == NULL
4190       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4191     return FALSE;
4192
4193   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4194            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4195   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4196                                                       ".rela.iplt",
4197                                                       flags);
4198   if (htab->reliplt == NULL
4199       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4200     return FALSE;
4201
4202   /* Create branch lookup table for plt_branch stubs.  */
4203   flags = (SEC_ALLOC | SEC_LOAD
4204            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4205   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4206                                                    flags);
4207   if (htab->brlt == NULL
4208       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4209     return FALSE;
4210
4211   if (!info->shared)
4212     return TRUE;
4213
4214   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4215            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4216   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4217                                                       ".rela.branch_lt",
4218                                                       flags);
4219   if (htab->relbrlt == NULL
4220       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4221     return FALSE;
4222
4223   return TRUE;
4224 }
4225
4226 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4227    not already done.  */
4228
4229 static bfd_boolean
4230 create_got_section (bfd *abfd, struct bfd_link_info *info)
4231 {
4232   asection *got, *relgot;
4233   flagword flags;
4234   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4235
4236   if (!is_ppc64_elf (abfd))
4237     return FALSE;
4238   if (htab == NULL)
4239     return FALSE;
4240
4241   if (!htab->got)
4242     {
4243       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4244         return FALSE;
4245
4246       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4247       if (!htab->got)
4248         abort ();
4249     }
4250
4251   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4252            | SEC_LINKER_CREATED);
4253
4254   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4255   if (!got
4256       || !bfd_set_section_alignment (abfd, got, 3))
4257     return FALSE;
4258
4259   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4260                                                flags | SEC_READONLY);
4261   if (!relgot
4262       || ! bfd_set_section_alignment (abfd, relgot, 3))
4263     return FALSE;
4264
4265   ppc64_elf_tdata (abfd)->got = got;
4266   ppc64_elf_tdata (abfd)->relgot = relgot;
4267   return TRUE;
4268 }
4269
4270 /* Create the dynamic sections, and set up shortcuts.  */
4271
4272 static bfd_boolean
4273 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4274 {
4275   struct ppc_link_hash_table *htab;
4276
4277   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4278     return FALSE;
4279
4280   htab = ppc_hash_table (info);
4281   if (htab == NULL)
4282     return FALSE;
4283
4284   if (!htab->got)
4285     htab->got = bfd_get_section_by_name (dynobj, ".got");
4286   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4287   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4288   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4289   if (!info->shared)
4290     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4291
4292   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4293       || (!info->shared && !htab->relbss))
4294     abort ();
4295
4296   return TRUE;
4297 }
4298
4299 /* Follow indirect and warning symbol links.  */
4300
4301 static inline struct bfd_link_hash_entry *
4302 follow_link (struct bfd_link_hash_entry *h)
4303 {
4304   while (h->type == bfd_link_hash_indirect
4305          || h->type == bfd_link_hash_warning)
4306     h = h->u.i.link;
4307   return h;
4308 }
4309
4310 static inline struct elf_link_hash_entry *
4311 elf_follow_link (struct elf_link_hash_entry *h)
4312 {
4313   return (struct elf_link_hash_entry *) follow_link (&h->root);
4314 }
4315
4316 static inline struct ppc_link_hash_entry *
4317 ppc_follow_link (struct ppc_link_hash_entry *h)
4318 {
4319   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4320 }
4321
4322 /* Merge PLT info on FROM with that on TO.  */
4323
4324 static void
4325 move_plt_plist (struct ppc_link_hash_entry *from,
4326                 struct ppc_link_hash_entry *to)
4327 {
4328   if (from->elf.plt.plist != NULL)
4329     {
4330       if (to->elf.plt.plist != NULL)
4331         {
4332           struct plt_entry **entp;
4333           struct plt_entry *ent;
4334
4335           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4336             {
4337               struct plt_entry *dent;
4338
4339               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4340                 if (dent->addend == ent->addend)
4341                   {
4342                     dent->plt.refcount += ent->plt.refcount;
4343                     *entp = ent->next;
4344                     break;
4345                   }
4346               if (dent == NULL)
4347                 entp = &ent->next;
4348             }
4349           *entp = to->elf.plt.plist;
4350         }
4351
4352       to->elf.plt.plist = from->elf.plt.plist;
4353       from->elf.plt.plist = NULL;
4354     }
4355 }
4356
4357 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4358
4359 static void
4360 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4361                                 struct elf_link_hash_entry *dir,
4362                                 struct elf_link_hash_entry *ind)
4363 {
4364   struct ppc_link_hash_entry *edir, *eind;
4365
4366   edir = (struct ppc_link_hash_entry *) dir;
4367   eind = (struct ppc_link_hash_entry *) ind;
4368
4369   edir->is_func |= eind->is_func;
4370   edir->is_func_descriptor |= eind->is_func_descriptor;
4371   edir->tls_mask |= eind->tls_mask;
4372   if (eind->oh != NULL)
4373     edir->oh = ppc_follow_link (eind->oh);
4374
4375   /* If called to transfer flags for a weakdef during processing
4376      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4377      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4378   if (!(ELIMINATE_COPY_RELOCS
4379         && eind->elf.root.type != bfd_link_hash_indirect
4380         && edir->elf.dynamic_adjusted))
4381     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4382
4383   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4384   edir->elf.ref_regular |= eind->elf.ref_regular;
4385   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4386   edir->elf.needs_plt |= eind->elf.needs_plt;
4387
4388   /* If we were called to copy over info for a weak sym, that's all.  */
4389   if (eind->elf.root.type != bfd_link_hash_indirect)
4390     return;
4391
4392   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4393   if (eind->dyn_relocs != NULL)
4394     {
4395       if (edir->dyn_relocs != NULL)
4396         {
4397           struct elf_dyn_relocs **pp;
4398           struct elf_dyn_relocs *p;
4399
4400           /* Add reloc counts against the indirect sym to the direct sym
4401              list.  Merge any entries against the same section.  */
4402           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4403             {
4404               struct elf_dyn_relocs *q;
4405
4406               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4407                 if (q->sec == p->sec)
4408                   {
4409                     q->pc_count += p->pc_count;
4410                     q->count += p->count;
4411                     *pp = p->next;
4412                     break;
4413                   }
4414               if (q == NULL)
4415                 pp = &p->next;
4416             }
4417           *pp = edir->dyn_relocs;
4418         }
4419
4420       edir->dyn_relocs = eind->dyn_relocs;
4421       eind->dyn_relocs = NULL;
4422     }
4423
4424   /* Copy over got entries that we may have already seen to the
4425      symbol which just became indirect.  */
4426   if (eind->elf.got.glist != NULL)
4427     {
4428       if (edir->elf.got.glist != NULL)
4429         {
4430           struct got_entry **entp;
4431           struct got_entry *ent;
4432
4433           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4434             {
4435               struct got_entry *dent;
4436
4437               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4438                 if (dent->addend == ent->addend
4439                     && dent->owner == ent->owner
4440                     && dent->tls_type == ent->tls_type)
4441                   {
4442                     dent->got.refcount += ent->got.refcount;
4443                     *entp = ent->next;
4444                     break;
4445                   }
4446               if (dent == NULL)
4447                 entp = &ent->next;
4448             }
4449           *entp = edir->elf.got.glist;
4450         }
4451
4452       edir->elf.got.glist = eind->elf.got.glist;
4453       eind->elf.got.glist = NULL;
4454     }
4455
4456   /* And plt entries.  */
4457   move_plt_plist (eind, edir);
4458
4459   if (eind->elf.dynindx != -1)
4460     {
4461       if (edir->elf.dynindx != -1)
4462         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4463                                 edir->elf.dynstr_index);
4464       edir->elf.dynindx = eind->elf.dynindx;
4465       edir->elf.dynstr_index = eind->elf.dynstr_index;
4466       eind->elf.dynindx = -1;
4467       eind->elf.dynstr_index = 0;
4468     }
4469 }
4470
4471 /* Find the function descriptor hash entry from the given function code
4472    hash entry FH.  Link the entries via their OH fields.  */
4473
4474 static struct ppc_link_hash_entry *
4475 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4476 {
4477   struct ppc_link_hash_entry *fdh = fh->oh;
4478
4479   if (fdh == NULL)
4480     {
4481       const char *fd_name = fh->elf.root.root.string + 1;
4482
4483       fdh = (struct ppc_link_hash_entry *)
4484         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4485       if (fdh == NULL)
4486         return fdh;
4487
4488       fdh->is_func_descriptor = 1;
4489       fdh->oh = fh;
4490       fh->is_func = 1;
4491       fh->oh = fdh;
4492     }
4493
4494   return ppc_follow_link (fdh);
4495 }
4496
4497 /* Make a fake function descriptor sym for the code sym FH.  */
4498
4499 static struct ppc_link_hash_entry *
4500 make_fdh (struct bfd_link_info *info,
4501           struct ppc_link_hash_entry *fh)
4502 {
4503   bfd *abfd;
4504   asymbol *newsym;
4505   struct bfd_link_hash_entry *bh;
4506   struct ppc_link_hash_entry *fdh;
4507
4508   abfd = fh->elf.root.u.undef.abfd;
4509   newsym = bfd_make_empty_symbol (abfd);
4510   newsym->name = fh->elf.root.root.string + 1;
4511   newsym->section = bfd_und_section_ptr;
4512   newsym->value = 0;
4513   newsym->flags = BSF_WEAK;
4514
4515   bh = NULL;
4516   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4517                                          newsym->flags, newsym->section,
4518                                          newsym->value, NULL, FALSE, FALSE,
4519                                          &bh))
4520     return NULL;
4521
4522   fdh = (struct ppc_link_hash_entry *) bh;
4523   fdh->elf.non_elf = 0;
4524   fdh->fake = 1;
4525   fdh->is_func_descriptor = 1;
4526   fdh->oh = fh;
4527   fh->is_func = 1;
4528   fh->oh = fdh;
4529   return fdh;
4530 }
4531
4532 /* Fix function descriptor symbols defined in .opd sections to be
4533    function type.  */
4534
4535 static bfd_boolean
4536 ppc64_elf_add_symbol_hook (bfd *ibfd,
4537                            struct bfd_link_info *info,
4538                            Elf_Internal_Sym *isym,
4539                            const char **name ATTRIBUTE_UNUSED,
4540                            flagword *flags ATTRIBUTE_UNUSED,
4541                            asection **sec,
4542                            bfd_vma *value ATTRIBUTE_UNUSED)
4543 {
4544   if ((ibfd->flags & DYNAMIC) == 0
4545       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4546     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4547
4548   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4549     {
4550       if ((ibfd->flags & DYNAMIC) == 0)
4551         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4552     }
4553   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4554     ;
4555   else if (*sec != NULL
4556            && strcmp ((*sec)->name, ".opd") == 0)
4557     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4558
4559   return TRUE;
4560 }
4561
4562 /* This function makes an old ABI object reference to ".bar" cause the
4563    inclusion of a new ABI object archive that defines "bar".
4564    NAME is a symbol defined in an archive.  Return a symbol in the hash
4565    table that might be satisfied by the archive symbols.  */
4566
4567 static struct elf_link_hash_entry *
4568 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4569                                  struct bfd_link_info *info,
4570                                  const char *name)
4571 {
4572   struct elf_link_hash_entry *h;
4573   char *dot_name;
4574   size_t len;
4575
4576   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4577   if (h != NULL
4578       /* Don't return this sym if it is a fake function descriptor
4579          created by add_symbol_adjust.  */
4580       && !(h->root.type == bfd_link_hash_undefweak
4581            && ((struct ppc_link_hash_entry *) h)->fake))
4582     return h;
4583
4584   if (name[0] == '.')
4585     return h;
4586
4587   len = strlen (name);
4588   dot_name = bfd_alloc (abfd, len + 2);
4589   if (dot_name == NULL)
4590     return (struct elf_link_hash_entry *) 0 - 1;
4591   dot_name[0] = '.';
4592   memcpy (dot_name + 1, name, len + 1);
4593   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4594   bfd_release (abfd, dot_name);
4595   return h;
4596 }
4597
4598 /* This function satisfies all old ABI object references to ".bar" if a
4599    new ABI object defines "bar".  Well, at least, undefined dot symbols
4600    are made weak.  This stops later archive searches from including an
4601    object if we already have a function descriptor definition.  It also
4602    prevents the linker complaining about undefined symbols.
4603    We also check and correct mismatched symbol visibility here.  The
4604    most restrictive visibility of the function descriptor and the
4605    function entry symbol is used.  */
4606
4607 static bfd_boolean
4608 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4609 {
4610   struct ppc_link_hash_table *htab;
4611   struct ppc_link_hash_entry *fdh;
4612
4613   if (eh->elf.root.type == bfd_link_hash_indirect)
4614     return TRUE;
4615
4616   if (eh->elf.root.type == bfd_link_hash_warning)
4617     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4618
4619   if (eh->elf.root.root.string[0] != '.')
4620     abort ();
4621
4622   htab = ppc_hash_table (info);
4623   if (htab == NULL)
4624     return FALSE;
4625
4626   fdh = lookup_fdh (eh, htab);
4627   if (fdh == NULL)
4628     {
4629       if (!info->relocatable
4630           && (eh->elf.root.type == bfd_link_hash_undefined
4631               || eh->elf.root.type == bfd_link_hash_undefweak)
4632           && eh->elf.ref_regular)
4633         {
4634           /* Make an undefweak function descriptor sym, which is enough to
4635              pull in an --as-needed shared lib, but won't cause link
4636              errors.  Archives are handled elsewhere.  */
4637           fdh = make_fdh (info, eh);
4638           if (fdh == NULL)
4639             return FALSE;
4640           fdh->elf.ref_regular = 1;
4641         }
4642     }
4643   else
4644     {
4645       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4646       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4647       if (entry_vis < descr_vis)
4648         fdh->elf.other += entry_vis - descr_vis;
4649       else if (entry_vis > descr_vis)
4650         eh->elf.other += descr_vis - entry_vis;
4651
4652       if ((fdh->elf.root.type == bfd_link_hash_defined
4653            || fdh->elf.root.type == bfd_link_hash_defweak)
4654           && eh->elf.root.type == bfd_link_hash_undefined)
4655         {
4656           eh->elf.root.type = bfd_link_hash_undefweak;
4657           eh->was_undefined = 1;
4658           htab->twiddled_syms = 1;
4659         }
4660     }
4661
4662   return TRUE;
4663 }
4664
4665 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4666
4667 static bfd_boolean
4668 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4669 {
4670   struct ppc_link_hash_table *htab;
4671   struct ppc_link_hash_entry **p, *eh;
4672
4673   if (!is_ppc64_elf (info->output_bfd))
4674     return TRUE;
4675   htab = ppc_hash_table (info);
4676   if (htab == NULL)
4677     return FALSE;
4678
4679   if (is_ppc64_elf (ibfd))
4680     {
4681       p = &htab->dot_syms;
4682       while ((eh = *p) != NULL)
4683         {
4684           *p = NULL;
4685           if (!add_symbol_adjust (eh, info))
4686             return FALSE;
4687           p = &eh->u.next_dot_sym;
4688         }
4689     }
4690
4691   /* Clear the list for non-ppc64 input files.  */
4692   p = &htab->dot_syms;
4693   while ((eh = *p) != NULL)
4694     {
4695       *p = NULL;
4696       p = &eh->u.next_dot_sym;
4697     }
4698
4699   /* We need to fix the undefs list for any syms we have twiddled to
4700      undef_weak.  */
4701   if (htab->twiddled_syms)
4702     {
4703       bfd_link_repair_undef_list (&htab->elf.root);
4704       htab->twiddled_syms = 0;
4705     }
4706   return TRUE;
4707 }
4708
4709 /* Undo hash table changes when an --as-needed input file is determined
4710    not to be needed.  */
4711
4712 static bfd_boolean
4713 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4714                              struct bfd_link_info *info)
4715 {
4716   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4717
4718   if (htab == NULL)
4719     return FALSE;
4720
4721   htab->dot_syms = NULL;
4722   return TRUE;
4723 }
4724
4725 /* If --just-symbols against a final linked binary, then assume we need
4726    toc adjusting stubs when calling functions defined there.  */
4727
4728 static void
4729 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4730 {
4731   if ((sec->flags & SEC_CODE) != 0
4732       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4733       && is_ppc64_elf (sec->owner))
4734     {
4735       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4736       if (got != NULL
4737           && got->size >= elf_backend_got_header_size
4738           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4739         sec->has_toc_reloc = 1;
4740     }
4741   _bfd_elf_link_just_syms (sec, info);
4742 }
4743
4744 static struct plt_entry **
4745 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4746                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4747 {
4748   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4749   struct plt_entry **local_plt;
4750   unsigned char *local_got_tls_masks;
4751
4752   if (local_got_ents == NULL)
4753     {
4754       bfd_size_type size = symtab_hdr->sh_info;
4755
4756       size *= (sizeof (*local_got_ents)
4757                + sizeof (*local_plt)
4758                + sizeof (*local_got_tls_masks));
4759       local_got_ents = bfd_zalloc (abfd, size);
4760       if (local_got_ents == NULL)
4761         return NULL;
4762       elf_local_got_ents (abfd) = local_got_ents;
4763     }
4764
4765   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4766     {
4767       struct got_entry *ent;
4768
4769       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4770         if (ent->addend == r_addend
4771             && ent->owner == abfd
4772             && ent->tls_type == tls_type)
4773           break;
4774       if (ent == NULL)
4775         {
4776           bfd_size_type amt = sizeof (*ent);
4777           ent = bfd_alloc (abfd, amt);
4778           if (ent == NULL)
4779             return FALSE;
4780           ent->next = local_got_ents[r_symndx];
4781           ent->addend = r_addend;
4782           ent->owner = abfd;
4783           ent->tls_type = tls_type;
4784           ent->is_indirect = FALSE;
4785           ent->got.refcount = 0;
4786           local_got_ents[r_symndx] = ent;
4787         }
4788       ent->got.refcount += 1;
4789     }
4790
4791   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4792   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4793   local_got_tls_masks[r_symndx] |= tls_type;
4794
4795   return local_plt + r_symndx;
4796 }
4797
4798 static bfd_boolean
4799 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4800 {
4801   struct plt_entry *ent;
4802
4803   for (ent = *plist; ent != NULL; ent = ent->next)
4804     if (ent->addend == addend)
4805       break;
4806   if (ent == NULL)
4807     {
4808       bfd_size_type amt = sizeof (*ent);
4809       ent = bfd_alloc (abfd, amt);
4810       if (ent == NULL)
4811         return FALSE;
4812       ent->next = *plist;
4813       ent->addend = addend;
4814       ent->plt.refcount = 0;
4815       *plist = ent;
4816     }
4817   ent->plt.refcount += 1;
4818   return TRUE;
4819 }
4820
4821 static bfd_boolean
4822 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4823 {
4824   return (r_type == R_PPC64_REL24
4825           || r_type == R_PPC64_REL14
4826           || r_type == R_PPC64_REL14_BRTAKEN
4827           || r_type == R_PPC64_REL14_BRNTAKEN
4828           || r_type == R_PPC64_ADDR24
4829           || r_type == R_PPC64_ADDR14
4830           || r_type == R_PPC64_ADDR14_BRTAKEN
4831           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4832 }
4833
4834 /* Look through the relocs for a section during the first phase, and
4835    calculate needed space in the global offset table, procedure
4836    linkage table, and dynamic reloc sections.  */
4837
4838 static bfd_boolean
4839 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4840                         asection *sec, const Elf_Internal_Rela *relocs)
4841 {
4842   struct ppc_link_hash_table *htab;
4843   Elf_Internal_Shdr *symtab_hdr;
4844   struct elf_link_hash_entry **sym_hashes;
4845   const Elf_Internal_Rela *rel;
4846   const Elf_Internal_Rela *rel_end;
4847   asection *sreloc;
4848   asection **opd_sym_map;
4849   struct elf_link_hash_entry *tga, *dottga;
4850
4851   if (info->relocatable)
4852     return TRUE;
4853
4854   /* Don't do anything special with non-loaded, non-alloced sections.
4855      In particular, any relocs in such sections should not affect GOT
4856      and PLT reference counting (ie. we don't allow them to create GOT
4857      or PLT entries), there's no possibility or desire to optimize TLS
4858      relocs, and there's not much point in propagating relocs to shared
4859      libs that the dynamic linker won't relocate.  */
4860   if ((sec->flags & SEC_ALLOC) == 0)
4861     return TRUE;
4862
4863   BFD_ASSERT (is_ppc64_elf (abfd));
4864
4865   htab = ppc_hash_table (info);
4866   if (htab == NULL)
4867     return FALSE;
4868
4869   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4870                               FALSE, FALSE, TRUE);
4871   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4872                                  FALSE, FALSE, TRUE);
4873   symtab_hdr = &elf_symtab_hdr (abfd);
4874   sym_hashes = elf_sym_hashes (abfd);
4875   sreloc = NULL;
4876   opd_sym_map = NULL;
4877   if (strcmp (sec->name, ".opd") == 0)
4878     {
4879       /* Garbage collection needs some extra help with .opd sections.
4880          We don't want to necessarily keep everything referenced by
4881          relocs in .opd, as that would keep all functions.  Instead,
4882          if we reference an .opd symbol (a function descriptor), we
4883          want to keep the function code symbol's section.  This is
4884          easy for global symbols, but for local syms we need to keep
4885          information about the associated function section.  */
4886       bfd_size_type amt;
4887
4888       amt = sec->size * sizeof (*opd_sym_map) / 8;
4889       opd_sym_map = bfd_zalloc (abfd, amt);
4890       if (opd_sym_map == NULL)
4891         return FALSE;
4892       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4893       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4894       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4895     }
4896
4897   if (htab->sfpr == NULL
4898       && !create_linkage_sections (htab->elf.dynobj, info))
4899     return FALSE;
4900
4901   rel_end = relocs + sec->reloc_count;
4902   for (rel = relocs; rel < rel_end; rel++)
4903     {
4904       unsigned long r_symndx;
4905       struct elf_link_hash_entry *h;
4906       enum elf_ppc64_reloc_type r_type;
4907       int tls_type;
4908       struct _ppc64_elf_section_data *ppc64_sec;
4909       struct plt_entry **ifunc;
4910
4911       r_symndx = ELF64_R_SYM (rel->r_info);
4912       if (r_symndx < symtab_hdr->sh_info)
4913         h = NULL;
4914       else
4915         {
4916           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4917           h = elf_follow_link (h);
4918         }
4919
4920       tls_type = 0;
4921       ifunc = NULL;
4922       if (h != NULL)
4923         {
4924           if (h->type == STT_GNU_IFUNC)
4925             {
4926               h->needs_plt = 1;
4927               ifunc = &h->plt.plist;
4928             }
4929         }
4930       else
4931         {
4932           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4933                                                           abfd, r_symndx);
4934           if (isym == NULL)
4935             return FALSE;
4936
4937           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4938             {
4939               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4940                                              rel->r_addend, PLT_IFUNC);
4941               if (ifunc == NULL)
4942                 return FALSE;
4943             }
4944         }
4945       r_type = ELF64_R_TYPE (rel->r_info);
4946       if (is_branch_reloc (r_type))
4947         {
4948           if (h != NULL && (h == tga || h == dottga))
4949             {
4950               if (rel != relocs
4951                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4952                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4953                 /* We have a new-style __tls_get_addr call with a marker
4954                    reloc.  */
4955                 ;
4956               else
4957                 /* Mark this section as having an old-style call.  */
4958                 sec->has_tls_get_addr_call = 1;
4959             }
4960
4961           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4962           if (ifunc != NULL
4963               && !update_plt_info (abfd, ifunc, rel->r_addend))
4964             return FALSE;
4965         }
4966
4967       switch (r_type)
4968         {
4969         case R_PPC64_TLSGD:
4970         case R_PPC64_TLSLD:
4971           /* These special tls relocs tie a call to __tls_get_addr with
4972              its parameter symbol.  */
4973           break;
4974
4975         case R_PPC64_GOT_TLSLD16:
4976         case R_PPC64_GOT_TLSLD16_LO:
4977         case R_PPC64_GOT_TLSLD16_HI:
4978         case R_PPC64_GOT_TLSLD16_HA:
4979           tls_type = TLS_TLS | TLS_LD;
4980           goto dogottls;
4981
4982         case R_PPC64_GOT_TLSGD16:
4983         case R_PPC64_GOT_TLSGD16_LO:
4984         case R_PPC64_GOT_TLSGD16_HI:
4985         case R_PPC64_GOT_TLSGD16_HA:
4986           tls_type = TLS_TLS | TLS_GD;
4987           goto dogottls;
4988
4989         case R_PPC64_GOT_TPREL16_DS:
4990         case R_PPC64_GOT_TPREL16_LO_DS:
4991         case R_PPC64_GOT_TPREL16_HI:
4992         case R_PPC64_GOT_TPREL16_HA:
4993           if (!info->executable)
4994             info->flags |= DF_STATIC_TLS;
4995           tls_type = TLS_TLS | TLS_TPREL;
4996           goto dogottls;
4997
4998         case R_PPC64_GOT_DTPREL16_DS:
4999         case R_PPC64_GOT_DTPREL16_LO_DS:
5000         case R_PPC64_GOT_DTPREL16_HI:
5001         case R_PPC64_GOT_DTPREL16_HA:
5002           tls_type = TLS_TLS | TLS_DTPREL;
5003         dogottls:
5004           sec->has_tls_reloc = 1;
5005           /* Fall thru */
5006
5007         case R_PPC64_GOT16:
5008         case R_PPC64_GOT16_DS:
5009         case R_PPC64_GOT16_HA:
5010         case R_PPC64_GOT16_HI:
5011         case R_PPC64_GOT16_LO:
5012         case R_PPC64_GOT16_LO_DS:
5013           /* This symbol requires a global offset table entry.  */
5014           sec->has_toc_reloc = 1;
5015           if (r_type == R_PPC64_GOT_TLSLD16
5016               || r_type == R_PPC64_GOT_TLSGD16
5017               || r_type == R_PPC64_GOT_TPREL16_DS
5018               || r_type == R_PPC64_GOT_DTPREL16_DS
5019               || r_type == R_PPC64_GOT16
5020               || r_type == R_PPC64_GOT16_DS)
5021             {
5022               htab->do_multi_toc = 1;
5023               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5024             }
5025
5026           if (ppc64_elf_tdata (abfd)->got == NULL
5027               && !create_got_section (abfd, info))
5028             return FALSE;
5029
5030           if (h != NULL)
5031             {
5032               struct ppc_link_hash_entry *eh;
5033               struct got_entry *ent;
5034
5035               eh = (struct ppc_link_hash_entry *) h;
5036               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5037                 if (ent->addend == rel->r_addend
5038                     && ent->owner == abfd
5039                     && ent->tls_type == tls_type)
5040                   break;
5041               if (ent == NULL)
5042                 {
5043                   bfd_size_type amt = sizeof (*ent);
5044                   ent = bfd_alloc (abfd, amt);
5045                   if (ent == NULL)
5046                     return FALSE;
5047                   ent->next = eh->elf.got.glist;
5048                   ent->addend = rel->r_addend;
5049                   ent->owner = abfd;
5050                   ent->tls_type = tls_type;
5051                   ent->is_indirect = FALSE;
5052                   ent->got.refcount = 0;
5053                   eh->elf.got.glist = ent;
5054                 }
5055               ent->got.refcount += 1;
5056               eh->tls_mask |= tls_type;
5057             }
5058           else
5059             /* This is a global offset table entry for a local symbol.  */
5060             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5061                                         rel->r_addend, tls_type))
5062               return FALSE;
5063           break;
5064
5065         case R_PPC64_PLT16_HA:
5066         case R_PPC64_PLT16_HI:
5067         case R_PPC64_PLT16_LO:
5068         case R_PPC64_PLT32:
5069         case R_PPC64_PLT64:
5070           /* This symbol requires a procedure linkage table entry.  We
5071              actually build the entry in adjust_dynamic_symbol,
5072              because this might be a case of linking PIC code without
5073              linking in any dynamic objects, in which case we don't
5074              need to generate a procedure linkage table after all.  */
5075           if (h == NULL)
5076             {
5077               /* It does not make sense to have a procedure linkage
5078                  table entry for a local symbol.  */
5079               bfd_set_error (bfd_error_bad_value);
5080               return FALSE;
5081             }
5082           else
5083             {
5084               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5085                 return FALSE;
5086               h->needs_plt = 1;
5087               if (h->root.root.string[0] == '.'
5088                   && h->root.root.string[1] != '\0')
5089                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5090             }
5091           break;
5092
5093           /* The following relocations don't need to propagate the
5094              relocation if linking a shared object since they are
5095              section relative.  */
5096         case R_PPC64_SECTOFF:
5097         case R_PPC64_SECTOFF_LO:
5098         case R_PPC64_SECTOFF_HI:
5099         case R_PPC64_SECTOFF_HA:
5100         case R_PPC64_SECTOFF_DS:
5101         case R_PPC64_SECTOFF_LO_DS:
5102         case R_PPC64_DTPREL16:
5103         case R_PPC64_DTPREL16_LO:
5104         case R_PPC64_DTPREL16_HI:
5105         case R_PPC64_DTPREL16_HA:
5106         case R_PPC64_DTPREL16_DS:
5107         case R_PPC64_DTPREL16_LO_DS:
5108         case R_PPC64_DTPREL16_HIGHER:
5109         case R_PPC64_DTPREL16_HIGHERA:
5110         case R_PPC64_DTPREL16_HIGHEST:
5111         case R_PPC64_DTPREL16_HIGHESTA:
5112           break;
5113
5114           /* Nor do these.  */
5115         case R_PPC64_REL16:
5116         case R_PPC64_REL16_LO:
5117         case R_PPC64_REL16_HI:
5118         case R_PPC64_REL16_HA:
5119           break;
5120
5121         case R_PPC64_TOC16:
5122         case R_PPC64_TOC16_DS:
5123           htab->do_multi_toc = 1;
5124           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5125         case R_PPC64_TOC16_LO:
5126         case R_PPC64_TOC16_HI:
5127         case R_PPC64_TOC16_HA:
5128         case R_PPC64_TOC16_LO_DS:
5129           sec->has_toc_reloc = 1;
5130           break;
5131
5132           /* This relocation describes the C++ object vtable hierarchy.
5133              Reconstruct it for later use during GC.  */
5134         case R_PPC64_GNU_VTINHERIT:
5135           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5136             return FALSE;
5137           break;
5138
5139           /* This relocation describes which C++ vtable entries are actually
5140              used.  Record for later use during GC.  */
5141         case R_PPC64_GNU_VTENTRY:
5142           BFD_ASSERT (h != NULL);
5143           if (h != NULL
5144               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5145             return FALSE;
5146           break;
5147
5148         case R_PPC64_REL14:
5149         case R_PPC64_REL14_BRTAKEN:
5150         case R_PPC64_REL14_BRNTAKEN:
5151           {
5152             asection *dest = NULL;
5153
5154             /* Heuristic: If jumping outside our section, chances are
5155                we are going to need a stub.  */
5156             if (h != NULL)
5157               {
5158                 /* If the sym is weak it may be overridden later, so
5159                    don't assume we know where a weak sym lives.  */
5160                 if (h->root.type == bfd_link_hash_defined)
5161                   dest = h->root.u.def.section;
5162               }
5163             else
5164               {
5165                 Elf_Internal_Sym *isym;
5166
5167                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5168                                               abfd, r_symndx);
5169                 if (isym == NULL)
5170                   return FALSE;
5171
5172                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5173               }
5174
5175             if (dest != sec)
5176               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5177           }
5178           /* Fall through.  */
5179
5180         case R_PPC64_REL24:
5181           if (h != NULL && ifunc == NULL)
5182             {
5183               /* We may need a .plt entry if the function this reloc
5184                  refers to is in a shared lib.  */
5185               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5186                 return FALSE;
5187               h->needs_plt = 1;
5188               if (h->root.root.string[0] == '.'
5189                   && h->root.root.string[1] != '\0')
5190                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5191               if (h == tga || h == dottga)
5192                 sec->has_tls_reloc = 1;
5193             }
5194           break;
5195
5196         case R_PPC64_TPREL64:
5197           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5198           if (!info->executable)
5199             info->flags |= DF_STATIC_TLS;
5200           goto dotlstoc;
5201
5202         case R_PPC64_DTPMOD64:
5203           if (rel + 1 < rel_end
5204               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5205               && rel[1].r_offset == rel->r_offset + 8)
5206             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5207           else
5208             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5209           goto dotlstoc;
5210
5211         case R_PPC64_DTPREL64:
5212           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5213           if (rel != relocs
5214               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5215               && rel[-1].r_offset == rel->r_offset - 8)
5216             /* This is the second reloc of a dtpmod, dtprel pair.
5217                Don't mark with TLS_DTPREL.  */
5218             goto dodyn;
5219
5220         dotlstoc:
5221           sec->has_tls_reloc = 1;
5222           if (h != NULL)
5223             {
5224               struct ppc_link_hash_entry *eh;
5225               eh = (struct ppc_link_hash_entry *) h;
5226               eh->tls_mask |= tls_type;
5227             }
5228           else
5229             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5230                                         rel->r_addend, tls_type))
5231               return FALSE;
5232
5233           ppc64_sec = ppc64_elf_section_data (sec);
5234           if (ppc64_sec->sec_type != sec_toc)
5235             {
5236               bfd_size_type amt;
5237
5238               /* One extra to simplify get_tls_mask.  */
5239               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5240               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5241               if (ppc64_sec->u.toc.symndx == NULL)
5242                 return FALSE;
5243               amt = sec->size * sizeof (bfd_vma) / 8;
5244               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5245               if (ppc64_sec->u.toc.add == NULL)
5246                 return FALSE;
5247               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5248               ppc64_sec->sec_type = sec_toc;
5249             }
5250           BFD_ASSERT (rel->r_offset % 8 == 0);
5251           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5252           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5253
5254           /* Mark the second slot of a GD or LD entry.
5255              -1 to indicate GD and -2 to indicate LD.  */
5256           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5257             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5258           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5259             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5260           goto dodyn;
5261
5262         case R_PPC64_TPREL16:
5263         case R_PPC64_TPREL16_LO:
5264         case R_PPC64_TPREL16_HI:
5265         case R_PPC64_TPREL16_HA:
5266         case R_PPC64_TPREL16_DS:
5267         case R_PPC64_TPREL16_LO_DS:
5268         case R_PPC64_TPREL16_HIGHER:
5269         case R_PPC64_TPREL16_HIGHERA:
5270         case R_PPC64_TPREL16_HIGHEST:
5271         case R_PPC64_TPREL16_HIGHESTA:
5272           if (info->shared)
5273             {
5274               if (!info->executable)
5275                 info->flags |= DF_STATIC_TLS;
5276               goto dodyn;
5277             }
5278           break;
5279
5280         case R_PPC64_ADDR64:
5281           if (opd_sym_map != NULL
5282               && rel + 1 < rel_end
5283               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5284             {
5285               if (h != NULL)
5286                 {
5287                   if (h->root.root.string[0] == '.'
5288                       && h->root.root.string[1] != 0
5289                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5290                     ;
5291                   else
5292                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5293                 }
5294               else
5295                 {
5296                   asection *s;
5297                   Elf_Internal_Sym *isym;
5298
5299                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5300                                                 abfd, r_symndx);
5301                   if (isym == NULL)
5302                     return FALSE;
5303
5304                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5305                   if (s != NULL && s != sec)
5306                     opd_sym_map[rel->r_offset / 8] = s;
5307                 }
5308             }
5309           /* Fall through.  */
5310
5311         case R_PPC64_REL30:
5312         case R_PPC64_REL32:
5313         case R_PPC64_REL64:
5314         case R_PPC64_ADDR14:
5315         case R_PPC64_ADDR14_BRNTAKEN:
5316         case R_PPC64_ADDR14_BRTAKEN:
5317         case R_PPC64_ADDR16:
5318         case R_PPC64_ADDR16_DS:
5319         case R_PPC64_ADDR16_HA:
5320         case R_PPC64_ADDR16_HI:
5321         case R_PPC64_ADDR16_HIGHER:
5322         case R_PPC64_ADDR16_HIGHERA:
5323         case R_PPC64_ADDR16_HIGHEST:
5324         case R_PPC64_ADDR16_HIGHESTA:
5325         case R_PPC64_ADDR16_LO:
5326         case R_PPC64_ADDR16_LO_DS:
5327         case R_PPC64_ADDR24:
5328         case R_PPC64_ADDR32:
5329         case R_PPC64_UADDR16:
5330         case R_PPC64_UADDR32:
5331         case R_PPC64_UADDR64:
5332         case R_PPC64_TOC:
5333           if (h != NULL && !info->shared)
5334             /* We may need a copy reloc.  */
5335             h->non_got_ref = 1;
5336
5337           /* Don't propagate .opd relocs.  */
5338           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5339             break;
5340
5341           /* If we are creating a shared library, and this is a reloc
5342              against a global symbol, or a non PC relative reloc
5343              against a local symbol, then we need to copy the reloc
5344              into the shared library.  However, if we are linking with
5345              -Bsymbolic, we do not need to copy a reloc against a
5346              global symbol which is defined in an object we are
5347              including in the link (i.e., DEF_REGULAR is set).  At
5348              this point we have not seen all the input files, so it is
5349              possible that DEF_REGULAR is not set now but will be set
5350              later (it is never cleared).  In case of a weak definition,
5351              DEF_REGULAR may be cleared later by a strong definition in
5352              a shared library.  We account for that possibility below by
5353              storing information in the dyn_relocs field of the hash
5354              table entry.  A similar situation occurs when creating
5355              shared libraries and symbol visibility changes render the
5356              symbol local.
5357
5358              If on the other hand, we are creating an executable, we
5359              may need to keep relocations for symbols satisfied by a
5360              dynamic library if we manage to avoid copy relocs for the
5361              symbol.  */
5362         dodyn:
5363           if ((info->shared
5364                && (must_be_dyn_reloc (info, r_type)
5365                    || (h != NULL
5366                        && (! info->symbolic
5367                            || h->root.type == bfd_link_hash_defweak
5368                            || !h->def_regular))))
5369               || (ELIMINATE_COPY_RELOCS
5370                   && !info->shared
5371                   && h != NULL
5372                   && (h->root.type == bfd_link_hash_defweak
5373                       || !h->def_regular))
5374               || (!info->shared
5375                   && ifunc != NULL))
5376             {
5377               struct elf_dyn_relocs *p;
5378               struct elf_dyn_relocs **head;
5379
5380               /* We must copy these reloc types into the output file.
5381                  Create a reloc section in dynobj and make room for
5382                  this reloc.  */
5383               if (sreloc == NULL)
5384                 {
5385                   sreloc = _bfd_elf_make_dynamic_reloc_section
5386                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5387
5388                   if (sreloc == NULL)
5389                     return FALSE;
5390                 }
5391
5392               /* If this is a global symbol, we count the number of
5393                  relocations we need for this symbol.  */
5394               if (h != NULL)
5395                 {
5396                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5397                 }
5398               else
5399                 {
5400                   /* Track dynamic relocs needed for local syms too.
5401                      We really need local syms available to do this
5402                      easily.  Oh well.  */
5403                   asection *s;
5404                   void *vpp;
5405                   Elf_Internal_Sym *isym;
5406
5407                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5408                                                 abfd, r_symndx);
5409                   if (isym == NULL)
5410                     return FALSE;
5411
5412                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5413                   if (s == NULL)
5414                     s = sec;
5415
5416                   vpp = &elf_section_data (s)->local_dynrel;
5417                   head = (struct elf_dyn_relocs **) vpp;
5418                 }
5419
5420               p = *head;
5421               if (p == NULL || p->sec != sec)
5422                 {
5423                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5424                   if (p == NULL)
5425                     return FALSE;
5426                   p->next = *head;
5427                   *head = p;
5428                   p->sec = sec;
5429                   p->count = 0;
5430                   p->pc_count = 0;
5431                 }
5432
5433               p->count += 1;
5434               if (!must_be_dyn_reloc (info, r_type))
5435                 p->pc_count += 1;
5436             }
5437           break;
5438
5439         default:
5440           break;
5441         }
5442     }
5443
5444   return TRUE;
5445 }
5446
5447 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5448    of the code entry point, and its section.  */
5449
5450 static bfd_vma
5451 opd_entry_value (asection *opd_sec,
5452                  bfd_vma offset,
5453                  asection **code_sec,
5454                  bfd_vma *code_off)
5455 {
5456   bfd *opd_bfd = opd_sec->owner;
5457   Elf_Internal_Rela *relocs;
5458   Elf_Internal_Rela *lo, *hi, *look;
5459   bfd_vma val;
5460
5461   /* No relocs implies we are linking a --just-symbols object.  */
5462   if (opd_sec->reloc_count == 0)
5463     {
5464       char buf[8];
5465
5466       if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5467         return (bfd_vma) -1;
5468
5469       val = bfd_get_64 (opd_bfd, buf);
5470       if (code_sec != NULL)
5471         {
5472           asection *sec, *likely = NULL;
5473           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5474             if (sec->vma <= val
5475                 && (sec->flags & SEC_LOAD) != 0
5476                 && (sec->flags & SEC_ALLOC) != 0)
5477               likely = sec;
5478           if (likely != NULL)
5479             {
5480               *code_sec = likely;
5481               if (code_off != NULL)
5482                 *code_off = val - likely->vma;
5483             }
5484         }
5485       return val;
5486     }
5487
5488   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5489
5490   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5491   if (relocs == NULL)
5492     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5493
5494   /* Go find the opd reloc at the sym address.  */
5495   lo = relocs;
5496   BFD_ASSERT (lo != NULL);
5497   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5498   val = (bfd_vma) -1;
5499   while (lo < hi)
5500     {
5501       look = lo + (hi - lo) / 2;
5502       if (look->r_offset < offset)
5503         lo = look + 1;
5504       else if (look->r_offset > offset)
5505         hi = look;
5506       else
5507         {
5508           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5509
5510           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5511               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5512             {
5513               unsigned long symndx = ELF64_R_SYM (look->r_info);
5514               asection *sec;
5515
5516               if (symndx < symtab_hdr->sh_info)
5517                 {
5518                   Elf_Internal_Sym *sym;
5519
5520                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5521                   if (sym == NULL)
5522                     {
5523                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5524                                                   symtab_hdr->sh_info,
5525                                                   0, NULL, NULL, NULL);
5526                       if (sym == NULL)
5527                         break;
5528                       symtab_hdr->contents = (bfd_byte *) sym;
5529                     }
5530
5531                   sym += symndx;
5532                   val = sym->st_value;
5533                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5534                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5535                 }
5536               else
5537                 {
5538                   struct elf_link_hash_entry **sym_hashes;
5539                   struct elf_link_hash_entry *rh;
5540
5541                   sym_hashes = elf_sym_hashes (opd_bfd);
5542                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5543                   rh = elf_follow_link (rh);
5544                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5545                               || rh->root.type == bfd_link_hash_defweak);
5546                   val = rh->root.u.def.value;
5547                   sec = rh->root.u.def.section;
5548                 }
5549               val += look->r_addend;
5550               if (code_off != NULL)
5551                 *code_off = val;
5552               if (code_sec != NULL)
5553                 *code_sec = sec;
5554               if (sec != NULL && sec->output_section != NULL)
5555                 val += sec->output_section->vma + sec->output_offset;
5556             }
5557           break;
5558         }
5559     }
5560
5561   return val;
5562 }
5563
5564 /* Return true if symbol is defined in a regular object file.  */
5565
5566 static bfd_boolean
5567 is_static_defined (struct elf_link_hash_entry *h)
5568 {
5569   return ((h->root.type == bfd_link_hash_defined
5570            || h->root.type == bfd_link_hash_defweak)
5571           && h->root.u.def.section != NULL
5572           && h->root.u.def.section->output_section != NULL);
5573 }
5574
5575 /* If FDH is a function descriptor symbol, return the associated code
5576    entry symbol if it is defined.  Return NULL otherwise.  */
5577
5578 static struct ppc_link_hash_entry *
5579 defined_code_entry (struct ppc_link_hash_entry *fdh)
5580 {
5581   if (fdh->is_func_descriptor)
5582     {
5583       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5584       if (fh->elf.root.type == bfd_link_hash_defined
5585           || fh->elf.root.type == bfd_link_hash_defweak)
5586         return fh;
5587     }
5588   return NULL;
5589 }
5590
5591 /* If FH is a function code entry symbol, return the associated
5592    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5593
5594 static struct ppc_link_hash_entry *
5595 defined_func_desc (struct ppc_link_hash_entry *fh)
5596 {
5597   if (fh->oh != NULL
5598       && fh->oh->is_func_descriptor)
5599     {
5600       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5601       if (fdh->elf.root.type == bfd_link_hash_defined
5602           || fdh->elf.root.type == bfd_link_hash_defweak)
5603         return fdh;
5604     }
5605   return NULL;
5606 }
5607
5608 /* Mark all our entry sym sections, both opd and code section.  */
5609
5610 static void
5611 ppc64_elf_gc_keep (struct bfd_link_info *info)
5612 {
5613   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5614   struct bfd_sym_chain *sym;
5615
5616   if (htab == NULL)
5617     return;
5618
5619   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5620     {
5621       struct ppc_link_hash_entry *eh, *fh;
5622       asection *sec;
5623
5624       eh = (struct ppc_link_hash_entry *)
5625         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5626       if (eh == NULL)
5627         continue;
5628       if (eh->elf.root.type != bfd_link_hash_defined
5629           && eh->elf.root.type != bfd_link_hash_defweak)
5630         continue;
5631
5632       fh = defined_code_entry (eh);
5633       if (fh != NULL)
5634         {
5635           sec = fh->elf.root.u.def.section;
5636           sec->flags |= SEC_KEEP;
5637         }
5638       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5639                && opd_entry_value (eh->elf.root.u.def.section,
5640                                    eh->elf.root.u.def.value,
5641                                    &sec, NULL) != (bfd_vma) -1)
5642         sec->flags |= SEC_KEEP;
5643
5644       sec = eh->elf.root.u.def.section;
5645       sec->flags |= SEC_KEEP;
5646     }
5647 }
5648
5649 /* Mark sections containing dynamically referenced symbols.  When
5650    building shared libraries, we must assume that any visible symbol is
5651    referenced.  */
5652
5653 static bfd_boolean
5654 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5655 {
5656   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5657   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5658   struct ppc_link_hash_entry *fdh;
5659
5660   /* Dynamic linking info is on the func descriptor sym.  */
5661   fdh = defined_func_desc (eh);
5662   if (fdh != NULL)
5663     eh = fdh;
5664
5665   if ((eh->elf.root.type == bfd_link_hash_defined
5666        || eh->elf.root.type == bfd_link_hash_defweak)
5667       && (eh->elf.ref_dynamic
5668           || (!info->executable
5669               && eh->elf.def_regular
5670               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5671               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5672     {
5673       asection *code_sec;
5674       struct ppc_link_hash_entry *fh;
5675
5676       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5677
5678       /* Function descriptor syms cause the associated
5679          function code sym section to be marked.  */
5680       fh = defined_code_entry (eh);
5681       if (fh != NULL)
5682         {
5683           code_sec = fh->elf.root.u.def.section;
5684           code_sec->flags |= SEC_KEEP;
5685         }
5686       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5687                && opd_entry_value (eh->elf.root.u.def.section,
5688                                    eh->elf.root.u.def.value,
5689                                    &code_sec, NULL) != (bfd_vma) -1)
5690         code_sec->flags |= SEC_KEEP;
5691     }
5692
5693   return TRUE;
5694 }
5695
5696 /* Return the section that should be marked against GC for a given
5697    relocation.  */
5698
5699 static asection *
5700 ppc64_elf_gc_mark_hook (asection *sec,
5701                         struct bfd_link_info *info,
5702                         Elf_Internal_Rela *rel,
5703                         struct elf_link_hash_entry *h,
5704                         Elf_Internal_Sym *sym)
5705 {
5706   asection *rsec;
5707
5708   /* Syms return NULL if we're marking .opd, so we avoid marking all
5709      function sections, as all functions are referenced in .opd.  */
5710   rsec = NULL;
5711   if (get_opd_info (sec) != NULL)
5712     return rsec;
5713
5714   if (h != NULL)
5715     {
5716       enum elf_ppc64_reloc_type r_type;
5717       struct ppc_link_hash_entry *eh, *fh, *fdh;
5718
5719       r_type = ELF64_R_TYPE (rel->r_info);
5720       switch (r_type)
5721         {
5722         case R_PPC64_GNU_VTINHERIT:
5723         case R_PPC64_GNU_VTENTRY:
5724           break;
5725
5726         default:
5727           switch (h->root.type)
5728             {
5729             case bfd_link_hash_defined:
5730             case bfd_link_hash_defweak:
5731               eh = (struct ppc_link_hash_entry *) h;
5732               fdh = defined_func_desc (eh);
5733               if (fdh != NULL)
5734                 eh = fdh;
5735
5736               /* Function descriptor syms cause the associated
5737                  function code sym section to be marked.  */
5738               fh = defined_code_entry (eh);
5739               if (fh != NULL)
5740                 {
5741                   /* They also mark their opd section.  */
5742                   eh->elf.root.u.def.section->gc_mark = 1;
5743
5744                   rsec = fh->elf.root.u.def.section;
5745                 }
5746               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5747                        && opd_entry_value (eh->elf.root.u.def.section,
5748                                            eh->elf.root.u.def.value,
5749                                            &rsec, NULL) != (bfd_vma) -1)
5750                 eh->elf.root.u.def.section->gc_mark = 1;
5751               else
5752                 rsec = h->root.u.def.section;
5753               break;
5754
5755             case bfd_link_hash_common:
5756               rsec = h->root.u.c.p->section;
5757               break;
5758
5759             default:
5760               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5761             }
5762         }
5763     }
5764   else
5765     {
5766       struct _opd_sec_data *opd;
5767
5768       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5769       opd = get_opd_info (rsec);
5770       if (opd != NULL && opd->func_sec != NULL)
5771         {
5772           rsec->gc_mark = 1;
5773
5774           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5775         }
5776     }
5777
5778   return rsec;
5779 }
5780
5781 /* Update the .got, .plt. and dynamic reloc reference counts for the
5782    section being removed.  */
5783
5784 static bfd_boolean
5785 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5786                          asection *sec, const Elf_Internal_Rela *relocs)
5787 {
5788   struct ppc_link_hash_table *htab;
5789   Elf_Internal_Shdr *symtab_hdr;
5790   struct elf_link_hash_entry **sym_hashes;
5791   struct got_entry **local_got_ents;
5792   const Elf_Internal_Rela *rel, *relend;
5793
5794   if (info->relocatable)
5795     return TRUE;
5796
5797   if ((sec->flags & SEC_ALLOC) == 0)
5798     return TRUE;
5799
5800   elf_section_data (sec)->local_dynrel = NULL;
5801
5802   htab = ppc_hash_table (info);
5803   if (htab == NULL)
5804     return FALSE;
5805
5806   symtab_hdr = &elf_symtab_hdr (abfd);
5807   sym_hashes = elf_sym_hashes (abfd);
5808   local_got_ents = elf_local_got_ents (abfd);
5809
5810   relend = relocs + sec->reloc_count;
5811   for (rel = relocs; rel < relend; rel++)
5812     {
5813       unsigned long r_symndx;
5814       enum elf_ppc64_reloc_type r_type;
5815       struct elf_link_hash_entry *h = NULL;
5816       unsigned char tls_type = 0;
5817
5818       r_symndx = ELF64_R_SYM (rel->r_info);
5819       r_type = ELF64_R_TYPE (rel->r_info);
5820       if (r_symndx >= symtab_hdr->sh_info)
5821         {
5822           struct ppc_link_hash_entry *eh;
5823           struct elf_dyn_relocs **pp;
5824           struct elf_dyn_relocs *p;
5825
5826           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5827           h = elf_follow_link (h);
5828           eh = (struct ppc_link_hash_entry *) h;
5829
5830           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5831             if (p->sec == sec)
5832               {
5833                 /* Everything must go for SEC.  */
5834                 *pp = p->next;
5835                 break;
5836               }
5837         }
5838
5839       if (is_branch_reloc (r_type))
5840         {
5841           struct plt_entry **ifunc = NULL;
5842           if (h != NULL)
5843             {
5844               if (h->type == STT_GNU_IFUNC)
5845                 ifunc = &h->plt.plist;
5846             }
5847           else if (local_got_ents != NULL)
5848             {
5849               struct plt_entry **local_plt = (struct plt_entry **)
5850                 (local_got_ents + symtab_hdr->sh_info);
5851               unsigned char *local_got_tls_masks = (unsigned char *)
5852                 (local_plt + symtab_hdr->sh_info);
5853               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5854                 ifunc = local_plt + r_symndx;
5855             }
5856           if (ifunc != NULL)
5857             {
5858               struct plt_entry *ent;
5859
5860               for (ent = *ifunc; ent != NULL; ent = ent->next)
5861                 if (ent->addend == rel->r_addend)
5862                   break;
5863               if (ent == NULL)
5864                 abort ();
5865               if (ent->plt.refcount > 0)
5866                 ent->plt.refcount -= 1;
5867               continue;
5868             }
5869         }
5870
5871       switch (r_type)
5872         {
5873         case R_PPC64_GOT_TLSLD16:
5874         case R_PPC64_GOT_TLSLD16_LO:
5875         case R_PPC64_GOT_TLSLD16_HI:
5876         case R_PPC64_GOT_TLSLD16_HA:
5877           tls_type = TLS_TLS | TLS_LD;
5878           goto dogot;
5879
5880         case R_PPC64_GOT_TLSGD16:
5881         case R_PPC64_GOT_TLSGD16_LO:
5882         case R_PPC64_GOT_TLSGD16_HI:
5883         case R_PPC64_GOT_TLSGD16_HA:
5884           tls_type = TLS_TLS | TLS_GD;
5885           goto dogot;
5886
5887         case R_PPC64_GOT_TPREL16_DS:
5888         case R_PPC64_GOT_TPREL16_LO_DS:
5889         case R_PPC64_GOT_TPREL16_HI:
5890         case R_PPC64_GOT_TPREL16_HA:
5891           tls_type = TLS_TLS | TLS_TPREL;
5892           goto dogot;
5893
5894         case R_PPC64_GOT_DTPREL16_DS:
5895         case R_PPC64_GOT_DTPREL16_LO_DS:
5896         case R_PPC64_GOT_DTPREL16_HI:
5897         case R_PPC64_GOT_DTPREL16_HA:
5898           tls_type = TLS_TLS | TLS_DTPREL;
5899           goto dogot;
5900
5901         case R_PPC64_GOT16:
5902         case R_PPC64_GOT16_DS:
5903         case R_PPC64_GOT16_HA:
5904         case R_PPC64_GOT16_HI:
5905         case R_PPC64_GOT16_LO:
5906         case R_PPC64_GOT16_LO_DS:
5907         dogot:
5908           {
5909             struct got_entry *ent;
5910
5911             if (h != NULL)
5912               ent = h->got.glist;
5913             else
5914               ent = local_got_ents[r_symndx];
5915
5916             for (; ent != NULL; ent = ent->next)
5917               if (ent->addend == rel->r_addend
5918                   && ent->owner == abfd
5919                   && ent->tls_type == tls_type)
5920                 break;
5921             if (ent == NULL)
5922               abort ();
5923             if (ent->got.refcount > 0)
5924               ent->got.refcount -= 1;
5925           }
5926           break;
5927
5928         case R_PPC64_PLT16_HA:
5929         case R_PPC64_PLT16_HI:
5930         case R_PPC64_PLT16_LO:
5931         case R_PPC64_PLT32:
5932         case R_PPC64_PLT64:
5933         case R_PPC64_REL14:
5934         case R_PPC64_REL14_BRNTAKEN:
5935         case R_PPC64_REL14_BRTAKEN:
5936         case R_PPC64_REL24:
5937           if (h != NULL)
5938             {
5939               struct plt_entry *ent;
5940
5941               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5942                 if (ent->addend == rel->r_addend)
5943                   break;
5944               if (ent != NULL && ent->plt.refcount > 0)
5945                 ent->plt.refcount -= 1;
5946             }
5947           break;
5948
5949         default:
5950           break;
5951         }
5952     }
5953   return TRUE;
5954 }
5955
5956 /* The maximum size of .sfpr.  */
5957 #define SFPR_MAX (218*4)
5958
5959 struct sfpr_def_parms
5960 {
5961   const char name[12];
5962   unsigned char lo, hi;
5963   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5964   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5965 };
5966
5967 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5968
5969 static bfd_boolean
5970 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5971 {
5972   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5973   unsigned int i;
5974   size_t len = strlen (parm->name);
5975   bfd_boolean writing = FALSE;
5976   char sym[16];
5977
5978   if (htab == NULL)
5979     return FALSE;
5980
5981   memcpy (sym, parm->name, len);
5982   sym[len + 2] = 0;
5983
5984   for (i = parm->lo; i <= parm->hi; i++)
5985     {
5986       struct elf_link_hash_entry *h;
5987
5988       sym[len + 0] = i / 10 + '0';
5989       sym[len + 1] = i % 10 + '0';
5990       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5991       if (h != NULL
5992           && !h->def_regular)
5993         {
5994           h->root.type = bfd_link_hash_defined;
5995           h->root.u.def.section = htab->sfpr;
5996           h->root.u.def.value = htab->sfpr->size;
5997           h->type = STT_FUNC;
5998           h->def_regular = 1;
5999           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6000           writing = TRUE;
6001           if (htab->sfpr->contents == NULL)
6002             {
6003               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6004               if (htab->sfpr->contents == NULL)
6005                 return FALSE;
6006             }
6007         }
6008       if (writing)
6009         {
6010           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6011           if (i != parm->hi)
6012             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6013           else
6014             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6015           htab->sfpr->size = p - htab->sfpr->contents;
6016         }
6017     }
6018
6019   return TRUE;
6020 }
6021
6022 static bfd_byte *
6023 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6024 {
6025   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6026   return p + 4;
6027 }
6028
6029 static bfd_byte *
6030 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6031 {
6032   p = savegpr0 (abfd, p, r);
6033   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6034   p = p + 4;
6035   bfd_put_32 (abfd, BLR, p);
6036   return p + 4;
6037 }
6038
6039 static bfd_byte *
6040 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6041 {
6042   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6043   return p + 4;
6044 }
6045
6046 static bfd_byte *
6047 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6048 {
6049   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6050   p = p + 4;
6051   p = restgpr0 (abfd, p, r);
6052   bfd_put_32 (abfd, MTLR_R0, p);
6053   p = p + 4;
6054   if (r == 29)
6055     {
6056       p = restgpr0 (abfd, p, 30);
6057       p = restgpr0 (abfd, p, 31);
6058     }
6059   bfd_put_32 (abfd, BLR, p);
6060   return p + 4;
6061 }
6062
6063 static bfd_byte *
6064 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6065 {
6066   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6067   return p + 4;
6068 }
6069
6070 static bfd_byte *
6071 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6072 {
6073   p = savegpr1 (abfd, p, r);
6074   bfd_put_32 (abfd, BLR, p);
6075   return p + 4;
6076 }
6077
6078 static bfd_byte *
6079 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6080 {
6081   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6082   return p + 4;
6083 }
6084
6085 static bfd_byte *
6086 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6087 {
6088   p = restgpr1 (abfd, p, r);
6089   bfd_put_32 (abfd, BLR, p);
6090   return p + 4;
6091 }
6092
6093 static bfd_byte *
6094 savefpr (bfd *abfd, bfd_byte *p, int r)
6095 {
6096   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6097   return p + 4;
6098 }
6099
6100 static bfd_byte *
6101 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6102 {
6103   p = savefpr (abfd, p, r);
6104   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6105   p = p + 4;
6106   bfd_put_32 (abfd, BLR, p);
6107   return p + 4;
6108 }
6109
6110 static bfd_byte *
6111 restfpr (bfd *abfd, bfd_byte *p, int r)
6112 {
6113   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6114   return p + 4;
6115 }
6116
6117 static bfd_byte *
6118 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6119 {
6120   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6121   p = p + 4;
6122   p = restfpr (abfd, p, r);
6123   bfd_put_32 (abfd, MTLR_R0, p);
6124   p = p + 4;
6125   if (r == 29)
6126     {
6127       p = restfpr (abfd, p, 30);
6128       p = restfpr (abfd, p, 31);
6129     }
6130   bfd_put_32 (abfd, BLR, p);
6131   return p + 4;
6132 }
6133
6134 static bfd_byte *
6135 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6136 {
6137   p = savefpr (abfd, p, r);
6138   bfd_put_32 (abfd, BLR, p);
6139   return p + 4;
6140 }
6141
6142 static bfd_byte *
6143 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6144 {
6145   p = restfpr (abfd, p, r);
6146   bfd_put_32 (abfd, BLR, p);
6147   return p + 4;
6148 }
6149
6150 static bfd_byte *
6151 savevr (bfd *abfd, bfd_byte *p, int r)
6152 {
6153   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6154   p = p + 4;
6155   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6156   return p + 4;
6157 }
6158
6159 static bfd_byte *
6160 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6161 {
6162   p = savevr (abfd, p, r);
6163   bfd_put_32 (abfd, BLR, p);
6164   return p + 4;
6165 }
6166
6167 static bfd_byte *
6168 restvr (bfd *abfd, bfd_byte *p, int r)
6169 {
6170   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6171   p = p + 4;
6172   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6173   return p + 4;
6174 }
6175
6176 static bfd_byte *
6177 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6178 {
6179   p = restvr (abfd, p, r);
6180   bfd_put_32 (abfd, BLR, p);
6181   return p + 4;
6182 }
6183
6184 /* Called via elf_link_hash_traverse to transfer dynamic linking
6185    information on function code symbol entries to their corresponding
6186    function descriptor symbol entries.  */
6187
6188 static bfd_boolean
6189 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6190 {
6191   struct bfd_link_info *info;
6192   struct ppc_link_hash_table *htab;
6193   struct plt_entry *ent;
6194   struct ppc_link_hash_entry *fh;
6195   struct ppc_link_hash_entry *fdh;
6196   bfd_boolean force_local;
6197
6198   fh = (struct ppc_link_hash_entry *) h;
6199   if (fh->elf.root.type == bfd_link_hash_indirect)
6200     return TRUE;
6201
6202   info = inf;
6203   htab = ppc_hash_table (info);
6204   if (htab == NULL)
6205     return FALSE;
6206
6207   /* Resolve undefined references to dot-symbols as the value
6208      in the function descriptor, if we have one in a regular object.
6209      This is to satisfy cases like ".quad .foo".  Calls to functions
6210      in dynamic objects are handled elsewhere.  */
6211   if (fh->elf.root.type == bfd_link_hash_undefweak
6212       && fh->was_undefined
6213       && (fdh = defined_func_desc (fh)) != NULL
6214       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6215       && opd_entry_value (fdh->elf.root.u.def.section,
6216                           fdh->elf.root.u.def.value,
6217                           &fh->elf.root.u.def.section,
6218                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6219     {
6220       fh->elf.root.type = fdh->elf.root.type;
6221       fh->elf.forced_local = 1;
6222       fh->elf.def_regular = fdh->elf.def_regular;
6223       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6224     }
6225
6226   /* If this is a function code symbol, transfer dynamic linking
6227      information to the function descriptor symbol.  */
6228   if (!fh->is_func)
6229     return TRUE;
6230
6231   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6232     if (ent->plt.refcount > 0)
6233       break;
6234   if (ent == NULL
6235       || fh->elf.root.root.string[0] != '.'
6236       || fh->elf.root.root.string[1] == '\0')
6237     return TRUE;
6238
6239   /* Find the corresponding function descriptor symbol.  Create it
6240      as undefined if necessary.  */
6241
6242   fdh = lookup_fdh (fh, htab);
6243   if (fdh == NULL
6244       && !info->executable
6245       && (fh->elf.root.type == bfd_link_hash_undefined
6246           || fh->elf.root.type == bfd_link_hash_undefweak))
6247     {
6248       fdh = make_fdh (info, fh);
6249       if (fdh == NULL)
6250         return FALSE;
6251     }
6252
6253   /* Fake function descriptors are made undefweak.  If the function
6254      code symbol is strong undefined, make the fake sym the same.
6255      If the function code symbol is defined, then force the fake
6256      descriptor local;  We can't support overriding of symbols in a
6257      shared library on a fake descriptor.  */
6258
6259   if (fdh != NULL
6260       && fdh->fake
6261       && fdh->elf.root.type == bfd_link_hash_undefweak)
6262     {
6263       if (fh->elf.root.type == bfd_link_hash_undefined)
6264         {
6265           fdh->elf.root.type = bfd_link_hash_undefined;
6266           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6267         }
6268       else if (fh->elf.root.type == bfd_link_hash_defined
6269                || fh->elf.root.type == bfd_link_hash_defweak)
6270         {
6271           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6272         }
6273     }
6274
6275   if (fdh != NULL
6276       && !fdh->elf.forced_local
6277       && (!info->executable
6278           || fdh->elf.def_dynamic
6279           || fdh->elf.ref_dynamic
6280           || (fdh->elf.root.type == bfd_link_hash_undefweak
6281               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6282     {
6283       if (fdh->elf.dynindx == -1)
6284         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6285           return FALSE;
6286       fdh->elf.ref_regular |= fh->elf.ref_regular;
6287       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6288       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6289       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6290       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6291         {
6292           move_plt_plist (fh, fdh);
6293           fdh->elf.needs_plt = 1;
6294         }
6295       fdh->is_func_descriptor = 1;
6296       fdh->oh = fh;
6297       fh->oh = fdh;
6298     }
6299
6300   /* Now that the info is on the function descriptor, clear the
6301      function code sym info.  Any function code syms for which we
6302      don't have a definition in a regular file, we force local.
6303      This prevents a shared library from exporting syms that have
6304      been imported from another library.  Function code syms that
6305      are really in the library we must leave global to prevent the
6306      linker dragging in a definition from a static library.  */
6307   force_local = (!fh->elf.def_regular
6308                  || fdh == NULL
6309                  || !fdh->elf.def_regular
6310                  || fdh->elf.forced_local);
6311   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6312
6313   return TRUE;
6314 }
6315
6316 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6317    this hook to a) provide some gcc support functions, and b) transfer
6318    dynamic linking information gathered so far on function code symbol
6319    entries, to their corresponding function descriptor symbol entries.  */
6320
6321 static bfd_boolean
6322 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6323                             struct bfd_link_info *info)
6324 {
6325   struct ppc_link_hash_table *htab;
6326   unsigned int i;
6327   const struct sfpr_def_parms funcs[] =
6328     {
6329       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6330       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6331       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6332       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6333       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6334       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6335       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6336       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6337       { "._savef", 14, 31, savefpr, savefpr1_tail },
6338       { "._restf", 14, 31, restfpr, restfpr1_tail },
6339       { "_savevr_", 20, 31, savevr, savevr_tail },
6340       { "_restvr_", 20, 31, restvr, restvr_tail }
6341     };
6342
6343   htab = ppc_hash_table (info);
6344   if (htab == NULL)
6345     return FALSE;
6346
6347   if (htab->sfpr == NULL)
6348     /* We don't have any relocs.  */
6349     return TRUE;
6350
6351   /* Provide any missing _save* and _rest* functions.  */
6352   htab->sfpr->size = 0;
6353   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6354     if (!sfpr_define (info, &funcs[i]))
6355       return FALSE;
6356
6357   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6358
6359   if (htab->sfpr->size == 0)
6360     htab->sfpr->flags |= SEC_EXCLUDE;
6361
6362   return TRUE;
6363 }
6364
6365 /* Adjust a symbol defined by a dynamic object and referenced by a
6366    regular object.  The current definition is in some section of the
6367    dynamic object, but we're not including those sections.  We have to
6368    change the definition to something the rest of the link can
6369    understand.  */
6370
6371 static bfd_boolean
6372 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6373                                  struct elf_link_hash_entry *h)
6374 {
6375   struct ppc_link_hash_table *htab;
6376   asection *s;
6377
6378   htab = ppc_hash_table (info);
6379   if (htab == NULL)
6380     return FALSE;
6381
6382   /* Deal with function syms.  */
6383   if (h->type == STT_FUNC
6384       || h->type == STT_GNU_IFUNC
6385       || h->needs_plt)
6386     {
6387       /* Clear procedure linkage table information for any symbol that
6388          won't need a .plt entry.  */
6389       struct plt_entry *ent;
6390       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6391         if (ent->plt.refcount > 0)
6392           break;
6393       if (ent == NULL
6394           || (h->type != STT_GNU_IFUNC
6395               && (SYMBOL_CALLS_LOCAL (info, h)
6396                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6397                       && h->root.type == bfd_link_hash_undefweak))))
6398         {
6399           h->plt.plist = NULL;
6400           h->needs_plt = 0;
6401         }
6402     }
6403   else
6404     h->plt.plist = NULL;
6405
6406   /* If this is a weak symbol, and there is a real definition, the
6407      processor independent code will have arranged for us to see the
6408      real definition first, and we can just use the same value.  */
6409   if (h->u.weakdef != NULL)
6410     {
6411       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6412                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6413       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6414       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6415       if (ELIMINATE_COPY_RELOCS)
6416         h->non_got_ref = h->u.weakdef->non_got_ref;
6417       return TRUE;
6418     }
6419
6420   /* If we are creating a shared library, we must presume that the
6421      only references to the symbol are via the global offset table.
6422      For such cases we need not do anything here; the relocations will
6423      be handled correctly by relocate_section.  */
6424   if (info->shared)
6425     return TRUE;
6426
6427   /* If there are no references to this symbol that do not use the
6428      GOT, we don't need to generate a copy reloc.  */
6429   if (!h->non_got_ref)
6430     return TRUE;
6431
6432   /* Don't generate a copy reloc for symbols defined in the executable.  */
6433   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6434     return TRUE;
6435
6436   if (ELIMINATE_COPY_RELOCS)
6437     {
6438       struct ppc_link_hash_entry * eh;
6439       struct elf_dyn_relocs *p;
6440
6441       eh = (struct ppc_link_hash_entry *) h;
6442       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6443         {
6444           s = p->sec->output_section;
6445           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6446             break;
6447         }
6448
6449       /* If we didn't find any dynamic relocs in read-only sections, then
6450          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6451       if (p == NULL)
6452         {
6453           h->non_got_ref = 0;
6454           return TRUE;
6455         }
6456     }
6457
6458   if (h->plt.plist != NULL)
6459     {
6460       /* We should never get here, but unfortunately there are versions
6461          of gcc out there that improperly (for this ABI) put initialized
6462          function pointers, vtable refs and suchlike in read-only
6463          sections.  Allow them to proceed, but warn that this might
6464          break at runtime.  */
6465       info->callbacks->einfo
6466         (_("%P: copy reloc against `%s' requires lazy plt linking; "
6467            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6468          h->root.root.string);
6469     }
6470
6471   /* This is a reference to a symbol defined by a dynamic object which
6472      is not a function.  */
6473
6474   if (h->size == 0)
6475     {
6476       info->callbacks->einfo (_("%P: dynamic variable `%s' is zero size\n"),
6477                               h->root.root.string);
6478       return TRUE;
6479     }
6480
6481   /* We must allocate the symbol in our .dynbss section, which will
6482      become part of the .bss section of the executable.  There will be
6483      an entry for this symbol in the .dynsym section.  The dynamic
6484      object will contain position independent code, so all references
6485      from the dynamic object to this symbol will go through the global
6486      offset table.  The dynamic linker will use the .dynsym entry to
6487      determine the address it must put in the global offset table, so
6488      both the dynamic object and the regular object will refer to the
6489      same memory location for the variable.  */
6490
6491   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6492      to copy the initial value out of the dynamic object and into the
6493      runtime process image.  We need to remember the offset into the
6494      .rela.bss section we are going to use.  */
6495   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6496     {
6497       htab->relbss->size += sizeof (Elf64_External_Rela);
6498       h->needs_copy = 1;
6499     }
6500
6501   s = htab->dynbss;
6502
6503   return _bfd_elf_adjust_dynamic_copy (h, s);
6504 }
6505
6506 /* If given a function descriptor symbol, hide both the function code
6507    sym and the descriptor.  */
6508 static void
6509 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6510                        struct elf_link_hash_entry *h,
6511                        bfd_boolean force_local)
6512 {
6513   struct ppc_link_hash_entry *eh;
6514   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6515
6516   eh = (struct ppc_link_hash_entry *) h;
6517   if (eh->is_func_descriptor)
6518     {
6519       struct ppc_link_hash_entry *fh = eh->oh;
6520
6521       if (fh == NULL)
6522         {
6523           const char *p, *q;
6524           struct ppc_link_hash_table *htab;
6525           char save;
6526
6527           /* We aren't supposed to use alloca in BFD because on
6528              systems which do not have alloca the version in libiberty
6529              calls xmalloc, which might cause the program to crash
6530              when it runs out of memory.  This function doesn't have a
6531              return status, so there's no way to gracefully return an
6532              error.  So cheat.  We know that string[-1] can be safely
6533              accessed;  It's either a string in an ELF string table,
6534              or allocated in an objalloc structure.  */
6535
6536           p = eh->elf.root.root.string - 1;
6537           save = *p;
6538           *(char *) p = '.';
6539           htab = ppc_hash_table (info);
6540           if (htab == NULL)
6541             return;
6542
6543           fh = (struct ppc_link_hash_entry *)
6544             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6545           *(char *) p = save;
6546
6547           /* Unfortunately, if it so happens that the string we were
6548              looking for was allocated immediately before this string,
6549              then we overwrote the string terminator.  That's the only
6550              reason the lookup should fail.  */
6551           if (fh == NULL)
6552             {
6553               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6554               while (q >= eh->elf.root.root.string && *q == *p)
6555                 --q, --p;
6556               if (q < eh->elf.root.root.string && *p == '.')
6557                 fh = (struct ppc_link_hash_entry *)
6558                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6559             }
6560           if (fh != NULL)
6561             {
6562               eh->oh = fh;
6563               fh->oh = eh;
6564             }
6565         }
6566       if (fh != NULL)
6567         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6568     }
6569 }
6570
6571 static bfd_boolean
6572 get_sym_h (struct elf_link_hash_entry **hp,
6573            Elf_Internal_Sym **symp,
6574            asection **symsecp,
6575            unsigned char **tls_maskp,
6576            Elf_Internal_Sym **locsymsp,
6577            unsigned long r_symndx,
6578            bfd *ibfd)
6579 {
6580   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6581
6582   if (r_symndx >= symtab_hdr->sh_info)
6583     {
6584       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6585       struct elf_link_hash_entry *h;
6586
6587       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6588       h = elf_follow_link (h);
6589
6590       if (hp != NULL)
6591         *hp = h;
6592
6593       if (symp != NULL)
6594         *symp = NULL;
6595
6596       if (symsecp != NULL)
6597         {
6598           asection *symsec = NULL;
6599           if (h->root.type == bfd_link_hash_defined
6600               || h->root.type == bfd_link_hash_defweak)
6601             symsec = h->root.u.def.section;
6602           *symsecp = symsec;
6603         }
6604
6605       if (tls_maskp != NULL)
6606         {
6607           struct ppc_link_hash_entry *eh;
6608
6609           eh = (struct ppc_link_hash_entry *) h;
6610           *tls_maskp = &eh->tls_mask;
6611         }
6612     }
6613   else
6614     {
6615       Elf_Internal_Sym *sym;
6616       Elf_Internal_Sym *locsyms = *locsymsp;
6617
6618       if (locsyms == NULL)
6619         {
6620           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6621           if (locsyms == NULL)
6622             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6623                                             symtab_hdr->sh_info,
6624                                             0, NULL, NULL, NULL);
6625           if (locsyms == NULL)
6626             return FALSE;
6627           *locsymsp = locsyms;
6628         }
6629       sym = locsyms + r_symndx;
6630
6631       if (hp != NULL)
6632         *hp = NULL;
6633
6634       if (symp != NULL)
6635         *symp = sym;
6636
6637       if (symsecp != NULL)
6638         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6639
6640       if (tls_maskp != NULL)
6641         {
6642           struct got_entry **lgot_ents;
6643           unsigned char *tls_mask;
6644
6645           tls_mask = NULL;
6646           lgot_ents = elf_local_got_ents (ibfd);
6647           if (lgot_ents != NULL)
6648             {
6649               struct plt_entry **local_plt = (struct plt_entry **)
6650                 (lgot_ents + symtab_hdr->sh_info);
6651               unsigned char *lgot_masks = (unsigned char *)
6652                 (local_plt + symtab_hdr->sh_info);
6653               tls_mask = &lgot_masks[r_symndx];
6654             }
6655           *tls_maskp = tls_mask;
6656         }
6657     }
6658   return TRUE;
6659 }
6660
6661 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6662    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6663    type suitable for optimization, and 1 otherwise.  */
6664
6665 static int
6666 get_tls_mask (unsigned char **tls_maskp,
6667               unsigned long *toc_symndx,
6668               bfd_vma *toc_addend,
6669               Elf_Internal_Sym **locsymsp,
6670               const Elf_Internal_Rela *rel,
6671               bfd *ibfd)
6672 {
6673   unsigned long r_symndx;
6674   int next_r;
6675   struct elf_link_hash_entry *h;
6676   Elf_Internal_Sym *sym;
6677   asection *sec;
6678   bfd_vma off;
6679
6680   r_symndx = ELF64_R_SYM (rel->r_info);
6681   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6682     return 0;
6683
6684   if ((*tls_maskp != NULL && **tls_maskp != 0)
6685       || sec == NULL
6686       || ppc64_elf_section_data (sec) == NULL
6687       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6688     return 1;
6689
6690   /* Look inside a TOC section too.  */
6691   if (h != NULL)
6692     {
6693       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6694       off = h->root.u.def.value;
6695     }
6696   else
6697     off = sym->st_value;
6698   off += rel->r_addend;
6699   BFD_ASSERT (off % 8 == 0);
6700   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6701   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6702   if (toc_symndx != NULL)
6703     *toc_symndx = r_symndx;
6704   if (toc_addend != NULL)
6705     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6706   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6707     return 0;
6708   if ((h == NULL || is_static_defined (h))
6709       && (next_r == -1 || next_r == -2))
6710     return 1 - next_r;
6711   return 1;
6712 }
6713
6714 /* Adjust all global syms defined in opd sections.  In gcc generated
6715    code for the old ABI, these will already have been done.  */
6716
6717 static bfd_boolean
6718 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6719 {
6720   struct ppc_link_hash_entry *eh;
6721   asection *sym_sec;
6722   struct _opd_sec_data *opd;
6723
6724   if (h->root.type == bfd_link_hash_indirect)
6725     return TRUE;
6726
6727   if (h->root.type != bfd_link_hash_defined
6728       && h->root.type != bfd_link_hash_defweak)
6729     return TRUE;
6730
6731   eh = (struct ppc_link_hash_entry *) h;
6732   if (eh->adjust_done)
6733     return TRUE;
6734
6735   sym_sec = eh->elf.root.u.def.section;
6736   opd = get_opd_info (sym_sec);
6737   if (opd != NULL && opd->adjust != NULL)
6738     {
6739       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6740       if (adjust == -1)
6741         {
6742           /* This entry has been deleted.  */
6743           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6744           if (dsec == NULL)
6745             {
6746               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6747                 if (elf_discarded_section (dsec))
6748                   {
6749                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6750                     break;
6751                   }
6752             }
6753           eh->elf.root.u.def.value = 0;
6754           eh->elf.root.u.def.section = dsec;
6755         }
6756       else
6757         eh->elf.root.u.def.value += adjust;
6758       eh->adjust_done = 1;
6759     }
6760   return TRUE;
6761 }
6762
6763 /* Handles decrementing dynamic reloc counts for the reloc specified by
6764    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6765    have already been determined.  */
6766
6767 static bfd_boolean
6768 dec_dynrel_count (bfd_vma r_info,
6769                   asection *sec,
6770                   struct bfd_link_info *info,
6771                   Elf_Internal_Sym **local_syms,
6772                   struct elf_link_hash_entry *h,
6773                   asection *sym_sec)
6774 {
6775   enum elf_ppc64_reloc_type r_type;
6776   struct elf_dyn_relocs *p;
6777   struct elf_dyn_relocs **pp;
6778
6779   /* Can this reloc be dynamic?  This switch, and later tests here
6780      should be kept in sync with the code in check_relocs.  */
6781   r_type = ELF64_R_TYPE (r_info);
6782   switch (r_type)
6783     {
6784     default:
6785       return TRUE;
6786
6787     case R_PPC64_TPREL16:
6788     case R_PPC64_TPREL16_LO:
6789     case R_PPC64_TPREL16_HI:
6790     case R_PPC64_TPREL16_HA:
6791     case R_PPC64_TPREL16_DS:
6792     case R_PPC64_TPREL16_LO_DS:
6793     case R_PPC64_TPREL16_HIGHER:
6794     case R_PPC64_TPREL16_HIGHERA:
6795     case R_PPC64_TPREL16_HIGHEST:
6796     case R_PPC64_TPREL16_HIGHESTA:
6797       if (!info->shared)
6798         return TRUE;
6799
6800     case R_PPC64_TPREL64:
6801     case R_PPC64_DTPMOD64:
6802     case R_PPC64_DTPREL64:
6803     case R_PPC64_ADDR64:
6804     case R_PPC64_REL30:
6805     case R_PPC64_REL32:
6806     case R_PPC64_REL64:
6807     case R_PPC64_ADDR14:
6808     case R_PPC64_ADDR14_BRNTAKEN:
6809     case R_PPC64_ADDR14_BRTAKEN:
6810     case R_PPC64_ADDR16:
6811     case R_PPC64_ADDR16_DS:
6812     case R_PPC64_ADDR16_HA:
6813     case R_PPC64_ADDR16_HI:
6814     case R_PPC64_ADDR16_HIGHER:
6815     case R_PPC64_ADDR16_HIGHERA:
6816     case R_PPC64_ADDR16_HIGHEST:
6817     case R_PPC64_ADDR16_HIGHESTA:
6818     case R_PPC64_ADDR16_LO:
6819     case R_PPC64_ADDR16_LO_DS:
6820     case R_PPC64_ADDR24:
6821     case R_PPC64_ADDR32:
6822     case R_PPC64_UADDR16:
6823     case R_PPC64_UADDR32:
6824     case R_PPC64_UADDR64:
6825     case R_PPC64_TOC:
6826       break;
6827     }
6828
6829   if (local_syms != NULL)
6830     {
6831       unsigned long r_symndx;
6832       Elf_Internal_Sym *sym;
6833       bfd *ibfd = sec->owner;
6834
6835       r_symndx = ELF64_R_SYM (r_info);
6836       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6837         return FALSE;
6838     }
6839
6840   if ((info->shared
6841        && (must_be_dyn_reloc (info, r_type)
6842            || (h != NULL
6843                && (!info->symbolic
6844                    || h->root.type == bfd_link_hash_defweak
6845                    || !h->def_regular))))
6846       || (ELIMINATE_COPY_RELOCS
6847           && !info->shared
6848           && h != NULL
6849           && (h->root.type == bfd_link_hash_defweak
6850               || !h->def_regular)))
6851     ;
6852   else
6853     return TRUE;
6854
6855   if (h != NULL)
6856     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6857   else
6858     {
6859       if (sym_sec != NULL)
6860         {
6861           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6862           pp = (struct elf_dyn_relocs **) vpp;
6863         }
6864       else
6865         {
6866           void *vpp = &elf_section_data (sec)->local_dynrel;
6867           pp = (struct elf_dyn_relocs **) vpp;
6868         }
6869
6870       /* elf_gc_sweep may have already removed all dyn relocs associated
6871          with local syms for a given section.  Don't report a dynreloc
6872          miscount.  */
6873       if (*pp == NULL)
6874         return TRUE;
6875     }
6876
6877   while ((p = *pp) != NULL)
6878     {
6879       if (p->sec == sec)
6880         {
6881           if (!must_be_dyn_reloc (info, r_type))
6882             p->pc_count -= 1;
6883           p->count -= 1;
6884           if (p->count == 0)
6885             *pp = p->next;
6886           return TRUE;
6887         }
6888       pp = &p->next;
6889     }
6890
6891   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
6892                           sec->owner, sec);
6893   bfd_set_error (bfd_error_bad_value);
6894   return FALSE;
6895 }
6896
6897 /* Remove unused Official Procedure Descriptor entries.  Currently we
6898    only remove those associated with functions in discarded link-once
6899    sections, or weakly defined functions that have been overridden.  It
6900    would be possible to remove many more entries for statically linked
6901    applications.  */
6902
6903 bfd_boolean
6904 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
6905 {
6906   bfd *ibfd;
6907   bfd_boolean some_edited = FALSE;
6908   asection *need_pad = NULL;
6909
6910   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6911     {
6912       asection *sec;
6913       Elf_Internal_Rela *relstart, *rel, *relend;
6914       Elf_Internal_Shdr *symtab_hdr;
6915       Elf_Internal_Sym *local_syms;
6916       bfd_vma offset;
6917       struct _opd_sec_data *opd;
6918       bfd_boolean need_edit, add_aux_fields;
6919       bfd_size_type cnt_16b = 0;
6920
6921       if (!is_ppc64_elf (ibfd))
6922         continue;
6923
6924       sec = bfd_get_section_by_name (ibfd, ".opd");
6925       if (sec == NULL || sec->size == 0)
6926         continue;
6927
6928       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6929         continue;
6930
6931       if (sec->output_section == bfd_abs_section_ptr)
6932         continue;
6933
6934       /* Look through the section relocs.  */
6935       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6936         continue;
6937
6938       local_syms = NULL;
6939       symtab_hdr = &elf_symtab_hdr (ibfd);
6940
6941       /* Read the relocations.  */
6942       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6943                                             info->keep_memory);
6944       if (relstart == NULL)
6945         return FALSE;
6946
6947       /* First run through the relocs to check they are sane, and to
6948          determine whether we need to edit this opd section.  */
6949       need_edit = FALSE;
6950       need_pad = sec;
6951       offset = 0;
6952       relend = relstart + sec->reloc_count;
6953       for (rel = relstart; rel < relend; )
6954         {
6955           enum elf_ppc64_reloc_type r_type;
6956           unsigned long r_symndx;
6957           asection *sym_sec;
6958           struct elf_link_hash_entry *h;
6959           Elf_Internal_Sym *sym;
6960
6961           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6962              only interested in the reloc pointing to a function entry
6963              point.  */
6964           if (rel->r_offset != offset
6965               || rel + 1 >= relend
6966               || (rel + 1)->r_offset != offset + 8)
6967             {
6968               /* If someone messes with .opd alignment then after a
6969                  "ld -r" we might have padding in the middle of .opd.
6970                  Also, there's nothing to prevent someone putting
6971                  something silly in .opd with the assembler.  No .opd
6972                  optimization for them!  */
6973             broken_opd:
6974               (*_bfd_error_handler)
6975                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6976               need_edit = FALSE;
6977               break;
6978             }
6979
6980           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6981               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6982             {
6983               (*_bfd_error_handler)
6984                 (_("%B: unexpected reloc type %u in .opd section"),
6985                  ibfd, r_type);
6986               need_edit = FALSE;
6987               break;
6988             }
6989
6990           r_symndx = ELF64_R_SYM (rel->r_info);
6991           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6992                           r_symndx, ibfd))
6993             goto error_ret;
6994
6995           if (sym_sec == NULL || sym_sec->owner == NULL)
6996             {
6997               const char *sym_name;
6998               if (h != NULL)
6999                 sym_name = h->root.root.string;
7000               else
7001                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7002                                              sym_sec);
7003
7004               (*_bfd_error_handler)
7005                 (_("%B: undefined sym `%s' in .opd section"),
7006                  ibfd, sym_name);
7007               need_edit = FALSE;
7008               break;
7009             }
7010
7011           /* opd entries are always for functions defined in the
7012              current input bfd.  If the symbol isn't defined in the
7013              input bfd, then we won't be using the function in this
7014              bfd;  It must be defined in a linkonce section in another
7015              bfd, or is weak.  It's also possible that we are
7016              discarding the function due to a linker script /DISCARD/,
7017              which we test for via the output_section.  */
7018           if (sym_sec->owner != ibfd
7019               || sym_sec->output_section == bfd_abs_section_ptr)
7020             need_edit = TRUE;
7021
7022           rel += 2;
7023           if (rel == relend
7024               || (rel + 1 == relend && rel->r_offset == offset + 16))
7025             {
7026               if (sec->size == offset + 24)
7027                 {
7028                   need_pad = NULL;
7029                   break;
7030                 }
7031               if (rel == relend && sec->size == offset + 16)
7032                 {
7033                   cnt_16b++;
7034                   break;
7035                 }
7036               goto broken_opd;
7037             }
7038
7039           if (rel->r_offset == offset + 24)
7040             offset += 24;
7041           else if (rel->r_offset != offset + 16)
7042             goto broken_opd;
7043           else if (rel + 1 < relend
7044                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7045                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7046             {
7047               offset += 16;
7048               cnt_16b++;
7049             }
7050           else if (rel + 2 < relend
7051                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7052                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7053             {
7054               offset += 24;
7055               rel += 1;
7056             }
7057           else
7058             goto broken_opd;
7059         }
7060
7061       add_aux_fields = non_overlapping && cnt_16b > 0;
7062
7063       if (need_edit || add_aux_fields)
7064         {
7065           Elf_Internal_Rela *write_rel;
7066           Elf_Internal_Shdr *rel_hdr;
7067           bfd_byte *rptr, *wptr;
7068           bfd_byte *new_contents;
7069           bfd_boolean skip;
7070           long opd_ent_size;
7071           bfd_size_type amt;
7072
7073           new_contents = NULL;
7074           amt = sec->size * sizeof (long) / 8;
7075           opd = &ppc64_elf_section_data (sec)->u.opd;
7076           opd->adjust = bfd_zalloc (sec->owner, amt);
7077           if (opd->adjust == NULL)
7078             return FALSE;
7079           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7080
7081           /* This seems a waste of time as input .opd sections are all
7082              zeros as generated by gcc, but I suppose there's no reason
7083              this will always be so.  We might start putting something in
7084              the third word of .opd entries.  */
7085           if ((sec->flags & SEC_IN_MEMORY) == 0)
7086             {
7087               bfd_byte *loc;
7088               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7089                 {
7090                   if (loc != NULL)
7091                     free (loc);
7092                 error_ret:
7093                   if (local_syms != NULL
7094                       && symtab_hdr->contents != (unsigned char *) local_syms)
7095                     free (local_syms);
7096                   if (elf_section_data (sec)->relocs != relstart)
7097                     free (relstart);
7098                   return FALSE;
7099                 }
7100               sec->contents = loc;
7101               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7102             }
7103
7104           elf_section_data (sec)->relocs = relstart;
7105
7106           new_contents = sec->contents;
7107           if (add_aux_fields)
7108             {
7109               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7110               if (new_contents == NULL)
7111                 return FALSE;
7112               need_pad = FALSE;
7113             }
7114           wptr = new_contents;
7115           rptr = sec->contents;
7116
7117           write_rel = relstart;
7118           skip = FALSE;
7119           offset = 0;
7120           opd_ent_size = 0;
7121           for (rel = relstart; rel < relend; rel++)
7122             {
7123               unsigned long r_symndx;
7124               asection *sym_sec;
7125               struct elf_link_hash_entry *h;
7126               Elf_Internal_Sym *sym;
7127
7128               r_symndx = ELF64_R_SYM (rel->r_info);
7129               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7130                               r_symndx, ibfd))
7131                 goto error_ret;
7132
7133               if (rel->r_offset == offset)
7134                 {
7135                   struct ppc_link_hash_entry *fdh = NULL;
7136
7137                   /* See if the .opd entry is full 24 byte or
7138                      16 byte (with fd_aux entry overlapped with next
7139                      fd_func).  */
7140                   opd_ent_size = 24;
7141                   if ((rel + 2 == relend && sec->size == offset + 16)
7142                       || (rel + 3 < relend
7143                           && rel[2].r_offset == offset + 16
7144                           && rel[3].r_offset == offset + 24
7145                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7146                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7147                     opd_ent_size = 16;
7148
7149                   if (h != NULL
7150                       && h->root.root.string[0] == '.')
7151                     {
7152                       struct ppc_link_hash_table *htab;
7153
7154                       htab = ppc_hash_table (info);
7155                       if (htab != NULL)
7156                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7157                                           htab);
7158                       if (fdh != NULL
7159                           && fdh->elf.root.type != bfd_link_hash_defined
7160                           && fdh->elf.root.type != bfd_link_hash_defweak)
7161                         fdh = NULL;
7162                     }
7163
7164                   skip = (sym_sec->owner != ibfd
7165                           || sym_sec->output_section == bfd_abs_section_ptr);
7166                   if (skip)
7167                     {
7168                       if (fdh != NULL && sym_sec->owner == ibfd)
7169                         {
7170                           /* Arrange for the function descriptor sym
7171                              to be dropped.  */
7172                           fdh->elf.root.u.def.value = 0;
7173                           fdh->elf.root.u.def.section = sym_sec;
7174                         }
7175                       opd->adjust[rel->r_offset / 8] = -1;
7176                     }
7177                   else
7178                     {
7179                       /* We'll be keeping this opd entry.  */
7180
7181                       if (fdh != NULL)
7182                         {
7183                           /* Redefine the function descriptor symbol to
7184                              this location in the opd section.  It is
7185                              necessary to update the value here rather
7186                              than using an array of adjustments as we do
7187                              for local symbols, because various places
7188                              in the generic ELF code use the value
7189                              stored in u.def.value.  */
7190                           fdh->elf.root.u.def.value = wptr - new_contents;
7191                           fdh->adjust_done = 1;
7192                         }
7193
7194                       /* Local syms are a bit tricky.  We could
7195                          tweak them as they can be cached, but
7196                          we'd need to look through the local syms
7197                          for the function descriptor sym which we
7198                          don't have at the moment.  So keep an
7199                          array of adjustments.  */
7200                       opd->adjust[rel->r_offset / 8]
7201                         = (wptr - new_contents) - (rptr - sec->contents);
7202
7203                       if (wptr != rptr)
7204                         memcpy (wptr, rptr, opd_ent_size);
7205                       wptr += opd_ent_size;
7206                       if (add_aux_fields && opd_ent_size == 16)
7207                         {
7208                           memset (wptr, '\0', 8);
7209                           wptr += 8;
7210                         }
7211                     }
7212                   rptr += opd_ent_size;
7213                   offset += opd_ent_size;
7214                 }
7215
7216               if (skip)
7217                 {
7218                   if (!NO_OPD_RELOCS
7219                       && !info->relocatable
7220                       && !dec_dynrel_count (rel->r_info, sec, info,
7221                                             NULL, h, sym_sec))
7222                     goto error_ret;
7223                 }
7224               else
7225                 {
7226                   /* We need to adjust any reloc offsets to point to the
7227                      new opd entries.  While we're at it, we may as well
7228                      remove redundant relocs.  */
7229                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7230                   if (write_rel != rel)
7231                     memcpy (write_rel, rel, sizeof (*rel));
7232                   ++write_rel;
7233                 }
7234             }
7235
7236           sec->size = wptr - new_contents;
7237           sec->reloc_count = write_rel - relstart;
7238           if (add_aux_fields)
7239             {
7240               free (sec->contents);
7241               sec->contents = new_contents;
7242             }
7243
7244           /* Fudge the header size too, as this is used later in
7245              elf_bfd_final_link if we are emitting relocs.  */
7246           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7247           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7248           some_edited = TRUE;
7249         }
7250       else if (elf_section_data (sec)->relocs != relstart)
7251         free (relstart);
7252
7253       if (local_syms != NULL
7254           && symtab_hdr->contents != (unsigned char *) local_syms)
7255         {
7256           if (!info->keep_memory)
7257             free (local_syms);
7258           else
7259             symtab_hdr->contents = (unsigned char *) local_syms;
7260         }
7261     }
7262
7263   if (some_edited)
7264     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7265
7266   /* If we are doing a final link and the last .opd entry is just 16 byte
7267      long, add a 8 byte padding after it.  */
7268   if (need_pad != NULL && !info->relocatable)
7269     {
7270       bfd_byte *p;
7271
7272       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7273         {
7274           BFD_ASSERT (need_pad->size > 0);
7275
7276           p = bfd_malloc (need_pad->size + 8);
7277           if (p == NULL)
7278             return FALSE;
7279
7280           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7281                                           p, 0, need_pad->size))
7282             return FALSE;
7283
7284           need_pad->contents = p;
7285           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7286         }
7287       else
7288         {
7289           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7290           if (p == NULL)
7291             return FALSE;
7292
7293           need_pad->contents = p;
7294         }
7295
7296       memset (need_pad->contents + need_pad->size, 0, 8);
7297       need_pad->size += 8;
7298     }
7299
7300   return TRUE;
7301 }
7302
7303 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7304
7305 asection *
7306 ppc64_elf_tls_setup (struct bfd_link_info *info,
7307                      int no_tls_get_addr_opt,
7308                      int *no_multi_toc)
7309 {
7310   struct ppc_link_hash_table *htab;
7311
7312   htab = ppc_hash_table (info);
7313   if (htab == NULL)
7314     return NULL;
7315
7316   if (*no_multi_toc)
7317     htab->do_multi_toc = 0;
7318   else if (!htab->do_multi_toc)
7319     *no_multi_toc = 1;
7320
7321   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7322                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7323                                               FALSE, FALSE, TRUE));
7324   /* Move dynamic linking info to the function descriptor sym.  */
7325   if (htab->tls_get_addr != NULL)
7326     func_desc_adjust (&htab->tls_get_addr->elf, info);
7327   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7328                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7329                                                  FALSE, FALSE, TRUE));
7330   if (!no_tls_get_addr_opt)
7331     {
7332       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7333
7334       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7335                                   FALSE, FALSE, TRUE);
7336       if (opt != NULL)
7337         func_desc_adjust (opt, info);
7338       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7339                                      FALSE, FALSE, TRUE);
7340       if (opt_fd != NULL
7341           && (opt_fd->root.type == bfd_link_hash_defined
7342               || opt_fd->root.type == bfd_link_hash_defweak))
7343         {
7344           /* If glibc supports an optimized __tls_get_addr call stub,
7345              signalled by the presence of __tls_get_addr_opt, and we'll
7346              be calling __tls_get_addr via a plt call stub, then
7347              make __tls_get_addr point to __tls_get_addr_opt.  */
7348           tga_fd = &htab->tls_get_addr_fd->elf;
7349           if (htab->elf.dynamic_sections_created
7350               && tga_fd != NULL
7351               && (tga_fd->type == STT_FUNC
7352                   || tga_fd->needs_plt)
7353               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7354                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7355                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7356             {
7357               struct plt_entry *ent;
7358
7359               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7360                 if (ent->plt.refcount > 0)
7361                   break;
7362               if (ent != NULL)
7363                 {
7364                   tga_fd->root.type = bfd_link_hash_indirect;
7365                   tga_fd->root.u.i.link = &opt_fd->root;
7366                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7367                   if (opt_fd->dynindx != -1)
7368                     {
7369                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7370                       opt_fd->dynindx = -1;
7371                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7372                                               opt_fd->dynstr_index);
7373                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7374                         return NULL;
7375                     }
7376                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7377                   tga = &htab->tls_get_addr->elf;
7378                   if (opt != NULL && tga != NULL)
7379                     {
7380                       tga->root.type = bfd_link_hash_indirect;
7381                       tga->root.u.i.link = &opt->root;
7382                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7383                       _bfd_elf_link_hash_hide_symbol (info, opt,
7384                                                       tga->forced_local);
7385                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7386                     }
7387                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7388                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7389                   if (htab->tls_get_addr != NULL)
7390                     {
7391                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7392                       htab->tls_get_addr->is_func = 1;
7393                     }
7394                 }
7395             }
7396         }
7397       else
7398         no_tls_get_addr_opt = TRUE;
7399     }
7400   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7401   return _bfd_elf_tls_setup (info->output_bfd, info);
7402 }
7403
7404 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7405    HASH1 or HASH2.  */
7406
7407 static bfd_boolean
7408 branch_reloc_hash_match (const bfd *ibfd,
7409                          const Elf_Internal_Rela *rel,
7410                          const struct ppc_link_hash_entry *hash1,
7411                          const struct ppc_link_hash_entry *hash2)
7412 {
7413   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7414   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7415   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7416
7417   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7418     {
7419       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7420       struct elf_link_hash_entry *h;
7421
7422       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7423       h = elf_follow_link (h);
7424       if (h == &hash1->elf || h == &hash2->elf)
7425         return TRUE;
7426     }
7427   return FALSE;
7428 }
7429
7430 /* Run through all the TLS relocs looking for optimization
7431    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7432    a preliminary section layout so that we know the TLS segment
7433    offsets.  We can't optimize earlier because some optimizations need
7434    to know the tp offset, and we need to optimize before allocating
7435    dynamic relocations.  */
7436
7437 bfd_boolean
7438 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7439 {
7440   bfd *ibfd;
7441   asection *sec;
7442   struct ppc_link_hash_table *htab;
7443   unsigned char *toc_ref;
7444   int pass;
7445
7446   if (info->relocatable || !info->executable)
7447     return TRUE;
7448
7449   htab = ppc_hash_table (info);
7450   if (htab == NULL)
7451     return FALSE;
7452
7453   /* Make two passes over the relocs.  On the first pass, mark toc
7454      entries involved with tls relocs, and check that tls relocs
7455      involved in setting up a tls_get_addr call are indeed followed by
7456      such a call.  If they are not, we can't do any tls optimization.
7457      On the second pass twiddle tls_mask flags to notify
7458      relocate_section that optimization can be done, and adjust got
7459      and plt refcounts.  */
7460   toc_ref = NULL;
7461   for (pass = 0; pass < 2; ++pass)
7462     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7463       {
7464         Elf_Internal_Sym *locsyms = NULL;
7465         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7466
7467         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7468           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7469             {
7470               Elf_Internal_Rela *relstart, *rel, *relend;
7471               bfd_boolean found_tls_get_addr_arg = 0;
7472
7473               /* Read the relocations.  */
7474               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7475                                                     info->keep_memory);
7476               if (relstart == NULL)
7477                 return FALSE;
7478
7479               relend = relstart + sec->reloc_count;
7480               for (rel = relstart; rel < relend; rel++)
7481                 {
7482                   enum elf_ppc64_reloc_type r_type;
7483                   unsigned long r_symndx;
7484                   struct elf_link_hash_entry *h;
7485                   Elf_Internal_Sym *sym;
7486                   asection *sym_sec;
7487                   unsigned char *tls_mask;
7488                   unsigned char tls_set, tls_clear, tls_type = 0;
7489                   bfd_vma value;
7490                   bfd_boolean ok_tprel, is_local;
7491                   long toc_ref_index = 0;
7492                   int expecting_tls_get_addr = 0;
7493                   bfd_boolean ret = FALSE;
7494
7495                   r_symndx = ELF64_R_SYM (rel->r_info);
7496                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7497                                   r_symndx, ibfd))
7498                     {
7499                     err_free_rel:
7500                       if (elf_section_data (sec)->relocs != relstart)
7501                         free (relstart);
7502                       if (toc_ref != NULL)
7503                         free (toc_ref);
7504                       if (locsyms != NULL
7505                           && (elf_symtab_hdr (ibfd).contents
7506                               != (unsigned char *) locsyms))
7507                         free (locsyms);
7508                       return ret;
7509                     }
7510
7511                   if (h != NULL)
7512                     {
7513                       if (h->root.type == bfd_link_hash_defined
7514                           || h->root.type == bfd_link_hash_defweak)
7515                         value = h->root.u.def.value;
7516                       else if (h->root.type == bfd_link_hash_undefweak)
7517                         value = 0;
7518                       else
7519                         {
7520                           found_tls_get_addr_arg = 0;
7521                           continue;
7522                         }
7523                     }
7524                   else
7525                     /* Symbols referenced by TLS relocs must be of type
7526                        STT_TLS.  So no need for .opd local sym adjust.  */
7527                     value = sym->st_value;
7528
7529                   ok_tprel = FALSE;
7530                   is_local = FALSE;
7531                   if (h == NULL
7532                       || !h->def_dynamic)
7533                     {
7534                       is_local = TRUE;
7535                       if (h != NULL
7536                           && h->root.type == bfd_link_hash_undefweak)
7537                         ok_tprel = TRUE;
7538                       else
7539                         {
7540                           value += sym_sec->output_offset;
7541                           value += sym_sec->output_section->vma;
7542                           value -= htab->elf.tls_sec->vma;
7543                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7544                                       < (bfd_vma) 1 << 32);
7545                         }
7546                     }
7547
7548                   r_type = ELF64_R_TYPE (rel->r_info);
7549                   /* If this section has old-style __tls_get_addr calls
7550                      without marker relocs, then check that each
7551                      __tls_get_addr call reloc is preceded by a reloc
7552                      that conceivably belongs to the __tls_get_addr arg
7553                      setup insn.  If we don't find matching arg setup
7554                      relocs, don't do any tls optimization.  */
7555                   if (pass == 0
7556                       && sec->has_tls_get_addr_call
7557                       && h != NULL
7558                       && (h == &htab->tls_get_addr->elf
7559                           || h == &htab->tls_get_addr_fd->elf)
7560                       && !found_tls_get_addr_arg
7561                       && is_branch_reloc (r_type))
7562                     {
7563                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7564                                                 "TLS optimization disabled\n"),
7565                                               ibfd, sec, rel->r_offset);
7566                       ret = TRUE;
7567                       goto err_free_rel;
7568                     }
7569
7570                   found_tls_get_addr_arg = 0;
7571                   switch (r_type)
7572                     {
7573                     case R_PPC64_GOT_TLSLD16:
7574                     case R_PPC64_GOT_TLSLD16_LO:
7575                       expecting_tls_get_addr = 1;
7576                       found_tls_get_addr_arg = 1;
7577                       /* Fall thru */
7578
7579                     case R_PPC64_GOT_TLSLD16_HI:
7580                     case R_PPC64_GOT_TLSLD16_HA:
7581                       /* These relocs should never be against a symbol
7582                          defined in a shared lib.  Leave them alone if
7583                          that turns out to be the case.  */
7584                       if (!is_local)
7585                         continue;
7586
7587                       /* LD -> LE */
7588                       tls_set = 0;
7589                       tls_clear = TLS_LD;
7590                       tls_type = TLS_TLS | TLS_LD;
7591                       break;
7592
7593                     case R_PPC64_GOT_TLSGD16:
7594                     case R_PPC64_GOT_TLSGD16_LO:
7595                       expecting_tls_get_addr = 1;
7596                       found_tls_get_addr_arg = 1;
7597                       /* Fall thru */
7598
7599                     case R_PPC64_GOT_TLSGD16_HI:
7600                     case R_PPC64_GOT_TLSGD16_HA:
7601                       if (ok_tprel)
7602                         /* GD -> LE */
7603                         tls_set = 0;
7604                       else
7605                         /* GD -> IE */
7606                         tls_set = TLS_TLS | TLS_TPRELGD;
7607                       tls_clear = TLS_GD;
7608                       tls_type = TLS_TLS | TLS_GD;
7609                       break;
7610
7611                     case R_PPC64_GOT_TPREL16_DS:
7612                     case R_PPC64_GOT_TPREL16_LO_DS:
7613                     case R_PPC64_GOT_TPREL16_HI:
7614                     case R_PPC64_GOT_TPREL16_HA:
7615                       if (ok_tprel)
7616                         {
7617                           /* IE -> LE */
7618                           tls_set = 0;
7619                           tls_clear = TLS_TPREL;
7620                           tls_type = TLS_TLS | TLS_TPREL;
7621                           break;
7622                         }
7623                       continue;
7624
7625                     case R_PPC64_TLSGD:
7626                     case R_PPC64_TLSLD:
7627                       found_tls_get_addr_arg = 1;
7628                       /* Fall thru */
7629
7630                     case R_PPC64_TLS:
7631                     case R_PPC64_TOC16:
7632                     case R_PPC64_TOC16_LO:
7633                       if (sym_sec == NULL || sym_sec != toc)
7634                         continue;
7635
7636                       /* Mark this toc entry as referenced by a TLS
7637                          code sequence.  We can do that now in the
7638                          case of R_PPC64_TLS, and after checking for
7639                          tls_get_addr for the TOC16 relocs.  */
7640                       if (toc_ref == NULL)
7641                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7642                       if (toc_ref == NULL)
7643                         goto err_free_rel;
7644
7645                       if (h != NULL)
7646                         value = h->root.u.def.value;
7647                       else
7648                         value = sym->st_value;
7649                       value += rel->r_addend;
7650                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7651                       toc_ref_index = (value + toc->output_offset) / 8;
7652                       if (r_type == R_PPC64_TLS
7653                           || r_type == R_PPC64_TLSGD
7654                           || r_type == R_PPC64_TLSLD)
7655                         {
7656                           toc_ref[toc_ref_index] = 1;
7657                           continue;
7658                         }
7659
7660                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7661                         continue;
7662
7663                       tls_set = 0;
7664                       tls_clear = 0;
7665                       expecting_tls_get_addr = 2;
7666                       break;
7667
7668                     case R_PPC64_TPREL64:
7669                       if (pass == 0
7670                           || sec != toc
7671                           || toc_ref == NULL
7672                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7673                         continue;
7674                       if (ok_tprel)
7675                         {
7676                           /* IE -> LE */
7677                           tls_set = TLS_EXPLICIT;
7678                           tls_clear = TLS_TPREL;
7679                           break;
7680                         }
7681                       continue;
7682
7683                     case R_PPC64_DTPMOD64:
7684                       if (pass == 0
7685                           || sec != toc
7686                           || toc_ref == NULL
7687                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7688                         continue;
7689                       if (rel + 1 < relend
7690                           && (rel[1].r_info
7691                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7692                           && rel[1].r_offset == rel->r_offset + 8)
7693                         {
7694                           if (ok_tprel)
7695                             /* GD -> LE */
7696                             tls_set = TLS_EXPLICIT | TLS_GD;
7697                           else
7698                             /* GD -> IE */
7699                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7700                           tls_clear = TLS_GD;
7701                         }
7702                       else
7703                         {
7704                           if (!is_local)
7705                             continue;
7706
7707                           /* LD -> LE */
7708                           tls_set = TLS_EXPLICIT;
7709                           tls_clear = TLS_LD;
7710                         }
7711                       break;
7712
7713                     default:
7714                       continue;
7715                     }
7716
7717                   if (pass == 0)
7718                     {
7719                       if (!expecting_tls_get_addr
7720                           || !sec->has_tls_get_addr_call)
7721                         continue;
7722
7723                       if (rel + 1 < relend
7724                           && branch_reloc_hash_match (ibfd, rel + 1,
7725                                                       htab->tls_get_addr,
7726                                                       htab->tls_get_addr_fd))
7727                         {
7728                           if (expecting_tls_get_addr == 2)
7729                             {
7730                               /* Check for toc tls entries.  */
7731                               unsigned char *toc_tls;
7732                               int retval;
7733
7734                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7735                                                      &locsyms,
7736                                                      rel, ibfd);
7737                               if (retval == 0)
7738                                 goto err_free_rel;
7739                               if (toc_tls != NULL)
7740                                 {
7741                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7742                                     found_tls_get_addr_arg = 1;
7743                                   if (retval > 1)
7744                                     toc_ref[toc_ref_index] = 1;
7745                                 }
7746                             }
7747                           continue;
7748                         }
7749
7750                       if (expecting_tls_get_addr != 1)
7751                         continue;
7752
7753                       /* Uh oh, we didn't find the expected call.  We
7754                          could just mark this symbol to exclude it
7755                          from tls optimization but it's safer to skip
7756                          the entire optimization.  */
7757                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
7758                                                 "TLS optimization disabled\n"),
7759                                               ibfd, sec, rel->r_offset);
7760                       ret = TRUE;
7761                       goto err_free_rel;
7762                     }
7763
7764                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7765                     {
7766                       struct plt_entry *ent;
7767                       for (ent = htab->tls_get_addr->elf.plt.plist;
7768                            ent != NULL;
7769                            ent = ent->next)
7770                         if (ent->addend == 0)
7771                           {
7772                             if (ent->plt.refcount > 0)
7773                               {
7774                                 ent->plt.refcount -= 1;
7775                                 expecting_tls_get_addr = 0;
7776                               }
7777                             break;
7778                           }
7779                     }
7780
7781                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7782                     {
7783                       struct plt_entry *ent;
7784                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7785                            ent != NULL;
7786                            ent = ent->next)
7787                         if (ent->addend == 0)
7788                           {
7789                             if (ent->plt.refcount > 0)
7790                               ent->plt.refcount -= 1;
7791                             break;
7792                           }
7793                     }
7794
7795                   if (tls_clear == 0)
7796                     continue;
7797
7798                   if ((tls_set & TLS_EXPLICIT) == 0)
7799                     {
7800                       struct got_entry *ent;
7801
7802                       /* Adjust got entry for this reloc.  */
7803                       if (h != NULL)
7804                         ent = h->got.glist;
7805                       else
7806                         ent = elf_local_got_ents (ibfd)[r_symndx];
7807
7808                       for (; ent != NULL; ent = ent->next)
7809                         if (ent->addend == rel->r_addend
7810                             && ent->owner == ibfd
7811                             && ent->tls_type == tls_type)
7812                           break;
7813                       if (ent == NULL)
7814                         abort ();
7815
7816                       if (tls_set == 0)
7817                         {
7818                           /* We managed to get rid of a got entry.  */
7819                           if (ent->got.refcount > 0)
7820                             ent->got.refcount -= 1;
7821                         }
7822                     }
7823                   else
7824                     {
7825                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7826                          we'll lose one or two dyn relocs.  */
7827                       if (!dec_dynrel_count (rel->r_info, sec, info,
7828                                              NULL, h, sym_sec))
7829                         return FALSE;
7830
7831                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7832                         {
7833                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7834                                                  NULL, h, sym_sec))
7835                             return FALSE;
7836                         }
7837                     }
7838
7839                   *tls_mask |= tls_set;
7840                   *tls_mask &= ~tls_clear;
7841                 }
7842
7843               if (elf_section_data (sec)->relocs != relstart)
7844                 free (relstart);
7845             }
7846
7847         if (locsyms != NULL
7848             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7849           {
7850             if (!info->keep_memory)
7851               free (locsyms);
7852             else
7853               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7854           }
7855       }
7856
7857   if (toc_ref != NULL)
7858     free (toc_ref);
7859   return TRUE;
7860 }
7861
7862 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7863    the values of any global symbols in a toc section that has been
7864    edited.  Globals in toc sections should be a rarity, so this function
7865    sets a flag if any are found in toc sections other than the one just
7866    edited, so that futher hash table traversals can be avoided.  */
7867
7868 struct adjust_toc_info
7869 {
7870   asection *toc;
7871   unsigned long *skip;
7872   bfd_boolean global_toc_syms;
7873 };
7874
7875 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7876
7877 static bfd_boolean
7878 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7879 {
7880   struct ppc_link_hash_entry *eh;
7881   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7882   unsigned long i;
7883
7884   if (h->root.type != bfd_link_hash_defined
7885       && h->root.type != bfd_link_hash_defweak)
7886     return TRUE;
7887
7888   eh = (struct ppc_link_hash_entry *) h;
7889   if (eh->adjust_done)
7890     return TRUE;
7891
7892   if (eh->elf.root.u.def.section == toc_inf->toc)
7893     {
7894       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
7895         i = toc_inf->toc->rawsize >> 3;
7896       else
7897         i = eh->elf.root.u.def.value >> 3;
7898
7899       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
7900         {
7901           (*_bfd_error_handler)
7902             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
7903           do
7904             ++i;
7905           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
7906           eh->elf.root.u.def.value = (bfd_vma) i << 3;
7907         }
7908
7909       eh->elf.root.u.def.value -= toc_inf->skip[i];
7910       eh->adjust_done = 1;
7911     }
7912   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7913     toc_inf->global_toc_syms = TRUE;
7914
7915   return TRUE;
7916 }
7917
7918 /* Examine all relocs referencing .toc sections in order to remove
7919    unused .toc entries.  */
7920
7921 bfd_boolean
7922 ppc64_elf_edit_toc (struct bfd_link_info *info)
7923 {
7924   bfd *ibfd;
7925   struct adjust_toc_info toc_inf;
7926   struct ppc_link_hash_table *htab = ppc_hash_table (info);
7927
7928   htab->do_toc_opt = 1;
7929   toc_inf.global_toc_syms = TRUE;
7930   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7931     {
7932       asection *toc, *sec;
7933       Elf_Internal_Shdr *symtab_hdr;
7934       Elf_Internal_Sym *local_syms;
7935       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
7936       unsigned long *skip, *drop;
7937       unsigned char *used;
7938       unsigned char *keep, last, some_unused;
7939
7940       if (!is_ppc64_elf (ibfd))
7941         continue;
7942
7943       toc = bfd_get_section_by_name (ibfd, ".toc");
7944       if (toc == NULL
7945           || toc->size == 0
7946           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7947           || elf_discarded_section (toc))
7948         continue;
7949
7950       toc_relocs = NULL;
7951       local_syms = NULL;
7952       symtab_hdr = &elf_symtab_hdr (ibfd);
7953
7954       /* Look at sections dropped from the final link.  */
7955       skip = NULL;
7956       relstart = NULL;
7957       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7958         {
7959           if (sec->reloc_count == 0
7960               || !elf_discarded_section (sec)
7961               || get_opd_info (sec)
7962               || (sec->flags & SEC_ALLOC) == 0
7963               || (sec->flags & SEC_DEBUGGING) != 0)
7964             continue;
7965
7966           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7967           if (relstart == NULL)
7968             goto error_ret;
7969
7970           /* Run through the relocs to see which toc entries might be
7971              unused.  */
7972           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7973             {
7974               enum elf_ppc64_reloc_type r_type;
7975               unsigned long r_symndx;
7976               asection *sym_sec;
7977               struct elf_link_hash_entry *h;
7978               Elf_Internal_Sym *sym;
7979               bfd_vma val;
7980
7981               r_type = ELF64_R_TYPE (rel->r_info);
7982               switch (r_type)
7983                 {
7984                 default:
7985                   continue;
7986
7987                 case R_PPC64_TOC16:
7988                 case R_PPC64_TOC16_LO:
7989                 case R_PPC64_TOC16_HI:
7990                 case R_PPC64_TOC16_HA:
7991                 case R_PPC64_TOC16_DS:
7992                 case R_PPC64_TOC16_LO_DS:
7993                   break;
7994                 }
7995
7996               r_symndx = ELF64_R_SYM (rel->r_info);
7997               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7998                               r_symndx, ibfd))
7999                 goto error_ret;
8000
8001               if (sym_sec != toc)
8002                 continue;
8003
8004               if (h != NULL)
8005                 val = h->root.u.def.value;
8006               else
8007                 val = sym->st_value;
8008               val += rel->r_addend;
8009
8010               if (val >= toc->size)
8011                 continue;
8012
8013               /* Anything in the toc ought to be aligned to 8 bytes.
8014                  If not, don't mark as unused.  */
8015               if (val & 7)
8016                 continue;
8017
8018               if (skip == NULL)
8019                 {
8020                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8021                   if (skip == NULL)
8022                     goto error_ret;
8023                 }
8024
8025               skip[val >> 3] = ref_from_discarded;
8026             }
8027
8028           if (elf_section_data (sec)->relocs != relstart)
8029             free (relstart);
8030         }
8031
8032       /* For largetoc loads of address constants, we can convert
8033          .  addis rx,2,addr@got@ha
8034          .  ld ry,addr@got@l(rx)
8035          to
8036          .  addis rx,2,addr@toc@ha
8037          .  addi ry,rx,addr@toc@l
8038          when addr is within 2G of the toc pointer.  This then means
8039          that the word storing "addr" in the toc is no longer needed.  */
8040
8041       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8042           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8043           && toc->reloc_count != 0)
8044         {
8045           /* Read toc relocs.  */
8046           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8047                                                   info->keep_memory);
8048           if (toc_relocs == NULL)
8049             goto error_ret;
8050
8051           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8052             {
8053               enum elf_ppc64_reloc_type r_type;
8054               unsigned long r_symndx;
8055               asection *sym_sec;
8056               struct elf_link_hash_entry *h;
8057               Elf_Internal_Sym *sym;
8058               bfd_vma val, addr;
8059
8060               r_type = ELF64_R_TYPE (rel->r_info);
8061               if (r_type != R_PPC64_ADDR64)
8062                 continue;
8063
8064               r_symndx = ELF64_R_SYM (rel->r_info);
8065               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8066                               r_symndx, ibfd))
8067                 goto error_ret;
8068
8069               if (sym_sec == NULL
8070                   || elf_discarded_section (sym_sec))
8071                 continue;
8072
8073               if (!SYMBOL_CALLS_LOCAL (info, h))
8074                 continue;
8075
8076               if (h != NULL)
8077                 {
8078                   if (h->type == STT_GNU_IFUNC)
8079                     continue;
8080                   val = h->root.u.def.value;
8081                 }
8082               else
8083                 {
8084                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8085                     continue;
8086                   val = sym->st_value;
8087                 }
8088               val += rel->r_addend;
8089               val += sym_sec->output_section->vma + sym_sec->output_offset;
8090
8091               /* We don't yet know the exact toc pointer value, but we
8092                  know it will be somewhere in the toc section.  Don't
8093                  optimize if the difference from any possible toc
8094                  pointer is outside [ff..f80008000, 7fff7fff].  */
8095               addr = toc->output_section->vma + TOC_BASE_OFF;
8096               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8097                 continue;
8098
8099               addr = toc->output_section->vma + toc->output_section->rawsize;
8100               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8101                 continue;
8102
8103               if (skip == NULL)
8104                 {
8105                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8106                   if (skip == NULL)
8107                     goto error_ret;
8108                 }
8109
8110               skip[rel->r_offset >> 3]
8111                 |= can_optimize | ((rel - toc_relocs) << 2);
8112             }
8113         }
8114
8115       if (skip == NULL)
8116         continue;
8117
8118       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8119       if (used == NULL)
8120         {
8121         error_ret:
8122           if (local_syms != NULL
8123               && symtab_hdr->contents != (unsigned char *) local_syms)
8124             free (local_syms);
8125           if (sec != NULL
8126               && relstart != NULL
8127               && elf_section_data (sec)->relocs != relstart)
8128             free (relstart);
8129           if (toc_relocs != NULL
8130               && elf_section_data (toc)->relocs != toc_relocs)
8131             free (toc_relocs);
8132           if (skip != NULL)
8133             free (skip);
8134           return FALSE;
8135         }
8136
8137       /* Now check all kept sections that might reference the toc.
8138          Check the toc itself last.  */
8139       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8140                   : ibfd->sections);
8141            sec != NULL;
8142            sec = (sec == toc ? NULL
8143                   : sec->next == NULL ? toc
8144                   : sec->next == toc && toc->next ? toc->next
8145                   : sec->next))
8146         {
8147           int repeat;
8148
8149           if (sec->reloc_count == 0
8150               || elf_discarded_section (sec)
8151               || get_opd_info (sec)
8152               || (sec->flags & SEC_ALLOC) == 0
8153               || (sec->flags & SEC_DEBUGGING) != 0)
8154             continue;
8155
8156           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8157                                                 info->keep_memory);
8158           if (relstart == NULL)
8159             goto error_ret;
8160
8161           /* Mark toc entries referenced as used.  */
8162           repeat = 0;
8163           do
8164             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8165               {
8166                 enum elf_ppc64_reloc_type r_type;
8167                 unsigned long r_symndx;
8168                 asection *sym_sec;
8169                 struct elf_link_hash_entry *h;
8170                 Elf_Internal_Sym *sym;
8171                 bfd_vma val;
8172
8173                 r_type = ELF64_R_TYPE (rel->r_info);
8174                 switch (r_type)
8175                   {
8176                   case R_PPC64_TOC16:
8177                   case R_PPC64_TOC16_LO:
8178                   case R_PPC64_TOC16_HI:
8179                   case R_PPC64_TOC16_HA:
8180                   case R_PPC64_TOC16_DS:
8181                   case R_PPC64_TOC16_LO_DS:
8182                     /* In case we're taking addresses of toc entries.  */
8183                   case R_PPC64_ADDR64:
8184                     break;
8185
8186                   default:
8187                     continue;
8188                   }
8189
8190                 r_symndx = ELF64_R_SYM (rel->r_info);
8191                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8192                                 r_symndx, ibfd))
8193                   {
8194                     free (used);
8195                     goto error_ret;
8196                   }
8197
8198                 if (sym_sec != toc)
8199                   continue;
8200
8201                 if (h != NULL)
8202                   val = h->root.u.def.value;
8203                 else
8204                   val = sym->st_value;
8205                 val += rel->r_addend;
8206
8207                 if (val >= toc->size)
8208                   continue;
8209
8210                 if ((skip[val >> 3] & can_optimize) != 0)
8211                   {
8212                     bfd_vma off;
8213                     unsigned char opc;
8214
8215                     switch (r_type)
8216                       {
8217                       case R_PPC64_TOC16_HA:
8218                         break;
8219
8220                       case R_PPC64_TOC16_LO_DS:
8221                         off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8222                         if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8223                           return FALSE;
8224                         if ((opc & (0x3f << 2)) == (58u << 2))
8225                           break;
8226                         /* Fall thru */
8227
8228                       default:
8229                         /* Wrong sort of reloc, or not a ld.  We may
8230                            as well clear ref_from_discarded too.  */
8231                         skip[val >> 3] = 0;
8232                       }
8233                   }
8234
8235                 /* For the toc section, we only mark as used if
8236                    this entry itself isn't unused.  */
8237                 if (sec == toc
8238                     && !used[val >> 3]
8239                     && (used[rel->r_offset >> 3]
8240                         || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8241                   /* Do all the relocs again, to catch reference
8242                      chains.  */
8243                   repeat = 1;
8244
8245                 used[val >> 3] = 1;
8246               }
8247           while (repeat);
8248
8249           if (elf_section_data (sec)->relocs != relstart)
8250             free (relstart);
8251         }
8252
8253       /* Merge the used and skip arrays.  Assume that TOC
8254          doublewords not appearing as either used or unused belong
8255          to to an entry more than one doubleword in size.  */
8256       for (drop = skip, keep = used, last = 0, some_unused = 0;
8257            drop < skip + (toc->size + 7) / 8;
8258            ++drop, ++keep)
8259         {
8260           if (*keep)
8261             {
8262               *drop &= ~ref_from_discarded;
8263               if ((*drop & can_optimize) != 0)
8264                 some_unused = 1;
8265               last = 0;
8266             }
8267           else if ((*drop & ref_from_discarded) != 0)
8268             {
8269               some_unused = 1;
8270               last = ref_from_discarded;
8271             }
8272           else
8273             *drop = last;
8274         }
8275
8276       free (used);
8277
8278       if (some_unused)
8279         {
8280           bfd_byte *contents, *src;
8281           unsigned long off;
8282           Elf_Internal_Sym *sym;
8283           bfd_boolean local_toc_syms = FALSE;
8284
8285           /* Shuffle the toc contents, and at the same time convert the
8286              skip array from booleans into offsets.  */
8287           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8288             goto error_ret;
8289
8290           elf_section_data (toc)->this_hdr.contents = contents;
8291
8292           for (src = contents, off = 0, drop = skip;
8293                src < contents + toc->size;
8294                src += 8, ++drop)
8295             {
8296               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8297                 off += 8;
8298               else if (off != 0)
8299                 {
8300                   *drop = off;
8301                   memcpy (src - off, src, 8);
8302                 }
8303             }
8304           *drop = off;
8305           toc->rawsize = toc->size;
8306           toc->size = src - contents - off;
8307
8308           /* Adjust addends for relocs against the toc section sym,
8309              and optimize any accesses we can.  */
8310           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8311             {
8312               if (sec->reloc_count == 0
8313                   || elf_discarded_section (sec))
8314                 continue;
8315
8316               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8317                                                     info->keep_memory);
8318               if (relstart == NULL)
8319                 goto error_ret;
8320
8321               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8322                 {
8323                   enum elf_ppc64_reloc_type r_type;
8324                   unsigned long r_symndx;
8325                   asection *sym_sec;
8326                   struct elf_link_hash_entry *h;
8327                   bfd_vma val;
8328
8329                   r_type = ELF64_R_TYPE (rel->r_info);
8330                   switch (r_type)
8331                     {
8332                     default:
8333                       continue;
8334
8335                     case R_PPC64_TOC16:
8336                     case R_PPC64_TOC16_LO:
8337                     case R_PPC64_TOC16_HI:
8338                     case R_PPC64_TOC16_HA:
8339                     case R_PPC64_TOC16_DS:
8340                     case R_PPC64_TOC16_LO_DS:
8341                     case R_PPC64_ADDR64:
8342                       break;
8343                     }
8344
8345                   r_symndx = ELF64_R_SYM (rel->r_info);
8346                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8347                                   r_symndx, ibfd))
8348                     goto error_ret;
8349
8350                   if (sym_sec != toc)
8351                     continue;
8352
8353                   if (h != NULL)
8354                     val = h->root.u.def.value;
8355                   else
8356                     {
8357                       val = sym->st_value;
8358                       if (val != 0)
8359                         local_toc_syms = TRUE;
8360                     }
8361
8362                   val += rel->r_addend;
8363
8364                   if (val > toc->rawsize)
8365                     val = toc->rawsize;
8366                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8367                     continue;
8368                   else if ((skip[val >> 3] & can_optimize) != 0)
8369                     {
8370                       Elf_Internal_Rela *tocrel
8371                         = toc_relocs + (skip[val >> 3] >> 2);
8372                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8373
8374                       switch (r_type)
8375                         {
8376                         case R_PPC64_TOC16_HA:
8377                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8378                           break;
8379
8380                         case R_PPC64_TOC16_LO_DS:
8381                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8382                           break;
8383
8384                         default:
8385                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8386                             ppc_howto_init ();
8387                           info->callbacks->einfo
8388                             (_("%P: %H: %s relocation references "
8389                                "optimized away TOC entry\n"),
8390                              ibfd, sec, rel->r_offset,
8391                              ppc64_elf_howto_table[r_type]->name);
8392                           bfd_set_error (bfd_error_bad_value);
8393                           goto error_ret;
8394                         }
8395                       rel->r_addend = tocrel->r_addend;
8396                       elf_section_data (sec)->relocs = relstart;
8397                       continue;
8398                     }
8399
8400                   if (h != NULL || sym->st_value != 0)
8401                     continue;
8402
8403                   rel->r_addend -= skip[val >> 3];
8404                   elf_section_data (sec)->relocs = relstart;
8405                 }
8406
8407               if (elf_section_data (sec)->relocs != relstart)
8408                 free (relstart);
8409             }
8410
8411           /* We shouldn't have local or global symbols defined in the TOC,
8412              but handle them anyway.  */
8413           if (local_syms != NULL)
8414             for (sym = local_syms;
8415                  sym < local_syms + symtab_hdr->sh_info;
8416                  ++sym)
8417               if (sym->st_value != 0
8418                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8419                 {
8420                   unsigned long i;
8421
8422                   if (sym->st_value > toc->rawsize)
8423                     i = toc->rawsize >> 3;
8424                   else
8425                     i = sym->st_value >> 3;
8426
8427                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8428                     {
8429                       if (local_toc_syms)
8430                         (*_bfd_error_handler)
8431                           (_("%s defined on removed toc entry"),
8432                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8433                       do
8434                         ++i;
8435                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8436                       sym->st_value = (bfd_vma) i << 3;
8437                     }
8438
8439                   sym->st_value -= skip[i];
8440                   symtab_hdr->contents = (unsigned char *) local_syms;
8441                 }
8442
8443           /* Adjust any global syms defined in this toc input section.  */
8444           if (toc_inf.global_toc_syms)
8445             {
8446               toc_inf.toc = toc;
8447               toc_inf.skip = skip;
8448               toc_inf.global_toc_syms = FALSE;
8449               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8450                                       &toc_inf);
8451             }
8452
8453           if (toc->reloc_count != 0)
8454             {
8455               Elf_Internal_Shdr *rel_hdr;
8456               Elf_Internal_Rela *wrel;
8457               bfd_size_type sz;
8458
8459               /* Remove unused toc relocs, and adjust those we keep.  */
8460               if (toc_relocs == NULL)
8461                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8462                                                         info->keep_memory);
8463               if (toc_relocs == NULL)
8464                 goto error_ret;
8465
8466               wrel = toc_relocs;
8467               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8468                 if ((skip[rel->r_offset >> 3]
8469                      & (ref_from_discarded | can_optimize)) == 0)
8470                   {
8471                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8472                     wrel->r_info = rel->r_info;
8473                     wrel->r_addend = rel->r_addend;
8474                     ++wrel;
8475                   }
8476                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8477                                             &local_syms, NULL, NULL))
8478                   goto error_ret;
8479
8480               elf_section_data (toc)->relocs = toc_relocs;
8481               toc->reloc_count = wrel - toc_relocs;
8482               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8483               sz = rel_hdr->sh_entsize;
8484               rel_hdr->sh_size = toc->reloc_count * sz;
8485             }
8486         }
8487       else if (toc_relocs != NULL
8488                && elf_section_data (toc)->relocs != toc_relocs)
8489         free (toc_relocs);
8490
8491       if (local_syms != NULL
8492           && symtab_hdr->contents != (unsigned char *) local_syms)
8493         {
8494           if (!info->keep_memory)
8495             free (local_syms);
8496           else
8497             symtab_hdr->contents = (unsigned char *) local_syms;
8498         }
8499       free (skip);
8500     }
8501
8502   return TRUE;
8503 }
8504
8505 /* Return true iff input section I references the TOC using
8506    instructions limited to +/-32k offsets.  */
8507
8508 bfd_boolean
8509 ppc64_elf_has_small_toc_reloc (asection *i)
8510 {
8511   return (is_ppc64_elf (i->owner)
8512           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8513 }
8514
8515 /* Allocate space for one GOT entry.  */
8516
8517 static void
8518 allocate_got (struct elf_link_hash_entry *h,
8519               struct bfd_link_info *info,
8520               struct got_entry *gent)
8521 {
8522   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8523   bfd_boolean dyn;
8524   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8525   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8526                  ? 16 : 8);
8527   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8528                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8529   asection *got = ppc64_elf_tdata (gent->owner)->got;
8530
8531   gent->got.offset = got->size;
8532   got->size += entsize;
8533
8534   dyn = htab->elf.dynamic_sections_created;
8535   if ((info->shared
8536        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8537             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8538                 || h->root.type != bfd_link_hash_undefweak))
8539     {
8540       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8541       relgot->size += rentsize;
8542     }
8543   else if (h->type == STT_GNU_IFUNC)
8544     {
8545       asection *relgot = htab->reliplt;
8546       relgot->size += rentsize;
8547       htab->got_reli_size += rentsize;
8548     }
8549 }
8550
8551 /* This function merges got entries in the same toc group.  */
8552
8553 static void
8554 merge_got_entries (struct got_entry **pent)
8555 {
8556   struct got_entry *ent, *ent2;
8557
8558   for (ent = *pent; ent != NULL; ent = ent->next)
8559     if (!ent->is_indirect)
8560       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8561         if (!ent2->is_indirect
8562             && ent2->addend == ent->addend
8563             && ent2->tls_type == ent->tls_type
8564             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8565           {
8566             ent2->is_indirect = TRUE;
8567             ent2->got.ent = ent;
8568           }
8569 }
8570
8571 /* Allocate space in .plt, .got and associated reloc sections for
8572    dynamic relocs.  */
8573
8574 static bfd_boolean
8575 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8576 {
8577   struct bfd_link_info *info;
8578   struct ppc_link_hash_table *htab;
8579   asection *s;
8580   struct ppc_link_hash_entry *eh;
8581   struct elf_dyn_relocs *p;
8582   struct got_entry **pgent, *gent;
8583
8584   if (h->root.type == bfd_link_hash_indirect)
8585     return TRUE;
8586
8587   info = (struct bfd_link_info *) inf;
8588   htab = ppc_hash_table (info);
8589   if (htab == NULL)
8590     return FALSE;
8591
8592   if ((htab->elf.dynamic_sections_created
8593        && h->dynindx != -1
8594        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8595       || h->type == STT_GNU_IFUNC)
8596     {
8597       struct plt_entry *pent;
8598       bfd_boolean doneone = FALSE;
8599       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8600         if (pent->plt.refcount > 0)
8601           {
8602             if (!htab->elf.dynamic_sections_created
8603                 || h->dynindx == -1)
8604               {
8605                 s = htab->iplt;
8606                 pent->plt.offset = s->size;
8607                 s->size += PLT_ENTRY_SIZE;
8608                 s = htab->reliplt;
8609               }
8610             else
8611               {
8612                 /* If this is the first .plt entry, make room for the special
8613                    first entry.  */
8614                 s = htab->plt;
8615                 if (s->size == 0)
8616                   s->size += PLT_INITIAL_ENTRY_SIZE;
8617
8618                 pent->plt.offset = s->size;
8619
8620                 /* Make room for this entry.  */
8621                 s->size += PLT_ENTRY_SIZE;
8622
8623                 /* Make room for the .glink code.  */
8624                 s = htab->glink;
8625                 if (s->size == 0)
8626                   s->size += GLINK_CALL_STUB_SIZE;
8627                 /* We need bigger stubs past index 32767.  */
8628                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8629                   s->size += 4;
8630                 s->size += 2*4;
8631
8632                 /* We also need to make an entry in the .rela.plt section.  */
8633                 s = htab->relplt;
8634               }
8635             s->size += sizeof (Elf64_External_Rela);
8636             doneone = TRUE;
8637           }
8638         else
8639           pent->plt.offset = (bfd_vma) -1;
8640       if (!doneone)
8641         {
8642           h->plt.plist = NULL;
8643           h->needs_plt = 0;
8644         }
8645     }
8646   else
8647     {
8648       h->plt.plist = NULL;
8649       h->needs_plt = 0;
8650     }
8651
8652   eh = (struct ppc_link_hash_entry *) h;
8653   /* Run through the TLS GD got entries first if we're changing them
8654      to TPREL.  */
8655   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8656     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8657       if (gent->got.refcount > 0
8658           && (gent->tls_type & TLS_GD) != 0)
8659         {
8660           /* This was a GD entry that has been converted to TPREL.  If
8661              there happens to be a TPREL entry we can use that one.  */
8662           struct got_entry *ent;
8663           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8664             if (ent->got.refcount > 0
8665                 && (ent->tls_type & TLS_TPREL) != 0
8666                 && ent->addend == gent->addend
8667                 && ent->owner == gent->owner)
8668               {
8669                 gent->got.refcount = 0;
8670                 break;
8671               }
8672
8673           /* If not, then we'll be using our own TPREL entry.  */
8674           if (gent->got.refcount != 0)
8675             gent->tls_type = TLS_TLS | TLS_TPREL;
8676         }
8677
8678   /* Remove any list entry that won't generate a word in the GOT before
8679      we call merge_got_entries.  Otherwise we risk merging to empty
8680      entries.  */
8681   pgent = &h->got.glist;
8682   while ((gent = *pgent) != NULL)
8683     if (gent->got.refcount > 0)
8684       {
8685         if ((gent->tls_type & TLS_LD) != 0
8686             && !h->def_dynamic)
8687           {
8688             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8689             *pgent = gent->next;
8690           }
8691         else
8692           pgent = &gent->next;
8693       }
8694     else
8695       *pgent = gent->next;
8696
8697   if (!htab->do_multi_toc)
8698     merge_got_entries (&h->got.glist);
8699
8700   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8701     if (!gent->is_indirect)
8702       {
8703         /* Make sure this symbol is output as a dynamic symbol.
8704            Undefined weak syms won't yet be marked as dynamic,
8705            nor will all TLS symbols.  */
8706         if (h->dynindx == -1
8707             && !h->forced_local
8708             && h->type != STT_GNU_IFUNC
8709             && htab->elf.dynamic_sections_created)
8710           {
8711             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8712               return FALSE;
8713           }
8714
8715         if (!is_ppc64_elf (gent->owner))
8716           abort ();
8717
8718         allocate_got (h, info, gent);
8719       }
8720
8721   if (eh->dyn_relocs == NULL
8722       || (!htab->elf.dynamic_sections_created
8723           && h->type != STT_GNU_IFUNC))
8724     return TRUE;
8725
8726   /* In the shared -Bsymbolic case, discard space allocated for
8727      dynamic pc-relative relocs against symbols which turn out to be
8728      defined in regular objects.  For the normal shared case, discard
8729      space for relocs that have become local due to symbol visibility
8730      changes.  */
8731
8732   if (info->shared)
8733     {
8734       /* Relocs that use pc_count are those that appear on a call insn,
8735          or certain REL relocs (see must_be_dyn_reloc) that can be
8736          generated via assembly.  We want calls to protected symbols to
8737          resolve directly to the function rather than going via the plt.
8738          If people want function pointer comparisons to work as expected
8739          then they should avoid writing weird assembly.  */
8740       if (SYMBOL_CALLS_LOCAL (info, h))
8741         {
8742           struct elf_dyn_relocs **pp;
8743
8744           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8745             {
8746               p->count -= p->pc_count;
8747               p->pc_count = 0;
8748               if (p->count == 0)
8749                 *pp = p->next;
8750               else
8751                 pp = &p->next;
8752             }
8753         }
8754
8755       /* Also discard relocs on undefined weak syms with non-default
8756          visibility.  */
8757       if (eh->dyn_relocs != NULL
8758           && h->root.type == bfd_link_hash_undefweak)
8759         {
8760           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8761             eh->dyn_relocs = NULL;
8762
8763           /* Make sure this symbol is output as a dynamic symbol.
8764              Undefined weak syms won't yet be marked as dynamic.  */
8765           else if (h->dynindx == -1
8766                    && !h->forced_local)
8767             {
8768               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8769                 return FALSE;
8770             }
8771         }
8772     }
8773   else if (h->type == STT_GNU_IFUNC)
8774     {
8775       if (!h->non_got_ref)
8776         eh->dyn_relocs = NULL;
8777     }
8778   else if (ELIMINATE_COPY_RELOCS)
8779     {
8780       /* For the non-shared case, discard space for relocs against
8781          symbols which turn out to need copy relocs or are not
8782          dynamic.  */
8783
8784       if (!h->non_got_ref
8785           && !h->def_regular)
8786         {
8787           /* Make sure this symbol is output as a dynamic symbol.
8788              Undefined weak syms won't yet be marked as dynamic.  */
8789           if (h->dynindx == -1
8790               && !h->forced_local)
8791             {
8792               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8793                 return FALSE;
8794             }
8795
8796           /* If that succeeded, we know we'll be keeping all the
8797              relocs.  */
8798           if (h->dynindx != -1)
8799             goto keep;
8800         }
8801
8802       eh->dyn_relocs = NULL;
8803
8804     keep: ;
8805     }
8806
8807   /* Finally, allocate space.  */
8808   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8809     {
8810       asection *sreloc = elf_section_data (p->sec)->sreloc;
8811       if (!htab->elf.dynamic_sections_created)
8812         sreloc = htab->reliplt;
8813       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8814     }
8815
8816   return TRUE;
8817 }
8818
8819 /* Find any dynamic relocs that apply to read-only sections.  */
8820
8821 static bfd_boolean
8822 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8823 {
8824   struct ppc_link_hash_entry *eh;
8825   struct elf_dyn_relocs *p;
8826
8827   eh = (struct ppc_link_hash_entry *) h;
8828   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8829     {
8830       asection *s = p->sec->output_section;
8831
8832       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8833         {
8834           struct bfd_link_info *info = inf;
8835
8836           info->flags |= DF_TEXTREL;
8837
8838           /* Not an error, just cut short the traversal.  */
8839           return FALSE;
8840         }
8841     }
8842   return TRUE;
8843 }
8844
8845 /* Set the sizes of the dynamic sections.  */
8846
8847 static bfd_boolean
8848 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8849                                  struct bfd_link_info *info)
8850 {
8851   struct ppc_link_hash_table *htab;
8852   bfd *dynobj;
8853   asection *s;
8854   bfd_boolean relocs;
8855   bfd *ibfd;
8856   struct got_entry *first_tlsld;
8857
8858   htab = ppc_hash_table (info);
8859   if (htab == NULL)
8860     return FALSE;
8861
8862   dynobj = htab->elf.dynobj;
8863   if (dynobj == NULL)
8864     abort ();
8865
8866   if (htab->elf.dynamic_sections_created)
8867     {
8868       /* Set the contents of the .interp section to the interpreter.  */
8869       if (info->executable)
8870         {
8871           s = bfd_get_section_by_name (dynobj, ".interp");
8872           if (s == NULL)
8873             abort ();
8874           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8875           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8876         }
8877     }
8878
8879   /* Set up .got offsets for local syms, and space for local dynamic
8880      relocs.  */
8881   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8882     {
8883       struct got_entry **lgot_ents;
8884       struct got_entry **end_lgot_ents;
8885       struct plt_entry **local_plt;
8886       struct plt_entry **end_local_plt;
8887       unsigned char *lgot_masks;
8888       bfd_size_type locsymcount;
8889       Elf_Internal_Shdr *symtab_hdr;
8890       asection *srel;
8891
8892       if (!is_ppc64_elf (ibfd))
8893         continue;
8894
8895       for (s = ibfd->sections; s != NULL; s = s->next)
8896         {
8897           struct elf_dyn_relocs *p;
8898
8899           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8900             {
8901               if (!bfd_is_abs_section (p->sec)
8902                   && bfd_is_abs_section (p->sec->output_section))
8903                 {
8904                   /* Input section has been discarded, either because
8905                      it is a copy of a linkonce section or due to
8906                      linker script /DISCARD/, so we'll be discarding
8907                      the relocs too.  */
8908                 }
8909               else if (p->count != 0)
8910                 {
8911                   srel = elf_section_data (p->sec)->sreloc;
8912                   if (!htab->elf.dynamic_sections_created)
8913                     srel = htab->reliplt;
8914                   srel->size += p->count * sizeof (Elf64_External_Rela);
8915                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8916                     info->flags |= DF_TEXTREL;
8917                 }
8918             }
8919         }
8920
8921       lgot_ents = elf_local_got_ents (ibfd);
8922       if (!lgot_ents)
8923         continue;
8924
8925       symtab_hdr = &elf_symtab_hdr (ibfd);
8926       locsymcount = symtab_hdr->sh_info;
8927       end_lgot_ents = lgot_ents + locsymcount;
8928       local_plt = (struct plt_entry **) end_lgot_ents;
8929       end_local_plt = local_plt + locsymcount;
8930       lgot_masks = (unsigned char *) end_local_plt;
8931       s = ppc64_elf_tdata (ibfd)->got;
8932       srel = ppc64_elf_tdata (ibfd)->relgot;
8933       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8934         {
8935           struct got_entry **pent, *ent;
8936
8937           pent = lgot_ents;
8938           while ((ent = *pent) != NULL)
8939             if (ent->got.refcount > 0)
8940               {
8941                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8942                   {
8943                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
8944                     *pent = ent->next;
8945                   }
8946                 else
8947                   {
8948                     unsigned int num = 1;
8949                     ent->got.offset = s->size;
8950                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8951                       num = 2;
8952                     s->size += num * 8;
8953                     if (info->shared)
8954                       srel->size += num * sizeof (Elf64_External_Rela);
8955                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8956                       {
8957                         htab->reliplt->size
8958                           += num * sizeof (Elf64_External_Rela);
8959                         htab->got_reli_size
8960                           += num * sizeof (Elf64_External_Rela);
8961                       }
8962                     pent = &ent->next;
8963                   }
8964               }
8965             else
8966               *pent = ent->next;
8967         }
8968
8969       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8970       for (; local_plt < end_local_plt; ++local_plt)
8971         {
8972           struct plt_entry *ent;
8973
8974           for (ent = *local_plt; ent != NULL; ent = ent->next)
8975             if (ent->plt.refcount > 0)
8976               {
8977                 s = htab->iplt;
8978                 ent->plt.offset = s->size;
8979                 s->size += PLT_ENTRY_SIZE;
8980
8981                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8982               }
8983             else
8984               ent->plt.offset = (bfd_vma) -1;
8985         }
8986     }
8987
8988   /* Allocate global sym .plt and .got entries, and space for global
8989      sym dynamic relocs.  */
8990   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8991
8992   first_tlsld = NULL;
8993   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8994     {
8995       struct got_entry *ent;
8996
8997       if (!is_ppc64_elf (ibfd))
8998         continue;
8999
9000       ent = ppc64_tlsld_got (ibfd);
9001       if (ent->got.refcount > 0)
9002         {
9003           if (!htab->do_multi_toc && first_tlsld != NULL)
9004             {
9005               ent->is_indirect = TRUE;
9006               ent->got.ent = first_tlsld;
9007             }
9008           else
9009             {
9010               if (first_tlsld == NULL)
9011                 first_tlsld = ent;
9012               s = ppc64_elf_tdata (ibfd)->got;
9013               ent->got.offset = s->size;
9014               ent->owner = ibfd;
9015               s->size += 16;
9016               if (info->shared)
9017                 {
9018                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9019                   srel->size += sizeof (Elf64_External_Rela);
9020                 }
9021             }
9022         }
9023       else
9024         ent->got.offset = (bfd_vma) -1;
9025     }
9026
9027   /* We now have determined the sizes of the various dynamic sections.
9028      Allocate memory for them.  */
9029   relocs = FALSE;
9030   for (s = dynobj->sections; s != NULL; s = s->next)
9031     {
9032       if ((s->flags & SEC_LINKER_CREATED) == 0)
9033         continue;
9034
9035       if (s == htab->brlt || s == htab->relbrlt)
9036         /* These haven't been allocated yet;  don't strip.  */
9037         continue;
9038       else if (s == htab->got
9039                || s == htab->plt
9040                || s == htab->iplt
9041                || s == htab->glink
9042                || s == htab->dynbss)
9043         {
9044           /* Strip this section if we don't need it; see the
9045              comment below.  */
9046         }
9047       else if (s == htab->glink_eh_frame)
9048         {
9049           if (!bfd_is_abs_section (s->output_section))
9050             /* Not sized yet.  */
9051             continue;
9052         }
9053       else if (CONST_STRNEQ (s->name, ".rela"))
9054         {
9055           if (s->size != 0)
9056             {
9057               if (s != htab->relplt)
9058                 relocs = TRUE;
9059
9060               /* We use the reloc_count field as a counter if we need
9061                  to copy relocs into the output file.  */
9062               s->reloc_count = 0;
9063             }
9064         }
9065       else
9066         {
9067           /* It's not one of our sections, so don't allocate space.  */
9068           continue;
9069         }
9070
9071       if (s->size == 0)
9072         {
9073           /* If we don't need this section, strip it from the
9074              output file.  This is mostly to handle .rela.bss and
9075              .rela.plt.  We must create both sections in
9076              create_dynamic_sections, because they must be created
9077              before the linker maps input sections to output
9078              sections.  The linker does that before
9079              adjust_dynamic_symbol is called, and it is that
9080              function which decides whether anything needs to go
9081              into these sections.  */
9082           s->flags |= SEC_EXCLUDE;
9083           continue;
9084         }
9085
9086       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9087         continue;
9088
9089       /* Allocate memory for the section contents.  We use bfd_zalloc
9090          here in case unused entries are not reclaimed before the
9091          section's contents are written out.  This should not happen,
9092          but this way if it does we get a R_PPC64_NONE reloc in .rela
9093          sections instead of garbage.
9094          We also rely on the section contents being zero when writing
9095          the GOT.  */
9096       s->contents = bfd_zalloc (dynobj, s->size);
9097       if (s->contents == NULL)
9098         return FALSE;
9099     }
9100
9101   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9102     {
9103       if (!is_ppc64_elf (ibfd))
9104         continue;
9105
9106       s = ppc64_elf_tdata (ibfd)->got;
9107       if (s != NULL && s != htab->got)
9108         {
9109           if (s->size == 0)
9110             s->flags |= SEC_EXCLUDE;
9111           else
9112             {
9113               s->contents = bfd_zalloc (ibfd, s->size);
9114               if (s->contents == NULL)
9115                 return FALSE;
9116             }
9117         }
9118       s = ppc64_elf_tdata (ibfd)->relgot;
9119       if (s != NULL)
9120         {
9121           if (s->size == 0)
9122             s->flags |= SEC_EXCLUDE;
9123           else
9124             {
9125               s->contents = bfd_zalloc (ibfd, s->size);
9126               if (s->contents == NULL)
9127                 return FALSE;
9128               relocs = TRUE;
9129               s->reloc_count = 0;
9130             }
9131         }
9132     }
9133
9134   if (htab->elf.dynamic_sections_created)
9135     {
9136       /* Add some entries to the .dynamic section.  We fill in the
9137          values later, in ppc64_elf_finish_dynamic_sections, but we
9138          must add the entries now so that we get the correct size for
9139          the .dynamic section.  The DT_DEBUG entry is filled in by the
9140          dynamic linker and used by the debugger.  */
9141 #define add_dynamic_entry(TAG, VAL) \
9142   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9143
9144       if (info->executable)
9145         {
9146           if (!add_dynamic_entry (DT_DEBUG, 0))
9147             return FALSE;
9148         }
9149
9150       if (htab->plt != NULL && htab->plt->size != 0)
9151         {
9152           if (!add_dynamic_entry (DT_PLTGOT, 0)
9153               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9154               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9155               || !add_dynamic_entry (DT_JMPREL, 0)
9156               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9157             return FALSE;
9158         }
9159
9160       if (NO_OPD_RELOCS)
9161         {
9162           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9163               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9164             return FALSE;
9165         }
9166
9167       if (!htab->no_tls_get_addr_opt
9168           && htab->tls_get_addr_fd != NULL
9169           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9170           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9171         return FALSE;
9172
9173       if (relocs)
9174         {
9175           if (!add_dynamic_entry (DT_RELA, 0)
9176               || !add_dynamic_entry (DT_RELASZ, 0)
9177               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9178             return FALSE;
9179
9180           /* If any dynamic relocs apply to a read-only section,
9181              then we need a DT_TEXTREL entry.  */
9182           if ((info->flags & DF_TEXTREL) == 0)
9183             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9184
9185           if ((info->flags & DF_TEXTREL) != 0)
9186             {
9187               if (!add_dynamic_entry (DT_TEXTREL, 0))
9188                 return FALSE;
9189             }
9190         }
9191     }
9192 #undef add_dynamic_entry
9193
9194   return TRUE;
9195 }
9196
9197 /* Determine the type of stub needed, if any, for a call.  */
9198
9199 static inline enum ppc_stub_type
9200 ppc_type_of_stub (asection *input_sec,
9201                   const Elf_Internal_Rela *rel,
9202                   struct ppc_link_hash_entry **hash,
9203                   struct plt_entry **plt_ent,
9204                   bfd_vma destination)
9205 {
9206   struct ppc_link_hash_entry *h = *hash;
9207   bfd_vma location;
9208   bfd_vma branch_offset;
9209   bfd_vma max_branch_offset;
9210   enum elf_ppc64_reloc_type r_type;
9211
9212   if (h != NULL)
9213     {
9214       struct plt_entry *ent;
9215       struct ppc_link_hash_entry *fdh = h;
9216       if (h->oh != NULL
9217           && h->oh->is_func_descriptor)
9218         {
9219           fdh = ppc_follow_link (h->oh);
9220           *hash = fdh;
9221         }
9222
9223       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9224         if (ent->addend == rel->r_addend
9225             && ent->plt.offset != (bfd_vma) -1)
9226           {
9227             *plt_ent = ent;
9228             return ppc_stub_plt_call;
9229           }
9230
9231       /* Here, we know we don't have a plt entry.  If we don't have a
9232          either a defined function descriptor or a defined entry symbol
9233          in a regular object file, then it is pointless trying to make
9234          any other type of stub.  */
9235       if (!is_static_defined (&fdh->elf)
9236           && !is_static_defined (&h->elf))
9237         return ppc_stub_none;
9238     }
9239   else if (elf_local_got_ents (input_sec->owner) != NULL)
9240     {
9241       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9242       struct plt_entry **local_plt = (struct plt_entry **)
9243         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9244       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9245
9246       if (local_plt[r_symndx] != NULL)
9247         {
9248           struct plt_entry *ent;
9249
9250           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9251             if (ent->addend == rel->r_addend
9252                 && ent->plt.offset != (bfd_vma) -1)
9253               {
9254                 *plt_ent = ent;
9255                 return ppc_stub_plt_call;
9256               }
9257         }
9258     }
9259
9260   /* Determine where the call point is.  */
9261   location = (input_sec->output_offset
9262               + input_sec->output_section->vma
9263               + rel->r_offset);
9264
9265   branch_offset = destination - location;
9266   r_type = ELF64_R_TYPE (rel->r_info);
9267
9268   /* Determine if a long branch stub is needed.  */
9269   max_branch_offset = 1 << 25;
9270   if (r_type != R_PPC64_REL24)
9271     max_branch_offset = 1 << 15;
9272
9273   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9274     /* We need a stub.  Figure out whether a long_branch or plt_branch
9275        is needed later.  */
9276     return ppc_stub_long_branch;
9277
9278   return ppc_stub_none;
9279 }
9280
9281 /* Build a .plt call stub.  */
9282
9283 static inline bfd_byte *
9284 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r,
9285                 bfd_boolean plt_static_chain)
9286 {
9287 #define PPC_LO(v) ((v) & 0xffff)
9288 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9289 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9290
9291   if (PPC_HA (offset) != 0)
9292     {
9293       if (r != NULL)
9294         {
9295           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9296           r[1].r_offset = r[0].r_offset + 8;
9297           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9298           r[1].r_addend = r[0].r_addend;
9299           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9300             {
9301               r[2].r_offset = r[1].r_offset + 4;
9302               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9303               r[2].r_addend = r[0].r_addend;
9304             }
9305           else
9306             {
9307               r[2].r_offset = r[1].r_offset + 8;
9308               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9309               r[2].r_addend = r[0].r_addend + 8;
9310               if (plt_static_chain)
9311                 {
9312                   r[3].r_offset = r[2].r_offset + 4;
9313                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9314                   r[3].r_addend = r[0].r_addend + 16;
9315                 }
9316             }
9317         }
9318       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9319       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9320       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9321       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9322         {
9323           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9324           offset = 0;
9325         }
9326       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9327       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9328       if (plt_static_chain)
9329         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9330       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9331     }
9332   else
9333     {
9334       if (r != NULL)
9335         {
9336           r[0].r_offset += 4;
9337           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9338           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9339             {
9340               r[1].r_offset = r[0].r_offset + 4;
9341               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9342               r[1].r_addend = r[0].r_addend;
9343             }
9344           else
9345             {
9346               r[1].r_offset = r[0].r_offset + 8;
9347               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9348               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9349               if (plt_static_chain)
9350                 {
9351                   r[2].r_offset = r[1].r_offset + 4;
9352                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9353                   r[2].r_addend = r[0].r_addend + 8;
9354                 }
9355             }
9356         }
9357       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9358       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9359       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9360         {
9361           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9362           offset = 0;
9363         }
9364       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9365       if (plt_static_chain)
9366         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9367       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9368       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9369     }
9370   return p;
9371 }
9372
9373 /* Build a special .plt call stub for __tls_get_addr.  */
9374
9375 #define LD_R11_0R3      0xe9630000
9376 #define LD_R12_0R3      0xe9830000
9377 #define MR_R0_R3        0x7c601b78
9378 #define CMPDI_R11_0     0x2c2b0000
9379 #define ADD_R3_R12_R13  0x7c6c6a14
9380 #define BEQLR           0x4d820020
9381 #define MR_R3_R0        0x7c030378
9382 #define MFLR_R11        0x7d6802a6
9383 #define STD_R11_0R1     0xf9610000
9384 #define BCTRL           0x4e800421
9385 #define LD_R11_0R1      0xe9610000
9386 #define LD_R2_0R1       0xe8410000
9387 #define MTLR_R11        0x7d6803a6
9388
9389 static inline bfd_byte *
9390 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9391                          Elf_Internal_Rela *r, bfd_boolean plt_static_chain)
9392 {
9393   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9394   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9395   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9396   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9397   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9398   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9399   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9400   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9401   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9402
9403   if (r != NULL)
9404     r[0].r_offset += 9 * 4;
9405   p = build_plt_stub (obfd, p, offset, r, plt_static_chain);
9406   bfd_put_32 (obfd, BCTRL, p - 4);
9407
9408   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9409   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9410   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9411   bfd_put_32 (obfd, BLR, p),                    p += 4;
9412
9413   return p;
9414 }
9415
9416 static Elf_Internal_Rela *
9417 get_relocs (asection *sec, int count)
9418 {
9419   Elf_Internal_Rela *relocs;
9420   struct bfd_elf_section_data *elfsec_data;
9421
9422   elfsec_data = elf_section_data (sec);
9423   relocs = elfsec_data->relocs;
9424   if (relocs == NULL)
9425     {
9426       bfd_size_type relsize;
9427       relsize = sec->reloc_count * sizeof (*relocs);
9428       relocs = bfd_alloc (sec->owner, relsize);
9429       if (relocs == NULL)
9430         return NULL;
9431       elfsec_data->relocs = relocs;
9432       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9433                                           sizeof (Elf_Internal_Shdr));
9434       if (elfsec_data->rela.hdr == NULL)
9435         return NULL;
9436       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9437                                         * sizeof (Elf64_External_Rela));
9438       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9439       sec->reloc_count = 0;
9440     }
9441   relocs += sec->reloc_count;
9442   sec->reloc_count += count;
9443   return relocs;
9444 }
9445
9446 static bfd_vma
9447 get_r2off (struct bfd_link_info *info,
9448            struct ppc_stub_hash_entry *stub_entry)
9449 {
9450   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9451   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9452
9453   if (r2off == 0)
9454     {
9455       /* Support linking -R objects.  Get the toc pointer from the
9456          opd entry.  */
9457       char buf[8];
9458       asection *opd = stub_entry->h->elf.root.u.def.section;
9459       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9460
9461       if (strcmp (opd->name, ".opd") != 0
9462           || opd->reloc_count != 0)
9463         {
9464           info->callbacks->einfo (_("%P: cannot find opd entry toc for %s\n"),
9465                                   stub_entry->h->elf.root.root.string);
9466           bfd_set_error (bfd_error_bad_value);
9467           return 0;
9468         }
9469       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9470         return 0;
9471       r2off = bfd_get_64 (opd->owner, buf);
9472       r2off -= elf_gp (info->output_bfd);
9473     }
9474   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9475   return r2off;
9476 }
9477
9478 static bfd_boolean
9479 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9480 {
9481   struct ppc_stub_hash_entry *stub_entry;
9482   struct ppc_branch_hash_entry *br_entry;
9483   struct bfd_link_info *info;
9484   struct ppc_link_hash_table *htab;
9485   bfd_byte *loc;
9486   bfd_byte *p;
9487   bfd_vma dest, off;
9488   int size;
9489   Elf_Internal_Rela *r;
9490   asection *plt;
9491
9492   /* Massage our args to the form they really have.  */
9493   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9494   info = in_arg;
9495
9496   htab = ppc_hash_table (info);
9497   if (htab == NULL)
9498     return FALSE;
9499
9500   /* Make a note of the offset within the stubs for this entry.  */
9501   stub_entry->stub_offset = stub_entry->stub_sec->size;
9502   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9503
9504   htab->stub_count[stub_entry->stub_type - 1] += 1;
9505   switch (stub_entry->stub_type)
9506     {
9507     case ppc_stub_long_branch:
9508     case ppc_stub_long_branch_r2off:
9509       /* Branches are relative.  This is where we are going to.  */
9510       off = dest = (stub_entry->target_value
9511                     + stub_entry->target_section->output_offset
9512                     + stub_entry->target_section->output_section->vma);
9513
9514       /* And this is where we are coming from.  */
9515       off -= (stub_entry->stub_offset
9516               + stub_entry->stub_sec->output_offset
9517               + stub_entry->stub_sec->output_section->vma);
9518
9519       size = 4;
9520       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9521         {
9522           bfd_vma r2off = get_r2off (info, stub_entry);
9523
9524           if (r2off == 0)
9525             {
9526               htab->stub_error = TRUE;
9527               return FALSE;
9528             }
9529           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9530           loc += 4;
9531           size = 12;
9532           if (PPC_HA (r2off) != 0)
9533             {
9534               size = 16;
9535               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9536               loc += 4;
9537             }
9538           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9539           loc += 4;
9540           off -= size - 4;
9541         }
9542       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9543
9544       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9545         {
9546           info->callbacks->einfo (_("%P: long branch stub `%s' offset overflow\n"),
9547                                   stub_entry->root.string);
9548           htab->stub_error = TRUE;
9549           return FALSE;
9550         }
9551
9552       if (info->emitrelocations)
9553         {
9554           r = get_relocs (stub_entry->stub_sec, 1);
9555           if (r == NULL)
9556             return FALSE;
9557           r->r_offset = loc - stub_entry->stub_sec->contents;
9558           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9559           r->r_addend = dest;
9560           if (stub_entry->h != NULL)
9561             {
9562               struct elf_link_hash_entry **hashes;
9563               unsigned long symndx;
9564               struct ppc_link_hash_entry *h;
9565
9566               hashes = elf_sym_hashes (htab->stub_bfd);
9567               if (hashes == NULL)
9568                 {
9569                   bfd_size_type hsize;
9570
9571                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9572                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9573                   if (hashes == NULL)
9574                     return FALSE;
9575                   elf_sym_hashes (htab->stub_bfd) = hashes;
9576                   htab->stub_globals = 1;
9577                 }
9578               symndx = htab->stub_globals++;
9579               h = stub_entry->h;
9580               hashes[symndx] = &h->elf;
9581               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9582               if (h->oh != NULL && h->oh->is_func)
9583                 h = ppc_follow_link (h->oh);
9584               if (h->elf.root.u.def.section != stub_entry->target_section)
9585                 /* H is an opd symbol.  The addend must be zero.  */
9586                 r->r_addend = 0;
9587               else
9588                 {
9589                   off = (h->elf.root.u.def.value
9590                          + h->elf.root.u.def.section->output_offset
9591                          + h->elf.root.u.def.section->output_section->vma);
9592                   r->r_addend -= off;
9593                 }
9594             }
9595         }
9596       break;
9597
9598     case ppc_stub_plt_branch:
9599     case ppc_stub_plt_branch_r2off:
9600       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9601                                          stub_entry->root.string + 9,
9602                                          FALSE, FALSE);
9603       if (br_entry == NULL)
9604         {
9605           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
9606                                   stub_entry->root.string);
9607           htab->stub_error = TRUE;
9608           return FALSE;
9609         }
9610
9611       dest = (stub_entry->target_value
9612               + stub_entry->target_section->output_offset
9613               + stub_entry->target_section->output_section->vma);
9614
9615       bfd_put_64 (htab->brlt->owner, dest,
9616                   htab->brlt->contents + br_entry->offset);
9617
9618       if (br_entry->iter == htab->stub_iteration)
9619         {
9620           br_entry->iter = 0;
9621
9622           if (htab->relbrlt != NULL)
9623             {
9624               /* Create a reloc for the branch lookup table entry.  */
9625               Elf_Internal_Rela rela;
9626               bfd_byte *rl;
9627
9628               rela.r_offset = (br_entry->offset
9629                                + htab->brlt->output_offset
9630                                + htab->brlt->output_section->vma);
9631               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9632               rela.r_addend = dest;
9633
9634               rl = htab->relbrlt->contents;
9635               rl += (htab->relbrlt->reloc_count++
9636                      * sizeof (Elf64_External_Rela));
9637               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9638             }
9639           else if (info->emitrelocations)
9640             {
9641               r = get_relocs (htab->brlt, 1);
9642               if (r == NULL)
9643                 return FALSE;
9644               /* brlt, being SEC_LINKER_CREATED does not go through the
9645                  normal reloc processing.  Symbols and offsets are not
9646                  translated from input file to output file form, so
9647                  set up the offset per the output file.  */
9648               r->r_offset = (br_entry->offset
9649                              + htab->brlt->output_offset
9650                              + htab->brlt->output_section->vma);
9651               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9652               r->r_addend = dest;
9653             }
9654         }
9655
9656       dest = (br_entry->offset
9657               + htab->brlt->output_offset
9658               + htab->brlt->output_section->vma);
9659
9660       off = (dest
9661              - elf_gp (htab->brlt->output_section->owner)
9662              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9663
9664       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9665         {
9666           info->callbacks->einfo
9667             (_("%P: linkage table error against `%s'\n"),
9668              stub_entry->root.string);
9669           bfd_set_error (bfd_error_bad_value);
9670           htab->stub_error = TRUE;
9671           return FALSE;
9672         }
9673
9674       if (info->emitrelocations)
9675         {
9676           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9677           if (r == NULL)
9678             return FALSE;
9679           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9680           if (bfd_big_endian (info->output_bfd))
9681             r[0].r_offset += 2;
9682           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9683             r[0].r_offset += 4;
9684           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9685           r[0].r_addend = dest;
9686           if (PPC_HA (off) != 0)
9687             {
9688               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9689               r[1].r_offset = r[0].r_offset + 4;
9690               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9691               r[1].r_addend = r[0].r_addend;
9692             }
9693         }
9694
9695       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9696         {
9697           if (PPC_HA (off) != 0)
9698             {
9699               size = 16;
9700               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9701               loc += 4;
9702               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9703             }
9704           else
9705             {
9706               size = 12;
9707               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9708             }
9709         }
9710       else
9711         {
9712           bfd_vma r2off = get_r2off (info, stub_entry);
9713
9714           if (r2off == 0)
9715             {
9716               htab->stub_error = TRUE;
9717               return FALSE;
9718             }
9719
9720           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9721           loc += 4;
9722           size = 20;
9723           if (PPC_HA (off) != 0)
9724             {
9725               size += 4;
9726               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9727               loc += 4;
9728               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9729               loc += 4;
9730             }
9731           else
9732             {
9733               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9734               loc += 4;
9735             }
9736
9737           if (PPC_HA (r2off) != 0)
9738             {
9739               size += 4;
9740               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9741               loc += 4;
9742             }
9743           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9744         }
9745       loc += 4;
9746       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9747       loc += 4;
9748       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9749       break;
9750
9751     case ppc_stub_plt_call:
9752       if (stub_entry->h != NULL
9753           && stub_entry->h->is_func_descriptor
9754           && stub_entry->h->oh != NULL)
9755         {
9756           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9757
9758           /* If the old-ABI "dot-symbol" is undefined make it weak so
9759              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9760              FIXME: We used to define the symbol on one of the call
9761              stubs instead, which is why we test symbol section id
9762              against htab->top_id in various places.  Likely all
9763              these checks could now disappear.  */
9764           if (fh->elf.root.type == bfd_link_hash_undefined)
9765             fh->elf.root.type = bfd_link_hash_undefweak;
9766           /* Stop undo_symbol_twiddle changing it back to undefined.  */
9767           fh->was_undefined = 0;
9768         }
9769
9770       /* Now build the stub.  */
9771       dest = stub_entry->plt_ent->plt.offset & ~1;
9772       if (dest >= (bfd_vma) -2)
9773         abort ();
9774
9775       plt = htab->plt;
9776       if (!htab->elf.dynamic_sections_created
9777           || stub_entry->h == NULL
9778           || stub_entry->h->elf.dynindx == -1)
9779         plt = htab->iplt;
9780
9781       dest += plt->output_offset + plt->output_section->vma;
9782
9783       if (stub_entry->h == NULL
9784           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9785         {
9786           Elf_Internal_Rela rela;
9787           bfd_byte *rl;
9788
9789           rela.r_offset = dest;
9790           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9791           rela.r_addend = (stub_entry->target_value
9792                            + stub_entry->target_section->output_offset
9793                            + stub_entry->target_section->output_section->vma);
9794
9795           rl = (htab->reliplt->contents
9796                 + (htab->reliplt->reloc_count++
9797                    * sizeof (Elf64_External_Rela)));
9798           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9799           stub_entry->plt_ent->plt.offset |= 1;
9800         }
9801
9802       off = (dest
9803              - elf_gp (plt->output_section->owner)
9804              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9805
9806       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9807         {
9808           info->callbacks->einfo
9809             (_("%P: linkage table error against `%s'\n"),
9810              stub_entry->h != NULL
9811              ? stub_entry->h->elf.root.root.string
9812              : "<local sym>");
9813           bfd_set_error (bfd_error_bad_value);
9814           htab->stub_error = TRUE;
9815           return FALSE;
9816         }
9817
9818       r = NULL;
9819       if (info->emitrelocations)
9820         {
9821           r = get_relocs (stub_entry->stub_sec,
9822                           (2
9823                            + (PPC_HA (off) != 0)
9824                            + (htab->plt_static_chain
9825                               && PPC_HA (off + 16) == PPC_HA (off))));
9826           if (r == NULL)
9827             return FALSE;
9828           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9829           if (bfd_big_endian (info->output_bfd))
9830             r[0].r_offset += 2;
9831           r[0].r_addend = dest;
9832         }
9833       if (stub_entry->h != NULL
9834           && (stub_entry->h == htab->tls_get_addr_fd
9835               || stub_entry->h == htab->tls_get_addr)
9836           && !htab->no_tls_get_addr_opt)
9837         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r,
9838                                      htab->plt_static_chain);
9839       else
9840         p = build_plt_stub (htab->stub_bfd, loc, off, r,
9841                             htab->plt_static_chain);
9842       size = p - loc;
9843       break;
9844
9845     default:
9846       BFD_FAIL ();
9847       return FALSE;
9848     }
9849
9850   stub_entry->stub_sec->size += size;
9851
9852   if (htab->emit_stub_syms)
9853     {
9854       struct elf_link_hash_entry *h;
9855       size_t len1, len2;
9856       char *name;
9857       const char *const stub_str[] = { "long_branch",
9858                                        "long_branch_r2off",
9859                                        "plt_branch",
9860                                        "plt_branch_r2off",
9861                                        "plt_call" };
9862
9863       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9864       len2 = strlen (stub_entry->root.string);
9865       name = bfd_malloc (len1 + len2 + 2);
9866       if (name == NULL)
9867         return FALSE;
9868       memcpy (name, stub_entry->root.string, 9);
9869       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9870       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9871       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9872       if (h == NULL)
9873         return FALSE;
9874       if (h->root.type == bfd_link_hash_new)
9875         {
9876           h->root.type = bfd_link_hash_defined;
9877           h->root.u.def.section = stub_entry->stub_sec;
9878           h->root.u.def.value = stub_entry->stub_offset;
9879           h->ref_regular = 1;
9880           h->def_regular = 1;
9881           h->ref_regular_nonweak = 1;
9882           h->forced_local = 1;
9883           h->non_elf = 0;
9884         }
9885     }
9886
9887   return TRUE;
9888 }
9889
9890 /* As above, but don't actually build the stub.  Just bump offset so
9891    we know stub section sizes, and select plt_branch stubs where
9892    long_branch stubs won't do.  */
9893
9894 static bfd_boolean
9895 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9896 {
9897   struct ppc_stub_hash_entry *stub_entry;
9898   struct bfd_link_info *info;
9899   struct ppc_link_hash_table *htab;
9900   bfd_vma off;
9901   int size;
9902
9903   /* Massage our args to the form they really have.  */
9904   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9905   info = in_arg;
9906
9907   htab = ppc_hash_table (info);
9908   if (htab == NULL)
9909     return FALSE;
9910
9911   if (stub_entry->stub_type == ppc_stub_plt_call)
9912     {
9913       asection *plt;
9914       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9915       if (off >= (bfd_vma) -2)
9916         abort ();
9917       plt = htab->plt;
9918       if (!htab->elf.dynamic_sections_created
9919           || stub_entry->h == NULL
9920           || stub_entry->h->elf.dynindx == -1)
9921         plt = htab->iplt;
9922       off += (plt->output_offset
9923               + plt->output_section->vma
9924               - elf_gp (plt->output_section->owner)
9925               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9926
9927       size = PLT_CALL_STUB_SIZE;
9928       if (!htab->plt_static_chain)
9929         size -= 4;
9930       if (PPC_HA (off) == 0)
9931         size -= 4;
9932       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9933         size += 4;
9934       if (stub_entry->h != NULL
9935           && (stub_entry->h == htab->tls_get_addr_fd
9936               || stub_entry->h == htab->tls_get_addr)
9937           && !htab->no_tls_get_addr_opt)
9938         size += 13 * 4;
9939       if (info->emitrelocations)
9940         {
9941           stub_entry->stub_sec->reloc_count
9942             += (2
9943                 + (PPC_HA (off) != 0)
9944                 + (htab->plt_static_chain
9945                    && PPC_HA (off + 16) == PPC_HA (off)));
9946           stub_entry->stub_sec->flags |= SEC_RELOC;
9947         }
9948     }
9949   else
9950     {
9951       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9952          variants.  */
9953       bfd_vma r2off = 0;
9954
9955       off = (stub_entry->target_value
9956              + stub_entry->target_section->output_offset
9957              + stub_entry->target_section->output_section->vma);
9958       off -= (stub_entry->stub_sec->size
9959               + stub_entry->stub_sec->output_offset
9960               + stub_entry->stub_sec->output_section->vma);
9961
9962       /* Reset the stub type from the plt variant in case we now
9963          can reach with a shorter stub.  */
9964       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9965         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9966
9967       size = 4;
9968       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9969         {
9970           r2off = get_r2off (info, stub_entry);
9971           if (r2off == 0)
9972             {
9973               htab->stub_error = TRUE;
9974               return FALSE;
9975             }
9976           size = 12;
9977           if (PPC_HA (r2off) != 0)
9978             size = 16;
9979           off -= size - 4;
9980         }
9981
9982       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9983       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9984         {
9985           struct ppc_branch_hash_entry *br_entry;
9986
9987           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9988                                              stub_entry->root.string + 9,
9989                                              TRUE, FALSE);
9990           if (br_entry == NULL)
9991             {
9992               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
9993                                       stub_entry->root.string);
9994               htab->stub_error = TRUE;
9995               return FALSE;
9996             }
9997
9998           if (br_entry->iter != htab->stub_iteration)
9999             {
10000               br_entry->iter = htab->stub_iteration;
10001               br_entry->offset = htab->brlt->size;
10002               htab->brlt->size += 8;
10003
10004               if (htab->relbrlt != NULL)
10005                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10006               else if (info->emitrelocations)
10007                 {
10008                   htab->brlt->reloc_count += 1;
10009                   htab->brlt->flags |= SEC_RELOC;
10010                 }
10011             }
10012
10013           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10014           off = (br_entry->offset
10015                  + htab->brlt->output_offset
10016                  + htab->brlt->output_section->vma
10017                  - elf_gp (htab->brlt->output_section->owner)
10018                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10019
10020           if (info->emitrelocations)
10021             {
10022               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10023               stub_entry->stub_sec->flags |= SEC_RELOC;
10024             }
10025
10026           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10027             {
10028               size = 12;
10029               if (PPC_HA (off) != 0)
10030                 size = 16;
10031             }
10032           else
10033             {
10034               size = 20;
10035               if (PPC_HA (off) != 0)
10036                 size += 4;
10037
10038               if (PPC_HA (r2off) != 0)
10039                 size += 4;
10040             }
10041         }
10042       else if (info->emitrelocations)
10043         {
10044           stub_entry->stub_sec->reloc_count += 1;
10045           stub_entry->stub_sec->flags |= SEC_RELOC;
10046         }
10047     }
10048
10049   stub_entry->stub_sec->size += size;
10050   return TRUE;
10051 }
10052
10053 /* Set up various things so that we can make a list of input sections
10054    for each output section included in the link.  Returns -1 on error,
10055    0 when no stubs will be needed, and 1 on success.  */
10056
10057 int
10058 ppc64_elf_setup_section_lists
10059   (struct bfd_link_info *info,
10060    asection *(*add_stub_section) (const char *, asection *),
10061    void (*layout_sections_again) (void))
10062 {
10063   bfd *input_bfd;
10064   int top_id, top_index, id;
10065   asection *section;
10066   asection **input_list;
10067   bfd_size_type amt;
10068   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10069
10070   if (htab == NULL)
10071     return -1;
10072   /* Stash our params away.  */
10073   htab->add_stub_section = add_stub_section;
10074   htab->layout_sections_again = layout_sections_again;
10075
10076   if (htab->brlt == NULL)
10077     return 0;
10078
10079   /* Find the top input section id.  */
10080   for (input_bfd = info->input_bfds, top_id = 3;
10081        input_bfd != NULL;
10082        input_bfd = input_bfd->link_next)
10083     {
10084       for (section = input_bfd->sections;
10085            section != NULL;
10086            section = section->next)
10087         {
10088           if (top_id < section->id)
10089             top_id = section->id;
10090         }
10091     }
10092
10093   htab->top_id = top_id;
10094   amt = sizeof (struct map_stub) * (top_id + 1);
10095   htab->stub_group = bfd_zmalloc (amt);
10096   if (htab->stub_group == NULL)
10097     return -1;
10098
10099   /* Set toc_off for com, und, abs and ind sections.  */
10100   for (id = 0; id < 3; id++)
10101     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10102
10103   /* We can't use output_bfd->section_count here to find the top output
10104      section index as some sections may have been removed, and
10105      strip_excluded_output_sections doesn't renumber the indices.  */
10106   for (section = info->output_bfd->sections, top_index = 0;
10107        section != NULL;
10108        section = section->next)
10109     {
10110       if (top_index < section->index)
10111         top_index = section->index;
10112     }
10113
10114   htab->top_index = top_index;
10115   amt = sizeof (asection *) * (top_index + 1);
10116   input_list = bfd_zmalloc (amt);
10117   htab->input_list = input_list;
10118   if (input_list == NULL)
10119     return -1;
10120
10121   return 1;
10122 }
10123
10124 /* Set up for first pass at multitoc partitioning.  */
10125
10126 void
10127 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10128 {
10129   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10130
10131   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10132   htab->toc_curr = elf_gp (info->output_bfd);
10133   htab->toc_bfd = NULL;
10134   htab->toc_first_sec = NULL;
10135 }
10136
10137 /* The linker repeatedly calls this function for each TOC input section
10138    and linker generated GOT section.  Group input bfds such that the toc
10139    within a group is less than 64k in size.  */
10140
10141 bfd_boolean
10142 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10143 {
10144   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10145   bfd_vma addr, off, limit;
10146
10147   if (htab == NULL)
10148     return FALSE;
10149
10150   if (!htab->second_toc_pass)
10151     {
10152       /* Keep track of the first .toc or .got section for this input bfd.  */
10153       if (htab->toc_bfd != isec->owner)
10154         {
10155           htab->toc_bfd = isec->owner;
10156           htab->toc_first_sec = isec;
10157         }
10158
10159       addr = isec->output_offset + isec->output_section->vma;
10160       off = addr - htab->toc_curr;
10161       limit = 0x80008000;
10162       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10163         limit = 0x10000;
10164       if (off + isec->size > limit)
10165         {
10166           addr = (htab->toc_first_sec->output_offset
10167                   + htab->toc_first_sec->output_section->vma);
10168           htab->toc_curr = addr;
10169         }
10170
10171       /* toc_curr is the base address of this toc group.  Set elf_gp
10172          for the input section to be the offset relative to the
10173          output toc base plus 0x8000.  Making the input elf_gp an
10174          offset allows us to move the toc as a whole without
10175          recalculating input elf_gp.  */
10176       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10177       off += TOC_BASE_OFF;
10178
10179       /* Die if someone uses a linker script that doesn't keep input
10180          file .toc and .got together.  */
10181       if (elf_gp (isec->owner) != 0
10182           && elf_gp (isec->owner) != off)
10183         return FALSE;
10184
10185       elf_gp (isec->owner) = off;
10186       return TRUE;
10187     }
10188
10189   /* During the second pass toc_first_sec points to the start of
10190      a toc group, and toc_curr is used to track the old elf_gp.
10191      We use toc_bfd to ensure we only look at each bfd once.  */
10192   if (htab->toc_bfd == isec->owner)
10193     return TRUE;
10194   htab->toc_bfd = isec->owner;
10195
10196   if (htab->toc_first_sec == NULL
10197       || htab->toc_curr != elf_gp (isec->owner))
10198     {
10199       htab->toc_curr = elf_gp (isec->owner);
10200       htab->toc_first_sec = isec;
10201     }
10202   addr = (htab->toc_first_sec->output_offset
10203           + htab->toc_first_sec->output_section->vma);
10204   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10205   elf_gp (isec->owner) = off;
10206
10207   return TRUE;
10208 }
10209
10210 /* Called via elf_link_hash_traverse to merge GOT entries for global
10211    symbol H.  */
10212
10213 static bfd_boolean
10214 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10215 {
10216   if (h->root.type == bfd_link_hash_indirect)
10217     return TRUE;
10218
10219   merge_got_entries (&h->got.glist);
10220
10221   return TRUE;
10222 }
10223
10224 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10225    symbol H.  */
10226
10227 static bfd_boolean
10228 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10229 {
10230   struct got_entry *gent;
10231
10232   if (h->root.type == bfd_link_hash_indirect)
10233     return TRUE;
10234
10235   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10236     if (!gent->is_indirect)
10237       allocate_got (h, (struct bfd_link_info *) inf, gent);
10238   return TRUE;
10239 }
10240
10241 /* Called on the first multitoc pass after the last call to
10242    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10243    entries.  */
10244
10245 bfd_boolean
10246 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10247 {
10248   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10249   struct bfd *ibfd, *ibfd2;
10250   bfd_boolean done_something;
10251
10252   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10253
10254   if (!htab->do_multi_toc)
10255     return FALSE;
10256
10257   /* Merge global sym got entries within a toc group.  */
10258   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10259
10260   /* And tlsld_got.  */
10261   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10262     {
10263       struct got_entry *ent, *ent2;
10264
10265       if (!is_ppc64_elf (ibfd))
10266         continue;
10267
10268       ent = ppc64_tlsld_got (ibfd);
10269       if (!ent->is_indirect
10270           && ent->got.offset != (bfd_vma) -1)
10271         {
10272           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10273             {
10274               if (!is_ppc64_elf (ibfd2))
10275                 continue;
10276
10277               ent2 = ppc64_tlsld_got (ibfd2);
10278               if (!ent2->is_indirect
10279                   && ent2->got.offset != (bfd_vma) -1
10280                   && elf_gp (ibfd2) == elf_gp (ibfd))
10281                 {
10282                   ent2->is_indirect = TRUE;
10283                   ent2->got.ent = ent;
10284                 }
10285             }
10286         }
10287     }
10288
10289   /* Zap sizes of got sections.  */
10290   htab->reliplt->rawsize = htab->reliplt->size;
10291   htab->reliplt->size -= htab->got_reli_size;
10292   htab->got_reli_size = 0;
10293
10294   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10295     {
10296       asection *got, *relgot;
10297
10298       if (!is_ppc64_elf (ibfd))
10299         continue;
10300
10301       got = ppc64_elf_tdata (ibfd)->got;
10302       if (got != NULL)
10303         {
10304           got->rawsize = got->size;
10305           got->size = 0;
10306           relgot = ppc64_elf_tdata (ibfd)->relgot;
10307           relgot->rawsize = relgot->size;
10308           relgot->size = 0;
10309         }
10310     }
10311
10312   /* Now reallocate the got, local syms first.  We don't need to
10313      allocate section contents again since we never increase size.  */
10314   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10315     {
10316       struct got_entry **lgot_ents;
10317       struct got_entry **end_lgot_ents;
10318       struct plt_entry **local_plt;
10319       struct plt_entry **end_local_plt;
10320       unsigned char *lgot_masks;
10321       bfd_size_type locsymcount;
10322       Elf_Internal_Shdr *symtab_hdr;
10323       asection *s, *srel;
10324
10325       if (!is_ppc64_elf (ibfd))
10326         continue;
10327
10328       lgot_ents = elf_local_got_ents (ibfd);
10329       if (!lgot_ents)
10330         continue;
10331
10332       symtab_hdr = &elf_symtab_hdr (ibfd);
10333       locsymcount = symtab_hdr->sh_info;
10334       end_lgot_ents = lgot_ents + locsymcount;
10335       local_plt = (struct plt_entry **) end_lgot_ents;
10336       end_local_plt = local_plt + locsymcount;
10337       lgot_masks = (unsigned char *) end_local_plt;
10338       s = ppc64_elf_tdata (ibfd)->got;
10339       srel = ppc64_elf_tdata (ibfd)->relgot;
10340       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10341         {
10342           struct got_entry *ent;
10343
10344           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10345             {
10346               unsigned int num = 1;
10347               ent->got.offset = s->size;
10348               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10349                 num = 2;
10350               s->size += num * 8;
10351               if (info->shared)
10352                 srel->size += num * sizeof (Elf64_External_Rela);
10353               else if ((*lgot_masks & PLT_IFUNC) != 0)
10354                 {
10355                   htab->reliplt->size
10356                     += num * sizeof (Elf64_External_Rela);
10357                   htab->got_reli_size
10358                     += num * sizeof (Elf64_External_Rela);
10359                 }
10360             }
10361         }
10362     }
10363
10364   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10365
10366   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10367     {
10368       struct got_entry *ent;
10369
10370       if (!is_ppc64_elf (ibfd))
10371         continue;
10372
10373       ent = ppc64_tlsld_got (ibfd);
10374       if (!ent->is_indirect
10375           && ent->got.offset != (bfd_vma) -1)
10376         {
10377           asection *s = ppc64_elf_tdata (ibfd)->got;
10378           ent->got.offset = s->size;
10379           s->size += 16;
10380           if (info->shared)
10381             {
10382               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10383               srel->size += sizeof (Elf64_External_Rela);
10384             }
10385         }
10386     }
10387
10388   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10389   if (!done_something)
10390     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10391       {
10392         asection *got;
10393
10394         if (!is_ppc64_elf (ibfd))
10395           continue;
10396
10397         got = ppc64_elf_tdata (ibfd)->got;
10398         if (got != NULL)
10399           {
10400             done_something = got->rawsize != got->size;
10401             if (done_something)
10402               break;
10403           }
10404       }
10405
10406   if (done_something)
10407     (*htab->layout_sections_again) ();
10408
10409   /* Set up for second pass over toc sections to recalculate elf_gp
10410      on input sections.  */
10411   htab->toc_bfd = NULL;
10412   htab->toc_first_sec = NULL;
10413   htab->second_toc_pass = TRUE;
10414   return done_something;
10415 }
10416
10417 /* Called after second pass of multitoc partitioning.  */
10418
10419 void
10420 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10421 {
10422   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10423
10424   /* After the second pass, toc_curr tracks the TOC offset used
10425      for code sections below in ppc64_elf_next_input_section.  */
10426   htab->toc_curr = TOC_BASE_OFF;
10427 }
10428
10429 /* No toc references were found in ISEC.  If the code in ISEC makes no
10430    calls, then there's no need to use toc adjusting stubs when branching
10431    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10432    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10433    needed, and 2 if a cyclical call-graph was found but no other reason
10434    for a stub was detected.  If called from the top level, a return of
10435    2 means the same as a return of 0.  */
10436
10437 static int
10438 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10439 {
10440   int ret;
10441
10442   /* Mark this section as checked.  */
10443   isec->call_check_done = 1;
10444
10445   /* We know none of our code bearing sections will need toc stubs.  */
10446   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10447     return 0;
10448
10449   if (isec->size == 0)
10450     return 0;
10451
10452   if (isec->output_section == NULL)
10453     return 0;
10454
10455   ret = 0;
10456   if (isec->reloc_count != 0)
10457     {
10458       Elf_Internal_Rela *relstart, *rel;
10459       Elf_Internal_Sym *local_syms;
10460       struct ppc_link_hash_table *htab;
10461
10462       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10463                                             info->keep_memory);
10464       if (relstart == NULL)
10465         return -1;
10466
10467       /* Look for branches to outside of this section.  */
10468       local_syms = NULL;
10469       htab = ppc_hash_table (info);
10470       if (htab == NULL)
10471         return -1;
10472
10473       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10474         {
10475           enum elf_ppc64_reloc_type r_type;
10476           unsigned long r_symndx;
10477           struct elf_link_hash_entry *h;
10478           struct ppc_link_hash_entry *eh;
10479           Elf_Internal_Sym *sym;
10480           asection *sym_sec;
10481           struct _opd_sec_data *opd;
10482           bfd_vma sym_value;
10483           bfd_vma dest;
10484
10485           r_type = ELF64_R_TYPE (rel->r_info);
10486           if (r_type != R_PPC64_REL24
10487               && r_type != R_PPC64_REL14
10488               && r_type != R_PPC64_REL14_BRTAKEN
10489               && r_type != R_PPC64_REL14_BRNTAKEN)
10490             continue;
10491
10492           r_symndx = ELF64_R_SYM (rel->r_info);
10493           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10494                           isec->owner))
10495             {
10496               ret = -1;
10497               break;
10498             }
10499
10500           /* Calls to dynamic lib functions go through a plt call stub
10501              that uses r2.  */
10502           eh = (struct ppc_link_hash_entry *) h;
10503           if (eh != NULL
10504               && (eh->elf.plt.plist != NULL
10505                   || (eh->oh != NULL
10506                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10507             {
10508               ret = 1;
10509               break;
10510             }
10511
10512           if (sym_sec == NULL)
10513             /* Ignore other undefined symbols.  */
10514             continue;
10515
10516           /* Assume branches to other sections not included in the
10517              link need stubs too, to cover -R and absolute syms.  */
10518           if (sym_sec->output_section == NULL)
10519             {
10520               ret = 1;
10521               break;
10522             }
10523
10524           if (h == NULL)
10525             sym_value = sym->st_value;
10526           else
10527             {
10528               if (h->root.type != bfd_link_hash_defined
10529                   && h->root.type != bfd_link_hash_defweak)
10530                 abort ();
10531               sym_value = h->root.u.def.value;
10532             }
10533           sym_value += rel->r_addend;
10534
10535           /* If this branch reloc uses an opd sym, find the code section.  */
10536           opd = get_opd_info (sym_sec);
10537           if (opd != NULL)
10538             {
10539               if (h == NULL && opd->adjust != NULL)
10540                 {
10541                   long adjust;
10542
10543                   adjust = opd->adjust[sym->st_value / 8];
10544                   if (adjust == -1)
10545                     /* Assume deleted functions won't ever be called.  */
10546                     continue;
10547                   sym_value += adjust;
10548                 }
10549
10550               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10551               if (dest == (bfd_vma) -1)
10552                 continue;
10553             }
10554           else
10555             dest = (sym_value
10556                     + sym_sec->output_offset
10557                     + sym_sec->output_section->vma);
10558
10559           /* Ignore branch to self.  */
10560           if (sym_sec == isec)
10561             continue;
10562
10563           /* If the called function uses the toc, we need a stub.  */
10564           if (sym_sec->has_toc_reloc
10565               || sym_sec->makes_toc_func_call)
10566             {
10567               ret = 1;
10568               break;
10569             }
10570
10571           /* Assume any branch that needs a long branch stub might in fact
10572              need a plt_branch stub.  A plt_branch stub uses r2.  */
10573           else if (dest - (isec->output_offset
10574                            + isec->output_section->vma
10575                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10576             {
10577               ret = 1;
10578               break;
10579             }
10580
10581           /* If calling back to a section in the process of being
10582              tested, we can't say for sure that no toc adjusting stubs
10583              are needed, so don't return zero.  */
10584           else if (sym_sec->call_check_in_progress)
10585             ret = 2;
10586
10587           /* Branches to another section that itself doesn't have any TOC
10588              references are OK.  Recursively call ourselves to check.  */
10589           else if (!sym_sec->call_check_done)
10590             {
10591               int recur;
10592
10593               /* Mark current section as indeterminate, so that other
10594                  sections that call back to current won't be marked as
10595                  known.  */
10596               isec->call_check_in_progress = 1;
10597               recur = toc_adjusting_stub_needed (info, sym_sec);
10598               isec->call_check_in_progress = 0;
10599
10600               if (recur != 0)
10601                 {
10602                   ret = recur;
10603                   if (recur != 2)
10604                     break;
10605                 }
10606             }
10607         }
10608
10609       if (local_syms != NULL
10610           && (elf_symtab_hdr (isec->owner).contents
10611               != (unsigned char *) local_syms))
10612         free (local_syms);
10613       if (elf_section_data (isec)->relocs != relstart)
10614         free (relstart);
10615     }
10616
10617   if ((ret & 1) == 0
10618       && isec->map_head.s != NULL
10619       && (strcmp (isec->output_section->name, ".init") == 0
10620           || strcmp (isec->output_section->name, ".fini") == 0))
10621     {
10622       if (isec->map_head.s->has_toc_reloc
10623           || isec->map_head.s->makes_toc_func_call)
10624         ret = 1;
10625       else if (!isec->map_head.s->call_check_done)
10626         {
10627           int recur;
10628           isec->call_check_in_progress = 1;
10629           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10630           isec->call_check_in_progress = 0;
10631           if (recur != 0)
10632             ret = recur;
10633         }
10634     }
10635
10636   if (ret == 1)
10637     isec->makes_toc_func_call = 1;
10638
10639   return ret;
10640 }
10641
10642 /* The linker repeatedly calls this function for each input section,
10643    in the order that input sections are linked into output sections.
10644    Build lists of input sections to determine groupings between which
10645    we may insert linker stubs.  */
10646
10647 bfd_boolean
10648 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10649 {
10650   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10651
10652   if (htab == NULL)
10653     return FALSE;
10654
10655   if ((isec->output_section->flags & SEC_CODE) != 0
10656       && isec->output_section->index <= htab->top_index)
10657     {
10658       asection **list = htab->input_list + isec->output_section->index;
10659       /* Steal the link_sec pointer for our list.  */
10660 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10661       /* This happens to make the list in reverse order,
10662          which is what we want.  */
10663       PREV_SEC (isec) = *list;
10664       *list = isec;
10665     }
10666
10667   if (htab->multi_toc_needed)
10668     {
10669       /* If a code section has a function that uses the TOC then we need
10670          to use the right TOC (obviously).  Also, make sure that .opd gets
10671          the correct TOC value for R_PPC64_TOC relocs that don't have or
10672          can't find their function symbol (shouldn't ever happen now).
10673          Also specially treat .fixup for the linux kernel.  .fixup
10674          contains branches, but only back to the function that hit an
10675          exception.  */
10676       if (isec->has_toc_reloc
10677           || (isec->flags & SEC_CODE) == 0
10678           || strcmp (isec->name, ".fixup") == 0)
10679         {
10680           if (elf_gp (isec->owner) != 0)
10681             htab->toc_curr = elf_gp (isec->owner);
10682         }
10683       else
10684         {
10685           if (!isec->call_check_done
10686               && toc_adjusting_stub_needed (info, isec) < 0)
10687             return FALSE;
10688           /* If we make a local call from this section, ie. a branch
10689              without a following nop, then we have no place to put a
10690              toc restoring insn.  We must use the same toc group as
10691              the callee.
10692              Testing makes_toc_func_call actually tests for *any*
10693              calls to functions that need a good toc pointer.  A more
10694              precise test would be better, as this one will set
10695              incorrect values for pasted .init/.fini fragments.
10696              (Fixed later in check_pasted_section.)  */
10697           if (isec->makes_toc_func_call
10698               && elf_gp (isec->owner) != 0)
10699             htab->toc_curr = elf_gp (isec->owner);
10700         }
10701     }
10702
10703   /* Functions that don't use the TOC can belong in any TOC group.
10704      Use the last TOC base.  */
10705   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10706   return TRUE;
10707 }
10708
10709 /* Check that all .init and .fini sections use the same toc, if they
10710    have toc relocs.  */
10711
10712 static bfd_boolean
10713 check_pasted_section (struct bfd_link_info *info, const char *name)
10714 {
10715   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10716
10717   if (o != NULL)
10718     {
10719       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10720       bfd_vma toc_off = 0;
10721       asection *i;
10722
10723       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10724         if (i->has_toc_reloc)
10725           {
10726             if (toc_off == 0)
10727               toc_off = htab->stub_group[i->id].toc_off;
10728             else if (toc_off != htab->stub_group[i->id].toc_off)
10729               return FALSE;
10730           }
10731
10732       if (toc_off == 0)
10733         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10734           if (i->makes_toc_func_call)
10735             {
10736               toc_off = htab->stub_group[i->id].toc_off;
10737               break;
10738             }
10739
10740       /* Make sure the whole pasted function uses the same toc offset.  */
10741       if (toc_off != 0)
10742         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10743           htab->stub_group[i->id].toc_off = toc_off;
10744     }
10745   return TRUE;
10746 }
10747
10748 bfd_boolean
10749 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10750 {
10751   return (check_pasted_section (info, ".init")
10752           & check_pasted_section (info, ".fini"));
10753 }
10754
10755 /* See whether we can group stub sections together.  Grouping stub
10756    sections may result in fewer stubs.  More importantly, we need to
10757    put all .init* and .fini* stubs at the beginning of the .init or
10758    .fini output sections respectively, because glibc splits the
10759    _init and _fini functions into multiple parts.  Putting a stub in
10760    the middle of a function is not a good idea.  */
10761
10762 static void
10763 group_sections (struct ppc_link_hash_table *htab,
10764                 bfd_size_type stub_group_size,
10765                 bfd_boolean stubs_always_before_branch)
10766 {
10767   asection **list;
10768   bfd_size_type stub14_group_size;
10769   bfd_boolean suppress_size_errors;
10770
10771   suppress_size_errors = FALSE;
10772   stub14_group_size = stub_group_size;
10773   if (stub_group_size == 1)
10774     {
10775       /* Default values.  */
10776       if (stubs_always_before_branch)
10777         {
10778           stub_group_size = 0x1e00000;
10779           stub14_group_size = 0x7800;
10780         }
10781       else
10782         {
10783           stub_group_size = 0x1c00000;
10784           stub14_group_size = 0x7000;
10785         }
10786       suppress_size_errors = TRUE;
10787     }
10788
10789   list = htab->input_list + htab->top_index;
10790   do
10791     {
10792       asection *tail = *list;
10793       while (tail != NULL)
10794         {
10795           asection *curr;
10796           asection *prev;
10797           bfd_size_type total;
10798           bfd_boolean big_sec;
10799           bfd_vma curr_toc;
10800
10801           curr = tail;
10802           total = tail->size;
10803           big_sec = total > (ppc64_elf_section_data (tail) != NULL
10804                              && ppc64_elf_section_data (tail)->has_14bit_branch
10805                              ? stub14_group_size : stub_group_size);
10806           if (big_sec && !suppress_size_errors)
10807             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10808                                      tail->owner, tail);
10809           curr_toc = htab->stub_group[tail->id].toc_off;
10810
10811           while ((prev = PREV_SEC (curr)) != NULL
10812                  && ((total += curr->output_offset - prev->output_offset)
10813                      < (ppc64_elf_section_data (prev) != NULL
10814                         && ppc64_elf_section_data (prev)->has_14bit_branch
10815                         ? stub14_group_size : stub_group_size))
10816                  && htab->stub_group[prev->id].toc_off == curr_toc)
10817             curr = prev;
10818
10819           /* OK, the size from the start of CURR to the end is less
10820              than stub_group_size and thus can be handled by one stub
10821              section.  (or the tail section is itself larger than
10822              stub_group_size, in which case we may be toast.)  We
10823              should really be keeping track of the total size of stubs
10824              added here, as stubs contribute to the final output
10825              section size.  That's a little tricky, and this way will
10826              only break if stubs added make the total size more than
10827              2^25, ie. for the default stub_group_size, if stubs total
10828              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10829           do
10830             {
10831               prev = PREV_SEC (tail);
10832               /* Set up this stub group.  */
10833               htab->stub_group[tail->id].link_sec = curr;
10834             }
10835           while (tail != curr && (tail = prev) != NULL);
10836
10837           /* But wait, there's more!  Input sections up to stub_group_size
10838              bytes before the stub section can be handled by it too.
10839              Don't do this if we have a really large section after the
10840              stubs, as adding more stubs increases the chance that
10841              branches may not reach into the stub section.  */
10842           if (!stubs_always_before_branch && !big_sec)
10843             {
10844               total = 0;
10845               while (prev != NULL
10846                      && ((total += tail->output_offset - prev->output_offset)
10847                          < (ppc64_elf_section_data (prev) != NULL
10848                             && ppc64_elf_section_data (prev)->has_14bit_branch
10849                             ? stub14_group_size : stub_group_size))
10850                      && htab->stub_group[prev->id].toc_off == curr_toc)
10851                 {
10852                   tail = prev;
10853                   prev = PREV_SEC (tail);
10854                   htab->stub_group[tail->id].link_sec = curr;
10855                 }
10856             }
10857           tail = prev;
10858         }
10859     }
10860   while (list-- != htab->input_list);
10861   free (htab->input_list);
10862 #undef PREV_SEC
10863 }
10864
10865 static const unsigned char glink_eh_frame_cie[] =
10866 {
10867   0, 0, 0, 16,                          /* length.  */
10868   0, 0, 0, 0,                           /* id.  */
10869   1,                                    /* CIE version.  */
10870   'z', 'R', 0,                          /* Augmentation string.  */
10871   4,                                    /* Code alignment.  */
10872   0x78,                                 /* Data alignment.  */
10873   65,                                   /* RA reg.  */
10874   1,                                    /* Augmentation size.  */
10875   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
10876   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
10877 };
10878
10879 /* Stripping output sections is normally done before dynamic section
10880    symbols have been allocated.  This function is called later, and
10881    handles cases like htab->brlt which is mapped to its own output
10882    section.  */
10883
10884 static void
10885 maybe_strip_output (struct bfd_link_info *info, asection *isec)
10886 {
10887   if (isec->size == 0
10888       && isec->output_section->size == 0
10889       && !bfd_section_removed_from_list (info->output_bfd,
10890                                          isec->output_section)
10891       && elf_section_data (isec->output_section)->dynindx == 0)
10892     {
10893       isec->output_section->flags |= SEC_EXCLUDE;
10894       bfd_section_list_remove (info->output_bfd, isec->output_section);
10895       info->output_bfd->section_count--;
10896     }
10897 }
10898
10899 /* Determine and set the size of the stub section for a final link.
10900
10901    The basic idea here is to examine all the relocations looking for
10902    PC-relative calls to a target that is unreachable with a "bl"
10903    instruction.  */
10904
10905 bfd_boolean
10906 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
10907                       bfd_boolean plt_static_chain)
10908 {
10909   bfd_size_type stub_group_size;
10910   bfd_boolean stubs_always_before_branch;
10911   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10912
10913   if (htab == NULL)
10914     return FALSE;
10915
10916   htab->plt_static_chain = plt_static_chain;
10917   stubs_always_before_branch = group_size < 0;
10918   if (group_size < 0)
10919     stub_group_size = -group_size;
10920   else
10921     stub_group_size = group_size;
10922
10923   group_sections (htab, stub_group_size, stubs_always_before_branch);
10924
10925   while (1)
10926     {
10927       bfd *input_bfd;
10928       unsigned int bfd_indx;
10929       asection *stub_sec;
10930
10931       htab->stub_iteration += 1;
10932
10933       for (input_bfd = info->input_bfds, bfd_indx = 0;
10934            input_bfd != NULL;
10935            input_bfd = input_bfd->link_next, bfd_indx++)
10936         {
10937           Elf_Internal_Shdr *symtab_hdr;
10938           asection *section;
10939           Elf_Internal_Sym *local_syms = NULL;
10940
10941           if (!is_ppc64_elf (input_bfd))
10942             continue;
10943
10944           /* We'll need the symbol table in a second.  */
10945           symtab_hdr = &elf_symtab_hdr (input_bfd);
10946           if (symtab_hdr->sh_info == 0)
10947             continue;
10948
10949           /* Walk over each section attached to the input bfd.  */
10950           for (section = input_bfd->sections;
10951                section != NULL;
10952                section = section->next)
10953             {
10954               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10955
10956               /* If there aren't any relocs, then there's nothing more
10957                  to do.  */
10958               if ((section->flags & SEC_RELOC) == 0
10959                   || (section->flags & SEC_ALLOC) == 0
10960                   || (section->flags & SEC_LOAD) == 0
10961                   || (section->flags & SEC_CODE) == 0
10962                   || section->reloc_count == 0)
10963                 continue;
10964
10965               /* If this section is a link-once section that will be
10966                  discarded, then don't create any stubs.  */
10967               if (section->output_section == NULL
10968                   || section->output_section->owner != info->output_bfd)
10969                 continue;
10970
10971               /* Get the relocs.  */
10972               internal_relocs
10973                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10974                                              info->keep_memory);
10975               if (internal_relocs == NULL)
10976                 goto error_ret_free_local;
10977
10978               /* Now examine each relocation.  */
10979               irela = internal_relocs;
10980               irelaend = irela + section->reloc_count;
10981               for (; irela < irelaend; irela++)
10982                 {
10983                   enum elf_ppc64_reloc_type r_type;
10984                   unsigned int r_indx;
10985                   enum ppc_stub_type stub_type;
10986                   struct ppc_stub_hash_entry *stub_entry;
10987                   asection *sym_sec, *code_sec;
10988                   bfd_vma sym_value, code_value;
10989                   bfd_vma destination;
10990                   bfd_boolean ok_dest;
10991                   struct ppc_link_hash_entry *hash;
10992                   struct ppc_link_hash_entry *fdh;
10993                   struct elf_link_hash_entry *h;
10994                   Elf_Internal_Sym *sym;
10995                   char *stub_name;
10996                   const asection *id_sec;
10997                   struct _opd_sec_data *opd;
10998                   struct plt_entry *plt_ent;
10999
11000                   r_type = ELF64_R_TYPE (irela->r_info);
11001                   r_indx = ELF64_R_SYM (irela->r_info);
11002
11003                   if (r_type >= R_PPC64_max)
11004                     {
11005                       bfd_set_error (bfd_error_bad_value);
11006                       goto error_ret_free_internal;
11007                     }
11008
11009                   /* Only look for stubs on branch instructions.  */
11010                   if (r_type != R_PPC64_REL24
11011                       && r_type != R_PPC64_REL14
11012                       && r_type != R_PPC64_REL14_BRTAKEN
11013                       && r_type != R_PPC64_REL14_BRNTAKEN)
11014                     continue;
11015
11016                   /* Now determine the call target, its name, value,
11017                      section.  */
11018                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11019                                   r_indx, input_bfd))
11020                     goto error_ret_free_internal;
11021                   hash = (struct ppc_link_hash_entry *) h;
11022
11023                   ok_dest = FALSE;
11024                   fdh = NULL;
11025                   sym_value = 0;
11026                   if (hash == NULL)
11027                     {
11028                       sym_value = sym->st_value;
11029                       ok_dest = TRUE;
11030                     }
11031                   else if (hash->elf.root.type == bfd_link_hash_defined
11032                            || hash->elf.root.type == bfd_link_hash_defweak)
11033                     {
11034                       sym_value = hash->elf.root.u.def.value;
11035                       if (sym_sec->output_section != NULL)
11036                         ok_dest = TRUE;
11037                     }
11038                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11039                            || hash->elf.root.type == bfd_link_hash_undefined)
11040                     {
11041                       /* Recognise an old ABI func code entry sym, and
11042                          use the func descriptor sym instead if it is
11043                          defined.  */
11044                       if (hash->elf.root.root.string[0] == '.'
11045                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11046                         {
11047                           if (fdh->elf.root.type == bfd_link_hash_defined
11048                               || fdh->elf.root.type == bfd_link_hash_defweak)
11049                             {
11050                               sym_sec = fdh->elf.root.u.def.section;
11051                               sym_value = fdh->elf.root.u.def.value;
11052                               if (sym_sec->output_section != NULL)
11053                                 ok_dest = TRUE;
11054                             }
11055                           else
11056                             fdh = NULL;
11057                         }
11058                     }
11059                   else
11060                     {
11061                       bfd_set_error (bfd_error_bad_value);
11062                       goto error_ret_free_internal;
11063                     }
11064
11065                   destination = 0;
11066                   if (ok_dest)
11067                     {
11068                       sym_value += irela->r_addend;
11069                       destination = (sym_value
11070                                      + sym_sec->output_offset
11071                                      + sym_sec->output_section->vma);
11072                     }
11073
11074                   code_sec = sym_sec;
11075                   code_value = sym_value;
11076                   opd = get_opd_info (sym_sec);
11077                   if (opd != NULL)
11078                     {
11079                       bfd_vma dest;
11080
11081                       if (hash == NULL && opd->adjust != NULL)
11082                         {
11083                           long adjust = opd->adjust[sym_value / 8];
11084                           if (adjust == -1)
11085                             continue;
11086                           code_value += adjust;
11087                           sym_value += adjust;
11088                         }
11089                       dest = opd_entry_value (sym_sec, sym_value,
11090                                               &code_sec, &code_value);
11091                       if (dest != (bfd_vma) -1)
11092                         {
11093                           destination = dest;
11094                           if (fdh != NULL)
11095                             {
11096                               /* Fixup old ABI sym to point at code
11097                                  entry.  */
11098                               hash->elf.root.type = bfd_link_hash_defweak;
11099                               hash->elf.root.u.def.section = code_sec;
11100                               hash->elf.root.u.def.value = code_value;
11101                             }
11102                         }
11103                     }
11104
11105                   /* Determine what (if any) linker stub is needed.  */
11106                   plt_ent = NULL;
11107                   stub_type = ppc_type_of_stub (section, irela, &hash,
11108                                                 &plt_ent, destination);
11109
11110                   if (stub_type != ppc_stub_plt_call)
11111                     {
11112                       /* Check whether we need a TOC adjusting stub.
11113                          Since the linker pastes together pieces from
11114                          different object files when creating the
11115                          _init and _fini functions, it may be that a
11116                          call to what looks like a local sym is in
11117                          fact a call needing a TOC adjustment.  */
11118                       if (code_sec != NULL
11119                           && code_sec->output_section != NULL
11120                           && (htab->stub_group[code_sec->id].toc_off
11121                               != htab->stub_group[section->id].toc_off)
11122                           && (code_sec->has_toc_reloc
11123                               || code_sec->makes_toc_func_call))
11124                         stub_type = ppc_stub_long_branch_r2off;
11125                     }
11126
11127                   if (stub_type == ppc_stub_none)
11128                     continue;
11129
11130                   /* __tls_get_addr calls might be eliminated.  */
11131                   if (stub_type != ppc_stub_plt_call
11132                       && hash != NULL
11133                       && (hash == htab->tls_get_addr
11134                           || hash == htab->tls_get_addr_fd)
11135                       && section->has_tls_reloc
11136                       && irela != internal_relocs)
11137                     {
11138                       /* Get tls info.  */
11139                       unsigned char *tls_mask;
11140
11141                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11142                                          irela - 1, input_bfd))
11143                         goto error_ret_free_internal;
11144                       if (*tls_mask != 0)
11145                         continue;
11146                     }
11147
11148                   /* Support for grouping stub sections.  */
11149                   id_sec = htab->stub_group[section->id].link_sec;
11150
11151                   /* Get the name of this stub.  */
11152                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11153                   if (!stub_name)
11154                     goto error_ret_free_internal;
11155
11156                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11157                                                      stub_name, FALSE, FALSE);
11158                   if (stub_entry != NULL)
11159                     {
11160                       /* The proper stub has already been created.  */
11161                       free (stub_name);
11162                       continue;
11163                     }
11164
11165                   stub_entry = ppc_add_stub (stub_name, section, info);
11166                   if (stub_entry == NULL)
11167                     {
11168                       free (stub_name);
11169                     error_ret_free_internal:
11170                       if (elf_section_data (section)->relocs == NULL)
11171                         free (internal_relocs);
11172                     error_ret_free_local:
11173                       if (local_syms != NULL
11174                           && (symtab_hdr->contents
11175                               != (unsigned char *) local_syms))
11176                         free (local_syms);
11177                       return FALSE;
11178                     }
11179
11180                   stub_entry->stub_type = stub_type;
11181                   if (stub_type != ppc_stub_plt_call)
11182                     {
11183                       stub_entry->target_value = code_value;
11184                       stub_entry->target_section = code_sec;
11185                     }
11186                   else
11187                     {
11188                       stub_entry->target_value = sym_value;
11189                       stub_entry->target_section = sym_sec;
11190                     }
11191                   stub_entry->h = hash;
11192                   stub_entry->plt_ent = plt_ent;
11193                   stub_entry->addend = irela->r_addend;
11194
11195                   if (stub_entry->h != NULL)
11196                     htab->stub_globals += 1;
11197                 }
11198
11199               /* We're done with the internal relocs, free them.  */
11200               if (elf_section_data (section)->relocs != internal_relocs)
11201                 free (internal_relocs);
11202             }
11203
11204           if (local_syms != NULL
11205               && symtab_hdr->contents != (unsigned char *) local_syms)
11206             {
11207               if (!info->keep_memory)
11208                 free (local_syms);
11209               else
11210                 symtab_hdr->contents = (unsigned char *) local_syms;
11211             }
11212         }
11213
11214       /* We may have added some stubs.  Find out the new size of the
11215          stub sections.  */
11216       for (stub_sec = htab->stub_bfd->sections;
11217            stub_sec != NULL;
11218            stub_sec = stub_sec->next)
11219         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11220           {
11221             stub_sec->rawsize = stub_sec->size;
11222             stub_sec->size = 0;
11223             stub_sec->reloc_count = 0;
11224             stub_sec->flags &= ~SEC_RELOC;
11225           }
11226
11227       htab->brlt->size = 0;
11228       htab->brlt->reloc_count = 0;
11229       htab->brlt->flags &= ~SEC_RELOC;
11230       if (htab->relbrlt != NULL)
11231         htab->relbrlt->size = 0;
11232
11233       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11234
11235       if (info->emitrelocations
11236           && htab->glink != NULL && htab->glink->size != 0)
11237         {
11238           htab->glink->reloc_count = 1;
11239           htab->glink->flags |= SEC_RELOC;
11240         }
11241
11242       if (htab->glink_eh_frame != NULL
11243           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11244           && (htab->glink_eh_frame->flags & SEC_EXCLUDE) == 0)
11245         {
11246           bfd_size_type size = 0;
11247
11248           for (stub_sec = htab->stub_bfd->sections;
11249                stub_sec != NULL;
11250                stub_sec = stub_sec->next)
11251             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11252               size += 20;
11253           if (htab->glink != NULL && htab->glink->size != 0)
11254             size += 24;
11255           if (size != 0)
11256             size += sizeof (glink_eh_frame_cie);
11257           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11258           htab->glink_eh_frame->size = size;
11259         }
11260
11261       for (stub_sec = htab->stub_bfd->sections;
11262            stub_sec != NULL;
11263            stub_sec = stub_sec->next)
11264         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11265             && stub_sec->rawsize != stub_sec->size)
11266           break;
11267
11268       /* Exit from this loop when no stubs have been added, and no stubs
11269          have changed size.  */
11270       if (stub_sec == NULL
11271           && (htab->glink_eh_frame == NULL
11272               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11273         break;
11274
11275       /* Ask the linker to do its stuff.  */
11276       (*htab->layout_sections_again) ();
11277     }
11278
11279   maybe_strip_output (info, htab->brlt);
11280   if (htab->glink_eh_frame != NULL)
11281     maybe_strip_output (info, htab->glink_eh_frame);
11282
11283   return TRUE;
11284 }
11285
11286 /* Called after we have determined section placement.  If sections
11287    move, we'll be called again.  Provide a value for TOCstart.  */
11288
11289 bfd_vma
11290 ppc64_elf_toc (bfd *obfd)
11291 {
11292   asection *s;
11293   bfd_vma TOCstart;
11294
11295   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11296      order.  The TOC starts where the first of these sections starts.  */
11297   s = bfd_get_section_by_name (obfd, ".got");
11298   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11299     s = bfd_get_section_by_name (obfd, ".toc");
11300   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11301     s = bfd_get_section_by_name (obfd, ".tocbss");
11302   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11303     s = bfd_get_section_by_name (obfd, ".plt");
11304   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11305     {
11306       /* This may happen for
11307          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11308          .toc directive
11309          o  bad linker script
11310          o --gc-sections and empty TOC sections
11311
11312          FIXME: Warn user?  */
11313
11314       /* Look for a likely section.  We probably won't even be
11315          using TOCstart.  */
11316       for (s = obfd->sections; s != NULL; s = s->next)
11317         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11318                          | SEC_EXCLUDE))
11319             == (SEC_ALLOC | SEC_SMALL_DATA))
11320           break;
11321       if (s == NULL)
11322         for (s = obfd->sections; s != NULL; s = s->next)
11323           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11324               == (SEC_ALLOC | SEC_SMALL_DATA))
11325             break;
11326       if (s == NULL)
11327         for (s = obfd->sections; s != NULL; s = s->next)
11328           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11329               == SEC_ALLOC)
11330             break;
11331       if (s == NULL)
11332         for (s = obfd->sections; s != NULL; s = s->next)
11333           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11334             break;
11335     }
11336
11337   TOCstart = 0;
11338   if (s != NULL)
11339     TOCstart = s->output_section->vma + s->output_offset;
11340
11341   return TOCstart;
11342 }
11343
11344 /* Build all the stubs associated with the current output file.
11345    The stubs are kept in a hash table attached to the main linker
11346    hash table.  This function is called via gldelf64ppc_finish.  */
11347
11348 bfd_boolean
11349 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11350                        struct bfd_link_info *info,
11351                        char **stats)
11352 {
11353   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11354   asection *stub_sec;
11355   bfd_byte *p;
11356   int stub_sec_count = 0;
11357
11358   if (htab == NULL)
11359     return FALSE;
11360
11361   htab->emit_stub_syms = emit_stub_syms;
11362
11363   /* Allocate memory to hold the linker stubs.  */
11364   for (stub_sec = htab->stub_bfd->sections;
11365        stub_sec != NULL;
11366        stub_sec = stub_sec->next)
11367     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11368         && stub_sec->size != 0)
11369       {
11370         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11371         if (stub_sec->contents == NULL)
11372           return FALSE;
11373         /* We want to check that built size is the same as calculated
11374            size.  rawsize is a convenient location to use.  */
11375         stub_sec->rawsize = stub_sec->size;
11376         stub_sec->size = 0;
11377       }
11378
11379   if (htab->glink != NULL && htab->glink->size != 0)
11380     {
11381       unsigned int indx;
11382       bfd_vma plt0;
11383
11384       /* Build the .glink plt call stub.  */
11385       if (htab->emit_stub_syms)
11386         {
11387           struct elf_link_hash_entry *h;
11388           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11389                                     TRUE, FALSE, FALSE);
11390           if (h == NULL)
11391             return FALSE;
11392           if (h->root.type == bfd_link_hash_new)
11393             {
11394               h->root.type = bfd_link_hash_defined;
11395               h->root.u.def.section = htab->glink;
11396               h->root.u.def.value = 8;
11397               h->ref_regular = 1;
11398               h->def_regular = 1;
11399               h->ref_regular_nonweak = 1;
11400               h->forced_local = 1;
11401               h->non_elf = 0;
11402             }
11403         }
11404       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11405       if (info->emitrelocations)
11406         {
11407           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11408           if (r == NULL)
11409             return FALSE;
11410           r->r_offset = (htab->glink->output_offset
11411                          + htab->glink->output_section->vma);
11412           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11413           r->r_addend = plt0;
11414         }
11415       p = htab->glink->contents;
11416       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11417       bfd_put_64 (htab->glink->owner, plt0, p);
11418       p += 8;
11419       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11420       p += 4;
11421       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11422       p += 4;
11423       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11424       p += 4;
11425       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11426       p += 4;
11427       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11428       p += 4;
11429       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11430       p += 4;
11431       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11432       p += 4;
11433       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11434       p += 4;
11435       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11436       p += 4;
11437       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11438       p += 4;
11439       bfd_put_32 (htab->glink->owner, BCTR, p);
11440       p += 4;
11441       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11442         {
11443           bfd_put_32 (htab->glink->owner, NOP, p);
11444           p += 4;
11445         }
11446
11447       /* Build the .glink lazy link call stubs.  */
11448       indx = 0;
11449       while (p < htab->glink->contents + htab->glink->size)
11450         {
11451           if (indx < 0x8000)
11452             {
11453               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11454               p += 4;
11455             }
11456           else
11457             {
11458               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11459               p += 4;
11460               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11461               p += 4;
11462             }
11463           bfd_put_32 (htab->glink->owner,
11464                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11465           indx++;
11466           p += 4;
11467         }
11468       htab->glink->rawsize = p - htab->glink->contents;
11469     }
11470
11471   if (htab->brlt->size != 0)
11472     {
11473       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11474                                          htab->brlt->size);
11475       if (htab->brlt->contents == NULL)
11476         return FALSE;
11477     }
11478   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11479     {
11480       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11481                                             htab->relbrlt->size);
11482       if (htab->relbrlt->contents == NULL)
11483         return FALSE;
11484     }
11485
11486   if (htab->glink_eh_frame != NULL
11487       && htab->glink_eh_frame->size != 0)
11488     {
11489       bfd_vma val;
11490
11491       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
11492       if (p == NULL)
11493         return FALSE;
11494       htab->glink_eh_frame->contents = p;
11495
11496       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11497
11498       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
11499       /* CIE length (rewrite in case little-endian).  */
11500       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
11501       p += sizeof (glink_eh_frame_cie);
11502
11503       for (stub_sec = htab->stub_bfd->sections;
11504            stub_sec != NULL;
11505            stub_sec = stub_sec->next)
11506         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11507           {
11508             /* FDE length.  */
11509             bfd_put_32 (htab->elf.dynobj, 16, p);
11510             p += 4;
11511             /* CIE pointer.  */
11512             val = p - htab->glink_eh_frame->contents;
11513             bfd_put_32 (htab->elf.dynobj, val, p);
11514             p += 4;
11515             /* Offset to stub section.  */
11516             val = (stub_sec->output_section->vma
11517                    + stub_sec->output_offset);
11518             val -= (htab->glink_eh_frame->output_section->vma
11519                     + htab->glink_eh_frame->output_offset);
11520             val -= p - htab->glink_eh_frame->contents;
11521             if (val + 0x80000000 > 0xffffffff)
11522               {
11523                 info->callbacks->einfo
11524                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11525                    stub_sec->name);
11526                 return FALSE;
11527               }
11528             bfd_put_32 (htab->elf.dynobj, val, p);
11529             p += 4;
11530             /* stub section size.  */
11531             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
11532             p += 4;
11533             /* Augmentation.  */
11534             p += 1;
11535             /* Pad.  */
11536             p += 3;
11537           }
11538       if (htab->glink != NULL && htab->glink->size != 0)
11539         {
11540           /* FDE length.  */
11541           bfd_put_32 (htab->elf.dynobj, 20, p);
11542           p += 4;
11543           /* CIE pointer.  */
11544           val = p - htab->glink_eh_frame->contents;
11545           bfd_put_32 (htab->elf.dynobj, val, p);
11546           p += 4;
11547           /* Offset to .glink.  */
11548           val = (htab->glink->output_section->vma
11549                  + htab->glink->output_offset
11550                  + 8);
11551           val -= (htab->glink_eh_frame->output_section->vma
11552                   + htab->glink_eh_frame->output_offset);
11553           val -= p - htab->glink_eh_frame->contents;
11554           if (val + 0x80000000 > 0xffffffff)
11555             {
11556               info->callbacks->einfo
11557                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11558                  htab->glink->name);
11559               return FALSE;
11560             }
11561           bfd_put_32 (htab->elf.dynobj, val, p);
11562           p += 4;
11563           /* .glink size.  */
11564           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
11565           p += 4;
11566           /* Augmentation.  */
11567           p += 1;
11568
11569           *p++ = DW_CFA_advance_loc + 1;
11570           *p++ = DW_CFA_register;
11571           *p++ = 65;
11572           *p++ = 12;
11573           *p++ = DW_CFA_advance_loc + 4;
11574           *p++ = DW_CFA_restore_extended;
11575           *p++ = 65;
11576         }
11577       htab->glink_eh_frame->size = p - htab->glink_eh_frame->contents;
11578     }
11579
11580   /* Build the stubs as directed by the stub hash table.  */
11581   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11582
11583   if (htab->relbrlt != NULL)
11584     htab->relbrlt->reloc_count = 0;
11585
11586   for (stub_sec = htab->stub_bfd->sections;
11587        stub_sec != NULL;
11588        stub_sec = stub_sec->next)
11589     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11590       {
11591         stub_sec_count += 1;
11592         if (stub_sec->rawsize != stub_sec->size)
11593           break;
11594       }
11595
11596   if (stub_sec != NULL
11597       || htab->glink->rawsize != htab->glink->size
11598       || (htab->glink_eh_frame != NULL
11599           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
11600     {
11601       htab->stub_error = TRUE;
11602       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
11603     }
11604
11605   if (htab->stub_error)
11606     return FALSE;
11607
11608   if (stats != NULL)
11609     {
11610       *stats = bfd_malloc (500);
11611       if (*stats == NULL)
11612         return FALSE;
11613
11614       sprintf (*stats, _("linker stubs in %u group%s\n"
11615                          "  branch       %lu\n"
11616                          "  toc adjust   %lu\n"
11617                          "  long branch  %lu\n"
11618                          "  long toc adj %lu\n"
11619                          "  plt call     %lu"),
11620                stub_sec_count,
11621                stub_sec_count == 1 ? "" : "s",
11622                htab->stub_count[ppc_stub_long_branch - 1],
11623                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11624                htab->stub_count[ppc_stub_plt_branch - 1],
11625                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11626                htab->stub_count[ppc_stub_plt_call - 1]);
11627     }
11628   return TRUE;
11629 }
11630
11631 /* This function undoes the changes made by add_symbol_adjust.  */
11632
11633 static bfd_boolean
11634 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11635 {
11636   struct ppc_link_hash_entry *eh;
11637
11638   if (h->root.type == bfd_link_hash_indirect)
11639     return TRUE;
11640
11641   eh = (struct ppc_link_hash_entry *) h;
11642   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11643     return TRUE;
11644
11645   eh->elf.root.type = bfd_link_hash_undefined;
11646   return TRUE;
11647 }
11648
11649 void
11650 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11651 {
11652   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11653
11654   if (htab != NULL)
11655     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11656 }
11657
11658 /* What to do when ld finds relocations against symbols defined in
11659    discarded sections.  */
11660
11661 static unsigned int
11662 ppc64_elf_action_discarded (asection *sec)
11663 {
11664   if (strcmp (".opd", sec->name) == 0)
11665     return 0;
11666
11667   if (strcmp (".toc", sec->name) == 0)
11668     return 0;
11669
11670   if (strcmp (".toc1", sec->name) == 0)
11671     return 0;
11672
11673   return _bfd_elf_default_action_discarded (sec);
11674 }
11675
11676 /* REL points to a low-part reloc on a largetoc instruction sequence.
11677    Find the matching high-part reloc instruction and verify that it
11678    is addis REG,x,imm.  If so, set *REG to x and return a pointer to
11679    the high-part reloc.  */
11680
11681 static const Elf_Internal_Rela *
11682 ha_reloc_match (const Elf_Internal_Rela *relocs,
11683                 const Elf_Internal_Rela *rel,
11684                 unsigned int *reg,
11685                 bfd_boolean match_addend,
11686                 const bfd *input_bfd,
11687                 const bfd_byte *contents)
11688 {
11689   enum elf_ppc64_reloc_type r_type, r_type_ha;
11690   bfd_vma r_info_ha, r_addend;
11691
11692   r_type = ELF64_R_TYPE (rel->r_info);
11693   switch (r_type)
11694     {
11695     case R_PPC64_GOT_TLSLD16_LO:
11696     case R_PPC64_GOT_TLSGD16_LO:
11697     case R_PPC64_GOT_TPREL16_LO_DS:
11698     case R_PPC64_GOT_DTPREL16_LO_DS:
11699     case R_PPC64_GOT16_LO:
11700     case R_PPC64_TOC16_LO:
11701       r_type_ha = r_type + 2;
11702       break;
11703     case R_PPC64_GOT16_LO_DS:
11704       r_type_ha = R_PPC64_GOT16_HA;
11705       break;
11706     case R_PPC64_TOC16_LO_DS:
11707       r_type_ha = R_PPC64_TOC16_HA;
11708       break;
11709     default:
11710       abort ();
11711     }
11712   r_info_ha = ELF64_R_INFO (ELF64_R_SYM (rel->r_info), r_type_ha);
11713   r_addend = rel->r_addend;
11714
11715   while (--rel >= relocs)
11716     if (rel->r_info == r_info_ha
11717         && (!match_addend
11718             || rel->r_addend == r_addend))
11719       {
11720         const bfd_byte *p = contents + (rel->r_offset & ~3);
11721         unsigned int insn = bfd_get_32 (input_bfd, p);
11722         if ((insn & (0x3f << 26)) == (15u << 26) /* addis rt,x,imm */
11723             && (insn & (0x1f << 21)) == (*reg << 21))
11724           {
11725             *reg = (insn >> 16) & 0x1f;
11726             return rel;
11727           }
11728         break;
11729       }
11730   return NULL;
11731 }
11732
11733 /* The RELOCATE_SECTION function is called by the ELF backend linker
11734    to handle the relocations for a section.
11735
11736    The relocs are always passed as Rela structures; if the section
11737    actually uses Rel structures, the r_addend field will always be
11738    zero.
11739
11740    This function is responsible for adjust the section contents as
11741    necessary, and (if using Rela relocs and generating a
11742    relocatable output file) adjusting the reloc addend as
11743    necessary.
11744
11745    This function does not have to worry about setting the reloc
11746    address or the reloc symbol index.
11747
11748    LOCAL_SYMS is a pointer to the swapped in local symbols.
11749
11750    LOCAL_SECTIONS is an array giving the section in the input file
11751    corresponding to the st_shndx field of each local symbol.
11752
11753    The global hash table entry for the global symbols can be found
11754    via elf_sym_hashes (input_bfd).
11755
11756    When generating relocatable output, this function must handle
11757    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11758    going to be the section symbol corresponding to the output
11759    section, which means that the addend must be adjusted
11760    accordingly.  */
11761
11762 static bfd_boolean
11763 ppc64_elf_relocate_section (bfd *output_bfd,
11764                             struct bfd_link_info *info,
11765                             bfd *input_bfd,
11766                             asection *input_section,
11767                             bfd_byte *contents,
11768                             Elf_Internal_Rela *relocs,
11769                             Elf_Internal_Sym *local_syms,
11770                             asection **local_sections)
11771 {
11772   struct ppc_link_hash_table *htab;
11773   Elf_Internal_Shdr *symtab_hdr;
11774   struct elf_link_hash_entry **sym_hashes;
11775   Elf_Internal_Rela *rel;
11776   Elf_Internal_Rela *relend;
11777   Elf_Internal_Rela outrel;
11778   bfd_byte *loc;
11779   struct got_entry **local_got_ents;
11780   unsigned char *ha_opt;
11781   bfd_vma TOCstart;
11782   bfd_boolean no_ha_opt;
11783   bfd_boolean ret = TRUE;
11784   bfd_boolean is_opd;
11785   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11786   bfd_boolean is_power4 = FALSE;
11787   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11788
11789   /* Initialize howto table if needed.  */
11790   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11791     ppc_howto_init ();
11792
11793   htab = ppc_hash_table (info);
11794   if (htab == NULL)
11795     return FALSE;
11796
11797   /* Don't relocate stub sections.  */
11798   if (input_section->owner == htab->stub_bfd)
11799     return TRUE;
11800
11801   BFD_ASSERT (is_ppc64_elf (input_bfd));
11802
11803   local_got_ents = elf_local_got_ents (input_bfd);
11804   TOCstart = elf_gp (output_bfd);
11805   symtab_hdr = &elf_symtab_hdr (input_bfd);
11806   sym_hashes = elf_sym_hashes (input_bfd);
11807   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11808   ha_opt = NULL;
11809   no_ha_opt = FALSE;
11810
11811   rel = relocs;
11812   relend = relocs + input_section->reloc_count;
11813   for (; rel < relend; rel++)
11814     {
11815       enum elf_ppc64_reloc_type r_type;
11816       bfd_vma addend, orig_addend;
11817       bfd_reloc_status_type r;
11818       Elf_Internal_Sym *sym;
11819       asection *sec;
11820       struct elf_link_hash_entry *h_elf;
11821       struct ppc_link_hash_entry *h;
11822       struct ppc_link_hash_entry *fdh;
11823       const char *sym_name;
11824       unsigned long r_symndx, toc_symndx;
11825       bfd_vma toc_addend;
11826       unsigned char tls_mask, tls_gd, tls_type;
11827       unsigned char sym_type;
11828       bfd_vma relocation;
11829       bfd_boolean unresolved_reloc;
11830       bfd_boolean warned;
11831       unsigned int insn;
11832       unsigned int mask;
11833       struct ppc_stub_hash_entry *stub_entry;
11834       bfd_vma max_br_offset;
11835       bfd_vma from;
11836
11837       r_type = ELF64_R_TYPE (rel->r_info);
11838       r_symndx = ELF64_R_SYM (rel->r_info);
11839
11840       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11841          symbol of the previous ADDR64 reloc.  The symbol gives us the
11842          proper TOC base to use.  */
11843       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11844           && rel != relocs
11845           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11846           && is_opd)
11847         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11848
11849       sym = NULL;
11850       sec = NULL;
11851       h_elf = NULL;
11852       sym_name = NULL;
11853       unresolved_reloc = FALSE;
11854       warned = FALSE;
11855       orig_addend = rel->r_addend;
11856
11857       if (r_symndx < symtab_hdr->sh_info)
11858         {
11859           /* It's a local symbol.  */
11860           struct _opd_sec_data *opd;
11861
11862           sym = local_syms + r_symndx;
11863           sec = local_sections[r_symndx];
11864           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11865           sym_type = ELF64_ST_TYPE (sym->st_info);
11866           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11867           opd = get_opd_info (sec);
11868           if (opd != NULL && opd->adjust != NULL)
11869             {
11870               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11871               if (adjust == -1)
11872                 relocation = 0;
11873               else
11874                 {
11875                   /* If this is a relocation against the opd section sym
11876                      and we have edited .opd, adjust the reloc addend so
11877                      that ld -r and ld --emit-relocs output is correct.
11878                      If it is a reloc against some other .opd symbol,
11879                      then the symbol value will be adjusted later.  */
11880                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11881                     rel->r_addend += adjust;
11882                   else
11883                     relocation += adjust;
11884                 }
11885             }
11886         }
11887       else
11888         {
11889           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11890                                    r_symndx, symtab_hdr, sym_hashes,
11891                                    h_elf, sec, relocation,
11892                                    unresolved_reloc, warned);
11893           sym_name = h_elf->root.root.string;
11894           sym_type = h_elf->type;
11895         }
11896       h = (struct ppc_link_hash_entry *) h_elf;
11897
11898       if (sec != NULL && elf_discarded_section (sec))
11899         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
11900                                          rel, relend,
11901                                          ppc64_elf_howto_table[r_type],
11902                                          contents);
11903
11904       if (info->relocatable)
11905         continue;
11906
11907       /* TLS optimizations.  Replace instruction sequences and relocs
11908          based on information we collected in tls_optimize.  We edit
11909          RELOCS so that --emit-relocs will output something sensible
11910          for the final instruction stream.  */
11911       tls_mask = 0;
11912       tls_gd = 0;
11913       toc_symndx = 0;
11914       if (h != NULL)
11915         tls_mask = h->tls_mask;
11916       else if (local_got_ents != NULL)
11917         {
11918           struct plt_entry **local_plt = (struct plt_entry **)
11919             (local_got_ents + symtab_hdr->sh_info);
11920           unsigned char *lgot_masks = (unsigned char *)
11921             (local_plt + symtab_hdr->sh_info);
11922           tls_mask = lgot_masks[r_symndx];
11923         }
11924       if (tls_mask == 0
11925           && (r_type == R_PPC64_TLS
11926               || r_type == R_PPC64_TLSGD
11927               || r_type == R_PPC64_TLSLD))
11928         {
11929           /* Check for toc tls entries.  */
11930           unsigned char *toc_tls;
11931
11932           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11933                              &local_syms, rel, input_bfd))
11934             return FALSE;
11935
11936           if (toc_tls)
11937             tls_mask = *toc_tls;
11938         }
11939
11940       /* Check that tls relocs are used with tls syms, and non-tls
11941          relocs are used with non-tls syms.  */
11942       if (r_symndx != STN_UNDEF
11943           && r_type != R_PPC64_NONE
11944           && (h == NULL
11945               || h->elf.root.type == bfd_link_hash_defined
11946               || h->elf.root.type == bfd_link_hash_defweak)
11947           && (IS_PPC64_TLS_RELOC (r_type)
11948               != (sym_type == STT_TLS
11949                   || (sym_type == STT_SECTION
11950                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11951         {
11952           if (tls_mask != 0
11953               && (r_type == R_PPC64_TLS
11954                   || r_type == R_PPC64_TLSGD
11955                   || r_type == R_PPC64_TLSLD))
11956             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
11957             ;
11958           else
11959             info->callbacks->einfo
11960               (!IS_PPC64_TLS_RELOC (r_type)
11961                ? _("%P: %H: %s used with TLS symbol %s\n")
11962                : _("%P: %H: %s used with non-TLS symbol %s\n"),
11963                input_bfd, input_section, rel->r_offset,
11964                ppc64_elf_howto_table[r_type]->name,
11965                sym_name);
11966         }
11967
11968       /* Ensure reloc mapping code below stays sane.  */
11969       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11970           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11971           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
11972           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11973           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11974           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11975           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
11976           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11977           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11978           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11979         abort ();
11980
11981       switch (r_type)
11982         {
11983         default:
11984           break;
11985
11986         case R_PPC64_LO_DS_OPT:
11987           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11988           if ((insn & (0x3f << 26)) != 58u << 26)
11989             abort ();
11990           insn += (14u << 26) - (58u << 26);
11991           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11992           r_type = R_PPC64_TOC16_LO;
11993           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11994           break;
11995
11996         case R_PPC64_TOC16:
11997         case R_PPC64_TOC16_LO:
11998         case R_PPC64_TOC16_DS:
11999         case R_PPC64_TOC16_LO_DS:
12000           {
12001             /* Check for toc tls entries.  */
12002             unsigned char *toc_tls;
12003             int retval;
12004
12005             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12006                                    &local_syms, rel, input_bfd);
12007             if (retval == 0)
12008               return FALSE;
12009
12010             if (toc_tls)
12011               {
12012                 tls_mask = *toc_tls;
12013                 if (r_type == R_PPC64_TOC16_DS
12014                     || r_type == R_PPC64_TOC16_LO_DS)
12015                   {
12016                     if (tls_mask != 0
12017                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12018                       goto toctprel;
12019                   }
12020                 else
12021                   {
12022                     /* If we found a GD reloc pair, then we might be
12023                        doing a GD->IE transition.  */
12024                     if (retval == 2)
12025                       {
12026                         tls_gd = TLS_TPRELGD;
12027                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12028                           goto tls_ldgd_opt;
12029                       }
12030                     else if (retval == 3)
12031                       {
12032                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12033                           goto tls_ldgd_opt;
12034                       }
12035                   }
12036               }
12037           }
12038           break;
12039
12040         case R_PPC64_GOT_TPREL16_HI:
12041         case R_PPC64_GOT_TPREL16_HA:
12042           if (tls_mask != 0
12043               && (tls_mask & TLS_TPREL) == 0)
12044             {
12045               rel->r_offset -= d_offset;
12046               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12047               r_type = R_PPC64_NONE;
12048               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12049             }
12050           break;
12051
12052         case R_PPC64_GOT_TPREL16_DS:
12053         case R_PPC64_GOT_TPREL16_LO_DS:
12054           if (tls_mask != 0
12055               && (tls_mask & TLS_TPREL) == 0)
12056             {
12057             toctprel:
12058               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12059               insn &= 31 << 21;
12060               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12061               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12062               r_type = R_PPC64_TPREL16_HA;
12063               if (toc_symndx != 0)
12064                 {
12065                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12066                   rel->r_addend = toc_addend;
12067                   /* We changed the symbol.  Start over in order to
12068                      get h, sym, sec etc. right.  */
12069                   rel--;
12070                   continue;
12071                 }
12072               else
12073                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12074             }
12075           break;
12076
12077         case R_PPC64_TLS:
12078           if (tls_mask != 0
12079               && (tls_mask & TLS_TPREL) == 0)
12080             {
12081               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12082               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12083               if (insn == 0)
12084                 abort ();
12085               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12086               /* Was PPC64_TLS which sits on insn boundary, now
12087                  PPC64_TPREL16_LO which is at low-order half-word.  */
12088               rel->r_offset += d_offset;
12089               r_type = R_PPC64_TPREL16_LO;
12090               if (toc_symndx != 0)
12091                 {
12092                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12093                   rel->r_addend = toc_addend;
12094                   /* We changed the symbol.  Start over in order to
12095                      get h, sym, sec etc. right.  */
12096                   rel--;
12097                   continue;
12098                 }
12099               else
12100                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12101             }
12102           break;
12103
12104         case R_PPC64_GOT_TLSGD16_HI:
12105         case R_PPC64_GOT_TLSGD16_HA:
12106           tls_gd = TLS_TPRELGD;
12107           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12108             goto tls_gdld_hi;
12109           break;
12110
12111         case R_PPC64_GOT_TLSLD16_HI:
12112         case R_PPC64_GOT_TLSLD16_HA:
12113           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12114             {
12115             tls_gdld_hi:
12116               if ((tls_mask & tls_gd) != 0)
12117                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12118                           + R_PPC64_GOT_TPREL16_DS);
12119               else
12120                 {
12121                   rel->r_offset -= d_offset;
12122                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12123                   r_type = R_PPC64_NONE;
12124                 }
12125               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12126             }
12127           break;
12128
12129         case R_PPC64_GOT_TLSGD16:
12130         case R_PPC64_GOT_TLSGD16_LO:
12131           tls_gd = TLS_TPRELGD;
12132           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12133             goto tls_ldgd_opt;
12134           break;
12135
12136         case R_PPC64_GOT_TLSLD16:
12137         case R_PPC64_GOT_TLSLD16_LO:
12138           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12139             {
12140               unsigned int insn1, insn2, insn3;
12141               bfd_vma offset;
12142
12143             tls_ldgd_opt:
12144               offset = (bfd_vma) -1;
12145               /* If not using the newer R_PPC64_TLSGD/LD to mark
12146                  __tls_get_addr calls, we must trust that the call
12147                  stays with its arg setup insns, ie. that the next
12148                  reloc is the __tls_get_addr call associated with
12149                  the current reloc.  Edit both insns.  */
12150               if (input_section->has_tls_get_addr_call
12151                   && rel + 1 < relend
12152                   && branch_reloc_hash_match (input_bfd, rel + 1,
12153                                               htab->tls_get_addr,
12154                                               htab->tls_get_addr_fd))
12155                 offset = rel[1].r_offset;
12156               if ((tls_mask & tls_gd) != 0)
12157                 {
12158                   /* IE */
12159                   insn1 = bfd_get_32 (output_bfd,
12160                                       contents + rel->r_offset - d_offset);
12161                   insn1 &= (1 << 26) - (1 << 2);
12162                   insn1 |= 58 << 26;    /* ld */
12163                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12164                   if (offset != (bfd_vma) -1)
12165                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12166                   if ((tls_mask & TLS_EXPLICIT) == 0)
12167                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12168                               + R_PPC64_GOT_TPREL16_DS);
12169                   else
12170                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12171                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12172                 }
12173               else
12174                 {
12175                   /* LE */
12176                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12177                   insn2 = 0x38630000;   /* addi 3,3,0 */
12178                   if (tls_gd == 0)
12179                     {
12180                       /* Was an LD reloc.  */
12181                       if (toc_symndx)
12182                         sec = local_sections[toc_symndx];
12183                       for (r_symndx = 0;
12184                            r_symndx < symtab_hdr->sh_info;
12185                            r_symndx++)
12186                         if (local_sections[r_symndx] == sec)
12187                           break;
12188                       if (r_symndx >= symtab_hdr->sh_info)
12189                         r_symndx = STN_UNDEF;
12190                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12191                       if (r_symndx != STN_UNDEF)
12192                         rel->r_addend -= (local_syms[r_symndx].st_value
12193                                           + sec->output_offset
12194                                           + sec->output_section->vma);
12195                     }
12196                   else if (toc_symndx != 0)
12197                     {
12198                       r_symndx = toc_symndx;
12199                       rel->r_addend = toc_addend;
12200                     }
12201                   r_type = R_PPC64_TPREL16_HA;
12202                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12203                   if (offset != (bfd_vma) -1)
12204                     {
12205                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12206                                                     R_PPC64_TPREL16_LO);
12207                       rel[1].r_offset = offset + d_offset;
12208                       rel[1].r_addend = rel->r_addend;
12209                     }
12210                 }
12211               bfd_put_32 (output_bfd, insn1,
12212                           contents + rel->r_offset - d_offset);
12213               if (offset != (bfd_vma) -1)
12214                 {
12215                   insn3 = bfd_get_32 (output_bfd,
12216                                       contents + offset + 4);
12217                   if (insn3 == NOP
12218                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12219                     {
12220                       rel[1].r_offset += 4;
12221                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12222                       insn2 = NOP;
12223                     }
12224                   bfd_put_32 (output_bfd, insn2, contents + offset);
12225                 }
12226               if ((tls_mask & tls_gd) == 0
12227                   && (tls_gd == 0 || toc_symndx != 0))
12228                 {
12229                   /* We changed the symbol.  Start over in order
12230                      to get h, sym, sec etc. right.  */
12231                   rel--;
12232                   continue;
12233                 }
12234             }
12235           break;
12236
12237         case R_PPC64_TLSGD:
12238           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12239             {
12240               unsigned int insn2, insn3;
12241               bfd_vma offset = rel->r_offset;
12242
12243               if ((tls_mask & TLS_TPRELGD) != 0)
12244                 {
12245                   /* IE */
12246                   r_type = R_PPC64_NONE;
12247                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12248                 }
12249               else
12250                 {
12251                   /* LE */
12252                   if (toc_symndx != 0)
12253                     {
12254                       r_symndx = toc_symndx;
12255                       rel->r_addend = toc_addend;
12256                     }
12257                   r_type = R_PPC64_TPREL16_LO;
12258                   rel->r_offset = offset + d_offset;
12259                   insn2 = 0x38630000;   /* addi 3,3,0 */
12260                 }
12261               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12262               /* Zap the reloc on the _tls_get_addr call too.  */
12263               BFD_ASSERT (offset == rel[1].r_offset);
12264               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12265               insn3 = bfd_get_32 (output_bfd,
12266                                   contents + offset + 4);
12267               if (insn3 == NOP
12268                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12269                 {
12270                   rel->r_offset += 4;
12271                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12272                   insn2 = NOP;
12273                 }
12274               bfd_put_32 (output_bfd, insn2, contents + offset);
12275               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12276                 {
12277                   rel--;
12278                   continue;
12279                 }
12280             }
12281           break;
12282
12283         case R_PPC64_TLSLD:
12284           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12285             {
12286               unsigned int insn2, insn3;
12287               bfd_vma offset = rel->r_offset;
12288
12289               if (toc_symndx)
12290                 sec = local_sections[toc_symndx];
12291               for (r_symndx = 0;
12292                    r_symndx < symtab_hdr->sh_info;
12293                    r_symndx++)
12294                 if (local_sections[r_symndx] == sec)
12295                   break;
12296               if (r_symndx >= symtab_hdr->sh_info)
12297                 r_symndx = STN_UNDEF;
12298               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12299               if (r_symndx != STN_UNDEF)
12300                 rel->r_addend -= (local_syms[r_symndx].st_value
12301                                   + sec->output_offset
12302                                   + sec->output_section->vma);
12303
12304               r_type = R_PPC64_TPREL16_LO;
12305               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12306               rel->r_offset = offset + d_offset;
12307               /* Zap the reloc on the _tls_get_addr call too.  */
12308               BFD_ASSERT (offset == rel[1].r_offset);
12309               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12310               insn2 = 0x38630000;       /* addi 3,3,0 */
12311               insn3 = bfd_get_32 (output_bfd,
12312                                   contents + offset + 4);
12313               if (insn3 == NOP
12314                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12315                 {
12316                   rel->r_offset += 4;
12317                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12318                   insn2 = NOP;
12319                 }
12320               bfd_put_32 (output_bfd, insn2, contents + offset);
12321               rel--;
12322               continue;
12323             }
12324           break;
12325
12326         case R_PPC64_DTPMOD64:
12327           if (rel + 1 < relend
12328               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12329               && rel[1].r_offset == rel->r_offset + 8)
12330             {
12331               if ((tls_mask & TLS_GD) == 0)
12332                 {
12333                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12334                   if ((tls_mask & TLS_TPRELGD) != 0)
12335                     r_type = R_PPC64_TPREL64;
12336                   else
12337                     {
12338                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12339                       r_type = R_PPC64_NONE;
12340                     }
12341                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12342                 }
12343             }
12344           else
12345             {
12346               if ((tls_mask & TLS_LD) == 0)
12347                 {
12348                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12349                   r_type = R_PPC64_NONE;
12350                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12351                 }
12352             }
12353           break;
12354
12355         case R_PPC64_TPREL64:
12356           if ((tls_mask & TLS_TPREL) == 0)
12357             {
12358               r_type = R_PPC64_NONE;
12359               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12360             }
12361           break;
12362         }
12363
12364       /* Handle other relocations that tweak non-addend part of insn.  */
12365       insn = 0;
12366       max_br_offset = 1 << 25;
12367       addend = rel->r_addend;
12368       switch (r_type)
12369         {
12370         default:
12371           break;
12372
12373           /* Branch taken prediction relocations.  */
12374         case R_PPC64_ADDR14_BRTAKEN:
12375         case R_PPC64_REL14_BRTAKEN:
12376           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12377           /* Fall thru.  */
12378
12379           /* Branch not taken prediction relocations.  */
12380         case R_PPC64_ADDR14_BRNTAKEN:
12381         case R_PPC64_REL14_BRNTAKEN:
12382           insn |= bfd_get_32 (output_bfd,
12383                               contents + rel->r_offset) & ~(0x01 << 21);
12384           /* Fall thru.  */
12385
12386         case R_PPC64_REL14:
12387           max_br_offset = 1 << 15;
12388           /* Fall thru.  */
12389
12390         case R_PPC64_REL24:
12391           /* Calls to functions with a different TOC, such as calls to
12392              shared objects, need to alter the TOC pointer.  This is
12393              done using a linkage stub.  A REL24 branching to these
12394              linkage stubs needs to be followed by a nop, as the nop
12395              will be replaced with an instruction to restore the TOC
12396              base pointer.  */
12397           fdh = h;
12398           if (h != NULL
12399               && h->oh != NULL
12400               && h->oh->is_func_descriptor)
12401             fdh = ppc_follow_link (h->oh);
12402           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12403           if (stub_entry != NULL
12404               && (stub_entry->stub_type == ppc_stub_plt_call
12405                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12406                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12407             {
12408               bfd_boolean can_plt_call = FALSE;
12409
12410               if (rel->r_offset + 8 <= input_section->size)
12411                 {
12412                   unsigned long nop;
12413                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12414                   if (nop == NOP
12415                       || nop == CROR_151515 || nop == CROR_313131)
12416                     {
12417                       if (h != NULL
12418                           && (h == htab->tls_get_addr_fd
12419                               || h == htab->tls_get_addr)
12420                           && !htab->no_tls_get_addr_opt)
12421                         {
12422                           /* Special stub used, leave nop alone.  */
12423                         }
12424                       else
12425                         bfd_put_32 (input_bfd, LD_R2_40R1,
12426                                     contents + rel->r_offset + 4);
12427                       can_plt_call = TRUE;
12428                     }
12429                 }
12430
12431               if (!can_plt_call)
12432                 {
12433                   if (stub_entry->stub_type == ppc_stub_plt_call)
12434                     {
12435                       /* If this is a plain branch rather than a branch
12436                          and link, don't require a nop.  However, don't
12437                          allow tail calls in a shared library as they
12438                          will result in r2 being corrupted.  */
12439                       unsigned long br;
12440                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12441                       if (info->executable && (br & 1) == 0)
12442                         can_plt_call = TRUE;
12443                       else
12444                         stub_entry = NULL;
12445                     }
12446                   else if (h != NULL
12447                            && strcmp (h->elf.root.root.string,
12448                                       ".__libc_start_main") == 0)
12449                     {
12450                       /* Allow crt1 branch to go via a toc adjusting stub.  */
12451                       can_plt_call = TRUE;
12452                     }
12453                   else
12454                     {
12455                       if (strcmp (input_section->output_section->name,
12456                                   ".init") == 0
12457                           || strcmp (input_section->output_section->name,
12458                                      ".fini") == 0)
12459                         info->callbacks->einfo
12460                           (_("%P: %H: automatic multiple TOCs "
12461                              "not supported using your crt files; "
12462                              "recompile with -mminimal-toc or upgrade gcc\n"),
12463                            input_bfd, input_section, rel->r_offset);
12464                       else
12465                         info->callbacks->einfo
12466                           (_("%P: %H: sibling call optimization to `%s' "
12467                              "does not allow automatic multiple TOCs; "
12468                              "recompile with -mminimal-toc or "
12469                              "-fno-optimize-sibling-calls, "
12470                              "or make `%s' extern\n"),
12471                            input_bfd, input_section, rel->r_offset,
12472                            sym_name,
12473                            sym_name);
12474                       bfd_set_error (bfd_error_bad_value);
12475                       ret = FALSE;
12476                     }
12477                 }
12478
12479               if (can_plt_call
12480                   && stub_entry->stub_type == ppc_stub_plt_call)
12481                 unresolved_reloc = FALSE;
12482             }
12483
12484           if ((stub_entry == NULL
12485                || stub_entry->stub_type == ppc_stub_long_branch
12486                || stub_entry->stub_type == ppc_stub_plt_branch)
12487               && get_opd_info (sec) != NULL)
12488             {
12489               /* The branch destination is the value of the opd entry. */
12490               bfd_vma off = (relocation + addend
12491                              - sec->output_section->vma
12492                              - sec->output_offset);
12493               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12494               if (dest != (bfd_vma) -1)
12495                 {
12496                   relocation = dest;
12497                   addend = 0;
12498                 }
12499             }
12500
12501           /* If the branch is out of reach we ought to have a long
12502              branch stub.  */
12503           from = (rel->r_offset
12504                   + input_section->output_offset
12505                   + input_section->output_section->vma);
12506
12507           if (stub_entry != NULL
12508               && (stub_entry->stub_type == ppc_stub_long_branch
12509                   || stub_entry->stub_type == ppc_stub_plt_branch)
12510               && (r_type == R_PPC64_ADDR14_BRTAKEN
12511                   || r_type == R_PPC64_ADDR14_BRNTAKEN
12512                   || (relocation + addend - from + max_br_offset
12513                       < 2 * max_br_offset)))
12514             /* Don't use the stub if this branch is in range.  */
12515             stub_entry = NULL;
12516
12517           if (stub_entry != NULL)
12518             {
12519               /* Munge up the value and addend so that we call the stub
12520                  rather than the procedure directly.  */
12521               relocation = (stub_entry->stub_offset
12522                             + stub_entry->stub_sec->output_offset
12523                             + stub_entry->stub_sec->output_section->vma);
12524               addend = 0;
12525             }
12526
12527           if (insn != 0)
12528             {
12529               if (is_power4)
12530                 {
12531                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12532                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12533                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12534                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12535                     insn |= 0x02 << 21;
12536                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12537                     insn |= 0x08 << 21;
12538                   else
12539                     break;
12540                 }
12541               else
12542                 {
12543                   /* Invert 'y' bit if not the default.  */
12544                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12545                     insn ^= 0x01 << 21;
12546                 }
12547
12548               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12549             }
12550
12551           /* NOP out calls to undefined weak functions.
12552              We can thus call a weak function without first
12553              checking whether the function is defined.  */
12554           else if (h != NULL
12555                    && h->elf.root.type == bfd_link_hash_undefweak
12556                    && h->elf.dynindx == -1
12557                    && r_type == R_PPC64_REL24
12558                    && relocation == 0
12559                    && addend == 0)
12560             {
12561               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12562               continue;
12563             }
12564           break;
12565         }
12566
12567       /* Set `addend'.  */
12568       tls_type = 0;
12569       switch (r_type)
12570         {
12571         default:
12572           info->callbacks->einfo
12573             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
12574              input_bfd, (int) r_type, sym_name);
12575
12576           bfd_set_error (bfd_error_bad_value);
12577           ret = FALSE;
12578           continue;
12579
12580         case R_PPC64_NONE:
12581         case R_PPC64_TLS:
12582         case R_PPC64_TLSGD:
12583         case R_PPC64_TLSLD:
12584         case R_PPC64_GNU_VTINHERIT:
12585         case R_PPC64_GNU_VTENTRY:
12586           continue;
12587
12588           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12589              address in the GOT as relocation value instead of the
12590              symbol's value itself.  Also, create a GOT entry for the
12591              symbol and put the symbol value there.  */
12592         case R_PPC64_GOT_TLSGD16:
12593         case R_PPC64_GOT_TLSGD16_LO:
12594         case R_PPC64_GOT_TLSGD16_HI:
12595         case R_PPC64_GOT_TLSGD16_HA:
12596           tls_type = TLS_TLS | TLS_GD;
12597           goto dogot;
12598
12599         case R_PPC64_GOT_TLSLD16:
12600         case R_PPC64_GOT_TLSLD16_LO:
12601         case R_PPC64_GOT_TLSLD16_HI:
12602         case R_PPC64_GOT_TLSLD16_HA:
12603           tls_type = TLS_TLS | TLS_LD;
12604           goto dogot;
12605
12606         case R_PPC64_GOT_TPREL16_DS:
12607         case R_PPC64_GOT_TPREL16_LO_DS:
12608         case R_PPC64_GOT_TPREL16_HI:
12609         case R_PPC64_GOT_TPREL16_HA:
12610           tls_type = TLS_TLS | TLS_TPREL;
12611           goto dogot;
12612
12613         case R_PPC64_GOT_DTPREL16_DS:
12614         case R_PPC64_GOT_DTPREL16_LO_DS:
12615         case R_PPC64_GOT_DTPREL16_HI:
12616         case R_PPC64_GOT_DTPREL16_HA:
12617           tls_type = TLS_TLS | TLS_DTPREL;
12618           goto dogot;
12619
12620         case R_PPC64_GOT16:
12621         case R_PPC64_GOT16_LO:
12622         case R_PPC64_GOT16_HI:
12623         case R_PPC64_GOT16_HA:
12624         case R_PPC64_GOT16_DS:
12625         case R_PPC64_GOT16_LO_DS:
12626         dogot:
12627           {
12628             /* Relocation is to the entry for this symbol in the global
12629                offset table.  */
12630             asection *got;
12631             bfd_vma *offp;
12632             bfd_vma off;
12633             unsigned long indx = 0;
12634             struct got_entry *ent;
12635
12636             if (tls_type == (TLS_TLS | TLS_LD)
12637                 && (h == NULL
12638                     || !h->elf.def_dynamic))
12639               ent = ppc64_tlsld_got (input_bfd);
12640             else
12641               {
12642
12643                 if (h != NULL)
12644                   {
12645                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12646                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12647                                                           &h->elf)
12648                         || (info->shared
12649                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12650                       /* This is actually a static link, or it is a
12651                          -Bsymbolic link and the symbol is defined
12652                          locally, or the symbol was forced to be local
12653                          because of a version file.  */
12654                       ;
12655                     else
12656                       {
12657                         indx = h->elf.dynindx;
12658                         unresolved_reloc = FALSE;
12659                       }
12660                     ent = h->elf.got.glist;
12661                   }
12662                 else
12663                   {
12664                     if (local_got_ents == NULL)
12665                       abort ();
12666                     ent = local_got_ents[r_symndx];
12667                   }
12668
12669                 for (; ent != NULL; ent = ent->next)
12670                   if (ent->addend == orig_addend
12671                       && ent->owner == input_bfd
12672                       && ent->tls_type == tls_type)
12673                     break;
12674               }
12675
12676             if (ent == NULL)
12677               abort ();
12678             if (ent->is_indirect)
12679               ent = ent->got.ent;
12680             offp = &ent->got.offset;
12681             got = ppc64_elf_tdata (ent->owner)->got;
12682             if (got == NULL)
12683               abort ();
12684
12685             /* The offset must always be a multiple of 8.  We use the
12686                least significant bit to record whether we have already
12687                processed this entry.  */
12688             off = *offp;
12689             if ((off & 1) != 0)
12690               off &= ~1;
12691             else
12692               {
12693                 /* Generate relocs for the dynamic linker, except in
12694                    the case of TLSLD where we'll use one entry per
12695                    module.  */
12696                 asection *relgot;
12697                 bfd_boolean ifunc;
12698
12699                 *offp = off | 1;
12700                 relgot = NULL;
12701                 ifunc = (h != NULL
12702                          ? h->elf.type == STT_GNU_IFUNC
12703                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12704                 if ((info->shared || indx != 0)
12705                     && (h == NULL
12706                         || (tls_type == (TLS_TLS | TLS_LD)
12707                             && !h->elf.def_dynamic)
12708                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12709                         || h->elf.root.type != bfd_link_hash_undefweak))
12710                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12711                 else if (ifunc)
12712                   relgot = htab->reliplt;
12713                 if (relgot != NULL)
12714                   {
12715                     outrel.r_offset = (got->output_section->vma
12716                                        + got->output_offset
12717                                        + off);
12718                     outrel.r_addend = addend;
12719                     if (tls_type & (TLS_LD | TLS_GD))
12720                       {
12721                         outrel.r_addend = 0;
12722                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12723                         if (tls_type == (TLS_TLS | TLS_GD))
12724                           {
12725                             loc = relgot->contents;
12726                             loc += (relgot->reloc_count++
12727                                     * sizeof (Elf64_External_Rela));
12728                             bfd_elf64_swap_reloca_out (output_bfd,
12729                                                        &outrel, loc);
12730                             outrel.r_offset += 8;
12731                             outrel.r_addend = addend;
12732                             outrel.r_info
12733                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12734                           }
12735                       }
12736                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12737                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12738                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12739                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12740                     else if (indx != 0)
12741                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12742                     else
12743                       {
12744                         if (ifunc)
12745                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12746                         else
12747                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12748
12749                         /* Write the .got section contents for the sake
12750                            of prelink.  */
12751                         loc = got->contents + off;
12752                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12753                                     loc);
12754                       }
12755
12756                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12757                       {
12758                         outrel.r_addend += relocation;
12759                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12760                           outrel.r_addend -= htab->elf.tls_sec->vma;
12761                       }
12762                     loc = relgot->contents;
12763                     loc += (relgot->reloc_count++
12764                             * sizeof (Elf64_External_Rela));
12765                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12766                   }
12767
12768                 /* Init the .got section contents here if we're not
12769                    emitting a reloc.  */
12770                 else
12771                   {
12772                     relocation += addend;
12773                     if (tls_type == (TLS_TLS | TLS_LD))
12774                       relocation = 1;
12775                     else if (tls_type != 0)
12776                       {
12777                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12778                         if (tls_type == (TLS_TLS | TLS_TPREL))
12779                           relocation += DTP_OFFSET - TP_OFFSET;
12780
12781                         if (tls_type == (TLS_TLS | TLS_GD))
12782                           {
12783                             bfd_put_64 (output_bfd, relocation,
12784                                         got->contents + off + 8);
12785                             relocation = 1;
12786                           }
12787                       }
12788
12789                     bfd_put_64 (output_bfd, relocation,
12790                                 got->contents + off);
12791                   }
12792               }
12793
12794             if (off >= (bfd_vma) -2)
12795               abort ();
12796
12797             relocation = got->output_section->vma + got->output_offset + off;
12798             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12799           }
12800           break;
12801
12802         case R_PPC64_PLT16_HA:
12803         case R_PPC64_PLT16_HI:
12804         case R_PPC64_PLT16_LO:
12805         case R_PPC64_PLT32:
12806         case R_PPC64_PLT64:
12807           /* Relocation is to the entry for this symbol in the
12808              procedure linkage table.  */
12809
12810           /* Resolve a PLT reloc against a local symbol directly,
12811              without using the procedure linkage table.  */
12812           if (h == NULL)
12813             break;
12814
12815           /* It's possible that we didn't make a PLT entry for this
12816              symbol.  This happens when statically linking PIC code,
12817              or when using -Bsymbolic.  Go find a match if there is a
12818              PLT entry.  */
12819           if (htab->plt != NULL)
12820             {
12821               struct plt_entry *ent;
12822               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12823                 if (ent->addend == orig_addend
12824                     && ent->plt.offset != (bfd_vma) -1)
12825                   {
12826                     relocation = (htab->plt->output_section->vma
12827                                   + htab->plt->output_offset
12828                                   + ent->plt.offset);
12829                     unresolved_reloc = FALSE;
12830                   }
12831             }
12832           break;
12833
12834         case R_PPC64_TOC:
12835           /* Relocation value is TOC base.  */
12836           relocation = TOCstart;
12837           if (r_symndx == STN_UNDEF)
12838             relocation += htab->stub_group[input_section->id].toc_off;
12839           else if (unresolved_reloc)
12840             ;
12841           else if (sec != NULL && sec->id <= htab->top_id)
12842             relocation += htab->stub_group[sec->id].toc_off;
12843           else
12844             unresolved_reloc = TRUE;
12845           goto dodyn;
12846
12847           /* TOC16 relocs.  We want the offset relative to the TOC base,
12848              which is the address of the start of the TOC plus 0x8000.
12849              The TOC consists of sections .got, .toc, .tocbss, and .plt,
12850              in this order.  */
12851         case R_PPC64_TOC16:
12852         case R_PPC64_TOC16_LO:
12853         case R_PPC64_TOC16_HI:
12854         case R_PPC64_TOC16_DS:
12855         case R_PPC64_TOC16_LO_DS:
12856         case R_PPC64_TOC16_HA:
12857           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12858           break;
12859
12860           /* Relocate against the beginning of the section.  */
12861         case R_PPC64_SECTOFF:
12862         case R_PPC64_SECTOFF_LO:
12863         case R_PPC64_SECTOFF_HI:
12864         case R_PPC64_SECTOFF_DS:
12865         case R_PPC64_SECTOFF_LO_DS:
12866         case R_PPC64_SECTOFF_HA:
12867           if (sec != NULL)
12868             addend -= sec->output_section->vma;
12869           break;
12870
12871         case R_PPC64_REL16:
12872         case R_PPC64_REL16_LO:
12873         case R_PPC64_REL16_HI:
12874         case R_PPC64_REL16_HA:
12875           break;
12876
12877         case R_PPC64_REL14:
12878         case R_PPC64_REL14_BRNTAKEN:
12879         case R_PPC64_REL14_BRTAKEN:
12880         case R_PPC64_REL24:
12881           break;
12882
12883         case R_PPC64_TPREL16:
12884         case R_PPC64_TPREL16_LO:
12885         case R_PPC64_TPREL16_HI:
12886         case R_PPC64_TPREL16_HA:
12887         case R_PPC64_TPREL16_DS:
12888         case R_PPC64_TPREL16_LO_DS:
12889         case R_PPC64_TPREL16_HIGHER:
12890         case R_PPC64_TPREL16_HIGHERA:
12891         case R_PPC64_TPREL16_HIGHEST:
12892         case R_PPC64_TPREL16_HIGHESTA:
12893           if (h != NULL
12894               && h->elf.root.type == bfd_link_hash_undefweak
12895               && h->elf.dynindx == -1)
12896             {
12897               /* Make this relocation against an undefined weak symbol
12898                  resolve to zero.  This is really just a tweak, since
12899                  code using weak externs ought to check that they are
12900                  defined before using them.  */
12901               bfd_byte *p = contents + rel->r_offset - d_offset;
12902
12903               insn = bfd_get_32 (output_bfd, p);
12904               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12905               if (insn != 0)
12906                 bfd_put_32 (output_bfd, insn, p);
12907               break;
12908             }
12909           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12910           if (info->shared)
12911             /* The TPREL16 relocs shouldn't really be used in shared
12912                libs as they will result in DT_TEXTREL being set, but
12913                support them anyway.  */
12914             goto dodyn;
12915           break;
12916
12917         case R_PPC64_DTPREL16:
12918         case R_PPC64_DTPREL16_LO:
12919         case R_PPC64_DTPREL16_HI:
12920         case R_PPC64_DTPREL16_HA:
12921         case R_PPC64_DTPREL16_DS:
12922         case R_PPC64_DTPREL16_LO_DS:
12923         case R_PPC64_DTPREL16_HIGHER:
12924         case R_PPC64_DTPREL16_HIGHERA:
12925         case R_PPC64_DTPREL16_HIGHEST:
12926         case R_PPC64_DTPREL16_HIGHESTA:
12927           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12928           break;
12929
12930         case R_PPC64_DTPMOD64:
12931           relocation = 1;
12932           addend = 0;
12933           goto dodyn;
12934
12935         case R_PPC64_TPREL64:
12936           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12937           goto dodyn;
12938
12939         case R_PPC64_DTPREL64:
12940           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12941           /* Fall thru */
12942
12943           /* Relocations that may need to be propagated if this is a
12944              dynamic object.  */
12945         case R_PPC64_REL30:
12946         case R_PPC64_REL32:
12947         case R_PPC64_REL64:
12948         case R_PPC64_ADDR14:
12949         case R_PPC64_ADDR14_BRNTAKEN:
12950         case R_PPC64_ADDR14_BRTAKEN:
12951         case R_PPC64_ADDR16:
12952         case R_PPC64_ADDR16_DS:
12953         case R_PPC64_ADDR16_HA:
12954         case R_PPC64_ADDR16_HI:
12955         case R_PPC64_ADDR16_HIGHER:
12956         case R_PPC64_ADDR16_HIGHERA:
12957         case R_PPC64_ADDR16_HIGHEST:
12958         case R_PPC64_ADDR16_HIGHESTA:
12959         case R_PPC64_ADDR16_LO:
12960         case R_PPC64_ADDR16_LO_DS:
12961         case R_PPC64_ADDR24:
12962         case R_PPC64_ADDR32:
12963         case R_PPC64_ADDR64:
12964         case R_PPC64_UADDR16:
12965         case R_PPC64_UADDR32:
12966         case R_PPC64_UADDR64:
12967         dodyn:
12968           if ((input_section->flags & SEC_ALLOC) == 0)
12969             break;
12970
12971           if (NO_OPD_RELOCS && is_opd)
12972             break;
12973
12974           if ((info->shared
12975                && (h == NULL
12976                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12977                    || h->elf.root.type != bfd_link_hash_undefweak)
12978                && (must_be_dyn_reloc (info, r_type)
12979                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12980               || (ELIMINATE_COPY_RELOCS
12981                   && !info->shared
12982                   && h != NULL
12983                   && h->elf.dynindx != -1
12984                   && !h->elf.non_got_ref
12985                   && !h->elf.def_regular)
12986               || (!info->shared
12987                   && (h != NULL
12988                       ? h->elf.type == STT_GNU_IFUNC
12989                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12990             {
12991               bfd_boolean skip, relocate;
12992               asection *sreloc;
12993               bfd_vma out_off;
12994
12995               /* When generating a dynamic object, these relocations
12996                  are copied into the output file to be resolved at run
12997                  time.  */
12998
12999               skip = FALSE;
13000               relocate = FALSE;
13001
13002               out_off = _bfd_elf_section_offset (output_bfd, info,
13003                                                  input_section, rel->r_offset);
13004               if (out_off == (bfd_vma) -1)
13005                 skip = TRUE;
13006               else if (out_off == (bfd_vma) -2)
13007                 skip = TRUE, relocate = TRUE;
13008               out_off += (input_section->output_section->vma
13009                           + input_section->output_offset);
13010               outrel.r_offset = out_off;
13011               outrel.r_addend = rel->r_addend;
13012
13013               /* Optimize unaligned reloc use.  */
13014               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13015                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13016                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13017               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13018                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13019                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13020               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13021                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13022                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13023
13024               if (skip)
13025                 memset (&outrel, 0, sizeof outrel);
13026               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13027                        && !is_opd
13028                        && r_type != R_PPC64_TOC)
13029                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13030               else
13031                 {
13032                   /* This symbol is local, or marked to become local,
13033                      or this is an opd section reloc which must point
13034                      at a local function.  */
13035                   outrel.r_addend += relocation;
13036                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13037                     {
13038                       if (is_opd && h != NULL)
13039                         {
13040                           /* Lie about opd entries.  This case occurs
13041                              when building shared libraries and we
13042                              reference a function in another shared
13043                              lib.  The same thing happens for a weak
13044                              definition in an application that's
13045                              overridden by a strong definition in a
13046                              shared lib.  (I believe this is a generic
13047                              bug in binutils handling of weak syms.)
13048                              In these cases we won't use the opd
13049                              entry in this lib.  */
13050                           unresolved_reloc = FALSE;
13051                         }
13052                       if (!is_opd
13053                           && r_type == R_PPC64_ADDR64
13054                           && (h != NULL
13055                               ? h->elf.type == STT_GNU_IFUNC
13056                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13057                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13058                       else
13059                         {
13060                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13061
13062                           /* We need to relocate .opd contents for ld.so.
13063                              Prelink also wants simple and consistent rules
13064                              for relocs.  This make all RELATIVE relocs have
13065                              *r_offset equal to r_addend.  */
13066                           relocate = TRUE;
13067                         }
13068                     }
13069                   else
13070                     {
13071                       long indx = 0;
13072
13073                       if (h != NULL
13074                           ? h->elf.type == STT_GNU_IFUNC
13075                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13076                         {
13077                           info->callbacks->einfo
13078                             (_("%P: %H: relocation %s for indirect "
13079                                "function %s unsupported\n"),
13080                              input_bfd, input_section, rel->r_offset,
13081                              ppc64_elf_howto_table[r_type]->name,
13082                              sym_name);
13083                           ret = FALSE;
13084                         }
13085                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13086                         ;
13087                       else if (sec == NULL || sec->owner == NULL)
13088                         {
13089                           bfd_set_error (bfd_error_bad_value);
13090                           return FALSE;
13091                         }
13092                       else
13093                         {
13094                           asection *osec;
13095
13096                           osec = sec->output_section;
13097                           indx = elf_section_data (osec)->dynindx;
13098
13099                           if (indx == 0)
13100                             {
13101                               if ((osec->flags & SEC_READONLY) == 0
13102                                   && htab->elf.data_index_section != NULL)
13103                                 osec = htab->elf.data_index_section;
13104                               else
13105                                 osec = htab->elf.text_index_section;
13106                               indx = elf_section_data (osec)->dynindx;
13107                             }
13108                           BFD_ASSERT (indx != 0);
13109
13110                           /* We are turning this relocation into one
13111                              against a section symbol, so subtract out
13112                              the output section's address but not the
13113                              offset of the input section in the output
13114                              section.  */
13115                           outrel.r_addend -= osec->vma;
13116                         }
13117
13118                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13119                     }
13120                 }
13121
13122               sreloc = elf_section_data (input_section)->sreloc;
13123               if (!htab->elf.dynamic_sections_created)
13124                 sreloc = htab->reliplt;
13125               if (sreloc == NULL)
13126                 abort ();
13127
13128               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13129                   >= sreloc->size)
13130                 abort ();
13131               loc = sreloc->contents;
13132               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13133               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13134
13135               /* If this reloc is against an external symbol, it will
13136                  be computed at runtime, so there's no need to do
13137                  anything now.  However, for the sake of prelink ensure
13138                  that the section contents are a known value.  */
13139               if (! relocate)
13140                 {
13141                   unresolved_reloc = FALSE;
13142                   /* The value chosen here is quite arbitrary as ld.so
13143                      ignores section contents except for the special
13144                      case of .opd where the contents might be accessed
13145                      before relocation.  Choose zero, as that won't
13146                      cause reloc overflow.  */
13147                   relocation = 0;
13148                   addend = 0;
13149                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13150                      to improve backward compatibility with older
13151                      versions of ld.  */
13152                   if (r_type == R_PPC64_ADDR64)
13153                     addend = outrel.r_addend;
13154                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13155                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13156                     addend = (input_section->output_section->vma
13157                               + input_section->output_offset
13158                               + rel->r_offset);
13159                 }
13160             }
13161           break;
13162
13163         case R_PPC64_COPY:
13164         case R_PPC64_GLOB_DAT:
13165         case R_PPC64_JMP_SLOT:
13166         case R_PPC64_JMP_IREL:
13167         case R_PPC64_RELATIVE:
13168           /* We shouldn't ever see these dynamic relocs in relocatable
13169              files.  */
13170           /* Fall through.  */
13171
13172         case R_PPC64_PLTGOT16:
13173         case R_PPC64_PLTGOT16_DS:
13174         case R_PPC64_PLTGOT16_HA:
13175         case R_PPC64_PLTGOT16_HI:
13176         case R_PPC64_PLTGOT16_LO:
13177         case R_PPC64_PLTGOT16_LO_DS:
13178         case R_PPC64_PLTREL32:
13179         case R_PPC64_PLTREL64:
13180           /* These ones haven't been implemented yet.  */
13181
13182           info->callbacks->einfo
13183             (_("%P: %B: relocation %s is not supported for symbol %s\n"),
13184              input_bfd,
13185              ppc64_elf_howto_table[r_type]->name, sym_name);
13186
13187           bfd_set_error (bfd_error_invalid_operation);
13188           ret = FALSE;
13189           continue;
13190         }
13191
13192       /* Multi-instruction sequences that access the TOC can be
13193          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13194          to             nop;           addi rb,r2,x;  */
13195       switch (r_type)
13196         {
13197         default:
13198           break;
13199
13200         case R_PPC64_GOT_TLSLD16_HI:
13201         case R_PPC64_GOT_TLSGD16_HI:
13202         case R_PPC64_GOT_TPREL16_HI:
13203         case R_PPC64_GOT_DTPREL16_HI:
13204         case R_PPC64_GOT16_HI:
13205         case R_PPC64_TOC16_HI:
13206           /* These relocs would only be useful if building up an
13207              offset to later add to r2, perhaps in an indexed
13208              addressing mode instruction.  Don't try to optimize.
13209              Unfortunately, the possibility of someone building up an
13210              offset like this or even with the HA relocs, means that
13211              we need to check the high insn when optimizing the low
13212              insn.  */
13213           break;
13214
13215         case R_PPC64_GOT_TLSLD16_HA:
13216         case R_PPC64_GOT_TLSGD16_HA:
13217         case R_PPC64_GOT_TPREL16_HA:
13218         case R_PPC64_GOT_DTPREL16_HA:
13219         case R_PPC64_GOT16_HA:
13220         case R_PPC64_TOC16_HA:
13221           /* nop is done later.  */
13222           break;
13223
13224         case R_PPC64_GOT_TLSLD16_LO:
13225         case R_PPC64_GOT_TLSGD16_LO:
13226         case R_PPC64_GOT_TPREL16_LO_DS:
13227         case R_PPC64_GOT_DTPREL16_LO_DS:
13228         case R_PPC64_GOT16_LO:
13229         case R_PPC64_GOT16_LO_DS:
13230         case R_PPC64_TOC16_LO:
13231         case R_PPC64_TOC16_LO_DS:
13232           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000)
13233             {
13234               bfd_byte *p = contents + (rel->r_offset & ~3);
13235               insn = bfd_get_32 (input_bfd, p);
13236               if ((insn & (0x3f << 26)) == 14u << 26 /* addi */
13237                   || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
13238                   || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
13239                   || (insn & (0x3f << 26)) == 36u << 26 /* stw */
13240                   || (insn & (0x3f << 26)) == 38u << 26 /* stb */
13241                   || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
13242                   || (insn & (0x3f << 26)) == 42u << 26 /* lha */
13243                   || (insn & (0x3f << 26)) == 44u << 26 /* sth */
13244                   || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
13245                   || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
13246                   || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
13247                   || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
13248                   || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
13249                   || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
13250                   || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
13251                       && (insn & 3) != 1)
13252                   || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
13253                       && ((insn & 3) == 0 || (insn & 3) == 3)))
13254                 {
13255                   unsigned int reg = (insn >> 16) & 0x1f;
13256                   const Elf_Internal_Rela *ha;
13257                   bfd_boolean match_addend;
13258
13259                   match_addend = (sym != NULL
13260                                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION);
13261                   ha = ha_reloc_match (relocs, rel, &reg, match_addend,
13262                                        input_bfd, contents);
13263                   if (ha != NULL)
13264                     {
13265                       insn &= ~(0x1f << 16);
13266                       insn |= reg << 16;
13267                       bfd_put_32 (input_bfd, insn, p);
13268                       if (ha_opt == NULL)
13269                         {
13270                           ha_opt = bfd_zmalloc (input_section->reloc_count);
13271                           if (ha_opt == NULL)
13272                             return FALSE;
13273                         }
13274                       ha_opt[ha - relocs] = 1;
13275                     }
13276                   else
13277                     /* If we don't find a matching high part insn,
13278                        something is fishy.  Refuse to nop any high
13279                        part insn in this section.  */
13280                     no_ha_opt = TRUE;
13281                 }
13282             }
13283           break;
13284         }
13285
13286       /* Do any further special processing.  */
13287       switch (r_type)
13288         {
13289         default:
13290           break;
13291
13292         case R_PPC64_ADDR16_HA:
13293         case R_PPC64_REL16_HA:
13294         case R_PPC64_ADDR16_HIGHERA:
13295         case R_PPC64_ADDR16_HIGHESTA:
13296         case R_PPC64_TOC16_HA:
13297         case R_PPC64_SECTOFF_HA:
13298         case R_PPC64_TPREL16_HA:
13299         case R_PPC64_DTPREL16_HA:
13300         case R_PPC64_TPREL16_HIGHER:
13301         case R_PPC64_TPREL16_HIGHERA:
13302         case R_PPC64_TPREL16_HIGHEST:
13303         case R_PPC64_TPREL16_HIGHESTA:
13304         case R_PPC64_DTPREL16_HIGHER:
13305         case R_PPC64_DTPREL16_HIGHERA:
13306         case R_PPC64_DTPREL16_HIGHEST:
13307         case R_PPC64_DTPREL16_HIGHESTA:
13308           /* It's just possible that this symbol is a weak symbol
13309              that's not actually defined anywhere. In that case,
13310              'sec' would be NULL, and we should leave the symbol
13311              alone (it will be set to zero elsewhere in the link).  */
13312           if (sec == NULL)
13313             break;
13314           /* Fall thru */
13315
13316         case R_PPC64_GOT16_HA:
13317         case R_PPC64_PLTGOT16_HA:
13318         case R_PPC64_PLT16_HA:
13319         case R_PPC64_GOT_TLSGD16_HA:
13320         case R_PPC64_GOT_TLSLD16_HA:
13321         case R_PPC64_GOT_TPREL16_HA:
13322         case R_PPC64_GOT_DTPREL16_HA:
13323           /* Add 0x10000 if sign bit in 0:15 is set.
13324              Bits 0:15 are not used.  */
13325           addend += 0x8000;
13326           break;
13327
13328         case R_PPC64_ADDR16_DS:
13329         case R_PPC64_ADDR16_LO_DS:
13330         case R_PPC64_GOT16_DS:
13331         case R_PPC64_GOT16_LO_DS:
13332         case R_PPC64_PLT16_LO_DS:
13333         case R_PPC64_SECTOFF_DS:
13334         case R_PPC64_SECTOFF_LO_DS:
13335         case R_PPC64_TOC16_DS:
13336         case R_PPC64_TOC16_LO_DS:
13337         case R_PPC64_PLTGOT16_DS:
13338         case R_PPC64_PLTGOT16_LO_DS:
13339         case R_PPC64_GOT_TPREL16_DS:
13340         case R_PPC64_GOT_TPREL16_LO_DS:
13341         case R_PPC64_GOT_DTPREL16_DS:
13342         case R_PPC64_GOT_DTPREL16_LO_DS:
13343         case R_PPC64_TPREL16_DS:
13344         case R_PPC64_TPREL16_LO_DS:
13345         case R_PPC64_DTPREL16_DS:
13346         case R_PPC64_DTPREL16_LO_DS:
13347           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13348           mask = 3;
13349           /* If this reloc is against an lq insn, then the value must be
13350              a multiple of 16.  This is somewhat of a hack, but the
13351              "correct" way to do this by defining _DQ forms of all the
13352              _DS relocs bloats all reloc switches in this file.  It
13353              doesn't seem to make much sense to use any of these relocs
13354              in data, so testing the insn should be safe.  */
13355           if ((insn & (0x3f << 26)) == (56u << 26))
13356             mask = 15;
13357           if (((relocation + addend) & mask) != 0)
13358             {
13359               info->callbacks->einfo
13360                 (_("%P: %H: error: %s not a multiple of %u\n"),
13361                  input_bfd, input_section, rel->r_offset,
13362                  ppc64_elf_howto_table[r_type]->name,
13363                  mask + 1);
13364               bfd_set_error (bfd_error_bad_value);
13365               ret = FALSE;
13366               continue;
13367             }
13368           break;
13369         }
13370
13371       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13372          because such sections are not SEC_ALLOC and thus ld.so will
13373          not process them.  */
13374       if (unresolved_reloc
13375           && !((input_section->flags & SEC_DEBUGGING) != 0
13376                && h->elf.def_dynamic))
13377         {
13378           info->callbacks->einfo
13379             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
13380              input_bfd, input_section, rel->r_offset,
13381              ppc64_elf_howto_table[(int) r_type]->name,
13382              h->elf.root.root.string);
13383           ret = FALSE;
13384         }
13385
13386       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13387                                     input_bfd,
13388                                     input_section,
13389                                     contents,
13390                                     rel->r_offset,
13391                                     relocation,
13392                                     addend);
13393
13394       if (r != bfd_reloc_ok)
13395         {
13396           if (sym_name == NULL)
13397             sym_name = "(null)";
13398           if (r == bfd_reloc_overflow)
13399             {
13400               if (warned)
13401                 continue;
13402               if (h != NULL
13403                   && h->elf.root.type == bfd_link_hash_undefweak
13404                   && ppc64_elf_howto_table[r_type]->pc_relative)
13405                 {
13406                   /* Assume this is a call protected by other code that
13407                      detects the symbol is undefined.  If this is the case,
13408                      we can safely ignore the overflow.  If not, the
13409                      program is hosed anyway, and a little warning isn't
13410                      going to help.  */
13411
13412                   continue;
13413                 }
13414
13415               if (!((*info->callbacks->reloc_overflow)
13416                     (info, (h ? &h->elf.root : NULL), sym_name,
13417                      ppc64_elf_howto_table[r_type]->name,
13418                      orig_addend, input_bfd, input_section, rel->r_offset)))
13419                 return FALSE;
13420             }
13421           else
13422             {
13423               info->callbacks->einfo
13424                 (_("%P: %H: %s reloc against `%s': error %d\n"),
13425                  input_bfd, input_section, rel->r_offset,
13426                  ppc64_elf_howto_table[r_type]->name,
13427                  sym_name,
13428                  (int) r);
13429               ret = FALSE;
13430             }
13431         }
13432     }
13433
13434   if (ha_opt != NULL)
13435     {
13436       if (!no_ha_opt)
13437         {
13438           unsigned char *opt = ha_opt;
13439           rel = relocs;
13440           relend = relocs + input_section->reloc_count;
13441           for (; rel < relend; opt++, rel++)
13442             if (*opt != 0)
13443               {
13444                 bfd_byte *p = contents + (rel->r_offset & ~3);
13445                 bfd_put_32 (input_bfd, NOP, p);
13446               }
13447         }
13448       free (ha_opt);
13449     }
13450
13451   /* If we're emitting relocations, then shortly after this function
13452      returns, reloc offsets and addends for this section will be
13453      adjusted.  Worse, reloc symbol indices will be for the output
13454      file rather than the input.  Save a copy of the relocs for
13455      opd_entry_value.  */
13456   if (is_opd && (info->emitrelocations || info->relocatable))
13457     {
13458       bfd_size_type amt;
13459       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13460       rel = bfd_alloc (input_bfd, amt);
13461       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13462       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13463       if (rel == NULL)
13464         return FALSE;
13465       memcpy (rel, relocs, amt);
13466     }
13467   return ret;
13468 }
13469
13470 /* Adjust the value of any local symbols in opd sections.  */
13471
13472 static int
13473 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13474                               const char *name ATTRIBUTE_UNUSED,
13475                               Elf_Internal_Sym *elfsym,
13476                               asection *input_sec,
13477                               struct elf_link_hash_entry *h)
13478 {
13479   struct _opd_sec_data *opd;
13480   long adjust;
13481   bfd_vma value;
13482
13483   if (h != NULL)
13484     return 1;
13485
13486   opd = get_opd_info (input_sec);
13487   if (opd == NULL || opd->adjust == NULL)
13488     return 1;
13489
13490   value = elfsym->st_value - input_sec->output_offset;
13491   if (!info->relocatable)
13492     value -= input_sec->output_section->vma;
13493
13494   adjust = opd->adjust[value / 8];
13495   if (adjust == -1)
13496     return 2;
13497
13498   elfsym->st_value += adjust;
13499   return 1;
13500 }
13501
13502 /* Finish up dynamic symbol handling.  We set the contents of various
13503    dynamic sections here.  */
13504
13505 static bfd_boolean
13506 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13507                                  struct bfd_link_info *info,
13508                                  struct elf_link_hash_entry *h,
13509                                  Elf_Internal_Sym *sym)
13510 {
13511   struct ppc_link_hash_table *htab;
13512   struct plt_entry *ent;
13513   Elf_Internal_Rela rela;
13514   bfd_byte *loc;
13515
13516   htab = ppc_hash_table (info);
13517   if (htab == NULL)
13518     return FALSE;
13519
13520   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13521     if (ent->plt.offset != (bfd_vma) -1)
13522       {
13523         /* This symbol has an entry in the procedure linkage
13524            table.  Set it up.  */
13525         if (!htab->elf.dynamic_sections_created
13526             || h->dynindx == -1)
13527           {
13528             BFD_ASSERT (h->type == STT_GNU_IFUNC
13529                         && h->def_regular
13530                         && (h->root.type == bfd_link_hash_defined
13531                             || h->root.type == bfd_link_hash_defweak));
13532             rela.r_offset = (htab->iplt->output_section->vma
13533                              + htab->iplt->output_offset
13534                              + ent->plt.offset);
13535             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13536             rela.r_addend = (h->root.u.def.value
13537                              + h->root.u.def.section->output_offset
13538                              + h->root.u.def.section->output_section->vma
13539                              + ent->addend);
13540             loc = (htab->reliplt->contents
13541                    + (htab->reliplt->reloc_count++
13542                       * sizeof (Elf64_External_Rela)));
13543           }
13544         else
13545           {
13546             rela.r_offset = (htab->plt->output_section->vma
13547                              + htab->plt->output_offset
13548                              + ent->plt.offset);
13549             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13550             rela.r_addend = ent->addend;
13551             loc = (htab->relplt->contents
13552                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13553                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13554           }
13555         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13556       }
13557
13558   if (h->needs_copy)
13559     {
13560       /* This symbol needs a copy reloc.  Set it up.  */
13561
13562       if (h->dynindx == -1
13563           || (h->root.type != bfd_link_hash_defined
13564               && h->root.type != bfd_link_hash_defweak)
13565           || htab->relbss == NULL)
13566         abort ();
13567
13568       rela.r_offset = (h->root.u.def.value
13569                        + h->root.u.def.section->output_section->vma
13570                        + h->root.u.def.section->output_offset);
13571       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13572       rela.r_addend = 0;
13573       loc = htab->relbss->contents;
13574       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13575       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13576     }
13577
13578   /* Mark some specially defined symbols as absolute.  */
13579   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13580     sym->st_shndx = SHN_ABS;
13581
13582   return TRUE;
13583 }
13584
13585 /* Used to decide how to sort relocs in an optimal manner for the
13586    dynamic linker, before writing them out.  */
13587
13588 static enum elf_reloc_type_class
13589 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13590 {
13591   enum elf_ppc64_reloc_type r_type;
13592
13593   r_type = ELF64_R_TYPE (rela->r_info);
13594   switch (r_type)
13595     {
13596     case R_PPC64_RELATIVE:
13597       return reloc_class_relative;
13598     case R_PPC64_JMP_SLOT:
13599       return reloc_class_plt;
13600     case R_PPC64_COPY:
13601       return reloc_class_copy;
13602     default:
13603       return reloc_class_normal;
13604     }
13605 }
13606
13607 /* Finish up the dynamic sections.  */
13608
13609 static bfd_boolean
13610 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13611                                    struct bfd_link_info *info)
13612 {
13613   struct ppc_link_hash_table *htab;
13614   bfd *dynobj;
13615   asection *sdyn;
13616
13617   htab = ppc_hash_table (info);
13618   if (htab == NULL)
13619     return FALSE;
13620
13621   dynobj = htab->elf.dynobj;
13622   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13623
13624   if (htab->elf.dynamic_sections_created)
13625     {
13626       Elf64_External_Dyn *dyncon, *dynconend;
13627
13628       if (sdyn == NULL || htab->got == NULL)
13629         abort ();
13630
13631       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13632       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13633       for (; dyncon < dynconend; dyncon++)
13634         {
13635           Elf_Internal_Dyn dyn;
13636           asection *s;
13637
13638           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13639
13640           switch (dyn.d_tag)
13641             {
13642             default:
13643               continue;
13644
13645             case DT_PPC64_GLINK:
13646               s = htab->glink;
13647               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13648               /* We stupidly defined DT_PPC64_GLINK to be the start
13649                  of glink rather than the first entry point, which is
13650                  what ld.so needs, and now have a bigger stub to
13651                  support automatic multiple TOCs.  */
13652               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13653               break;
13654
13655             case DT_PPC64_OPD:
13656               s = bfd_get_section_by_name (output_bfd, ".opd");
13657               if (s == NULL)
13658                 continue;
13659               dyn.d_un.d_ptr = s->vma;
13660               break;
13661
13662             case DT_PPC64_OPDSZ:
13663               s = bfd_get_section_by_name (output_bfd, ".opd");
13664               if (s == NULL)
13665                 continue;
13666               dyn.d_un.d_val = s->size;
13667               break;
13668
13669             case DT_PLTGOT:
13670               s = htab->plt;
13671               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13672               break;
13673
13674             case DT_JMPREL:
13675               s = htab->relplt;
13676               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13677               break;
13678
13679             case DT_PLTRELSZ:
13680               dyn.d_un.d_val = htab->relplt->size;
13681               break;
13682
13683             case DT_RELASZ:
13684               /* Don't count procedure linkage table relocs in the
13685                  overall reloc count.  */
13686               s = htab->relplt;
13687               if (s == NULL)
13688                 continue;
13689               dyn.d_un.d_val -= s->size;
13690               break;
13691
13692             case DT_RELA:
13693               /* We may not be using the standard ELF linker script.
13694                  If .rela.plt is the first .rela section, we adjust
13695                  DT_RELA to not include it.  */
13696               s = htab->relplt;
13697               if (s == NULL)
13698                 continue;
13699               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13700                 continue;
13701               dyn.d_un.d_ptr += s->size;
13702               break;
13703             }
13704
13705           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13706         }
13707     }
13708
13709   if (htab->got != NULL && htab->got->size != 0)
13710     {
13711       /* Fill in the first entry in the global offset table.
13712          We use it to hold the link-time TOCbase.  */
13713       bfd_put_64 (output_bfd,
13714                   elf_gp (output_bfd) + TOC_BASE_OFF,
13715                   htab->got->contents);
13716
13717       /* Set .got entry size.  */
13718       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13719     }
13720
13721   if (htab->plt != NULL && htab->plt->size != 0)
13722     {
13723       /* Set .plt entry size.  */
13724       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13725         = PLT_ENTRY_SIZE;
13726     }
13727
13728   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13729      brlt ourselves if emitrelocations.  */
13730   if (htab->brlt != NULL
13731       && htab->brlt->reloc_count != 0
13732       && !_bfd_elf_link_output_relocs (output_bfd,
13733                                        htab->brlt,
13734                                        elf_section_data (htab->brlt)->rela.hdr,
13735                                        elf_section_data (htab->brlt)->relocs,
13736                                        NULL))
13737     return FALSE;
13738
13739   if (htab->glink != NULL
13740       && htab->glink->reloc_count != 0
13741       && !_bfd_elf_link_output_relocs (output_bfd,
13742                                        htab->glink,
13743                                        elf_section_data (htab->glink)->rela.hdr,
13744                                        elf_section_data (htab->glink)->relocs,
13745                                        NULL))
13746     return FALSE;
13747
13748
13749   if (htab->glink_eh_frame != NULL
13750       && htab->glink_eh_frame->sec_info_type == ELF_INFO_TYPE_EH_FRAME
13751       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
13752                                            htab->glink_eh_frame,
13753                                            htab->glink_eh_frame->contents))
13754     return FALSE;
13755
13756   /* We need to handle writing out multiple GOT sections ourselves,
13757      since we didn't add them to DYNOBJ.  We know dynobj is the first
13758      bfd.  */
13759   while ((dynobj = dynobj->link_next) != NULL)
13760     {
13761       asection *s;
13762
13763       if (!is_ppc64_elf (dynobj))
13764         continue;
13765
13766       s = ppc64_elf_tdata (dynobj)->got;
13767       if (s != NULL
13768           && s->size != 0
13769           && s->output_section != bfd_abs_section_ptr
13770           && !bfd_set_section_contents (output_bfd, s->output_section,
13771                                         s->contents, s->output_offset,
13772                                         s->size))
13773         return FALSE;
13774       s = ppc64_elf_tdata (dynobj)->relgot;
13775       if (s != NULL
13776           && s->size != 0
13777           && s->output_section != bfd_abs_section_ptr
13778           && !bfd_set_section_contents (output_bfd, s->output_section,
13779                                         s->contents, s->output_offset,
13780                                         s->size))
13781         return FALSE;
13782     }
13783
13784   return TRUE;
13785 }
13786
13787 #include "elf64-target.h"