bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010, 2011 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37 #include "dwarf2.h"
  38
  39 static bfd_reloc_status_type ppc64_elf_ha_reloc
  40   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  41 static bfd_reloc_status_type ppc64_elf_branch_reloc
  42   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  44   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  46   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  48   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  49 static bfd_reloc_status_type ppc64_elf_toc_reloc
  50   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  52   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  56   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  57 static bfd_vma opd_entry_value
  58   (asection *, bfd_vma, asection **, bfd_vma *);
  59
  60 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  61 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  62 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  63 #define TARGET_BIG_NAME         "elf64-powerpc"
  64 #define ELF_ARCH                bfd_arch_powerpc
  65 #define ELF_TARGET_ID           PPC64_ELF_DATA
  66 #define ELF_MACHINE_CODE        EM_PPC64
  67 #define ELF_MAXPAGESIZE         0x10000
  68 #define ELF_COMMONPAGESIZE      0x1000
  69 #define elf_info_to_howto       ppc64_elf_info_to_howto
  70
  71 #define elf_backend_want_got_sym 0
  72 #define elf_backend_want_plt_sym 0
  73 #define elf_backend_plt_alignment 3
  74 #define elf_backend_plt_not_loaded 1
  75 #define elf_backend_got_header_size 8
  76 #define elf_backend_can_gc_sections 1
  77 #define elf_backend_can_refcount 1
  78 #define elf_backend_rela_normal 1
  79 #define elf_backend_default_execstack 0
  80
  81 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  82 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  83 #define bfd_elf64_bfd_reloc_name_lookup       ppc64_elf_reloc_name_lookup
  84 #define bfd_elf64_bfd_merge_private_bfd_data  _bfd_generic_verify_endian_match
  85 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  86 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  87 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  88 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  89 #define bfd_elf64_bfd_link_just_syms          ppc64_elf_link_just_syms
  90
  91 #define elf_backend_object_p                  ppc64_elf_object_p
  92 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  93 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  94 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  95 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  96 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  97 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  98 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  99 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
 100 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
 101 #define elf_backend_check_relocs              ppc64_elf_check_relocs
 102 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 103 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 104 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 105 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 106 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 107 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 108 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 109 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 110 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 111 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 112 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 113 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 114 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 115 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 116 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 117 #define elf_backend_special_sections          ppc64_elf_special_sections
 118 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 119
 120 /* The name of the dynamic interpreter.  This is put in the .interp
 121    section.  */
 122 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 123
 124 /* The size in bytes of an entry in the procedure linkage table.  */
 125 #define PLT_ENTRY_SIZE 24
 126
 127 /* The initial size of the plt reserved for the dynamic linker.  */
 128 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 129
 130 /* TOC base pointers offset from start of TOC.  */
 131 #define TOC_BASE_OFF    0x8000
 132
 133 /* Offset of tp and dtp pointers from start of TLS block.  */
 134 #define TP_OFFSET       0x7000
 135 #define DTP_OFFSET      0x8000
 136
 137 /* .plt call stub instructions.  The normal stub is like this, but
 138    sometimes the .plt entry crosses a 64k boundary and we need to
 139    insert an addi to adjust r12.  */
 140 #define PLT_CALL_STUB_SIZE (7*4)
 141 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 142 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 143 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 144 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 145 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 146                                         /* ld    %r11,xxx+16@l(%r12) */
 147 #define BCTR            0x4e800420      /* bctr                      */
 148
 149
 150 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 151 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 152 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 153 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 154
 155 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 156 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 157
 158 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 159
 160 /* glink call stub instructions.  We enter with the index in R0.  */
 161 #define GLINK_CALL_STUB_SIZE (16*4)
 162                                         /* 0:                           */
 163                                         /*  .quad plt0-1f               */
 164                                         /* __glink:                     */
 165 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 166 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 167                                         /* 1:                           */
 168 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 169 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 170 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 171 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 172                                         /*  ld %11,0(%12)               */
 173                                         /*  ld %2,8(%12)                */
 174                                         /*  mtctr %11                   */
 175                                         /*  ld %11,16(%12)              */
 176                                         /*  bctr                        */
 177
 178 /* Pad with this.  */
 179 #define NOP             0x60000000
 180
 181 /* Some other nops.  */
 182 #define CROR_151515     0x4def7b82
 183 #define CROR_313131     0x4ffffb82
 184
 185 /* .glink entries for the first 32k functions are two instructions.  */
 186 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 187 #define B_DOT           0x48000000      /* b     .              */
 188
 189 /* After that, we need two instructions to load the index, followed by
 190    a branch.  */
 191 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 192 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 193
 194 /* Instructions used by the save and restore reg functions.  */
 195 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 196 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 197 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 198 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 199 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 200 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 201 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 202 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 203 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 204 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 205 #define BLR             0x4e800020      /* blr                  */
 206
 207 /* Since .opd is an array of descriptors and each entry will end up
 208    with identical R_PPC64_RELATIVE relocs, there is really no need to
 209    propagate .opd relocs;  The dynamic linker should be taught to
 210    relocate .opd without reloc entries.  */
 211 #ifndef NO_OPD_RELOCS
 212 #define NO_OPD_RELOCS 0
 213 #endif
 214 \f
 215 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 216
 217 /* Relocation HOWTO's.  */
 218 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 219
 220 static reloc_howto_type ppc64_elf_howto_raw[] = {
 221   /* This reloc does nothing.  */
 222   HOWTO (R_PPC64_NONE,          /* type */
 223          0,                     /* rightshift */
 224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          32,                    /* bitsize */
 226          FALSE,                 /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_dont, /* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_PPC64_NONE",        /* name */
 231          FALSE,                 /* partial_inplace */
 232          0,                     /* src_mask */
 233          0,                     /* dst_mask */
 234          FALSE),                /* pcrel_offset */
 235
 236   /* A standard 32 bit relocation.  */
 237   HOWTO (R_PPC64_ADDR32,        /* type */
 238          0,                     /* rightshift */
 239          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 240          32,                    /* bitsize */
 241          FALSE,                 /* pc_relative */
 242          0,                     /* bitpos */
 243          complain_overflow_bitfield, /* complain_on_overflow */
 244          bfd_elf_generic_reloc, /* special_function */
 245          "R_PPC64_ADDR32",      /* name */
 246          FALSE,                 /* partial_inplace */
 247          0,                     /* src_mask */
 248          0xffffffff,            /* dst_mask */
 249          FALSE),                /* pcrel_offset */
 250
 251   /* An absolute 26 bit branch; the lower two bits must be zero.
 252      FIXME: we don't check that, we just clear them.  */
 253   HOWTO (R_PPC64_ADDR24,        /* type */
 254          0,                     /* rightshift */
 255          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 256          26,                    /* bitsize */
 257          FALSE,                 /* pc_relative */
 258          0,                     /* bitpos */
 259          complain_overflow_bitfield, /* complain_on_overflow */
 260          bfd_elf_generic_reloc, /* special_function */
 261          "R_PPC64_ADDR24",      /* name */
 262          FALSE,                 /* partial_inplace */
 263          0,                     /* src_mask */
 264          0x03fffffc,            /* dst_mask */
 265          FALSE),                /* pcrel_offset */
 266
 267   /* A standard 16 bit relocation.  */
 268   HOWTO (R_PPC64_ADDR16,        /* type */
 269          0,                     /* rightshift */
 270          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          16,                    /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_bitfield, /* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_PPC64_ADDR16",      /* name */
 277          FALSE,                 /* partial_inplace */
 278          0,                     /* src_mask */
 279          0xffff,                /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281
 282   /* A 16 bit relocation without overflow.  */
 283   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 284          0,                     /* rightshift */
 285          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 286          16,                    /* bitsize */
 287          FALSE,                 /* pc_relative */
 288          0,                     /* bitpos */
 289          complain_overflow_dont,/* complain_on_overflow */
 290          bfd_elf_generic_reloc, /* special_function */
 291          "R_PPC64_ADDR16_LO",   /* name */
 292          FALSE,                 /* partial_inplace */
 293          0,                     /* src_mask */
 294          0xffff,                /* dst_mask */
 295          FALSE),                /* pcrel_offset */
 296
 297   /* Bits 16-31 of an address.  */
 298   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 299          16,                    /* rightshift */
 300          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 301          16,                    /* bitsize */
 302          FALSE,                 /* pc_relative */
 303          0,                     /* bitpos */
 304          complain_overflow_dont, /* complain_on_overflow */
 305          bfd_elf_generic_reloc, /* special_function */
 306          "R_PPC64_ADDR16_HI",   /* name */
 307          FALSE,                 /* partial_inplace */
 308          0,                     /* src_mask */
 309          0xffff,                /* dst_mask */
 310          FALSE),                /* pcrel_offset */
 311
 312   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 313      bits, treated as a signed number, is negative.  */
 314   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 315          16,                    /* rightshift */
 316          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 317          16,                    /* bitsize */
 318          FALSE,                 /* pc_relative */
 319          0,                     /* bitpos */
 320          complain_overflow_dont, /* complain_on_overflow */
 321          ppc64_elf_ha_reloc,    /* special_function */
 322          "R_PPC64_ADDR16_HA",   /* name */
 323          FALSE,                 /* partial_inplace */
 324          0,                     /* src_mask */
 325          0xffff,                /* dst_mask */
 326          FALSE),                /* pcrel_offset */
 327
 328   /* An absolute 16 bit branch; the lower two bits must be zero.
 329      FIXME: we don't check that, we just clear them.  */
 330   HOWTO (R_PPC64_ADDR14,        /* type */
 331          0,                     /* rightshift */
 332          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          FALSE,                 /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_bitfield, /* complain_on_overflow */
 337          ppc64_elf_branch_reloc, /* special_function */
 338          "R_PPC64_ADDR14",      /* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          0x0000fffc,            /* dst_mask */
 342          FALSE),                /* pcrel_offset */
 343
 344   /* An absolute 16 bit branch, for which bit 10 should be set to
 345      indicate that the branch is expected to be taken.  The lower two
 346      bits must be zero.  */
 347   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 348          0,                     /* rightshift */
 349          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 350          16,                    /* bitsize */
 351          FALSE,                 /* pc_relative */
 352          0,                     /* bitpos */
 353          complain_overflow_bitfield, /* complain_on_overflow */
 354          ppc64_elf_brtaken_reloc, /* special_function */
 355          "R_PPC64_ADDR14_BRTAKEN",/* name */
 356          FALSE,                 /* partial_inplace */
 357          0,                     /* src_mask */
 358          0x0000fffc,            /* dst_mask */
 359          FALSE),                /* pcrel_offset */
 360
 361   /* An absolute 16 bit branch, for which bit 10 should be set to
 362      indicate that the branch is not expected to be taken.  The lower
 363      two bits must be zero.  */
 364   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 365          0,                     /* rightshift */
 366          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 367          16,                    /* bitsize */
 368          FALSE,                 /* pc_relative */
 369          0,                     /* bitpos */
 370          complain_overflow_bitfield, /* complain_on_overflow */
 371          ppc64_elf_brtaken_reloc, /* special_function */
 372          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 373          FALSE,                 /* partial_inplace */
 374          0,                     /* src_mask */
 375          0x0000fffc,            /* dst_mask */
 376          FALSE),                /* pcrel_offset */
 377
 378   /* A relative 26 bit branch; the lower two bits must be zero.  */
 379   HOWTO (R_PPC64_REL24,         /* type */
 380          0,                     /* rightshift */
 381          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          26,                    /* bitsize */
 383          TRUE,                  /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_signed, /* complain_on_overflow */
 386          ppc64_elf_branch_reloc, /* special_function */
 387          "R_PPC64_REL24",       /* name */
 388          FALSE,                 /* partial_inplace */
 389          0,                     /* src_mask */
 390          0x03fffffc,            /* dst_mask */
 391          TRUE),                 /* pcrel_offset */
 392
 393   /* A relative 16 bit branch; the lower two bits must be zero.  */
 394   HOWTO (R_PPC64_REL14,         /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          16,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_signed, /* complain_on_overflow */
 401          ppc64_elf_branch_reloc, /* special_function */
 402          "R_PPC64_REL14",       /* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0x0000fffc,            /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 409      the branch is expected to be taken.  The lower two bits must be
 410      zero.  */
 411   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 412          0,                     /* rightshift */
 413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 414          16,                    /* bitsize */
 415          TRUE,                  /* pc_relative */
 416          0,                     /* bitpos */
 417          complain_overflow_signed, /* complain_on_overflow */
 418          ppc64_elf_brtaken_reloc, /* special_function */
 419          "R_PPC64_REL14_BRTAKEN", /* name */
 420          FALSE,                 /* partial_inplace */
 421          0,                     /* src_mask */
 422          0x0000fffc,            /* dst_mask */
 423          TRUE),                 /* pcrel_offset */
 424
 425   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 426      the branch is not expected to be taken.  The lower two bits must
 427      be zero.  */
 428   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 429          0,                     /* rightshift */
 430          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 431          16,                    /* bitsize */
 432          TRUE,                  /* pc_relative */
 433          0,                     /* bitpos */
 434          complain_overflow_signed, /* complain_on_overflow */
 435          ppc64_elf_brtaken_reloc, /* special_function */
 436          "R_PPC64_REL14_BRNTAKEN",/* name */
 437          FALSE,                 /* partial_inplace */
 438          0,                     /* src_mask */
 439          0x0000fffc,            /* dst_mask */
 440          TRUE),                 /* pcrel_offset */
 441
 442   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 443      symbol.  */
 444   HOWTO (R_PPC64_GOT16,         /* type */
 445          0,                     /* rightshift */
 446          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 447          16,                    /* bitsize */
 448          FALSE,                 /* pc_relative */
 449          0,                     /* bitpos */
 450          complain_overflow_signed, /* complain_on_overflow */
 451          ppc64_elf_unhandled_reloc, /* special_function */
 452          "R_PPC64_GOT16",       /* name */
 453          FALSE,                 /* partial_inplace */
 454          0,                     /* src_mask */
 455          0xffff,                /* dst_mask */
 456          FALSE),                /* pcrel_offset */
 457
 458   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 459      the symbol.  */
 460   HOWTO (R_PPC64_GOT16_LO,      /* type */
 461          0,                     /* rightshift */
 462          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 463          16,                    /* bitsize */
 464          FALSE,                 /* pc_relative */
 465          0,                     /* bitpos */
 466          complain_overflow_dont, /* complain_on_overflow */
 467          ppc64_elf_unhandled_reloc, /* special_function */
 468          "R_PPC64_GOT16_LO",    /* name */
 469          FALSE,                 /* partial_inplace */
 470          0,                     /* src_mask */
 471          0xffff,                /* dst_mask */
 472          FALSE),                /* pcrel_offset */
 473
 474   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 475      the symbol.  */
 476   HOWTO (R_PPC64_GOT16_HI,      /* type */
 477          16,                    /* rightshift */
 478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 479          16,                    /* bitsize */
 480          FALSE,                 /* pc_relative */
 481          0,                     /* bitpos */
 482          complain_overflow_dont,/* complain_on_overflow */
 483          ppc64_elf_unhandled_reloc, /* special_function */
 484          "R_PPC64_GOT16_HI",    /* name */
 485          FALSE,                 /* partial_inplace */
 486          0,                     /* src_mask */
 487          0xffff,                /* dst_mask */
 488          FALSE),                /* pcrel_offset */
 489
 490   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 491      the symbol.  */
 492   HOWTO (R_PPC64_GOT16_HA,      /* type */
 493          16,                    /* rightshift */
 494          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 495          16,                    /* bitsize */
 496          FALSE,                 /* pc_relative */
 497          0,                     /* bitpos */
 498          complain_overflow_dont,/* complain_on_overflow */
 499          ppc64_elf_unhandled_reloc, /* special_function */
 500          "R_PPC64_GOT16_HA",    /* name */
 501          FALSE,                 /* partial_inplace */
 502          0,                     /* src_mask */
 503          0xffff,                /* dst_mask */
 504          FALSE),                /* pcrel_offset */
 505
 506   /* This is used only by the dynamic linker.  The symbol should exist
 507      both in the object being run and in some shared library.  The
 508      dynamic linker copies the data addressed by the symbol from the
 509      shared library into the object, because the object being
 510      run has to have the data at some particular address.  */
 511   HOWTO (R_PPC64_COPY,          /* type */
 512          0,                     /* rightshift */
 513          0,                     /* this one is variable size */
 514          0,                     /* bitsize */
 515          FALSE,                 /* pc_relative */
 516          0,                     /* bitpos */
 517          complain_overflow_dont, /* complain_on_overflow */
 518          ppc64_elf_unhandled_reloc, /* special_function */
 519          "R_PPC64_COPY",        /* name */
 520          FALSE,                 /* partial_inplace */
 521          0,                     /* src_mask */
 522          0,                     /* dst_mask */
 523          FALSE),                /* pcrel_offset */
 524
 525   /* Like R_PPC64_ADDR64, but used when setting global offset table
 526      entries.  */
 527   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 528          0,                     /* rightshift */
 529          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 530          64,                    /* bitsize */
 531          FALSE,                 /* pc_relative */
 532          0,                     /* bitpos */
 533          complain_overflow_dont, /* complain_on_overflow */
 534          ppc64_elf_unhandled_reloc,  /* special_function */
 535          "R_PPC64_GLOB_DAT",    /* name */
 536          FALSE,                 /* partial_inplace */
 537          0,                     /* src_mask */
 538          ONES (64),             /* dst_mask */
 539          FALSE),                /* pcrel_offset */
 540
 541   /* Created by the link editor.  Marks a procedure linkage table
 542      entry for a symbol.  */
 543   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 544          0,                     /* rightshift */
 545          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          0,                     /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_dont, /* complain_on_overflow */
 550          ppc64_elf_unhandled_reloc, /* special_function */
 551          "R_PPC64_JMP_SLOT",    /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          0,                     /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557   /* Used only by the dynamic linker.  When the object is run, this
 558      doubleword64 is set to the load address of the object, plus the
 559      addend.  */
 560   HOWTO (R_PPC64_RELATIVE,      /* type */
 561          0,                     /* rightshift */
 562          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 563          64,                    /* bitsize */
 564          FALSE,                 /* pc_relative */
 565          0,                     /* bitpos */
 566          complain_overflow_dont, /* complain_on_overflow */
 567          bfd_elf_generic_reloc, /* special_function */
 568          "R_PPC64_RELATIVE",    /* name */
 569          FALSE,                 /* partial_inplace */
 570          0,                     /* src_mask */
 571          ONES (64),             /* dst_mask */
 572          FALSE),                /* pcrel_offset */
 573
 574   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 575   HOWTO (R_PPC64_UADDR32,       /* type */
 576          0,                     /* rightshift */
 577          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 578          32,                    /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          0,                     /* bitpos */
 581          complain_overflow_bitfield, /* complain_on_overflow */
 582          bfd_elf_generic_reloc, /* special_function */
 583          "R_PPC64_UADDR32",     /* name */
 584          FALSE,                 /* partial_inplace */
 585          0,                     /* src_mask */
 586          0xffffffff,            /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 590   HOWTO (R_PPC64_UADDR16,       /* type */
 591          0,                     /* rightshift */
 592          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 593          16,                    /* bitsize */
 594          FALSE,                 /* pc_relative */
 595          0,                     /* bitpos */
 596          complain_overflow_bitfield, /* complain_on_overflow */
 597          bfd_elf_generic_reloc, /* special_function */
 598          "R_PPC64_UADDR16",     /* name */
 599          FALSE,                 /* partial_inplace */
 600          0,                     /* src_mask */
 601          0xffff,                /* dst_mask */
 602          FALSE),                /* pcrel_offset */
 603
 604   /* 32-bit PC relative.  */
 605   HOWTO (R_PPC64_REL32,         /* type */
 606          0,                     /* rightshift */
 607          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 608          32,                    /* bitsize */
 609          TRUE,                  /* pc_relative */
 610          0,                     /* bitpos */
 611          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 612          complain_overflow_signed, /* complain_on_overflow */
 613          bfd_elf_generic_reloc, /* special_function */
 614          "R_PPC64_REL32",       /* name */
 615          FALSE,                 /* partial_inplace */
 616          0,                     /* src_mask */
 617          0xffffffff,            /* dst_mask */
 618          TRUE),                 /* pcrel_offset */
 619
 620   /* 32-bit relocation to the symbol's procedure linkage table.  */
 621   HOWTO (R_PPC64_PLT32,         /* type */
 622          0,                     /* rightshift */
 623          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 624          32,                    /* bitsize */
 625          FALSE,                 /* pc_relative */
 626          0,                     /* bitpos */
 627          complain_overflow_bitfield, /* complain_on_overflow */
 628          ppc64_elf_unhandled_reloc, /* special_function */
 629          "R_PPC64_PLT32",       /* name */
 630          FALSE,                 /* partial_inplace */
 631          0,                     /* src_mask */
 632          0xffffffff,            /* dst_mask */
 633          FALSE),                /* pcrel_offset */
 634
 635   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 636      FIXME: R_PPC64_PLTREL32 not supported.  */
 637   HOWTO (R_PPC64_PLTREL32,      /* type */
 638          0,                     /* rightshift */
 639          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          32,                    /* bitsize */
 641          TRUE,                  /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_signed, /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_PPC64_PLTREL32",    /* name */
 646          FALSE,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0xffffffff,            /* dst_mask */
 649          TRUE),                 /* pcrel_offset */
 650
 651   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 652      the symbol.  */
 653   HOWTO (R_PPC64_PLT16_LO,      /* type */
 654          0,                     /* rightshift */
 655          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          16,                    /* bitsize */
 657          FALSE,                 /* pc_relative */
 658          0,                     /* bitpos */
 659          complain_overflow_dont, /* complain_on_overflow */
 660          ppc64_elf_unhandled_reloc, /* special_function */
 661          "R_PPC64_PLT16_LO",    /* name */
 662          FALSE,                 /* partial_inplace */
 663          0,                     /* src_mask */
 664          0xffff,                /* dst_mask */
 665          FALSE),                /* pcrel_offset */
 666
 667   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 668      the symbol.  */
 669   HOWTO (R_PPC64_PLT16_HI,      /* type */
 670          16,                    /* rightshift */
 671          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 672          16,                    /* bitsize */
 673          FALSE,                 /* pc_relative */
 674          0,                     /* bitpos */
 675          complain_overflow_dont, /* complain_on_overflow */
 676          ppc64_elf_unhandled_reloc, /* special_function */
 677          "R_PPC64_PLT16_HI",    /* name */
 678          FALSE,                 /* partial_inplace */
 679          0,                     /* src_mask */
 680          0xffff,                /* dst_mask */
 681          FALSE),                /* pcrel_offset */
 682
 683   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 684      the symbol.  */
 685   HOWTO (R_PPC64_PLT16_HA,      /* type */
 686          16,                    /* rightshift */
 687          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 688          16,                    /* bitsize */
 689          FALSE,                 /* pc_relative */
 690          0,                     /* bitpos */
 691          complain_overflow_dont, /* complain_on_overflow */
 692          ppc64_elf_unhandled_reloc, /* special_function */
 693          "R_PPC64_PLT16_HA",    /* name */
 694          FALSE,                 /* partial_inplace */
 695          0,                     /* src_mask */
 696          0xffff,                /* dst_mask */
 697          FALSE),                /* pcrel_offset */
 698
 699   /* 16-bit section relative relocation.  */
 700   HOWTO (R_PPC64_SECTOFF,       /* type */
 701          0,                     /* rightshift */
 702          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 703          16,                    /* bitsize */
 704          FALSE,                 /* pc_relative */
 705          0,                     /* bitpos */
 706          complain_overflow_bitfield, /* complain_on_overflow */
 707          ppc64_elf_sectoff_reloc, /* special_function */
 708          "R_PPC64_SECTOFF",     /* name */
 709          FALSE,                 /* partial_inplace */
 710          0,                     /* src_mask */
 711          0xffff,                /* dst_mask */
 712          FALSE),                /* pcrel_offset */
 713
 714   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 715   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 716          0,                     /* rightshift */
 717          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_dont, /* complain_on_overflow */
 722          ppc64_elf_sectoff_reloc, /* special_function */
 723          "R_PPC64_SECTOFF_LO",  /* name */
 724          FALSE,                 /* partial_inplace */
 725          0,                     /* src_mask */
 726          0xffff,                /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   /* 16-bit upper half section relative relocation.  */
 730   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 731          16,                    /* rightshift */
 732          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 733          16,                    /* bitsize */
 734          FALSE,                 /* pc_relative */
 735          0,                     /* bitpos */
 736          complain_overflow_dont, /* complain_on_overflow */
 737          ppc64_elf_sectoff_reloc, /* special_function */
 738          "R_PPC64_SECTOFF_HI",  /* name */
 739          FALSE,                 /* partial_inplace */
 740          0,                     /* src_mask */
 741          0xffff,                /* dst_mask */
 742          FALSE),                /* pcrel_offset */
 743
 744   /* 16-bit upper half adjusted section relative relocation.  */
 745   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 746          16,                    /* rightshift */
 747          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 748          16,                    /* bitsize */
 749          FALSE,                 /* pc_relative */
 750          0,                     /* bitpos */
 751          complain_overflow_dont, /* complain_on_overflow */
 752          ppc64_elf_sectoff_ha_reloc, /* special_function */
 753          "R_PPC64_SECTOFF_HA",  /* name */
 754          FALSE,                 /* partial_inplace */
 755          0,                     /* src_mask */
 756          0xffff,                /* dst_mask */
 757          FALSE),                /* pcrel_offset */
 758
 759   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 760   HOWTO (R_PPC64_REL30,         /* type */
 761          2,                     /* rightshift */
 762          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          30,                    /* bitsize */
 764          TRUE,                  /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_dont, /* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_PPC64_REL30",       /* name */
 769          FALSE,                 /* partial_inplace */
 770          0,                     /* src_mask */
 771          0xfffffffc,            /* dst_mask */
 772          TRUE),                 /* pcrel_offset */
 773
 774   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 775
 776   /* A standard 64-bit relocation.  */
 777   HOWTO (R_PPC64_ADDR64,        /* type */
 778          0,                     /* rightshift */
 779          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 780          64,                    /* bitsize */
 781          FALSE,                 /* pc_relative */
 782          0,                     /* bitpos */
 783          complain_overflow_dont, /* complain_on_overflow */
 784          bfd_elf_generic_reloc, /* special_function */
 785          "R_PPC64_ADDR64",      /* name */
 786          FALSE,                 /* partial_inplace */
 787          0,                     /* src_mask */
 788          ONES (64),             /* dst_mask */
 789          FALSE),                /* pcrel_offset */
 790
 791   /* The bits 32-47 of an address.  */
 792   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 793          32,                    /* rightshift */
 794          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          FALSE,                 /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_dont, /* complain_on_overflow */
 799          bfd_elf_generic_reloc, /* special_function */
 800          "R_PPC64_ADDR16_HIGHER", /* name */
 801          FALSE,                 /* partial_inplace */
 802          0,                     /* src_mask */
 803          0xffff,                /* dst_mask */
 804          FALSE),                /* pcrel_offset */
 805
 806   /* The bits 32-47 of an address, plus 1 if the contents of the low
 807      16 bits, treated as a signed number, is negative.  */
 808   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 809          32,                    /* rightshift */
 810          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 811          16,                    /* bitsize */
 812          FALSE,                 /* pc_relative */
 813          0,                     /* bitpos */
 814          complain_overflow_dont, /* complain_on_overflow */
 815          ppc64_elf_ha_reloc,    /* special_function */
 816          "R_PPC64_ADDR16_HIGHERA", /* name */
 817          FALSE,                 /* partial_inplace */
 818          0,                     /* src_mask */
 819          0xffff,                /* dst_mask */
 820          FALSE),                /* pcrel_offset */
 821
 822   /* The bits 48-63 of an address.  */
 823   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 824          48,                    /* rightshift */
 825          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 826          16,                    /* bitsize */
 827          FALSE,                 /* pc_relative */
 828          0,                     /* bitpos */
 829          complain_overflow_dont, /* complain_on_overflow */
 830          bfd_elf_generic_reloc, /* special_function */
 831          "R_PPC64_ADDR16_HIGHEST", /* name */
 832          FALSE,                 /* partial_inplace */
 833          0,                     /* src_mask */
 834          0xffff,                /* dst_mask */
 835          FALSE),                /* pcrel_offset */
 836
 837   /* The bits 48-63 of an address, plus 1 if the contents of the low
 838      16 bits, treated as a signed number, is negative.  */
 839   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 840          48,                    /* rightshift */
 841          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 842          16,                    /* bitsize */
 843          FALSE,                 /* pc_relative */
 844          0,                     /* bitpos */
 845          complain_overflow_dont, /* complain_on_overflow */
 846          ppc64_elf_ha_reloc,    /* special_function */
 847          "R_PPC64_ADDR16_HIGHESTA", /* name */
 848          FALSE,                 /* partial_inplace */
 849          0,                     /* src_mask */
 850          0xffff,                /* dst_mask */
 851          FALSE),                /* pcrel_offset */
 852
 853   /* Like ADDR64, but may be unaligned.  */
 854   HOWTO (R_PPC64_UADDR64,       /* type */
 855          0,                     /* rightshift */
 856          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 857          64,                    /* bitsize */
 858          FALSE,                 /* pc_relative */
 859          0,                     /* bitpos */
 860          complain_overflow_dont, /* complain_on_overflow */
 861          bfd_elf_generic_reloc, /* special_function */
 862          "R_PPC64_UADDR64",     /* name */
 863          FALSE,                 /* partial_inplace */
 864          0,                     /* src_mask */
 865          ONES (64),             /* dst_mask */
 866          FALSE),                /* pcrel_offset */
 867
 868   /* 64-bit relative relocation.  */
 869   HOWTO (R_PPC64_REL64,         /* type */
 870          0,                     /* rightshift */
 871          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 872          64,                    /* bitsize */
 873          TRUE,                  /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_PPC64_REL64",       /* name */
 878          FALSE,                 /* partial_inplace */
 879          0,                     /* src_mask */
 880          ONES (64),             /* dst_mask */
 881          TRUE),                 /* pcrel_offset */
 882
 883   /* 64-bit relocation to the symbol's procedure linkage table.  */
 884   HOWTO (R_PPC64_PLT64,         /* type */
 885          0,                     /* rightshift */
 886          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 887          64,                    /* bitsize */
 888          FALSE,                 /* pc_relative */
 889          0,                     /* bitpos */
 890          complain_overflow_dont, /* complain_on_overflow */
 891          ppc64_elf_unhandled_reloc, /* special_function */
 892          "R_PPC64_PLT64",       /* name */
 893          FALSE,                 /* partial_inplace */
 894          0,                     /* src_mask */
 895          ONES (64),             /* dst_mask */
 896          FALSE),                /* pcrel_offset */
 897
 898   /* 64-bit PC relative relocation to the symbol's procedure linkage
 899      table.  */
 900   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 901   HOWTO (R_PPC64_PLTREL64,      /* type */
 902          0,                     /* rightshift */
 903          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 904          64,                    /* bitsize */
 905          TRUE,                  /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_dont, /* complain_on_overflow */
 908          ppc64_elf_unhandled_reloc, /* special_function */
 909          "R_PPC64_PLTREL64",    /* name */
 910          FALSE,                 /* partial_inplace */
 911          0,                     /* src_mask */
 912          ONES (64),             /* dst_mask */
 913          TRUE),                 /* pcrel_offset */
 914
 915   /* 16 bit TOC-relative relocation.  */
 916
 917   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 918   HOWTO (R_PPC64_TOC16,         /* type */
 919          0,                     /* rightshift */
 920          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 921          16,                    /* bitsize */
 922          FALSE,                 /* pc_relative */
 923          0,                     /* bitpos */
 924          complain_overflow_signed, /* complain_on_overflow */
 925          ppc64_elf_toc_reloc,   /* special_function */
 926          "R_PPC64_TOC16",       /* name */
 927          FALSE,                 /* partial_inplace */
 928          0,                     /* src_mask */
 929          0xffff,                /* dst_mask */
 930          FALSE),                /* pcrel_offset */
 931
 932   /* 16 bit TOC-relative relocation without overflow.  */
 933
 934   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 935   HOWTO (R_PPC64_TOC16_LO,      /* type */
 936          0,                     /* rightshift */
 937          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 938          16,                    /* bitsize */
 939          FALSE,                 /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont, /* complain_on_overflow */
 942          ppc64_elf_toc_reloc,   /* special_function */
 943          "R_PPC64_TOC16_LO",    /* name */
 944          FALSE,                 /* partial_inplace */
 945          0,                     /* src_mask */
 946          0xffff,                /* dst_mask */
 947          FALSE),                /* pcrel_offset */
 948
 949   /* 16 bit TOC-relative relocation, high 16 bits.  */
 950
 951   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 952   HOWTO (R_PPC64_TOC16_HI,      /* type */
 953          16,                    /* rightshift */
 954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 955          16,                    /* bitsize */
 956          FALSE,                 /* pc_relative */
 957          0,                     /* bitpos */
 958          complain_overflow_dont, /* complain_on_overflow */
 959          ppc64_elf_toc_reloc,   /* special_function */
 960          "R_PPC64_TOC16_HI",    /* name */
 961          FALSE,                 /* partial_inplace */
 962          0,                     /* src_mask */
 963          0xffff,                /* dst_mask */
 964          FALSE),                /* pcrel_offset */
 965
 966   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 967      contents of the low 16 bits, treated as a signed number, is
 968      negative.  */
 969
 970   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 971   HOWTO (R_PPC64_TOC16_HA,      /* type */
 972          16,                    /* rightshift */
 973          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 974          16,                    /* bitsize */
 975          FALSE,                 /* pc_relative */
 976          0,                     /* bitpos */
 977          complain_overflow_dont, /* complain_on_overflow */
 978          ppc64_elf_toc_ha_reloc, /* special_function */
 979          "R_PPC64_TOC16_HA",    /* name */
 980          FALSE,                 /* partial_inplace */
 981          0,                     /* src_mask */
 982          0xffff,                /* dst_mask */
 983          FALSE),                /* pcrel_offset */
 984
 985   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 986
 987   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 988   HOWTO (R_PPC64_TOC,           /* type */
 989          0,                     /* rightshift */
 990          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 991          64,                    /* bitsize */
 992          FALSE,                 /* pc_relative */
 993          0,                     /* bitpos */
 994          complain_overflow_bitfield, /* complain_on_overflow */
 995          ppc64_elf_toc64_reloc, /* special_function */
 996          "R_PPC64_TOC",         /* name */
 997          FALSE,                 /* partial_inplace */
 998          0,                     /* src_mask */
 999          ONES (64),             /* dst_mask */
1000          FALSE),                /* pcrel_offset */
1001
1002   /* Like R_PPC64_GOT16, but also informs the link editor that the
1003      value to relocate may (!) refer to a PLT entry which the link
1004      editor (a) may replace with the symbol value.  If the link editor
1005      is unable to fully resolve the symbol, it may (b) create a PLT
1006      entry and store the address to the new PLT entry in the GOT.
1007      This permits lazy resolution of function symbols at run time.
1008      The link editor may also skip all of this and just (c) emit a
1009      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1010   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1011     HOWTO (R_PPC64_PLTGOT16,    /* type */
1012          0,                     /* rightshift */
1013          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1014          16,                    /* bitsize */
1015          FALSE,                 /* pc_relative */
1016          0,                     /* bitpos */
1017          complain_overflow_signed, /* complain_on_overflow */
1018          ppc64_elf_unhandled_reloc, /* special_function */
1019          "R_PPC64_PLTGOT16",    /* name */
1020          FALSE,                 /* partial_inplace */
1021          0,                     /* src_mask */
1022          0xffff,                /* dst_mask */
1023          FALSE),                /* pcrel_offset */
1024
1025   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1026   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1027   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1028          0,                     /* rightshift */
1029          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1030          16,                    /* bitsize */
1031          FALSE,                 /* pc_relative */
1032          0,                     /* bitpos */
1033          complain_overflow_dont, /* complain_on_overflow */
1034          ppc64_elf_unhandled_reloc, /* special_function */
1035          "R_PPC64_PLTGOT16_LO", /* name */
1036          FALSE,                 /* partial_inplace */
1037          0,                     /* src_mask */
1038          0xffff,                /* dst_mask */
1039          FALSE),                /* pcrel_offset */
1040
1041   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1042   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1043   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1044          16,                    /* rightshift */
1045          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1046          16,                    /* bitsize */
1047          FALSE,                 /* pc_relative */
1048          0,                     /* bitpos */
1049          complain_overflow_dont, /* complain_on_overflow */
1050          ppc64_elf_unhandled_reloc, /* special_function */
1051          "R_PPC64_PLTGOT16_HI", /* name */
1052          FALSE,                 /* partial_inplace */
1053          0,                     /* src_mask */
1054          0xffff,                /* dst_mask */
1055          FALSE),                /* pcrel_offset */
1056
1057   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1058      1 if the contents of the low 16 bits, treated as a signed number,
1059      is negative.  */
1060   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1061   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1062          16,                    /* rightshift */
1063          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          16,                    /* bitsize */
1065          FALSE,                 /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_dont,/* complain_on_overflow */
1068          ppc64_elf_unhandled_reloc, /* special_function */
1069          "R_PPC64_PLTGOT16_HA", /* name */
1070          FALSE,                 /* partial_inplace */
1071          0,                     /* src_mask */
1072          0xffff,                /* dst_mask */
1073          FALSE),                /* pcrel_offset */
1074
1075   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1076   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1077          0,                     /* rightshift */
1078          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1079          16,                    /* bitsize */
1080          FALSE,                 /* pc_relative */
1081          0,                     /* bitpos */
1082          complain_overflow_bitfield, /* complain_on_overflow */
1083          bfd_elf_generic_reloc, /* special_function */
1084          "R_PPC64_ADDR16_DS",   /* name */
1085          FALSE,                 /* partial_inplace */
1086          0,                     /* src_mask */
1087          0xfffc,                /* dst_mask */
1088          FALSE),                /* pcrel_offset */
1089
1090   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1091   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1092          0,                     /* rightshift */
1093          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          16,                    /* bitsize */
1095          FALSE,                 /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_dont,/* complain_on_overflow */
1098          bfd_elf_generic_reloc, /* special_function */
1099          "R_PPC64_ADDR16_LO_DS",/* name */
1100          FALSE,                 /* partial_inplace */
1101          0,                     /* src_mask */
1102          0xfffc,                /* dst_mask */
1103          FALSE),                /* pcrel_offset */
1104
1105   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1106   HOWTO (R_PPC64_GOT16_DS,      /* type */
1107          0,                     /* rightshift */
1108          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1109          16,                    /* bitsize */
1110          FALSE,                 /* pc_relative */
1111          0,                     /* bitpos */
1112          complain_overflow_signed, /* complain_on_overflow */
1113          ppc64_elf_unhandled_reloc, /* special_function */
1114          "R_PPC64_GOT16_DS",    /* name */
1115          FALSE,                 /* partial_inplace */
1116          0,                     /* src_mask */
1117          0xfffc,                /* dst_mask */
1118          FALSE),                /* pcrel_offset */
1119
1120   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1121   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1122          0,                     /* rightshift */
1123          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1124          16,                    /* bitsize */
1125          FALSE,                 /* pc_relative */
1126          0,                     /* bitpos */
1127          complain_overflow_dont, /* complain_on_overflow */
1128          ppc64_elf_unhandled_reloc, /* special_function */
1129          "R_PPC64_GOT16_LO_DS", /* name */
1130          FALSE,                 /* partial_inplace */
1131          0,                     /* src_mask */
1132          0xfffc,                /* dst_mask */
1133          FALSE),                /* pcrel_offset */
1134
1135   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1136   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1137          0,                     /* rightshift */
1138          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1139          16,                    /* bitsize */
1140          FALSE,                 /* pc_relative */
1141          0,                     /* bitpos */
1142          complain_overflow_dont, /* complain_on_overflow */
1143          ppc64_elf_unhandled_reloc, /* special_function */
1144          "R_PPC64_PLT16_LO_DS", /* name */
1145          FALSE,                 /* partial_inplace */
1146          0,                     /* src_mask */
1147          0xfffc,                /* dst_mask */
1148          FALSE),                /* pcrel_offset */
1149
1150   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1151   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1152          0,                     /* rightshift */
1153          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1154          16,                    /* bitsize */
1155          FALSE,                 /* pc_relative */
1156          0,                     /* bitpos */
1157          complain_overflow_bitfield, /* complain_on_overflow */
1158          ppc64_elf_sectoff_reloc, /* special_function */
1159          "R_PPC64_SECTOFF_DS",  /* name */
1160          FALSE,                 /* partial_inplace */
1161          0,                     /* src_mask */
1162          0xfffc,                /* dst_mask */
1163          FALSE),                /* pcrel_offset */
1164
1165   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1166   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1167          0,                     /* rightshift */
1168          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1169          16,                    /* bitsize */
1170          FALSE,                 /* pc_relative */
1171          0,                     /* bitpos */
1172          complain_overflow_dont, /* complain_on_overflow */
1173          ppc64_elf_sectoff_reloc, /* special_function */
1174          "R_PPC64_SECTOFF_LO_DS",/* name */
1175          FALSE,                 /* partial_inplace */
1176          0,                     /* src_mask */
1177          0xfffc,                /* dst_mask */
1178          FALSE),                /* pcrel_offset */
1179
1180   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1181   HOWTO (R_PPC64_TOC16_DS,      /* type */
1182          0,                     /* rightshift */
1183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1184          16,                    /* bitsize */
1185          FALSE,                 /* pc_relative */
1186          0,                     /* bitpos */
1187          complain_overflow_signed, /* complain_on_overflow */
1188          ppc64_elf_toc_reloc,   /* special_function */
1189          "R_PPC64_TOC16_DS",    /* name */
1190          FALSE,                 /* partial_inplace */
1191          0,                     /* src_mask */
1192          0xfffc,                /* dst_mask */
1193          FALSE),                /* pcrel_offset */
1194
1195   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1196   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1197          0,                     /* rightshift */
1198          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1199          16,                    /* bitsize */
1200          FALSE,                 /* pc_relative */
1201          0,                     /* bitpos */
1202          complain_overflow_dont, /* complain_on_overflow */
1203          ppc64_elf_toc_reloc,   /* special_function */
1204          "R_PPC64_TOC16_LO_DS", /* name */
1205          FALSE,                 /* partial_inplace */
1206          0,                     /* src_mask */
1207          0xfffc,                /* dst_mask */
1208          FALSE),                /* pcrel_offset */
1209
1210   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1211   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1212   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1213          0,                     /* rightshift */
1214          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1215          16,                    /* bitsize */
1216          FALSE,                 /* pc_relative */
1217          0,                     /* bitpos */
1218          complain_overflow_signed, /* complain_on_overflow */
1219          ppc64_elf_unhandled_reloc, /* special_function */
1220          "R_PPC64_PLTGOT16_DS", /* name */
1221          FALSE,                 /* partial_inplace */
1222          0,                     /* src_mask */
1223          0xfffc,                /* dst_mask */
1224          FALSE),                /* pcrel_offset */
1225
1226   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1227   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1228   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1229          0,                     /* rightshift */
1230          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1231          16,                    /* bitsize */
1232          FALSE,                 /* pc_relative */
1233          0,                     /* bitpos */
1234          complain_overflow_dont, /* complain_on_overflow */
1235          ppc64_elf_unhandled_reloc, /* special_function */
1236          "R_PPC64_PLTGOT16_LO_DS",/* name */
1237          FALSE,                 /* partial_inplace */
1238          0,                     /* src_mask */
1239          0xfffc,                /* dst_mask */
1240          FALSE),                /* pcrel_offset */
1241
1242   /* Marker relocs for TLS.  */
1243   HOWTO (R_PPC64_TLS,
1244          0,                     /* rightshift */
1245          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1246          32,                    /* bitsize */
1247          FALSE,                 /* pc_relative */
1248          0,                     /* bitpos */
1249          complain_overflow_dont, /* complain_on_overflow */
1250          bfd_elf_generic_reloc, /* special_function */
1251          "R_PPC64_TLS",         /* name */
1252          FALSE,                 /* partial_inplace */
1253          0,                     /* src_mask */
1254          0,                     /* dst_mask */
1255          FALSE),                /* pcrel_offset */
1256
1257   HOWTO (R_PPC64_TLSGD,
1258          0,                     /* rightshift */
1259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1260          32,                    /* bitsize */
1261          FALSE,                 /* pc_relative */
1262          0,                     /* bitpos */
1263          complain_overflow_dont, /* complain_on_overflow */
1264          bfd_elf_generic_reloc, /* special_function */
1265          "R_PPC64_TLSGD",       /* name */
1266          FALSE,                 /* partial_inplace */
1267          0,                     /* src_mask */
1268          0,                     /* dst_mask */
1269          FALSE),                /* pcrel_offset */
1270
1271   HOWTO (R_PPC64_TLSLD,
1272          0,                     /* rightshift */
1273          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1274          32,                    /* bitsize */
1275          FALSE,                 /* pc_relative */
1276          0,                     /* bitpos */
1277          complain_overflow_dont, /* complain_on_overflow */
1278          bfd_elf_generic_reloc, /* special_function */
1279          "R_PPC64_TLSLD",       /* name */
1280          FALSE,                 /* partial_inplace */
1281          0,                     /* src_mask */
1282          0,                     /* dst_mask */
1283          FALSE),                /* pcrel_offset */
1284
1285   HOWTO (R_PPC64_TOCSAVE,
1286          0,                     /* rightshift */
1287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1288          32,                    /* bitsize */
1289          FALSE,                 /* pc_relative */
1290          0,                     /* bitpos */
1291          complain_overflow_dont, /* complain_on_overflow */
1292          bfd_elf_generic_reloc, /* special_function */
1293          "R_PPC64_TOCSAVE",     /* name */
1294          FALSE,                 /* partial_inplace */
1295          0,                     /* src_mask */
1296          0,                     /* dst_mask */
1297          FALSE),                /* pcrel_offset */
1298
1299   /* Computes the load module index of the load module that contains the
1300      definition of its TLS sym.  */
1301   HOWTO (R_PPC64_DTPMOD64,
1302          0,                     /* rightshift */
1303          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          64,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont, /* complain_on_overflow */
1308          ppc64_elf_unhandled_reloc, /* special_function */
1309          "R_PPC64_DTPMOD64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* Computes a dtv-relative displacement, the difference between the value
1316      of sym+add and the base address of the thread-local storage block that
1317      contains the definition of sym, minus 0x8000.  */
1318   HOWTO (R_PPC64_DTPREL64,
1319          0,                     /* rightshift */
1320          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1321          64,                    /* bitsize */
1322          FALSE,                 /* pc_relative */
1323          0,                     /* bitpos */
1324          complain_overflow_dont, /* complain_on_overflow */
1325          ppc64_elf_unhandled_reloc, /* special_function */
1326          "R_PPC64_DTPREL64",    /* name */
1327          FALSE,                 /* partial_inplace */
1328          0,                     /* src_mask */
1329          ONES (64),             /* dst_mask */
1330          FALSE),                /* pcrel_offset */
1331
1332   /* A 16 bit dtprel reloc.  */
1333   HOWTO (R_PPC64_DTPREL16,
1334          0,                     /* rightshift */
1335          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1336          16,                    /* bitsize */
1337          FALSE,                 /* pc_relative */
1338          0,                     /* bitpos */
1339          complain_overflow_signed, /* complain_on_overflow */
1340          ppc64_elf_unhandled_reloc, /* special_function */
1341          "R_PPC64_DTPREL16",    /* name */
1342          FALSE,                 /* partial_inplace */
1343          0,                     /* src_mask */
1344          0xffff,                /* dst_mask */
1345          FALSE),                /* pcrel_offset */
1346
1347   /* Like DTPREL16, but no overflow.  */
1348   HOWTO (R_PPC64_DTPREL16_LO,
1349          0,                     /* rightshift */
1350          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1351          16,                    /* bitsize */
1352          FALSE,                 /* pc_relative */
1353          0,                     /* bitpos */
1354          complain_overflow_dont, /* complain_on_overflow */
1355          ppc64_elf_unhandled_reloc, /* special_function */
1356          "R_PPC64_DTPREL16_LO", /* name */
1357          FALSE,                 /* partial_inplace */
1358          0,                     /* src_mask */
1359          0xffff,                /* dst_mask */
1360          FALSE),                /* pcrel_offset */
1361
1362   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1363   HOWTO (R_PPC64_DTPREL16_HI,
1364          16,                    /* rightshift */
1365          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1366          16,                    /* bitsize */
1367          FALSE,                 /* pc_relative */
1368          0,                     /* bitpos */
1369          complain_overflow_dont, /* complain_on_overflow */
1370          ppc64_elf_unhandled_reloc, /* special_function */
1371          "R_PPC64_DTPREL16_HI", /* name */
1372          FALSE,                 /* partial_inplace */
1373          0,                     /* src_mask */
1374          0xffff,                /* dst_mask */
1375          FALSE),                /* pcrel_offset */
1376
1377   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1378   HOWTO (R_PPC64_DTPREL16_HA,
1379          16,                    /* rightshift */
1380          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1381          16,                    /* bitsize */
1382          FALSE,                 /* pc_relative */
1383          0,                     /* bitpos */
1384          complain_overflow_dont, /* complain_on_overflow */
1385          ppc64_elf_unhandled_reloc, /* special_function */
1386          "R_PPC64_DTPREL16_HA", /* name */
1387          FALSE,                 /* partial_inplace */
1388          0,                     /* src_mask */
1389          0xffff,                /* dst_mask */
1390          FALSE),                /* pcrel_offset */
1391
1392   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1393   HOWTO (R_PPC64_DTPREL16_HIGHER,
1394          32,                    /* rightshift */
1395          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1396          16,                    /* bitsize */
1397          FALSE,                 /* pc_relative */
1398          0,                     /* bitpos */
1399          complain_overflow_dont, /* complain_on_overflow */
1400          ppc64_elf_unhandled_reloc, /* special_function */
1401          "R_PPC64_DTPREL16_HIGHER", /* name */
1402          FALSE,                 /* partial_inplace */
1403          0,                     /* src_mask */
1404          0xffff,                /* dst_mask */
1405          FALSE),                /* pcrel_offset */
1406
1407   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1408   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1409          32,                    /* rightshift */
1410          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1411          16,                    /* bitsize */
1412          FALSE,                 /* pc_relative */
1413          0,                     /* bitpos */
1414          complain_overflow_dont, /* complain_on_overflow */
1415          ppc64_elf_unhandled_reloc, /* special_function */
1416          "R_PPC64_DTPREL16_HIGHERA", /* name */
1417          FALSE,                 /* partial_inplace */
1418          0,                     /* src_mask */
1419          0xffff,                /* dst_mask */
1420          FALSE),                /* pcrel_offset */
1421
1422   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1423   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1424          48,                    /* rightshift */
1425          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1426          16,                    /* bitsize */
1427          FALSE,                 /* pc_relative */
1428          0,                     /* bitpos */
1429          complain_overflow_dont, /* complain_on_overflow */
1430          ppc64_elf_unhandled_reloc, /* special_function */
1431          "R_PPC64_DTPREL16_HIGHEST", /* name */
1432          FALSE,                 /* partial_inplace */
1433          0,                     /* src_mask */
1434          0xffff,                /* dst_mask */
1435          FALSE),                /* pcrel_offset */
1436
1437   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1438   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1439          48,                    /* rightshift */
1440          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1441          16,                    /* bitsize */
1442          FALSE,                 /* pc_relative */
1443          0,                     /* bitpos */
1444          complain_overflow_dont, /* complain_on_overflow */
1445          ppc64_elf_unhandled_reloc, /* special_function */
1446          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1447          FALSE,                 /* partial_inplace */
1448          0,                     /* src_mask */
1449          0xffff,                /* dst_mask */
1450          FALSE),                /* pcrel_offset */
1451
1452   /* Like DTPREL16, but for insns with a DS field.  */
1453   HOWTO (R_PPC64_DTPREL16_DS,
1454          0,                     /* rightshift */
1455          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1456          16,                    /* bitsize */
1457          FALSE,                 /* pc_relative */
1458          0,                     /* bitpos */
1459          complain_overflow_signed, /* complain_on_overflow */
1460          ppc64_elf_unhandled_reloc, /* special_function */
1461          "R_PPC64_DTPREL16_DS", /* name */
1462          FALSE,                 /* partial_inplace */
1463          0,                     /* src_mask */
1464          0xfffc,                /* dst_mask */
1465          FALSE),                /* pcrel_offset */
1466
1467   /* Like DTPREL16_DS, but no overflow.  */
1468   HOWTO (R_PPC64_DTPREL16_LO_DS,
1469          0,                     /* rightshift */
1470          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1471          16,                    /* bitsize */
1472          FALSE,                 /* pc_relative */
1473          0,                     /* bitpos */
1474          complain_overflow_dont, /* complain_on_overflow */
1475          ppc64_elf_unhandled_reloc, /* special_function */
1476          "R_PPC64_DTPREL16_LO_DS", /* name */
1477          FALSE,                 /* partial_inplace */
1478          0,                     /* src_mask */
1479          0xfffc,                /* dst_mask */
1480          FALSE),                /* pcrel_offset */
1481
1482   /* Computes a tp-relative displacement, the difference between the value of
1483      sym+add and the value of the thread pointer (r13).  */
1484   HOWTO (R_PPC64_TPREL64,
1485          0,                     /* rightshift */
1486          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          64,                    /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          ppc64_elf_unhandled_reloc, /* special_function */
1492          "R_PPC64_TPREL64",     /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          ONES (64),             /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* A 16 bit tprel reloc.  */
1499   HOWTO (R_PPC64_TPREL16,
1500          0,                     /* rightshift */
1501          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          16,                    /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_signed, /* complain_on_overflow */
1506          ppc64_elf_unhandled_reloc, /* special_function */
1507          "R_PPC64_TPREL16",     /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0xffff,                /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   /* Like TPREL16, but no overflow.  */
1514   HOWTO (R_PPC64_TPREL16_LO,
1515          0,                     /* rightshift */
1516          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1517          16,                    /* bitsize */
1518          FALSE,                 /* pc_relative */
1519          0,                     /* bitpos */
1520          complain_overflow_dont, /* complain_on_overflow */
1521          ppc64_elf_unhandled_reloc, /* special_function */
1522          "R_PPC64_TPREL16_LO",  /* name */
1523          FALSE,                 /* partial_inplace */
1524          0,                     /* src_mask */
1525          0xffff,                /* dst_mask */
1526          FALSE),                /* pcrel_offset */
1527
1528   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1529   HOWTO (R_PPC64_TPREL16_HI,
1530          16,                    /* rightshift */
1531          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1532          16,                    /* bitsize */
1533          FALSE,                 /* pc_relative */
1534          0,                     /* bitpos */
1535          complain_overflow_dont, /* complain_on_overflow */
1536          ppc64_elf_unhandled_reloc, /* special_function */
1537          "R_PPC64_TPREL16_HI",  /* name */
1538          FALSE,                 /* partial_inplace */
1539          0,                     /* src_mask */
1540          0xffff,                /* dst_mask */
1541          FALSE),                /* pcrel_offset */
1542
1543   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1544   HOWTO (R_PPC64_TPREL16_HA,
1545          16,                    /* rightshift */
1546          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1547          16,                    /* bitsize */
1548          FALSE,                 /* pc_relative */
1549          0,                     /* bitpos */
1550          complain_overflow_dont, /* complain_on_overflow */
1551          ppc64_elf_unhandled_reloc, /* special_function */
1552          "R_PPC64_TPREL16_HA",  /* name */
1553          FALSE,                 /* partial_inplace */
1554          0,                     /* src_mask */
1555          0xffff,                /* dst_mask */
1556          FALSE),                /* pcrel_offset */
1557
1558   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1559   HOWTO (R_PPC64_TPREL16_HIGHER,
1560          32,                    /* rightshift */
1561          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1562          16,                    /* bitsize */
1563          FALSE,                 /* pc_relative */
1564          0,                     /* bitpos */
1565          complain_overflow_dont, /* complain_on_overflow */
1566          ppc64_elf_unhandled_reloc, /* special_function */
1567          "R_PPC64_TPREL16_HIGHER",      /* name */
1568          FALSE,                 /* partial_inplace */
1569          0,                     /* src_mask */
1570          0xffff,                /* dst_mask */
1571          FALSE),                /* pcrel_offset */
1572
1573   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1574   HOWTO (R_PPC64_TPREL16_HIGHERA,
1575          32,                    /* rightshift */
1576          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1577          16,                    /* bitsize */
1578          FALSE,                 /* pc_relative */
1579          0,                     /* bitpos */
1580          complain_overflow_dont, /* complain_on_overflow */
1581          ppc64_elf_unhandled_reloc, /* special_function */
1582          "R_PPC64_TPREL16_HIGHERA", /* name */
1583          FALSE,                 /* partial_inplace */
1584          0,                     /* src_mask */
1585          0xffff,                /* dst_mask */
1586          FALSE),                /* pcrel_offset */
1587
1588   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1589   HOWTO (R_PPC64_TPREL16_HIGHEST,
1590          48,                    /* rightshift */
1591          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1592          16,                    /* bitsize */
1593          FALSE,                 /* pc_relative */
1594          0,                     /* bitpos */
1595          complain_overflow_dont, /* complain_on_overflow */
1596          ppc64_elf_unhandled_reloc, /* special_function */
1597          "R_PPC64_TPREL16_HIGHEST", /* name */
1598          FALSE,                 /* partial_inplace */
1599          0,                     /* src_mask */
1600          0xffff,                /* dst_mask */
1601          FALSE),                /* pcrel_offset */
1602
1603   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1604   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1605          48,                    /* rightshift */
1606          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1607          16,                    /* bitsize */
1608          FALSE,                 /* pc_relative */
1609          0,                     /* bitpos */
1610          complain_overflow_dont, /* complain_on_overflow */
1611          ppc64_elf_unhandled_reloc, /* special_function */
1612          "R_PPC64_TPREL16_HIGHESTA", /* name */
1613          FALSE,                 /* partial_inplace */
1614          0,                     /* src_mask */
1615          0xffff,                /* dst_mask */
1616          FALSE),                /* pcrel_offset */
1617
1618   /* Like TPREL16, but for insns with a DS field.  */
1619   HOWTO (R_PPC64_TPREL16_DS,
1620          0,                     /* rightshift */
1621          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1622          16,                    /* bitsize */
1623          FALSE,                 /* pc_relative */
1624          0,                     /* bitpos */
1625          complain_overflow_signed, /* complain_on_overflow */
1626          ppc64_elf_unhandled_reloc, /* special_function */
1627          "R_PPC64_TPREL16_DS",  /* name */
1628          FALSE,                 /* partial_inplace */
1629          0,                     /* src_mask */
1630          0xfffc,                /* dst_mask */
1631          FALSE),                /* pcrel_offset */
1632
1633   /* Like TPREL16_DS, but no overflow.  */
1634   HOWTO (R_PPC64_TPREL16_LO_DS,
1635          0,                     /* rightshift */
1636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1637          16,                    /* bitsize */
1638          FALSE,                 /* pc_relative */
1639          0,                     /* bitpos */
1640          complain_overflow_dont, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_TPREL16_LO_DS", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xfffc,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1649      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1650      to the first entry relative to the TOC base (r2).  */
1651   HOWTO (R_PPC64_GOT_TLSGD16,
1652          0,                     /* rightshift */
1653          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1654          16,                    /* bitsize */
1655          FALSE,                 /* pc_relative */
1656          0,                     /* bitpos */
1657          complain_overflow_signed, /* complain_on_overflow */
1658          ppc64_elf_unhandled_reloc, /* special_function */
1659          "R_PPC64_GOT_TLSGD16", /* name */
1660          FALSE,                 /* partial_inplace */
1661          0,                     /* src_mask */
1662          0xffff,                /* dst_mask */
1663          FALSE),                /* pcrel_offset */
1664
1665   /* Like GOT_TLSGD16, but no overflow.  */
1666   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1667          0,                     /* rightshift */
1668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1669          16,                    /* bitsize */
1670          FALSE,                 /* pc_relative */
1671          0,                     /* bitpos */
1672          complain_overflow_dont, /* complain_on_overflow */
1673          ppc64_elf_unhandled_reloc, /* special_function */
1674          "R_PPC64_GOT_TLSGD16_LO", /* name */
1675          FALSE,                 /* partial_inplace */
1676          0,                     /* src_mask */
1677          0xffff,                /* dst_mask */
1678          FALSE),                /* pcrel_offset */
1679
1680   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1681   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1682          16,                    /* rightshift */
1683          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1684          16,                    /* bitsize */
1685          FALSE,                 /* pc_relative */
1686          0,                     /* bitpos */
1687          complain_overflow_dont, /* complain_on_overflow */
1688          ppc64_elf_unhandled_reloc, /* special_function */
1689          "R_PPC64_GOT_TLSGD16_HI", /* name */
1690          FALSE,                 /* partial_inplace */
1691          0,                     /* src_mask */
1692          0xffff,                /* dst_mask */
1693          FALSE),                /* pcrel_offset */
1694
1695   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1696   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1697          16,                    /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_dont, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSGD16_HA", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1711      with values (sym+add)@dtpmod and zero, and computes the offset to the
1712      first entry relative to the TOC base (r2).  */
1713   HOWTO (R_PPC64_GOT_TLSLD16,
1714          0,                     /* rightshift */
1715          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1716          16,                    /* bitsize */
1717          FALSE,                 /* pc_relative */
1718          0,                     /* bitpos */
1719          complain_overflow_signed, /* complain_on_overflow */
1720          ppc64_elf_unhandled_reloc, /* special_function */
1721          "R_PPC64_GOT_TLSLD16", /* name */
1722          FALSE,                 /* partial_inplace */
1723          0,                     /* src_mask */
1724          0xffff,                /* dst_mask */
1725          FALSE),                /* pcrel_offset */
1726
1727   /* Like GOT_TLSLD16, but no overflow.  */
1728   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1729          0,                     /* rightshift */
1730          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1731          16,                    /* bitsize */
1732          FALSE,                 /* pc_relative */
1733          0,                     /* bitpos */
1734          complain_overflow_dont, /* complain_on_overflow */
1735          ppc64_elf_unhandled_reloc, /* special_function */
1736          "R_PPC64_GOT_TLSLD16_LO", /* name */
1737          FALSE,                 /* partial_inplace */
1738          0,                     /* src_mask */
1739          0xffff,                /* dst_mask */
1740          FALSE),                /* pcrel_offset */
1741
1742   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1743   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1744          16,                    /* rightshift */
1745          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1746          16,                    /* bitsize */
1747          FALSE,                 /* pc_relative */
1748          0,                     /* bitpos */
1749          complain_overflow_dont, /* complain_on_overflow */
1750          ppc64_elf_unhandled_reloc, /* special_function */
1751          "R_PPC64_GOT_TLSLD16_HI", /* name */
1752          FALSE,                 /* partial_inplace */
1753          0,                     /* src_mask */
1754          0xffff,                /* dst_mask */
1755          FALSE),                /* pcrel_offset */
1756
1757   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1758   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1759          16,                    /* rightshift */
1760          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1761          16,                    /* bitsize */
1762          FALSE,                 /* pc_relative */
1763          0,                     /* bitpos */
1764          complain_overflow_dont, /* complain_on_overflow */
1765          ppc64_elf_unhandled_reloc, /* special_function */
1766          "R_PPC64_GOT_TLSLD16_HA", /* name */
1767          FALSE,                 /* partial_inplace */
1768          0,                     /* src_mask */
1769          0xffff,                /* dst_mask */
1770          FALSE),                /* pcrel_offset */
1771
1772   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1773      the offset to the entry relative to the TOC base (r2).  */
1774   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1775          0,                     /* rightshift */
1776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1777          16,                    /* bitsize */
1778          FALSE,                 /* pc_relative */
1779          0,                     /* bitpos */
1780          complain_overflow_signed, /* complain_on_overflow */
1781          ppc64_elf_unhandled_reloc, /* special_function */
1782          "R_PPC64_GOT_DTPREL16_DS", /* name */
1783          FALSE,                 /* partial_inplace */
1784          0,                     /* src_mask */
1785          0xfffc,                /* dst_mask */
1786          FALSE),                /* pcrel_offset */
1787
1788   /* Like GOT_DTPREL16_DS, but no overflow.  */
1789   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1790          0,                     /* rightshift */
1791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1792          16,                    /* bitsize */
1793          FALSE,                 /* pc_relative */
1794          0,                     /* bitpos */
1795          complain_overflow_dont, /* complain_on_overflow */
1796          ppc64_elf_unhandled_reloc, /* special_function */
1797          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1798          FALSE,                 /* partial_inplace */
1799          0,                     /* src_mask */
1800          0xfffc,                /* dst_mask */
1801          FALSE),                /* pcrel_offset */
1802
1803   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1804   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1805          16,                    /* rightshift */
1806          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1807          16,                    /* bitsize */
1808          FALSE,                 /* pc_relative */
1809          0,                     /* bitpos */
1810          complain_overflow_dont, /* complain_on_overflow */
1811          ppc64_elf_unhandled_reloc, /* special_function */
1812          "R_PPC64_GOT_DTPREL16_HI", /* name */
1813          FALSE,                 /* partial_inplace */
1814          0,                     /* src_mask */
1815          0xffff,                /* dst_mask */
1816          FALSE),                /* pcrel_offset */
1817
1818   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1819   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1820          16,                    /* rightshift */
1821          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1822          16,                    /* bitsize */
1823          FALSE,                 /* pc_relative */
1824          0,                     /* bitpos */
1825          complain_overflow_dont, /* complain_on_overflow */
1826          ppc64_elf_unhandled_reloc, /* special_function */
1827          "R_PPC64_GOT_DTPREL16_HA", /* name */
1828          FALSE,                 /* partial_inplace */
1829          0,                     /* src_mask */
1830          0xffff,                /* dst_mask */
1831          FALSE),                /* pcrel_offset */
1832
1833   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1834      offset to the entry relative to the TOC base (r2).  */
1835   HOWTO (R_PPC64_GOT_TPREL16_DS,
1836          0,                     /* rightshift */
1837          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1838          16,                    /* bitsize */
1839          FALSE,                 /* pc_relative */
1840          0,                     /* bitpos */
1841          complain_overflow_signed, /* complain_on_overflow */
1842          ppc64_elf_unhandled_reloc, /* special_function */
1843          "R_PPC64_GOT_TPREL16_DS", /* name */
1844          FALSE,                 /* partial_inplace */
1845          0,                     /* src_mask */
1846          0xfffc,                /* dst_mask */
1847          FALSE),                /* pcrel_offset */
1848
1849   /* Like GOT_TPREL16_DS, but no overflow.  */
1850   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1851          0,                     /* rightshift */
1852          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1853          16,                    /* bitsize */
1854          FALSE,                 /* pc_relative */
1855          0,                     /* bitpos */
1856          complain_overflow_dont, /* complain_on_overflow */
1857          ppc64_elf_unhandled_reloc, /* special_function */
1858          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1859          FALSE,                 /* partial_inplace */
1860          0,                     /* src_mask */
1861          0xfffc,                /* dst_mask */
1862          FALSE),                /* pcrel_offset */
1863
1864   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1865   HOWTO (R_PPC64_GOT_TPREL16_HI,
1866          16,                    /* rightshift */
1867          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1868          16,                    /* bitsize */
1869          FALSE,                 /* pc_relative */
1870          0,                     /* bitpos */
1871          complain_overflow_dont, /* complain_on_overflow */
1872          ppc64_elf_unhandled_reloc, /* special_function */
1873          "R_PPC64_GOT_TPREL16_HI", /* name */
1874          FALSE,                 /* partial_inplace */
1875          0,                     /* src_mask */
1876          0xffff,                /* dst_mask */
1877          FALSE),                /* pcrel_offset */
1878
1879   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1880   HOWTO (R_PPC64_GOT_TPREL16_HA,
1881          16,                    /* rightshift */
1882          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1883          16,                    /* bitsize */
1884          FALSE,                 /* pc_relative */
1885          0,                     /* bitpos */
1886          complain_overflow_dont, /* complain_on_overflow */
1887          ppc64_elf_unhandled_reloc, /* special_function */
1888          "R_PPC64_GOT_TPREL16_HA", /* name */
1889          FALSE,                 /* partial_inplace */
1890          0,                     /* src_mask */
1891          0xffff,                /* dst_mask */
1892          FALSE),                /* pcrel_offset */
1893
1894   HOWTO (R_PPC64_JMP_IREL,      /* type */
1895          0,                     /* rightshift */
1896          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1897          0,                     /* bitsize */
1898          FALSE,                 /* pc_relative */
1899          0,                     /* bitpos */
1900          complain_overflow_dont, /* complain_on_overflow */
1901          ppc64_elf_unhandled_reloc, /* special_function */
1902          "R_PPC64_JMP_IREL",    /* name */
1903          FALSE,                 /* partial_inplace */
1904          0,                     /* src_mask */
1905          0,                     /* dst_mask */
1906          FALSE),                /* pcrel_offset */
1907
1908   HOWTO (R_PPC64_IRELATIVE,     /* type */
1909          0,                     /* rightshift */
1910          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1911          64,                    /* bitsize */
1912          FALSE,                 /* pc_relative */
1913          0,                     /* bitpos */
1914          complain_overflow_dont, /* complain_on_overflow */
1915          bfd_elf_generic_reloc, /* special_function */
1916          "R_PPC64_IRELATIVE",   /* name */
1917          FALSE,                 /* partial_inplace */
1918          0,                     /* src_mask */
1919          ONES (64),             /* dst_mask */
1920          FALSE),                /* pcrel_offset */
1921
1922   /* A 16 bit relative relocation.  */
1923   HOWTO (R_PPC64_REL16,         /* type */
1924          0,                     /* rightshift */
1925          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1926          16,                    /* bitsize */
1927          TRUE,                  /* pc_relative */
1928          0,                     /* bitpos */
1929          complain_overflow_bitfield, /* complain_on_overflow */
1930          bfd_elf_generic_reloc, /* special_function */
1931          "R_PPC64_REL16",       /* name */
1932          FALSE,                 /* partial_inplace */
1933          0,                     /* src_mask */
1934          0xffff,                /* dst_mask */
1935          TRUE),                 /* pcrel_offset */
1936
1937   /* A 16 bit relative relocation without overflow.  */
1938   HOWTO (R_PPC64_REL16_LO,      /* type */
1939          0,                     /* rightshift */
1940          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1941          16,                    /* bitsize */
1942          TRUE,                  /* pc_relative */
1943          0,                     /* bitpos */
1944          complain_overflow_dont,/* complain_on_overflow */
1945          bfd_elf_generic_reloc, /* special_function */
1946          "R_PPC64_REL16_LO",    /* name */
1947          FALSE,                 /* partial_inplace */
1948          0,                     /* src_mask */
1949          0xffff,                /* dst_mask */
1950          TRUE),                 /* pcrel_offset */
1951
1952   /* The high order 16 bits of a relative address.  */
1953   HOWTO (R_PPC64_REL16_HI,      /* type */
1954          16,                    /* rightshift */
1955          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1956          16,                    /* bitsize */
1957          TRUE,                  /* pc_relative */
1958          0,                     /* bitpos */
1959          complain_overflow_dont, /* complain_on_overflow */
1960          bfd_elf_generic_reloc, /* special_function */
1961          "R_PPC64_REL16_HI",    /* name */
1962          FALSE,                 /* partial_inplace */
1963          0,                     /* src_mask */
1964          0xffff,                /* dst_mask */
1965          TRUE),                 /* pcrel_offset */
1966
1967   /* The high order 16 bits of a relative address, plus 1 if the contents of
1968      the low 16 bits, treated as a signed number, is negative.  */
1969   HOWTO (R_PPC64_REL16_HA,      /* type */
1970          16,                    /* rightshift */
1971          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1972          16,                    /* bitsize */
1973          TRUE,                  /* pc_relative */
1974          0,                     /* bitpos */
1975          complain_overflow_dont, /* complain_on_overflow */
1976          ppc64_elf_ha_reloc,    /* special_function */
1977          "R_PPC64_REL16_HA",    /* name */
1978          FALSE,                 /* partial_inplace */
1979          0,                     /* src_mask */
1980          0xffff,                /* dst_mask */
1981          TRUE),                 /* pcrel_offset */
1982
1983   /* GNU extension to record C++ vtable hierarchy.  */
1984   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1985          0,                     /* rightshift */
1986          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1987          0,                     /* bitsize */
1988          FALSE,                 /* pc_relative */
1989          0,                     /* bitpos */
1990          complain_overflow_dont, /* complain_on_overflow */
1991          NULL,                  /* special_function */
1992          "R_PPC64_GNU_VTINHERIT", /* name */
1993          FALSE,                 /* partial_inplace */
1994          0,                     /* src_mask */
1995          0,                     /* dst_mask */
1996          FALSE),                /* pcrel_offset */
1997
1998   /* GNU extension to record C++ vtable member usage.  */
1999   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
2000          0,                     /* rightshift */
2001          0,                     /* size (0 = byte, 1 = short, 2 = long) */
2002          0,                     /* bitsize */
2003          FALSE,                 /* pc_relative */
2004          0,                     /* bitpos */
2005          complain_overflow_dont, /* complain_on_overflow */
2006          NULL,                  /* special_function */
2007          "R_PPC64_GNU_VTENTRY", /* name */
2008          FALSE,                 /* partial_inplace */
2009          0,                     /* src_mask */
2010          0,                     /* dst_mask */
2011          FALSE),                /* pcrel_offset */
2012 };
2013
2014 \f
2015 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2016    be done.  */
2017
2018 static void
2019 ppc_howto_init (void)
2020 {
2021   unsigned int i, type;
2022
2023   for (i = 0;
2024        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2025        i++)
2026     {
2027       type = ppc64_elf_howto_raw[i].type;
2028       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2029                           / sizeof (ppc64_elf_howto_table[0])));
2030       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2031     }
2032 }
2033
2034 static reloc_howto_type *
2035 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2036                              bfd_reloc_code_real_type code)
2037 {
2038   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2039
2040   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2041     /* Initialize howto table if needed.  */
2042     ppc_howto_init ();
2043
2044   switch (code)
2045     {
2046     default:
2047       return NULL;
2048
2049     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2050       break;
2051     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2052       break;
2053     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2054       break;
2055     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2056       break;
2057     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2058       break;
2059     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2060       break;
2061     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2062       break;
2063     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2064       break;
2065     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2066       break;
2067     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2068       break;
2069     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2070       break;
2071     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2072       break;
2073     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2074       break;
2075     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2076       break;
2077     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2078       break;
2079     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2080       break;
2081     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2082       break;
2083     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2084       break;
2085     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2086       break;
2087     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2088       break;
2089     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2090       break;
2091     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2092       break;
2093     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2094       break;
2095     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2096       break;
2097     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2098       break;
2099     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2100       break;
2101     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2102       break;
2103     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2104       break;
2105     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2106       break;
2107     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2108       break;
2109     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2110       break;
2111     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2112       break;
2113     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2114       break;
2115     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2116       break;
2117     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2118       break;
2119     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2120       break;
2121     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2122       break;
2123     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2124       break;
2125     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2126       break;
2127     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2128       break;
2129     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2130       break;
2131     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2132       break;
2133     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2134       break;
2135     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2136       break;
2137     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2138       break;
2139     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2140       break;
2141     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2142       break;
2143     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2144       break;
2145     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2146       break;
2147     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2148       break;
2149     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2150       break;
2151     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2152       break;
2153     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2154       break;
2155     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2156       break;
2157     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2158       break;
2159     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2160       break;
2161     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2162       break;
2163     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2164       break;
2165     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2166       break;
2167     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2168       break;
2169     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2170       break;
2171     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2172       break;
2173     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2174       break;
2175     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2176       break;
2177     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2178       break;
2179     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2180       break;
2181     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2182       break;
2183     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2184       break;
2185     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2186       break;
2187     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2188       break;
2189     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2190       break;
2191     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2192       break;
2193     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2194       break;
2195     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2196       break;
2197     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2198       break;
2199     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2200       break;
2201     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2202       break;
2203     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2204       break;
2205     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2206       break;
2207     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2208       break;
2209     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2210       break;
2211     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2212       break;
2213     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2214       break;
2215     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2216       break;
2217     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2218       break;
2219     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2220       break;
2221     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2222       break;
2223     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2224       break;
2225     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2226       break;
2227     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2228       break;
2229     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2230       break;
2231     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2232       break;
2233     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2234       break;
2235     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2236       break;
2237     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2238       break;
2239     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2240       break;
2241     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2242       break;
2243     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2244       break;
2245     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2246       break;
2247     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2248       break;
2249     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2250       break;
2251     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2252       break;
2253     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2254       break;
2255     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2256       break;
2257     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2258       break;
2259     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2260       break;
2261     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2262       break;
2263     }
2264
2265   return ppc64_elf_howto_table[r];
2266 };
2267
2268 static reloc_howto_type *
2269 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2270                              const char *r_name)
2271 {
2272   unsigned int i;
2273
2274   for (i = 0;
2275        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2276        i++)
2277     if (ppc64_elf_howto_raw[i].name != NULL
2278         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2279       return &ppc64_elf_howto_raw[i];
2280
2281   return NULL;
2282 }
2283
2284 /* Set the howto pointer for a PowerPC ELF reloc.  */
2285
2286 static void
2287 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2288                          Elf_Internal_Rela *dst)
2289 {
2290   unsigned int type;
2291
2292   /* Initialize howto table if needed.  */
2293   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2294     ppc_howto_init ();
2295
2296   type = ELF64_R_TYPE (dst->r_info);
2297   if (type >= (sizeof (ppc64_elf_howto_table)
2298                / sizeof (ppc64_elf_howto_table[0])))
2299     {
2300       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2301                              abfd, (int) type);
2302       type = R_PPC64_NONE;
2303     }
2304   cache_ptr->howto = ppc64_elf_howto_table[type];
2305 }
2306
2307 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2308
2309 static bfd_reloc_status_type
2310 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2311                     void *data, asection *input_section,
2312                     bfd *output_bfd, char **error_message)
2313 {
2314   /* If this is a relocatable link (output_bfd test tells us), just
2315      call the generic function.  Any adjustment will be done at final
2316      link time.  */
2317   if (output_bfd != NULL)
2318     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2319                                   input_section, output_bfd, error_message);
2320
2321   /* Adjust the addend for sign extension of the low 16 bits.
2322      We won't actually be using the low 16 bits, so trashing them
2323      doesn't matter.  */
2324   reloc_entry->addend += 0x8000;
2325   return bfd_reloc_continue;
2326 }
2327
2328 static bfd_reloc_status_type
2329 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2330                         void *data, asection *input_section,
2331                         bfd *output_bfd, char **error_message)
2332 {
2333   if (output_bfd != NULL)
2334     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2335                                   input_section, output_bfd, error_message);
2336
2337   if (strcmp (symbol->section->name, ".opd") == 0
2338       && (symbol->section->owner->flags & DYNAMIC) == 0)
2339     {
2340       bfd_vma dest = opd_entry_value (symbol->section,
2341                                       symbol->value + reloc_entry->addend,
2342                                       NULL, NULL);
2343       if (dest != (bfd_vma) -1)
2344         reloc_entry->addend = dest - (symbol->value
2345                                       + symbol->section->output_section->vma
2346                                       + symbol->section->output_offset);
2347     }
2348   return bfd_reloc_continue;
2349 }
2350
2351 static bfd_reloc_status_type
2352 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2353                          void *data, asection *input_section,
2354                          bfd *output_bfd, char **error_message)
2355 {
2356   long insn;
2357   enum elf_ppc64_reloc_type r_type;
2358   bfd_size_type octets;
2359   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2360   bfd_boolean is_power4 = FALSE;
2361
2362   /* If this is a relocatable link (output_bfd test tells us), just
2363      call the generic function.  Any adjustment will be done at final
2364      link time.  */
2365   if (output_bfd != NULL)
2366     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2367                                   input_section, output_bfd, error_message);
2368
2369   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2370   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2371   insn &= ~(0x01 << 21);
2372   r_type = reloc_entry->howto->type;
2373   if (r_type == R_PPC64_ADDR14_BRTAKEN
2374       || r_type == R_PPC64_REL14_BRTAKEN)
2375     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2376
2377   if (is_power4)
2378     {
2379       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2380          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2381          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2382       if ((insn & (0x14 << 21)) == (0x04 << 21))
2383         insn |= 0x02 << 21;
2384       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2385         insn |= 0x08 << 21;
2386       else
2387         goto out;
2388     }
2389   else
2390     {
2391       bfd_vma target = 0;
2392       bfd_vma from;
2393
2394       if (!bfd_is_com_section (symbol->section))
2395         target = symbol->value;
2396       target += symbol->section->output_section->vma;
2397       target += symbol->section->output_offset;
2398       target += reloc_entry->addend;
2399
2400       from = (reloc_entry->address
2401               + input_section->output_offset
2402               + input_section->output_section->vma);
2403
2404       /* Invert 'y' bit if not the default.  */
2405       if ((bfd_signed_vma) (target - from) < 0)
2406         insn ^= 0x01 << 21;
2407     }
2408   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2409  out:
2410   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2411                                  input_section, output_bfd, error_message);
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416                          void *data, asection *input_section,
2417                          bfd *output_bfd, char **error_message)
2418 {
2419   /* If this is a relocatable link (output_bfd test tells us), just
2420      call the generic function.  Any adjustment will be done at final
2421      link time.  */
2422   if (output_bfd != NULL)
2423     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424                                   input_section, output_bfd, error_message);
2425
2426   /* Subtract the symbol section base address.  */
2427   reloc_entry->addend -= symbol->section->output_section->vma;
2428   return bfd_reloc_continue;
2429 }
2430
2431 static bfd_reloc_status_type
2432 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2433                             void *data, asection *input_section,
2434                             bfd *output_bfd, char **error_message)
2435 {
2436   /* If this is a relocatable link (output_bfd test tells us), just
2437      call the generic function.  Any adjustment will be done at final
2438      link time.  */
2439   if (output_bfd != NULL)
2440     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2441                                   input_section, output_bfd, error_message);
2442
2443   /* Subtract the symbol section base address.  */
2444   reloc_entry->addend -= symbol->section->output_section->vma;
2445
2446   /* Adjust the addend for sign extension of the low 16 bits.  */
2447   reloc_entry->addend += 0x8000;
2448   return bfd_reloc_continue;
2449 }
2450
2451 static bfd_reloc_status_type
2452 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453                      void *data, asection *input_section,
2454                      bfd *output_bfd, char **error_message)
2455 {
2456   bfd_vma TOCstart;
2457
2458   /* If this is a relocatable link (output_bfd test tells us), just
2459      call the generic function.  Any adjustment will be done at final
2460      link time.  */
2461   if (output_bfd != NULL)
2462     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2463                                   input_section, output_bfd, error_message);
2464
2465   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2466   if (TOCstart == 0)
2467     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2468
2469   /* Subtract the TOC base address.  */
2470   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2471   return bfd_reloc_continue;
2472 }
2473
2474 static bfd_reloc_status_type
2475 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2476                         void *data, asection *input_section,
2477                         bfd *output_bfd, char **error_message)
2478 {
2479   bfd_vma TOCstart;
2480
2481   /* If this is a relocatable link (output_bfd test tells us), just
2482      call the generic function.  Any adjustment will be done at final
2483      link time.  */
2484   if (output_bfd != NULL)
2485     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2486                                   input_section, output_bfd, error_message);
2487
2488   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2489   if (TOCstart == 0)
2490     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2491
2492   /* Subtract the TOC base address.  */
2493   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2494
2495   /* Adjust the addend for sign extension of the low 16 bits.  */
2496   reloc_entry->addend += 0x8000;
2497   return bfd_reloc_continue;
2498 }
2499
2500 static bfd_reloc_status_type
2501 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2502                        void *data, asection *input_section,
2503                        bfd *output_bfd, char **error_message)
2504 {
2505   bfd_vma TOCstart;
2506   bfd_size_type octets;
2507
2508   /* If this is a relocatable link (output_bfd test tells us), just
2509      call the generic function.  Any adjustment will be done at final
2510      link time.  */
2511   if (output_bfd != NULL)
2512     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2513                                   input_section, output_bfd, error_message);
2514
2515   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2516   if (TOCstart == 0)
2517     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2518
2519   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2520   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2521   return bfd_reloc_ok;
2522 }
2523
2524 static bfd_reloc_status_type
2525 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526                            void *data, asection *input_section,
2527                            bfd *output_bfd, char **error_message)
2528 {
2529   /* If this is a relocatable link (output_bfd test tells us), just
2530      call the generic function.  Any adjustment will be done at final
2531      link time.  */
2532   if (output_bfd != NULL)
2533     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2534                                   input_section, output_bfd, error_message);
2535
2536   if (error_message != NULL)
2537     {
2538       static char buf[60];
2539       sprintf (buf, "generic linker can't handle %s",
2540                reloc_entry->howto->name);
2541       *error_message = buf;
2542     }
2543   return bfd_reloc_dangerous;
2544 }
2545
2546 /* Track GOT entries needed for a given symbol.  We might need more
2547    than one got entry per symbol.  */
2548 struct got_entry
2549 {
2550   struct got_entry *next;
2551
2552   /* The symbol addend that we'll be placing in the GOT.  */
2553   bfd_vma addend;
2554
2555   /* Unlike other ELF targets, we use separate GOT entries for the same
2556      symbol referenced from different input files.  This is to support
2557      automatic multiple TOC/GOT sections, where the TOC base can vary
2558      from one input file to another.  After partitioning into TOC groups
2559      we merge entries within the group.
2560
2561      Point to the BFD owning this GOT entry.  */
2562   bfd *owner;
2563
2564   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2565      TLS_TPREL or TLS_DTPREL for tls entries.  */
2566   unsigned char tls_type;
2567
2568   /* Non-zero if got.ent points to real entry.  */
2569   unsigned char is_indirect;
2570
2571   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2572   union
2573     {
2574       bfd_signed_vma refcount;
2575       bfd_vma offset;
2576       struct got_entry *ent;
2577     } got;
2578 };
2579
2580 /* The same for PLT.  */
2581 struct plt_entry
2582 {
2583   struct plt_entry *next;
2584
2585   bfd_vma addend;
2586
2587   union
2588     {
2589       bfd_signed_vma refcount;
2590       bfd_vma offset;
2591     } plt;
2592 };
2593
2594 struct ppc64_elf_obj_tdata
2595 {
2596   struct elf_obj_tdata elf;
2597
2598   /* Shortcuts to dynamic linker sections.  */
2599   asection *got;
2600   asection *relgot;
2601
2602   /* Used during garbage collection.  We attach global symbols defined
2603      on removed .opd entries to this section so that the sym is removed.  */
2604   asection *deleted_section;
2605
2606   /* TLS local dynamic got entry handling.  Support for multiple GOT
2607      sections means we potentially need one of these for each input bfd.  */
2608   struct got_entry tlsld_got;
2609
2610   /* A copy of relocs before they are modified for --emit-relocs.  */
2611   Elf_Internal_Rela *opd_relocs;
2612
2613   /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2614      the reloc to be in the range -32768 to 32767.  */
2615   unsigned int has_small_toc_reloc : 1;
2616
2617   /* Set if toc/got ha relocs detected not using r2, or lo reloc
2618      instruction not one we handle.  */
2619   unsigned int unexpected_toc_insn : 1;
2620 };
2621
2622 #define ppc64_elf_tdata(bfd) \
2623   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2624
2625 #define ppc64_tlsld_got(bfd) \
2626   (&ppc64_elf_tdata (bfd)->tlsld_got)
2627
2628 #define is_ppc64_elf(bfd) \
2629   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2630    && elf_object_id (bfd) == PPC64_ELF_DATA)
2631
2632 /* Override the generic function because we store some extras.  */
2633
2634 static bfd_boolean
2635 ppc64_elf_mkobject (bfd *abfd)
2636 {
2637   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2638                                   PPC64_ELF_DATA);
2639 }
2640
2641 /* Fix bad default arch selected for a 64 bit input bfd when the
2642    default is 32 bit.  */
2643
2644 static bfd_boolean
2645 ppc64_elf_object_p (bfd *abfd)
2646 {
2647   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2648     {
2649       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2650
2651       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2652         {
2653           /* Relies on arch after 32 bit default being 64 bit default.  */
2654           abfd->arch_info = abfd->arch_info->next;
2655           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2656         }
2657     }
2658   return TRUE;
2659 }
2660
2661 /* Support for core dump NOTE sections.  */
2662
2663 static bfd_boolean
2664 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2665 {
2666   size_t offset, size;
2667
2668   if (note->descsz != 504)
2669     return FALSE;
2670
2671   /* pr_cursig */
2672   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2673
2674   /* pr_pid */
2675   elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
2676
2677   /* pr_reg */
2678   offset = 112;
2679   size = 384;
2680
2681   /* Make a ".reg/999" section.  */
2682   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2683                                           size, note->descpos + offset);
2684 }
2685
2686 static bfd_boolean
2687 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2688 {
2689   if (note->descsz != 136)
2690     return FALSE;
2691
2692   elf_tdata (abfd)->core_pid
2693     = bfd_get_32 (abfd, note->descdata + 24);
2694   elf_tdata (abfd)->core_program
2695     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2696   elf_tdata (abfd)->core_command
2697     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2698
2699   return TRUE;
2700 }
2701
2702 static char *
2703 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2704                            ...)
2705 {
2706   switch (note_type)
2707     {
2708     default:
2709       return NULL;
2710
2711     case NT_PRPSINFO:
2712       {
2713         char data[136];
2714         va_list ap;
2715
2716         va_start (ap, note_type);
2717         memset (data, 0, 40);
2718         strncpy (data + 40, va_arg (ap, const char *), 16);
2719         strncpy (data + 56, va_arg (ap, const char *), 80);
2720         va_end (ap);
2721         return elfcore_write_note (abfd, buf, bufsiz,
2722                                    "CORE", note_type, data, sizeof (data));
2723       }
2724
2725     case NT_PRSTATUS:
2726       {
2727         char data[504];
2728         va_list ap;
2729         long pid;
2730         int cursig;
2731         const void *greg;
2732
2733         va_start (ap, note_type);
2734         memset (data, 0, 112);
2735         pid = va_arg (ap, long);
2736         bfd_put_32 (abfd, pid, data + 32);
2737         cursig = va_arg (ap, int);
2738         bfd_put_16 (abfd, cursig, data + 12);
2739         greg = va_arg (ap, const void *);
2740         memcpy (data + 112, greg, 384);
2741         memset (data + 496, 0, 8);
2742         va_end (ap);
2743         return elfcore_write_note (abfd, buf, bufsiz,
2744                                    "CORE", note_type, data, sizeof (data));
2745       }
2746     }
2747 }
2748
2749 /* Add extra PPC sections.  */
2750
2751 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2752 {
2753   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2754   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2755   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2756   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2757   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2758   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2759   { NULL,                     0,  0, 0,            0 }
2760 };
2761
2762 enum _ppc64_sec_type {
2763   sec_normal = 0,
2764   sec_opd = 1,
2765   sec_toc = 2
2766 };
2767
2768 struct _ppc64_elf_section_data
2769 {
2770   struct bfd_elf_section_data elf;
2771
2772   union
2773   {
2774     /* An array with one entry for each opd function descriptor.  */
2775     struct _opd_sec_data
2776     {
2777       /* Points to the function code section for local opd entries.  */
2778       asection **func_sec;
2779
2780       /* After editing .opd, adjust references to opd local syms.  */
2781       long *adjust;
2782     } opd;
2783
2784     /* An array for toc sections, indexed by offset/8.  */
2785     struct _toc_sec_data
2786     {
2787       /* Specifies the relocation symbol index used at a given toc offset.  */
2788       unsigned *symndx;
2789
2790       /* And the relocation addend.  */
2791       bfd_vma *add;
2792     } toc;
2793   } u;
2794
2795   enum _ppc64_sec_type sec_type:2;
2796
2797   /* Flag set when small branches are detected.  Used to
2798      select suitable defaults for the stub group size.  */
2799   unsigned int has_14bit_branch:1;
2800 };
2801
2802 #define ppc64_elf_section_data(sec) \
2803   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2804
2805 static bfd_boolean
2806 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2807 {
2808   if (!sec->used_by_bfd)
2809     {
2810       struct _ppc64_elf_section_data *sdata;
2811       bfd_size_type amt = sizeof (*sdata);
2812
2813       sdata = bfd_zalloc (abfd, amt);
2814       if (sdata == NULL)
2815         return FALSE;
2816       sec->used_by_bfd = sdata;
2817     }
2818
2819   return _bfd_elf_new_section_hook (abfd, sec);
2820 }
2821
2822 static struct _opd_sec_data *
2823 get_opd_info (asection * sec)
2824 {
2825   if (sec != NULL
2826       && ppc64_elf_section_data (sec) != NULL
2827       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2828     return &ppc64_elf_section_data (sec)->u.opd;
2829   return NULL;
2830 }
2831 \f
2832 /* Parameters for the qsort hook.  */
2833 static bfd_boolean synthetic_relocatable;
2834
2835 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2836
2837 static int
2838 compare_symbols (const void *ap, const void *bp)
2839 {
2840   const asymbol *a = * (const asymbol **) ap;
2841   const asymbol *b = * (const asymbol **) bp;
2842
2843   /* Section symbols first.  */
2844   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2845     return -1;
2846   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2847     return 1;
2848
2849   /* then .opd symbols.  */
2850   if (strcmp (a->section->name, ".opd") == 0
2851       && strcmp (b->section->name, ".opd") != 0)
2852     return -1;
2853   if (strcmp (a->section->name, ".opd") != 0
2854       && strcmp (b->section->name, ".opd") == 0)
2855     return 1;
2856
2857   /* then other code symbols.  */
2858   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2859       == (SEC_CODE | SEC_ALLOC)
2860       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2861          != (SEC_CODE | SEC_ALLOC))
2862     return -1;
2863
2864   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2865       != (SEC_CODE | SEC_ALLOC)
2866       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867          == (SEC_CODE | SEC_ALLOC))
2868     return 1;
2869
2870   if (synthetic_relocatable)
2871     {
2872       if (a->section->id < b->section->id)
2873         return -1;
2874
2875       if (a->section->id > b->section->id)
2876         return 1;
2877     }
2878
2879   if (a->value + a->section->vma < b->value + b->section->vma)
2880     return -1;
2881
2882   if (a->value + a->section->vma > b->value + b->section->vma)
2883     return 1;
2884
2885   /* For syms with the same value, prefer strong dynamic global function
2886      syms over other syms.  */
2887   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2888     return -1;
2889
2890   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2891     return 1;
2892
2893   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2894     return -1;
2895
2896   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2897     return 1;
2898
2899   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2900     return -1;
2901
2902   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2903     return 1;
2904
2905   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2906     return -1;
2907
2908   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2909     return 1;
2910
2911   return 0;
2912 }
2913
2914 /* Search SYMS for a symbol of the given VALUE.  */
2915
2916 static asymbol *
2917 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2918 {
2919   long mid;
2920
2921   if (id == -1)
2922     {
2923       while (lo < hi)
2924         {
2925           mid = (lo + hi) >> 1;
2926           if (syms[mid]->value + syms[mid]->section->vma < value)
2927             lo = mid + 1;
2928           else if (syms[mid]->value + syms[mid]->section->vma > value)
2929             hi = mid;
2930           else
2931             return syms[mid];
2932         }
2933     }
2934   else
2935     {
2936       while (lo < hi)
2937         {
2938           mid = (lo + hi) >> 1;
2939           if (syms[mid]->section->id < id)
2940             lo = mid + 1;
2941           else if (syms[mid]->section->id > id)
2942             hi = mid;
2943           else if (syms[mid]->value < value)
2944             lo = mid + 1;
2945           else if (syms[mid]->value > value)
2946             hi = mid;
2947           else
2948             return syms[mid];
2949         }
2950     }
2951   return NULL;
2952 }
2953
2954 static bfd_boolean
2955 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2956 {
2957   bfd_vma vma = *(bfd_vma *) ptr;
2958   return ((section->flags & SEC_ALLOC) != 0
2959           && section->vma <= vma
2960           && vma < section->vma + section->size);
2961 }
2962
2963 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2964    entry syms.  Also generate @plt symbols for the glink branch table.  */
2965
2966 static long
2967 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2968                                 long static_count, asymbol **static_syms,
2969                                 long dyn_count, asymbol **dyn_syms,
2970                                 asymbol **ret)
2971 {
2972   asymbol *s;
2973   long i;
2974   long count;
2975   char *names;
2976   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2977   asection *opd;
2978   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2979   asymbol **syms;
2980
2981   *ret = NULL;
2982
2983   opd = bfd_get_section_by_name (abfd, ".opd");
2984   if (opd == NULL)
2985     return 0;
2986
2987   symcount = static_count;
2988   if (!relocatable)
2989     symcount += dyn_count;
2990   if (symcount == 0)
2991     return 0;
2992
2993   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2994   if (syms == NULL)
2995     return -1;
2996
2997   if (!relocatable && static_count != 0 && dyn_count != 0)
2998     {
2999       /* Use both symbol tables.  */
3000       memcpy (syms, static_syms, static_count * sizeof (*syms));
3001       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3002     }
3003   else if (!relocatable && static_count == 0)
3004     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3005   else
3006     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3007
3008   synthetic_relocatable = relocatable;
3009   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3010
3011   if (!relocatable && symcount > 1)
3012     {
3013       long j;
3014       /* Trim duplicate syms, since we may have merged the normal and
3015          dynamic symbols.  Actually, we only care about syms that have
3016          different values, so trim any with the same value.  */
3017       for (i = 1, j = 1; i < symcount; ++i)
3018         if (syms[i - 1]->value + syms[i - 1]->section->vma
3019             != syms[i]->value + syms[i]->section->vma)
3020           syms[j++] = syms[i];
3021       symcount = j;
3022     }
3023
3024   i = 0;
3025   if (strcmp (syms[i]->section->name, ".opd") == 0)
3026     ++i;
3027   codesecsym = i;
3028
3029   for (; i < symcount; ++i)
3030     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3031          != (SEC_CODE | SEC_ALLOC))
3032         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3033       break;
3034   codesecsymend = i;
3035
3036   for (; i < symcount; ++i)
3037     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3038       break;
3039   secsymend = i;
3040
3041   for (; i < symcount; ++i)
3042     if (strcmp (syms[i]->section->name, ".opd") != 0)
3043       break;
3044   opdsymend = i;
3045
3046   for (; i < symcount; ++i)
3047     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3048         != (SEC_CODE | SEC_ALLOC))
3049       break;
3050   symcount = i;
3051
3052   count = 0;
3053
3054   if (relocatable)
3055     {
3056       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3057       arelent *r;
3058       size_t size;
3059       long relcount;
3060
3061       if (opdsymend == secsymend)
3062         goto done;
3063
3064       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3065       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3066       if (relcount == 0)
3067         goto done;
3068
3069       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3070         {
3071           count = -1;
3072           goto done;
3073         }
3074
3075       size = 0;
3076       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3077         {
3078           asymbol *sym;
3079
3080           while (r < opd->relocation + relcount
3081                  && r->address < syms[i]->value + opd->vma)
3082             ++r;
3083
3084           if (r == opd->relocation + relcount)
3085             break;
3086
3087           if (r->address != syms[i]->value + opd->vma)
3088             continue;
3089
3090           if (r->howto->type != R_PPC64_ADDR64)
3091             continue;
3092
3093           sym = *r->sym_ptr_ptr;
3094           if (!sym_exists_at (syms, opdsymend, symcount,
3095                               sym->section->id, sym->value + r->addend))
3096             {
3097               ++count;
3098               size += sizeof (asymbol);
3099               size += strlen (syms[i]->name) + 2;
3100             }
3101         }
3102
3103       s = *ret = bfd_malloc (size);
3104       if (s == NULL)
3105         {
3106           count = -1;
3107           goto done;
3108         }
3109
3110       names = (char *) (s + count);
3111
3112       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3113         {
3114           asymbol *sym;
3115
3116           while (r < opd->relocation + relcount
3117                  && r->address < syms[i]->value + opd->vma)
3118             ++r;
3119
3120           if (r == opd->relocation + relcount)
3121             break;
3122
3123           if (r->address != syms[i]->value + opd->vma)
3124             continue;
3125
3126           if (r->howto->type != R_PPC64_ADDR64)
3127             continue;
3128
3129           sym = *r->sym_ptr_ptr;
3130           if (!sym_exists_at (syms, opdsymend, symcount,
3131                               sym->section->id, sym->value + r->addend))
3132             {
3133               size_t len;
3134
3135               *s = *syms[i];
3136               s->flags |= BSF_SYNTHETIC;
3137               s->section = sym->section;
3138               s->value = sym->value + r->addend;
3139               s->name = names;
3140               *names++ = '.';
3141               len = strlen (syms[i]->name);
3142               memcpy (names, syms[i]->name, len + 1);
3143               names += len + 1;
3144               /* Have udata.p point back to the original symbol this
3145                  synthetic symbol was derived from.  */
3146               s->udata.p = syms[i];
3147               s++;
3148             }
3149         }
3150     }
3151   else
3152     {
3153       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3154       bfd_byte *contents;
3155       size_t size;
3156       long plt_count = 0;
3157       bfd_vma glink_vma = 0, resolv_vma = 0;
3158       asection *dynamic, *glink = NULL, *relplt = NULL;
3159       arelent *p;
3160
3161       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3162         {
3163           if (contents)
3164             {
3165             free_contents_and_exit:
3166               free (contents);
3167             }
3168           count = -1;
3169           goto done;
3170         }
3171
3172       size = 0;
3173       for (i = secsymend; i < opdsymend; ++i)
3174         {
3175           bfd_vma ent;
3176
3177           /* Ignore bogus symbols.  */
3178           if (syms[i]->value > opd->size - 8)
3179             continue;
3180
3181           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3182           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3183             {
3184               ++count;
3185               size += sizeof (asymbol);
3186               size += strlen (syms[i]->name) + 2;
3187             }
3188         }
3189
3190       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3191       if (dyn_count != 0
3192           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3193         {
3194           bfd_byte *dynbuf, *extdyn, *extdynend;
3195           size_t extdynsize;
3196           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3197
3198           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3199             goto free_contents_and_exit;
3200
3201           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3202           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3203
3204           extdyn = dynbuf;
3205           extdynend = extdyn + dynamic->size;
3206           for (; extdyn < extdynend; extdyn += extdynsize)
3207             {
3208               Elf_Internal_Dyn dyn;
3209               (*swap_dyn_in) (abfd, extdyn, &dyn);
3210
3211               if (dyn.d_tag == DT_NULL)
3212                 break;
3213
3214               if (dyn.d_tag == DT_PPC64_GLINK)
3215                 {
3216                   /* The first glink stub starts at offset 32; see comment in
3217                      ppc64_elf_finish_dynamic_sections. */
3218                   glink_vma = dyn.d_un.d_val + 32;
3219                   /* The .glink section usually does not survive the final
3220                      link; search for the section (usually .text) where the
3221                      glink stubs now reside.  */
3222                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3223                                                 &glink_vma);
3224                   break;
3225                 }
3226             }
3227
3228           free (dynbuf);
3229         }
3230
3231       if (glink != NULL)
3232         {
3233           /* Determine __glink trampoline by reading the relative branch
3234              from the first glink stub.  */
3235           bfd_byte buf[4];
3236           if (bfd_get_section_contents (abfd, glink, buf,
3237                                         glink_vma + 4 - glink->vma, 4))
3238             {
3239               unsigned int insn = bfd_get_32 (abfd, buf);
3240               insn ^= B_DOT;
3241               if ((insn & ~0x3fffffc) == 0)
3242                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3243             }
3244
3245           if (resolv_vma)
3246             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3247
3248           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3249           if (relplt != NULL)
3250             {
3251               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3252               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3253                 goto free_contents_and_exit;
3254
3255               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3256               size += plt_count * sizeof (asymbol);
3257
3258               p = relplt->relocation;
3259               for (i = 0; i < plt_count; i++, p++)
3260                 {
3261                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3262                   if (p->addend != 0)
3263                     size += sizeof ("+0x") - 1 + 16;
3264                 }
3265             }
3266         }
3267
3268       s = *ret = bfd_malloc (size);
3269       if (s == NULL)
3270         goto free_contents_and_exit;
3271
3272       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3273
3274       for (i = secsymend; i < opdsymend; ++i)
3275         {
3276           bfd_vma ent;
3277
3278           if (syms[i]->value > opd->size - 8)
3279             continue;
3280
3281           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3282           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3283             {
3284               long lo, hi;
3285               size_t len;
3286               asection *sec = abfd->sections;
3287
3288               *s = *syms[i];
3289               lo = codesecsym;
3290               hi = codesecsymend;
3291               while (lo < hi)
3292                 {
3293                   long mid = (lo + hi) >> 1;
3294                   if (syms[mid]->section->vma < ent)
3295                     lo = mid + 1;
3296                   else if (syms[mid]->section->vma > ent)
3297                     hi = mid;
3298                   else
3299                     {
3300                       sec = syms[mid]->section;
3301                       break;
3302                     }
3303                 }
3304
3305               if (lo >= hi && lo > codesecsym)
3306                 sec = syms[lo - 1]->section;
3307
3308               for (; sec != NULL; sec = sec->next)
3309                 {
3310                   if (sec->vma > ent)
3311                     break;
3312                   /* SEC_LOAD may not be set if SEC is from a separate debug
3313                      info file.  */
3314                   if ((sec->flags & SEC_ALLOC) == 0)
3315                     break;
3316                   if ((sec->flags & SEC_CODE) != 0)
3317                     s->section = sec;
3318                 }
3319               s->flags |= BSF_SYNTHETIC;
3320               s->value = ent - s->section->vma;
3321               s->name = names;
3322               *names++ = '.';
3323               len = strlen (syms[i]->name);
3324               memcpy (names, syms[i]->name, len + 1);
3325               names += len + 1;
3326               /* Have udata.p point back to the original symbol this
3327                  synthetic symbol was derived from.  */
3328               s->udata.p = syms[i];
3329               s++;
3330             }
3331         }
3332       free (contents);
3333
3334       if (glink != NULL && relplt != NULL)
3335         {
3336           if (resolv_vma)
3337             {
3338               /* Add a symbol for the main glink trampoline.  */
3339               memset (s, 0, sizeof *s);
3340               s->the_bfd = abfd;
3341               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3342               s->section = glink;
3343               s->value = resolv_vma - glink->vma;
3344               s->name = names;
3345               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3346               names += sizeof ("__glink_PLTresolve");
3347               s++;
3348               count++;
3349             }
3350
3351           /* FIXME: It would be very much nicer to put sym@plt on the
3352              stub rather than on the glink branch table entry.  The
3353              objdump disassembler would then use a sensible symbol
3354              name on plt calls.  The difficulty in doing so is
3355              a) finding the stubs, and,
3356              b) matching stubs against plt entries, and,
3357              c) there can be multiple stubs for a given plt entry.
3358
3359              Solving (a) could be done by code scanning, but older
3360              ppc64 binaries used different stubs to current code.
3361              (b) is the tricky one since you need to known the toc
3362              pointer for at least one function that uses a pic stub to
3363              be able to calculate the plt address referenced.
3364              (c) means gdb would need to set multiple breakpoints (or
3365              find the glink branch itself) when setting breakpoints
3366              for pending shared library loads.  */
3367           p = relplt->relocation;
3368           for (i = 0; i < plt_count; i++, p++)
3369             {
3370               size_t len;
3371
3372               *s = **p->sym_ptr_ptr;
3373               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3374                  we are defining a symbol, ensure one of them is set.  */
3375               if ((s->flags & BSF_LOCAL) == 0)
3376                 s->flags |= BSF_GLOBAL;
3377               s->flags |= BSF_SYNTHETIC;
3378               s->section = glink;
3379               s->value = glink_vma - glink->vma;
3380               s->name = names;
3381               s->udata.p = NULL;
3382               len = strlen ((*p->sym_ptr_ptr)->name);
3383               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3384               names += len;
3385               if (p->addend != 0)
3386                 {
3387                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3388                   names += sizeof ("+0x") - 1;
3389                   bfd_sprintf_vma (abfd, names, p->addend);
3390                   names += strlen (names);
3391                 }
3392               memcpy (names, "@plt", sizeof ("@plt"));
3393               names += sizeof ("@plt");
3394               s++;
3395               glink_vma += 8;
3396               if (i >= 0x8000)
3397                 glink_vma += 4;
3398             }
3399           count += plt_count;
3400         }
3401     }
3402
3403  done:
3404   free (syms);
3405   return count;
3406 }
3407 \f
3408 /* The following functions are specific to the ELF linker, while
3409    functions above are used generally.  Those named ppc64_elf_* are
3410    called by the main ELF linker code.  They appear in this file more
3411    or less in the order in which they are called.  eg.
3412    ppc64_elf_check_relocs is called early in the link process,
3413    ppc64_elf_finish_dynamic_sections is one of the last functions
3414    called.
3415
3416    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3417    functions have both a function code symbol and a function descriptor
3418    symbol.  A call to foo in a relocatable object file looks like:
3419
3420    .            .text
3421    .    x:
3422    .            bl      .foo
3423    .            nop
3424
3425    The function definition in another object file might be:
3426
3427    .            .section .opd
3428    .    foo:    .quad   .foo
3429    .            .quad   .TOC.@tocbase
3430    .            .quad   0
3431    .
3432    .            .text
3433    .    .foo:   blr
3434
3435    When the linker resolves the call during a static link, the branch
3436    unsurprisingly just goes to .foo and the .opd information is unused.
3437    If the function definition is in a shared library, things are a little
3438    different:  The call goes via a plt call stub, the opd information gets
3439    copied to the plt, and the linker patches the nop.
3440
3441    .    x:
3442    .            bl      .foo_stub
3443    .            ld      2,40(1)
3444    .
3445    .
3446    .    .foo_stub:
3447    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3448    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3449    .            std     2,40(1)                 # this is the general idea
3450    .            ld      11,0(12)
3451    .            ld      2,8(12)
3452    .            mtctr   11
3453    .            ld      11,16(12)
3454    .            bctr
3455    .
3456    .            .section .plt
3457    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3458
3459    The "reloc ()" notation is supposed to indicate that the linker emits
3460    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3461    copying.
3462
3463    What are the difficulties here?  Well, firstly, the relocations
3464    examined by the linker in check_relocs are against the function code
3465    sym .foo, while the dynamic relocation in the plt is emitted against
3466    the function descriptor symbol, foo.  Somewhere along the line, we need
3467    to carefully copy dynamic link information from one symbol to the other.
3468    Secondly, the generic part of the elf linker will make .foo a dynamic
3469    symbol as is normal for most other backends.  We need foo dynamic
3470    instead, at least for an application final link.  However, when
3471    creating a shared library containing foo, we need to have both symbols
3472    dynamic so that references to .foo are satisfied during the early
3473    stages of linking.  Otherwise the linker might decide to pull in a
3474    definition from some other object, eg. a static library.
3475
3476    Update: As of August 2004, we support a new convention.  Function
3477    calls may use the function descriptor symbol, ie. "bl foo".  This
3478    behaves exactly as "bl .foo".  */
3479
3480 /* Of those relocs that might be copied as dynamic relocs, this function
3481    selects those that must be copied when linking a shared library,
3482    even when the symbol is local.  */
3483
3484 static int
3485 must_be_dyn_reloc (struct bfd_link_info *info,
3486                    enum elf_ppc64_reloc_type r_type)
3487 {
3488   switch (r_type)
3489     {
3490     default:
3491       return 1;
3492
3493     case R_PPC64_REL32:
3494     case R_PPC64_REL64:
3495     case R_PPC64_REL30:
3496       return 0;
3497
3498     case R_PPC64_TPREL16:
3499     case R_PPC64_TPREL16_LO:
3500     case R_PPC64_TPREL16_HI:
3501     case R_PPC64_TPREL16_HA:
3502     case R_PPC64_TPREL16_DS:
3503     case R_PPC64_TPREL16_LO_DS:
3504     case R_PPC64_TPREL16_HIGHER:
3505     case R_PPC64_TPREL16_HIGHERA:
3506     case R_PPC64_TPREL16_HIGHEST:
3507     case R_PPC64_TPREL16_HIGHESTA:
3508     case R_PPC64_TPREL64:
3509       return !info->executable;
3510     }
3511 }
3512
3513 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3514    copying dynamic variables from a shared lib into an app's dynbss
3515    section, and instead use a dynamic relocation to point into the
3516    shared lib.  With code that gcc generates, it's vital that this be
3517    enabled;  In the PowerPC64 ABI, the address of a function is actually
3518    the address of a function descriptor, which resides in the .opd
3519    section.  gcc uses the descriptor directly rather than going via the
3520    GOT as some other ABI's do, which means that initialized function
3521    pointers must reference the descriptor.  Thus, a function pointer
3522    initialized to the address of a function in a shared library will
3523    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3524    redefines the function descriptor symbol to point to the copy.  This
3525    presents a problem as a plt entry for that function is also
3526    initialized from the function descriptor symbol and the copy reloc
3527    may not be initialized first.  */
3528 #define ELIMINATE_COPY_RELOCS 1
3529
3530 /* Section name for stubs is the associated section name plus this
3531    string.  */
3532 #define STUB_SUFFIX ".stub"
3533
3534 /* Linker stubs.
3535    ppc_stub_long_branch:
3536    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3537    destination, but a 24 bit branch in a stub section will reach.
3538    .    b       dest
3539
3540    ppc_stub_plt_branch:
3541    Similar to the above, but a 24 bit branch in the stub section won't
3542    reach its destination.
3543    .    addis   %r12,%r2,xxx@toc@ha
3544    .    ld      %r11,xxx@toc@l(%r12)
3545    .    mtctr   %r11
3546    .    bctr
3547
3548    ppc_stub_plt_call:
3549    Used to call a function in a shared library.  If it so happens that
3550    the plt entry referenced crosses a 64k boundary, then an extra
3551    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3552    .    addis   %r12,%r2,xxx@toc@ha
3553    .    std     %r2,40(%r1)
3554    .    ld      %r11,xxx+0@toc@l(%r12)
3555    .    mtctr   %r11
3556    .    ld      %r2,xxx+8@toc@l(%r12)
3557    .    ld      %r11,xxx+16@toc@l(%r12)
3558    .    bctr
3559
3560    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3561    code to adjust the value and save r2 to support multiple toc sections.
3562    A ppc_stub_long_branch with an r2 offset looks like:
3563    .    std     %r2,40(%r1)
3564    .    addis   %r2,%r2,off@ha
3565    .    addi    %r2,%r2,off@l
3566    .    b       dest
3567
3568    A ppc_stub_plt_branch with an r2 offset looks like:
3569    .    std     %r2,40(%r1)
3570    .    addis   %r12,%r2,xxx@toc@ha
3571    .    ld      %r11,xxx@toc@l(%r12)
3572    .    addis   %r2,%r2,off@ha
3573    .    addi    %r2,%r2,off@l
3574    .    mtctr   %r11
3575    .    bctr
3576
3577    In cases where the "addis" instruction would add zero, the "addis" is
3578    omitted and following instructions modified slightly in some cases.
3579 */
3580
3581 enum ppc_stub_type {
3582   ppc_stub_none,
3583   ppc_stub_long_branch,
3584   ppc_stub_long_branch_r2off,
3585   ppc_stub_plt_branch,
3586   ppc_stub_plt_branch_r2off,
3587   ppc_stub_plt_call
3588 };
3589
3590 struct ppc_stub_hash_entry {
3591
3592   /* Base hash table entry structure.  */
3593   struct bfd_hash_entry root;
3594
3595   enum ppc_stub_type stub_type;
3596
3597   /* The stub section.  */
3598   asection *stub_sec;
3599
3600   /* Offset within stub_sec of the beginning of this stub.  */
3601   bfd_vma stub_offset;
3602
3603   /* Given the symbol's value and its section we can determine its final
3604      value when building the stubs (so the stub knows where to jump.  */
3605   bfd_vma target_value;
3606   asection *target_section;
3607
3608   /* The symbol table entry, if any, that this was derived from.  */
3609   struct ppc_link_hash_entry *h;
3610   struct plt_entry *plt_ent;
3611
3612   /* And the reloc addend that this was derived from.  */
3613   bfd_vma addend;
3614
3615   /* Where this stub is being called from, or, in the case of combined
3616      stub sections, the first input section in the group.  */
3617   asection *id_sec;
3618 };
3619
3620 struct ppc_branch_hash_entry {
3621
3622   /* Base hash table entry structure.  */
3623   struct bfd_hash_entry root;
3624
3625   /* Offset within branch lookup table.  */
3626   unsigned int offset;
3627
3628   /* Generation marker.  */
3629   unsigned int iter;
3630 };
3631
3632 struct ppc_link_hash_entry
3633 {
3634   struct elf_link_hash_entry elf;
3635
3636   union {
3637     /* A pointer to the most recently used stub hash entry against this
3638        symbol.  */
3639     struct ppc_stub_hash_entry *stub_cache;
3640
3641     /* A pointer to the next symbol starting with a '.'  */
3642     struct ppc_link_hash_entry *next_dot_sym;
3643   } u;
3644
3645   /* Track dynamic relocs copied for this symbol.  */
3646   struct elf_dyn_relocs *dyn_relocs;
3647
3648   /* Link between function code and descriptor symbols.  */
3649   struct ppc_link_hash_entry *oh;
3650
3651   /* Flag function code and descriptor symbols.  */
3652   unsigned int is_func:1;
3653   unsigned int is_func_descriptor:1;
3654   unsigned int fake:1;
3655
3656   /* Whether global opd/toc sym has been adjusted or not.
3657      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3658      should be set for all globals defined in any opd/toc section.  */
3659   unsigned int adjust_done:1;
3660
3661   /* Set if we twiddled this symbol to weak at some stage.  */
3662   unsigned int was_undefined:1;
3663
3664   /* Contexts in which symbol is used in the GOT (or TOC).
3665      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3666      corresponding relocs are encountered during check_relocs.
3667      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3668      indicate the corresponding GOT entry type is not needed.
3669      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3670      a TPREL one.  We use a separate flag rather than setting TPREL
3671      just for convenience in distinguishing the two cases.  */
3672 #define TLS_GD           1      /* GD reloc. */
3673 #define TLS_LD           2      /* LD reloc. */
3674 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3675 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3676 #define TLS_TLS         16      /* Any TLS reloc.  */
3677 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3678 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3679 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3680   unsigned char tls_mask;
3681 };
3682
3683 /* ppc64 ELF linker hash table.  */
3684
3685 struct ppc_link_hash_table
3686 {
3687   struct elf_link_hash_table elf;
3688
3689   /* The stub hash table.  */
3690   struct bfd_hash_table stub_hash_table;
3691
3692   /* Another hash table for plt_branch stubs.  */
3693   struct bfd_hash_table branch_hash_table;
3694
3695   /* Hash table for function prologue tocsave.  */
3696   htab_t tocsave_htab;
3697
3698   /* Linker stub bfd.  */
3699   bfd *stub_bfd;
3700
3701   /* Linker call-backs.  */
3702   asection * (*add_stub_section) (const char *, asection *);
3703   void (*layout_sections_again) (void);
3704
3705   /* Array to keep track of which stub sections have been created, and
3706      information on stub grouping.  */
3707   struct map_stub {
3708     /* This is the section to which stubs in the group will be attached.  */
3709     asection *link_sec;
3710     /* The stub section.  */
3711     asection *stub_sec;
3712     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3713     bfd_vma toc_off;
3714   } *stub_group;
3715
3716   /* Temp used when calculating TOC pointers.  */
3717   bfd_vma toc_curr;
3718   bfd *toc_bfd;
3719   asection *toc_first_sec;
3720
3721   /* Highest input section id.  */
3722   int top_id;
3723
3724   /* Highest output section index.  */
3725   int top_index;
3726
3727   /* Used when adding symbols.  */
3728   struct ppc_link_hash_entry *dot_syms;
3729
3730   /* List of input sections for each output section.  */
3731   asection **input_list;
3732
3733   /* Short-cuts to get to dynamic linker sections.  */
3734   asection *got;
3735   asection *plt;
3736   asection *relplt;
3737   asection *iplt;
3738   asection *reliplt;
3739   asection *dynbss;
3740   asection *relbss;
3741   asection *glink;
3742   asection *sfpr;
3743   asection *brlt;
3744   asection *relbrlt;
3745   asection *glink_eh_frame;
3746
3747   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3748   struct ppc_link_hash_entry *tls_get_addr;
3749   struct ppc_link_hash_entry *tls_get_addr_fd;
3750
3751   /* The size of reliplt used by got entry relocs.  */
3752   bfd_size_type got_reli_size;
3753
3754   /* Statistics.  */
3755   unsigned long stub_count[ppc_stub_plt_call];
3756
3757   /* Number of stubs against global syms.  */
3758   unsigned long stub_globals;
3759
3760   /* Set if PLT call stubs should load r11.  */
3761   unsigned int plt_static_chain:1;
3762
3763   /* Set if we should emit symbols for stubs.  */
3764   unsigned int emit_stub_syms:1;
3765
3766   /* Set if __tls_get_addr optimization should not be done.  */
3767   unsigned int no_tls_get_addr_opt:1;
3768
3769   /* Support for multiple toc sections.  */
3770   unsigned int do_multi_toc:1;
3771   unsigned int multi_toc_needed:1;
3772   unsigned int second_toc_pass:1;
3773   unsigned int do_toc_opt:1;
3774
3775   /* Set on error.  */
3776   unsigned int stub_error:1;
3777
3778   /* Temp used by ppc64_elf_process_dot_syms.  */
3779   unsigned int twiddled_syms:1;
3780
3781   /* Incremented every time we size stubs.  */
3782   unsigned int stub_iteration;
3783
3784   /* Small local sym cache.  */
3785   struct sym_cache sym_cache;
3786 };
3787
3788 /* Rename some of the generic section flags to better document how they
3789    are used here.  */
3790
3791 /* Nonzero if this section has TLS related relocations.  */
3792 #define has_tls_reloc sec_flg0
3793
3794 /* Nonzero if this section has a call to __tls_get_addr.  */
3795 #define has_tls_get_addr_call sec_flg1
3796
3797 /* Nonzero if this section has any toc or got relocs.  */
3798 #define has_toc_reloc sec_flg2
3799
3800 /* Nonzero if this section has a call to another section that uses
3801    the toc or got.  */
3802 #define makes_toc_func_call sec_flg3
3803
3804 /* Recursion protection when determining above flag.  */
3805 #define call_check_in_progress sec_flg4
3806 #define call_check_done sec_flg5
3807
3808 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3809
3810 #define ppc_hash_table(p) \
3811   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3812   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3813
3814 #define ppc_stub_hash_lookup(table, string, create, copy) \
3815   ((struct ppc_stub_hash_entry *) \
3816    bfd_hash_lookup ((table), (string), (create), (copy)))
3817
3818 #define ppc_branch_hash_lookup(table, string, create, copy) \
3819   ((struct ppc_branch_hash_entry *) \
3820    bfd_hash_lookup ((table), (string), (create), (copy)))
3821
3822 /* Create an entry in the stub hash table.  */
3823
3824 static struct bfd_hash_entry *
3825 stub_hash_newfunc (struct bfd_hash_entry *entry,
3826                    struct bfd_hash_table *table,
3827                    const char *string)
3828 {
3829   /* Allocate the structure if it has not already been allocated by a
3830      subclass.  */
3831   if (entry == NULL)
3832     {
3833       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3834       if (entry == NULL)
3835         return entry;
3836     }
3837
3838   /* Call the allocation method of the superclass.  */
3839   entry = bfd_hash_newfunc (entry, table, string);
3840   if (entry != NULL)
3841     {
3842       struct ppc_stub_hash_entry *eh;
3843
3844       /* Initialize the local fields.  */
3845       eh = (struct ppc_stub_hash_entry *) entry;
3846       eh->stub_type = ppc_stub_none;
3847       eh->stub_sec = NULL;
3848       eh->stub_offset = 0;
3849       eh->target_value = 0;
3850       eh->target_section = NULL;
3851       eh->h = NULL;
3852       eh->id_sec = NULL;
3853     }
3854
3855   return entry;
3856 }
3857
3858 /* Create an entry in the branch hash table.  */
3859
3860 static struct bfd_hash_entry *
3861 branch_hash_newfunc (struct bfd_hash_entry *entry,
3862                      struct bfd_hash_table *table,
3863                      const char *string)
3864 {
3865   /* Allocate the structure if it has not already been allocated by a
3866      subclass.  */
3867   if (entry == NULL)
3868     {
3869       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3870       if (entry == NULL)
3871         return entry;
3872     }
3873
3874   /* Call the allocation method of the superclass.  */
3875   entry = bfd_hash_newfunc (entry, table, string);
3876   if (entry != NULL)
3877     {
3878       struct ppc_branch_hash_entry *eh;
3879
3880       /* Initialize the local fields.  */
3881       eh = (struct ppc_branch_hash_entry *) entry;
3882       eh->offset = 0;
3883       eh->iter = 0;
3884     }
3885
3886   return entry;
3887 }
3888
3889 /* Create an entry in a ppc64 ELF linker hash table.  */
3890
3891 static struct bfd_hash_entry *
3892 link_hash_newfunc (struct bfd_hash_entry *entry,
3893                    struct bfd_hash_table *table,
3894                    const char *string)
3895 {
3896   /* Allocate the structure if it has not already been allocated by a
3897      subclass.  */
3898   if (entry == NULL)
3899     {
3900       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3901       if (entry == NULL)
3902         return entry;
3903     }
3904
3905   /* Call the allocation method of the superclass.  */
3906   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3907   if (entry != NULL)
3908     {
3909       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3910
3911       memset (&eh->u.stub_cache, 0,
3912               (sizeof (struct ppc_link_hash_entry)
3913                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3914
3915       /* When making function calls, old ABI code references function entry
3916          points (dot symbols), while new ABI code references the function
3917          descriptor symbol.  We need to make any combination of reference and
3918          definition work together, without breaking archive linking.
3919
3920          For a defined function "foo" and an undefined call to "bar":
3921          An old object defines "foo" and ".foo", references ".bar" (possibly
3922          "bar" too).
3923          A new object defines "foo" and references "bar".
3924
3925          A new object thus has no problem with its undefined symbols being
3926          satisfied by definitions in an old object.  On the other hand, the
3927          old object won't have ".bar" satisfied by a new object.
3928
3929          Keep a list of newly added dot-symbols.  */
3930
3931       if (string[0] == '.')
3932         {
3933           struct ppc_link_hash_table *htab;
3934
3935           htab = (struct ppc_link_hash_table *) table;
3936           eh->u.next_dot_sym = htab->dot_syms;
3937           htab->dot_syms = eh;
3938         }
3939     }
3940
3941   return entry;
3942 }
3943
3944 struct tocsave_entry {
3945   asection *sec;
3946   bfd_vma offset;
3947 };
3948
3949 static hashval_t
3950 tocsave_htab_hash (const void *p)
3951 {
3952   const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3953   return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
3954 }
3955
3956 static int
3957 tocsave_htab_eq (const void *p1, const void *p2)
3958 {
3959   const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3960   const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3961   return e1->sec == e2->sec && e1->offset == e2->offset;
3962 }
3963
3964 /* Create a ppc64 ELF linker hash table.  */
3965
3966 static struct bfd_link_hash_table *
3967 ppc64_elf_link_hash_table_create (bfd *abfd)
3968 {
3969   struct ppc_link_hash_table *htab;
3970   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3971
3972   htab = bfd_zmalloc (amt);
3973   if (htab == NULL)
3974     return NULL;
3975
3976   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3977                                       sizeof (struct ppc_link_hash_entry),
3978                                       PPC64_ELF_DATA))
3979     {
3980       free (htab);
3981       return NULL;
3982     }
3983
3984   /* Init the stub hash table too.  */
3985   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3986                             sizeof (struct ppc_stub_hash_entry)))
3987     return NULL;
3988
3989   /* And the branch hash table.  */
3990   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3991                             sizeof (struct ppc_branch_hash_entry)))
3992     return NULL;
3993
3994   htab->tocsave_htab = htab_try_create (1024,
3995                                         tocsave_htab_hash,
3996                                         tocsave_htab_eq,
3997                                         NULL);
3998   if (htab->tocsave_htab == NULL)
3999     return NULL;
4000
4001   /* Initializing two fields of the union is just cosmetic.  We really
4002      only care about glist, but when compiled on a 32-bit host the
4003      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
4004      debugger inspection of these fields look nicer.  */
4005   htab->elf.init_got_refcount.refcount = 0;
4006   htab->elf.init_got_refcount.glist = NULL;
4007   htab->elf.init_plt_refcount.refcount = 0;
4008   htab->elf.init_plt_refcount.glist = NULL;
4009   htab->elf.init_got_offset.offset = 0;
4010   htab->elf.init_got_offset.glist = NULL;
4011   htab->elf.init_plt_offset.offset = 0;
4012   htab->elf.init_plt_offset.glist = NULL;
4013
4014   return &htab->elf.root;
4015 }
4016
4017 /* Free the derived linker hash table.  */
4018
4019 static void
4020 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4021 {
4022   struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4023
4024   bfd_hash_table_free (&htab->stub_hash_table);
4025   bfd_hash_table_free (&htab->branch_hash_table);
4026   if (htab->tocsave_htab)
4027     htab_delete (htab->tocsave_htab);
4028   _bfd_generic_link_hash_table_free (hash);
4029 }
4030
4031 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4032
4033 void
4034 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4035 {
4036   struct ppc_link_hash_table *htab;
4037
4038   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4039
4040 /* Always hook our dynamic sections into the first bfd, which is the
4041    linker created stub bfd.  This ensures that the GOT header is at
4042    the start of the output TOC section.  */
4043   htab = ppc_hash_table (info);
4044   if (htab == NULL)
4045     return;
4046   htab->stub_bfd = abfd;
4047   htab->elf.dynobj = abfd;
4048 }
4049
4050 /* Build a name for an entry in the stub hash table.  */
4051
4052 static char *
4053 ppc_stub_name (const asection *input_section,
4054                const asection *sym_sec,
4055                const struct ppc_link_hash_entry *h,
4056                const Elf_Internal_Rela *rel)
4057 {
4058   char *stub_name;
4059   bfd_size_type len;
4060
4061   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4062      offsets from a sym as a branch target?  In fact, we could
4063      probably assume the addend is always zero.  */
4064   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4065
4066   if (h)
4067     {
4068       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4069       stub_name = bfd_malloc (len);
4070       if (stub_name == NULL)
4071         return stub_name;
4072
4073       sprintf (stub_name, "%08x.%s+%x",
4074                input_section->id & 0xffffffff,
4075                h->elf.root.root.string,
4076                (int) rel->r_addend & 0xffffffff);
4077     }
4078   else
4079     {
4080       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4081       stub_name = bfd_malloc (len);
4082       if (stub_name == NULL)
4083         return stub_name;
4084
4085       sprintf (stub_name, "%08x.%x:%x+%x",
4086                input_section->id & 0xffffffff,
4087                sym_sec->id & 0xffffffff,
4088                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4089                (int) rel->r_addend & 0xffffffff);
4090     }
4091   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4092     stub_name[len - 2] = 0;
4093   return stub_name;
4094 }
4095
4096 /* Look up an entry in the stub hash.  Stub entries are cached because
4097    creating the stub name takes a bit of time.  */
4098
4099 static struct ppc_stub_hash_entry *
4100 ppc_get_stub_entry (const asection *input_section,
4101                     const asection *sym_sec,
4102                     struct ppc_link_hash_entry *h,
4103                     const Elf_Internal_Rela *rel,
4104                     struct ppc_link_hash_table *htab)
4105 {
4106   struct ppc_stub_hash_entry *stub_entry;
4107   const asection *id_sec;
4108
4109   /* If this input section is part of a group of sections sharing one
4110      stub section, then use the id of the first section in the group.
4111      Stub names need to include a section id, as there may well be
4112      more than one stub used to reach say, printf, and we need to
4113      distinguish between them.  */
4114   id_sec = htab->stub_group[input_section->id].link_sec;
4115
4116   if (h != NULL && h->u.stub_cache != NULL
4117       && h->u.stub_cache->h == h
4118       && h->u.stub_cache->id_sec == id_sec)
4119     {
4120       stub_entry = h->u.stub_cache;
4121     }
4122   else
4123     {
4124       char *stub_name;
4125
4126       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4127       if (stub_name == NULL)
4128         return NULL;
4129
4130       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4131                                          stub_name, FALSE, FALSE);
4132       if (h != NULL)
4133         h->u.stub_cache = stub_entry;
4134
4135       free (stub_name);
4136     }
4137
4138   return stub_entry;
4139 }
4140
4141 /* Add a new stub entry to the stub hash.  Not all fields of the new
4142    stub entry are initialised.  */
4143
4144 static struct ppc_stub_hash_entry *
4145 ppc_add_stub (const char *stub_name,
4146               asection *section,
4147               struct bfd_link_info *info)
4148 {
4149   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4150   asection *link_sec;
4151   asection *stub_sec;
4152   struct ppc_stub_hash_entry *stub_entry;
4153
4154   link_sec = htab->stub_group[section->id].link_sec;
4155   stub_sec = htab->stub_group[section->id].stub_sec;
4156   if (stub_sec == NULL)
4157     {
4158       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4159       if (stub_sec == NULL)
4160         {
4161           size_t namelen;
4162           bfd_size_type len;
4163           char *s_name;
4164
4165           namelen = strlen (link_sec->name);
4166           len = namelen + sizeof (STUB_SUFFIX);
4167           s_name = bfd_alloc (htab->stub_bfd, len);
4168           if (s_name == NULL)
4169             return NULL;
4170
4171           memcpy (s_name, link_sec->name, namelen);
4172           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4173           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4174           if (stub_sec == NULL)
4175             return NULL;
4176           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4177         }
4178       htab->stub_group[section->id].stub_sec = stub_sec;
4179     }
4180
4181   /* Enter this entry into the linker stub hash table.  */
4182   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4183                                      TRUE, FALSE);
4184   if (stub_entry == NULL)
4185     {
4186       info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4187                               section->owner, stub_name);
4188       return NULL;
4189     }
4190
4191   stub_entry->stub_sec = stub_sec;
4192   stub_entry->stub_offset = 0;
4193   stub_entry->id_sec = link_sec;
4194   return stub_entry;
4195 }
4196
4197 /* Create sections for linker generated code.  */
4198
4199 static bfd_boolean
4200 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4201 {
4202   struct ppc_link_hash_table *htab;
4203   flagword flags;
4204
4205   htab = ppc_hash_table (info);
4206   if (htab == NULL)
4207     return FALSE;
4208
4209   /* Create .sfpr for code to save and restore fp regs.  */
4210   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4211            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4212   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4213                                                    flags);
4214   if (htab->sfpr == NULL
4215       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4216     return FALSE;
4217
4218   /* Create .glink for lazy dynamic linking support.  */
4219   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4220                                                     flags);
4221   if (htab->glink == NULL
4222       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4223     return FALSE;
4224
4225   if (!info->no_ld_generated_unwind_info)
4226     {
4227       flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4228                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4229       htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4230                                                                  ".eh_frame",
4231                                                                  flags);
4232       if (htab->glink_eh_frame == NULL
4233           || !bfd_set_section_alignment (abfd, htab->glink_eh_frame, 2))
4234         return FALSE;
4235     }
4236
4237   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4238   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4239   if (htab->iplt == NULL
4240       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4241     return FALSE;
4242
4243   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4244            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4246                                                       ".rela.iplt",
4247                                                       flags);
4248   if (htab->reliplt == NULL
4249       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4250     return FALSE;
4251
4252   /* Create branch lookup table for plt_branch stubs.  */
4253   flags = (SEC_ALLOC | SEC_LOAD
4254            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4255   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4256                                                    flags);
4257   if (htab->brlt == NULL
4258       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4259     return FALSE;
4260
4261   if (!info->shared)
4262     return TRUE;
4263
4264   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4265            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4266   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4267                                                       ".rela.branch_lt",
4268                                                       flags);
4269   if (htab->relbrlt == NULL
4270       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4271     return FALSE;
4272
4273   return TRUE;
4274 }
4275
4276 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4277    not already done.  */
4278
4279 static bfd_boolean
4280 create_got_section (bfd *abfd, struct bfd_link_info *info)
4281 {
4282   asection *got, *relgot;
4283   flagword flags;
4284   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4285
4286   if (!is_ppc64_elf (abfd))
4287     return FALSE;
4288   if (htab == NULL)
4289     return FALSE;
4290
4291   if (!htab->got)
4292     {
4293       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4294         return FALSE;
4295
4296       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4297       if (!htab->got)
4298         abort ();
4299     }
4300
4301   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4302            | SEC_LINKER_CREATED);
4303
4304   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4305   if (!got
4306       || !bfd_set_section_alignment (abfd, got, 3))
4307     return FALSE;
4308
4309   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4310                                                flags | SEC_READONLY);
4311   if (!relgot
4312       || ! bfd_set_section_alignment (abfd, relgot, 3))
4313     return FALSE;
4314
4315   ppc64_elf_tdata (abfd)->got = got;
4316   ppc64_elf_tdata (abfd)->relgot = relgot;
4317   return TRUE;
4318 }
4319
4320 /* Create the dynamic sections, and set up shortcuts.  */
4321
4322 static bfd_boolean
4323 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4324 {
4325   struct ppc_link_hash_table *htab;
4326
4327   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4328     return FALSE;
4329
4330   htab = ppc_hash_table (info);
4331   if (htab == NULL)
4332     return FALSE;
4333
4334   if (!htab->got)
4335     htab->got = bfd_get_section_by_name (dynobj, ".got");
4336   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4337   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4338   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4339   if (!info->shared)
4340     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4341
4342   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4343       || (!info->shared && !htab->relbss))
4344     abort ();
4345
4346   return TRUE;
4347 }
4348
4349 /* Follow indirect and warning symbol links.  */
4350
4351 static inline struct bfd_link_hash_entry *
4352 follow_link (struct bfd_link_hash_entry *h)
4353 {
4354   while (h->type == bfd_link_hash_indirect
4355          || h->type == bfd_link_hash_warning)
4356     h = h->u.i.link;
4357   return h;
4358 }
4359
4360 static inline struct elf_link_hash_entry *
4361 elf_follow_link (struct elf_link_hash_entry *h)
4362 {
4363   return (struct elf_link_hash_entry *) follow_link (&h->root);
4364 }
4365
4366 static inline struct ppc_link_hash_entry *
4367 ppc_follow_link (struct ppc_link_hash_entry *h)
4368 {
4369   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4370 }
4371
4372 /* Merge PLT info on FROM with that on TO.  */
4373
4374 static void
4375 move_plt_plist (struct ppc_link_hash_entry *from,
4376                 struct ppc_link_hash_entry *to)
4377 {
4378   if (from->elf.plt.plist != NULL)
4379     {
4380       if (to->elf.plt.plist != NULL)
4381         {
4382           struct plt_entry **entp;
4383           struct plt_entry *ent;
4384
4385           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4386             {
4387               struct plt_entry *dent;
4388
4389               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4390                 if (dent->addend == ent->addend)
4391                   {
4392                     dent->plt.refcount += ent->plt.refcount;
4393                     *entp = ent->next;
4394                     break;
4395                   }
4396               if (dent == NULL)
4397                 entp = &ent->next;
4398             }
4399           *entp = to->elf.plt.plist;
4400         }
4401
4402       to->elf.plt.plist = from->elf.plt.plist;
4403       from->elf.plt.plist = NULL;
4404     }
4405 }
4406
4407 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4408
4409 static void
4410 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4411                                 struct elf_link_hash_entry *dir,
4412                                 struct elf_link_hash_entry *ind)
4413 {
4414   struct ppc_link_hash_entry *edir, *eind;
4415
4416   edir = (struct ppc_link_hash_entry *) dir;
4417   eind = (struct ppc_link_hash_entry *) ind;
4418
4419   edir->is_func |= eind->is_func;
4420   edir->is_func_descriptor |= eind->is_func_descriptor;
4421   edir->tls_mask |= eind->tls_mask;
4422   if (eind->oh != NULL)
4423     edir->oh = ppc_follow_link (eind->oh);
4424
4425   /* If called to transfer flags for a weakdef during processing
4426      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4427      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4428   if (!(ELIMINATE_COPY_RELOCS
4429         && eind->elf.root.type != bfd_link_hash_indirect
4430         && edir->elf.dynamic_adjusted))
4431     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4432
4433   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4434   edir->elf.ref_regular |= eind->elf.ref_regular;
4435   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4436   edir->elf.needs_plt |= eind->elf.needs_plt;
4437
4438   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4439   if (eind->dyn_relocs != NULL)
4440     {
4441       if (edir->dyn_relocs != NULL)
4442         {
4443           struct elf_dyn_relocs **pp;
4444           struct elf_dyn_relocs *p;
4445
4446           /* Add reloc counts against the indirect sym to the direct sym
4447              list.  Merge any entries against the same section.  */
4448           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4449             {
4450               struct elf_dyn_relocs *q;
4451
4452               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4453                 if (q->sec == p->sec)
4454                   {
4455                     q->pc_count += p->pc_count;
4456                     q->count += p->count;
4457                     *pp = p->next;
4458                     break;
4459                   }
4460               if (q == NULL)
4461                 pp = &p->next;
4462             }
4463           *pp = edir->dyn_relocs;
4464         }
4465
4466       edir->dyn_relocs = eind->dyn_relocs;
4467       eind->dyn_relocs = NULL;
4468     }
4469
4470   /* If we were called to copy over info for a weak sym, that's all.
4471      You might think dyn_relocs need not be copied over;  After all,
4472      both syms will be dynamic or both non-dynamic so we're just
4473      moving reloc accounting around.  However, ELIMINATE_COPY_RELOCS
4474      code in ppc64_elf_adjust_dynamic_symbol needs to check for
4475      dyn_relocs in read-only sections, and it does so on what is the
4476      DIR sym here.  */
4477   if (eind->elf.root.type != bfd_link_hash_indirect)
4478     return;
4479
4480   /* Copy over got entries that we may have already seen to the
4481      symbol which just became indirect.  */
4482   if (eind->elf.got.glist != NULL)
4483     {
4484       if (edir->elf.got.glist != NULL)
4485         {
4486           struct got_entry **entp;
4487           struct got_entry *ent;
4488
4489           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4490             {
4491               struct got_entry *dent;
4492
4493               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4494                 if (dent->addend == ent->addend
4495                     && dent->owner == ent->owner
4496                     && dent->tls_type == ent->tls_type)
4497                   {
4498                     dent->got.refcount += ent->got.refcount;
4499                     *entp = ent->next;
4500                     break;
4501                   }
4502               if (dent == NULL)
4503                 entp = &ent->next;
4504             }
4505           *entp = edir->elf.got.glist;
4506         }
4507
4508       edir->elf.got.glist = eind->elf.got.glist;
4509       eind->elf.got.glist = NULL;
4510     }
4511
4512   /* And plt entries.  */
4513   move_plt_plist (eind, edir);
4514
4515   if (eind->elf.dynindx != -1)
4516     {
4517       if (edir->elf.dynindx != -1)
4518         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4519                                 edir->elf.dynstr_index);
4520       edir->elf.dynindx = eind->elf.dynindx;
4521       edir->elf.dynstr_index = eind->elf.dynstr_index;
4522       eind->elf.dynindx = -1;
4523       eind->elf.dynstr_index = 0;
4524     }
4525 }
4526
4527 /* Find the function descriptor hash entry from the given function code
4528    hash entry FH.  Link the entries via their OH fields.  */
4529
4530 static struct ppc_link_hash_entry *
4531 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4532 {
4533   struct ppc_link_hash_entry *fdh = fh->oh;
4534
4535   if (fdh == NULL)
4536     {
4537       const char *fd_name = fh->elf.root.root.string + 1;
4538
4539       fdh = (struct ppc_link_hash_entry *)
4540         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4541       if (fdh == NULL)
4542         return fdh;
4543
4544       fdh->is_func_descriptor = 1;
4545       fdh->oh = fh;
4546       fh->is_func = 1;
4547       fh->oh = fdh;
4548     }
4549
4550   return ppc_follow_link (fdh);
4551 }
4552
4553 /* Make a fake function descriptor sym for the code sym FH.  */
4554
4555 static struct ppc_link_hash_entry *
4556 make_fdh (struct bfd_link_info *info,
4557           struct ppc_link_hash_entry *fh)
4558 {
4559   bfd *abfd;
4560   asymbol *newsym;
4561   struct bfd_link_hash_entry *bh;
4562   struct ppc_link_hash_entry *fdh;
4563
4564   abfd = fh->elf.root.u.undef.abfd;
4565   newsym = bfd_make_empty_symbol (abfd);
4566   newsym->name = fh->elf.root.root.string + 1;
4567   newsym->section = bfd_und_section_ptr;
4568   newsym->value = 0;
4569   newsym->flags = BSF_WEAK;
4570
4571   bh = NULL;
4572   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4573                                          newsym->flags, newsym->section,
4574                                          newsym->value, NULL, FALSE, FALSE,
4575                                          &bh))
4576     return NULL;
4577
4578   fdh = (struct ppc_link_hash_entry *) bh;
4579   fdh->elf.non_elf = 0;
4580   fdh->fake = 1;
4581   fdh->is_func_descriptor = 1;
4582   fdh->oh = fh;
4583   fh->is_func = 1;
4584   fh->oh = fdh;
4585   return fdh;
4586 }
4587
4588 /* Fix function descriptor symbols defined in .opd sections to be
4589    function type.  */
4590
4591 static bfd_boolean
4592 ppc64_elf_add_symbol_hook (bfd *ibfd,
4593                            struct bfd_link_info *info,
4594                            Elf_Internal_Sym *isym,
4595                            const char **name ATTRIBUTE_UNUSED,
4596                            flagword *flags ATTRIBUTE_UNUSED,
4597                            asection **sec,
4598                            bfd_vma *value ATTRIBUTE_UNUSED)
4599 {
4600   if ((ibfd->flags & DYNAMIC) == 0
4601       && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4602     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4603
4604   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4605     {
4606       if ((ibfd->flags & DYNAMIC) == 0)
4607         elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4608     }
4609   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4610     ;
4611   else if (*sec != NULL
4612            && strcmp ((*sec)->name, ".opd") == 0)
4613     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4614
4615   return TRUE;
4616 }
4617
4618 /* This function makes an old ABI object reference to ".bar" cause the
4619    inclusion of a new ABI object archive that defines "bar".
4620    NAME is a symbol defined in an archive.  Return a symbol in the hash
4621    table that might be satisfied by the archive symbols.  */
4622
4623 static struct elf_link_hash_entry *
4624 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4625                                  struct bfd_link_info *info,
4626                                  const char *name)
4627 {
4628   struct elf_link_hash_entry *h;
4629   char *dot_name;
4630   size_t len;
4631
4632   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4633   if (h != NULL
4634       /* Don't return this sym if it is a fake function descriptor
4635          created by add_symbol_adjust.  */
4636       && !(h->root.type == bfd_link_hash_undefweak
4637            && ((struct ppc_link_hash_entry *) h)->fake))
4638     return h;
4639
4640   if (name[0] == '.')
4641     return h;
4642
4643   len = strlen (name);
4644   dot_name = bfd_alloc (abfd, len + 2);
4645   if (dot_name == NULL)
4646     return (struct elf_link_hash_entry *) 0 - 1;
4647   dot_name[0] = '.';
4648   memcpy (dot_name + 1, name, len + 1);
4649   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4650   bfd_release (abfd, dot_name);
4651   return h;
4652 }
4653
4654 /* This function satisfies all old ABI object references to ".bar" if a
4655    new ABI object defines "bar".  Well, at least, undefined dot symbols
4656    are made weak.  This stops later archive searches from including an
4657    object if we already have a function descriptor definition.  It also
4658    prevents the linker complaining about undefined symbols.
4659    We also check and correct mismatched symbol visibility here.  The
4660    most restrictive visibility of the function descriptor and the
4661    function entry symbol is used.  */
4662
4663 static bfd_boolean
4664 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4665 {
4666   struct ppc_link_hash_table *htab;
4667   struct ppc_link_hash_entry *fdh;
4668
4669   if (eh->elf.root.type == bfd_link_hash_indirect)
4670     return TRUE;
4671
4672   if (eh->elf.root.type == bfd_link_hash_warning)
4673     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4674
4675   if (eh->elf.root.root.string[0] != '.')
4676     abort ();
4677
4678   htab = ppc_hash_table (info);
4679   if (htab == NULL)
4680     return FALSE;
4681
4682   fdh = lookup_fdh (eh, htab);
4683   if (fdh == NULL)
4684     {
4685       if (!info->relocatable
4686           && (eh->elf.root.type == bfd_link_hash_undefined
4687               || eh->elf.root.type == bfd_link_hash_undefweak)
4688           && eh->elf.ref_regular)
4689         {
4690           /* Make an undefweak function descriptor sym, which is enough to
4691              pull in an --as-needed shared lib, but won't cause link
4692              errors.  Archives are handled elsewhere.  */
4693           fdh = make_fdh (info, eh);
4694           if (fdh == NULL)
4695             return FALSE;
4696           fdh->elf.ref_regular = 1;
4697         }
4698     }
4699   else
4700     {
4701       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4702       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4703       if (entry_vis < descr_vis)
4704         fdh->elf.other += entry_vis - descr_vis;
4705       else if (entry_vis > descr_vis)
4706         eh->elf.other += descr_vis - entry_vis;
4707
4708       if ((fdh->elf.root.type == bfd_link_hash_defined
4709            || fdh->elf.root.type == bfd_link_hash_defweak)
4710           && eh->elf.root.type == bfd_link_hash_undefined)
4711         {
4712           eh->elf.root.type = bfd_link_hash_undefweak;
4713           eh->was_undefined = 1;
4714           htab->twiddled_syms = 1;
4715         }
4716     }
4717
4718   return TRUE;
4719 }
4720
4721 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4722
4723 static bfd_boolean
4724 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4725 {
4726   struct ppc_link_hash_table *htab;
4727   struct ppc_link_hash_entry **p, *eh;
4728
4729   if (!is_ppc64_elf (info->output_bfd))
4730     return TRUE;
4731   htab = ppc_hash_table (info);
4732   if (htab == NULL)
4733     return FALSE;
4734
4735   if (is_ppc64_elf (ibfd))
4736     {
4737       p = &htab->dot_syms;
4738       while ((eh = *p) != NULL)
4739         {
4740           *p = NULL;
4741           if (!add_symbol_adjust (eh, info))
4742             return FALSE;
4743           p = &eh->u.next_dot_sym;
4744         }
4745     }
4746
4747   /* Clear the list for non-ppc64 input files.  */
4748   p = &htab->dot_syms;
4749   while ((eh = *p) != NULL)
4750     {
4751       *p = NULL;
4752       p = &eh->u.next_dot_sym;
4753     }
4754
4755   /* We need to fix the undefs list for any syms we have twiddled to
4756      undef_weak.  */
4757   if (htab->twiddled_syms)
4758     {
4759       bfd_link_repair_undef_list (&htab->elf.root);
4760       htab->twiddled_syms = 0;
4761     }
4762   return TRUE;
4763 }
4764
4765 /* Undo hash table changes when an --as-needed input file is determined
4766    not to be needed.  */
4767
4768 static bfd_boolean
4769 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4770                              struct bfd_link_info *info)
4771 {
4772   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4773
4774   if (htab == NULL)
4775     return FALSE;
4776
4777   htab->dot_syms = NULL;
4778   return TRUE;
4779 }
4780
4781 /* If --just-symbols against a final linked binary, then assume we need
4782    toc adjusting stubs when calling functions defined there.  */
4783
4784 static void
4785 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4786 {
4787   if ((sec->flags & SEC_CODE) != 0
4788       && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4789       && is_ppc64_elf (sec->owner))
4790     {
4791       asection *got = bfd_get_section_by_name (sec->owner, ".got");
4792       if (got != NULL
4793           && got->size >= elf_backend_got_header_size
4794           && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4795         sec->has_toc_reloc = 1;
4796     }
4797   _bfd_elf_link_just_syms (sec, info);
4798 }
4799
4800 static struct plt_entry **
4801 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4802                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4803 {
4804   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4805   struct plt_entry **local_plt;
4806   unsigned char *local_got_tls_masks;
4807
4808   if (local_got_ents == NULL)
4809     {
4810       bfd_size_type size = symtab_hdr->sh_info;
4811
4812       size *= (sizeof (*local_got_ents)
4813                + sizeof (*local_plt)
4814                + sizeof (*local_got_tls_masks));
4815       local_got_ents = bfd_zalloc (abfd, size);
4816       if (local_got_ents == NULL)
4817         return NULL;
4818       elf_local_got_ents (abfd) = local_got_ents;
4819     }
4820
4821   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4822     {
4823       struct got_entry *ent;
4824
4825       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4826         if (ent->addend == r_addend
4827             && ent->owner == abfd
4828             && ent->tls_type == tls_type)
4829           break;
4830       if (ent == NULL)
4831         {
4832           bfd_size_type amt = sizeof (*ent);
4833           ent = bfd_alloc (abfd, amt);
4834           if (ent == NULL)
4835             return FALSE;
4836           ent->next = local_got_ents[r_symndx];
4837           ent->addend = r_addend;
4838           ent->owner = abfd;
4839           ent->tls_type = tls_type;
4840           ent->is_indirect = FALSE;
4841           ent->got.refcount = 0;
4842           local_got_ents[r_symndx] = ent;
4843         }
4844       ent->got.refcount += 1;
4845     }
4846
4847   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4848   local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4849   local_got_tls_masks[r_symndx] |= tls_type;
4850
4851   return local_plt + r_symndx;
4852 }
4853
4854 static bfd_boolean
4855 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4856 {
4857   struct plt_entry *ent;
4858
4859   for (ent = *plist; ent != NULL; ent = ent->next)
4860     if (ent->addend == addend)
4861       break;
4862   if (ent == NULL)
4863     {
4864       bfd_size_type amt = sizeof (*ent);
4865       ent = bfd_alloc (abfd, amt);
4866       if (ent == NULL)
4867         return FALSE;
4868       ent->next = *plist;
4869       ent->addend = addend;
4870       ent->plt.refcount = 0;
4871       *plist = ent;
4872     }
4873   ent->plt.refcount += 1;
4874   return TRUE;
4875 }
4876
4877 static bfd_boolean
4878 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4879 {
4880   return (r_type == R_PPC64_REL24
4881           || r_type == R_PPC64_REL14
4882           || r_type == R_PPC64_REL14_BRTAKEN
4883           || r_type == R_PPC64_REL14_BRNTAKEN
4884           || r_type == R_PPC64_ADDR24
4885           || r_type == R_PPC64_ADDR14
4886           || r_type == R_PPC64_ADDR14_BRTAKEN
4887           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4888 }
4889
4890 /* Look through the relocs for a section during the first phase, and
4891    calculate needed space in the global offset table, procedure
4892    linkage table, and dynamic reloc sections.  */
4893
4894 static bfd_boolean
4895 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4896                         asection *sec, const Elf_Internal_Rela *relocs)
4897 {
4898   struct ppc_link_hash_table *htab;
4899   Elf_Internal_Shdr *symtab_hdr;
4900   struct elf_link_hash_entry **sym_hashes;
4901   const Elf_Internal_Rela *rel;
4902   const Elf_Internal_Rela *rel_end;
4903   asection *sreloc;
4904   asection **opd_sym_map;
4905   struct elf_link_hash_entry *tga, *dottga;
4906
4907   if (info->relocatable)
4908     return TRUE;
4909
4910   /* Don't do anything special with non-loaded, non-alloced sections.
4911      In particular, any relocs in such sections should not affect GOT
4912      and PLT reference counting (ie. we don't allow them to create GOT
4913      or PLT entries), there's no possibility or desire to optimize TLS
4914      relocs, and there's not much point in propagating relocs to shared
4915      libs that the dynamic linker won't relocate.  */
4916   if ((sec->flags & SEC_ALLOC) == 0)
4917     return TRUE;
4918
4919   BFD_ASSERT (is_ppc64_elf (abfd));
4920
4921   htab = ppc_hash_table (info);
4922   if (htab == NULL)
4923     return FALSE;
4924
4925   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4926                               FALSE, FALSE, TRUE);
4927   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4928                                  FALSE, FALSE, TRUE);
4929   symtab_hdr = &elf_symtab_hdr (abfd);
4930   sym_hashes = elf_sym_hashes (abfd);
4931   sreloc = NULL;
4932   opd_sym_map = NULL;
4933   if (strcmp (sec->name, ".opd") == 0)
4934     {
4935       /* Garbage collection needs some extra help with .opd sections.
4936          We don't want to necessarily keep everything referenced by
4937          relocs in .opd, as that would keep all functions.  Instead,
4938          if we reference an .opd symbol (a function descriptor), we
4939          want to keep the function code symbol's section.  This is
4940          easy for global symbols, but for local syms we need to keep
4941          information about the associated function section.  */
4942       bfd_size_type amt;
4943
4944       amt = sec->size * sizeof (*opd_sym_map) / 8;
4945       opd_sym_map = bfd_zalloc (abfd, amt);
4946       if (opd_sym_map == NULL)
4947         return FALSE;
4948       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4949       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4950       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4951     }
4952
4953   if (htab->sfpr == NULL
4954       && !create_linkage_sections (htab->elf.dynobj, info))
4955     return FALSE;
4956
4957   rel_end = relocs + sec->reloc_count;
4958   for (rel = relocs; rel < rel_end; rel++)
4959     {
4960       unsigned long r_symndx;
4961       struct elf_link_hash_entry *h;
4962       enum elf_ppc64_reloc_type r_type;
4963       int tls_type;
4964       struct _ppc64_elf_section_data *ppc64_sec;
4965       struct plt_entry **ifunc;
4966
4967       r_symndx = ELF64_R_SYM (rel->r_info);
4968       if (r_symndx < symtab_hdr->sh_info)
4969         h = NULL;
4970       else
4971         {
4972           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4973           h = elf_follow_link (h);
4974         }
4975
4976       tls_type = 0;
4977       ifunc = NULL;
4978       if (h != NULL)
4979         {
4980           if (h->type == STT_GNU_IFUNC)
4981             {
4982               h->needs_plt = 1;
4983               ifunc = &h->plt.plist;
4984             }
4985         }
4986       else
4987         {
4988           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4989                                                           abfd, r_symndx);
4990           if (isym == NULL)
4991             return FALSE;
4992
4993           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4994             {
4995               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4996                                              rel->r_addend, PLT_IFUNC);
4997               if (ifunc == NULL)
4998                 return FALSE;
4999             }
5000         }
5001       r_type = ELF64_R_TYPE (rel->r_info);
5002       if (is_branch_reloc (r_type))
5003         {
5004           if (h != NULL && (h == tga || h == dottga))
5005             {
5006               if (rel != relocs
5007                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5008                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5009                 /* We have a new-style __tls_get_addr call with a marker
5010                    reloc.  */
5011                 ;
5012               else
5013                 /* Mark this section as having an old-style call.  */
5014                 sec->has_tls_get_addr_call = 1;
5015             }
5016
5017           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
5018           if (ifunc != NULL
5019               && !update_plt_info (abfd, ifunc, rel->r_addend))
5020             return FALSE;
5021         }
5022
5023       switch (r_type)
5024         {
5025         case R_PPC64_TLSGD:
5026         case R_PPC64_TLSLD:
5027           /* These special tls relocs tie a call to __tls_get_addr with
5028              its parameter symbol.  */
5029           break;
5030
5031         case R_PPC64_GOT_TLSLD16:
5032         case R_PPC64_GOT_TLSLD16_LO:
5033         case R_PPC64_GOT_TLSLD16_HI:
5034         case R_PPC64_GOT_TLSLD16_HA:
5035           tls_type = TLS_TLS | TLS_LD;
5036           goto dogottls;
5037
5038         case R_PPC64_GOT_TLSGD16:
5039         case R_PPC64_GOT_TLSGD16_LO:
5040         case R_PPC64_GOT_TLSGD16_HI:
5041         case R_PPC64_GOT_TLSGD16_HA:
5042           tls_type = TLS_TLS | TLS_GD;
5043           goto dogottls;
5044
5045         case R_PPC64_GOT_TPREL16_DS:
5046         case R_PPC64_GOT_TPREL16_LO_DS:
5047         case R_PPC64_GOT_TPREL16_HI:
5048         case R_PPC64_GOT_TPREL16_HA:
5049           if (!info->executable)
5050             info->flags |= DF_STATIC_TLS;
5051           tls_type = TLS_TLS | TLS_TPREL;
5052           goto dogottls;
5053
5054         case R_PPC64_GOT_DTPREL16_DS:
5055         case R_PPC64_GOT_DTPREL16_LO_DS:
5056         case R_PPC64_GOT_DTPREL16_HI:
5057         case R_PPC64_GOT_DTPREL16_HA:
5058           tls_type = TLS_TLS | TLS_DTPREL;
5059         dogottls:
5060           sec->has_tls_reloc = 1;
5061           /* Fall thru */
5062
5063         case R_PPC64_GOT16:
5064         case R_PPC64_GOT16_DS:
5065         case R_PPC64_GOT16_HA:
5066         case R_PPC64_GOT16_HI:
5067         case R_PPC64_GOT16_LO:
5068         case R_PPC64_GOT16_LO_DS:
5069           /* This symbol requires a global offset table entry.  */
5070           sec->has_toc_reloc = 1;
5071           if (r_type == R_PPC64_GOT_TLSLD16
5072               || r_type == R_PPC64_GOT_TLSGD16
5073               || r_type == R_PPC64_GOT_TPREL16_DS
5074               || r_type == R_PPC64_GOT_DTPREL16_DS
5075               || r_type == R_PPC64_GOT16
5076               || r_type == R_PPC64_GOT16_DS)
5077             {
5078               htab->do_multi_toc = 1;
5079               ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5080             }
5081
5082           if (ppc64_elf_tdata (abfd)->got == NULL
5083               && !create_got_section (abfd, info))
5084             return FALSE;
5085
5086           if (h != NULL)
5087             {
5088               struct ppc_link_hash_entry *eh;
5089               struct got_entry *ent;
5090
5091               eh = (struct ppc_link_hash_entry *) h;
5092               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5093                 if (ent->addend == rel->r_addend
5094                     && ent->owner == abfd
5095                     && ent->tls_type == tls_type)
5096                   break;
5097               if (ent == NULL)
5098                 {
5099                   bfd_size_type amt = sizeof (*ent);
5100                   ent = bfd_alloc (abfd, amt);
5101                   if (ent == NULL)
5102                     return FALSE;
5103                   ent->next = eh->elf.got.glist;
5104                   ent->addend = rel->r_addend;
5105                   ent->owner = abfd;
5106                   ent->tls_type = tls_type;
5107                   ent->is_indirect = FALSE;
5108                   ent->got.refcount = 0;
5109                   eh->elf.got.glist = ent;
5110                 }
5111               ent->got.refcount += 1;
5112               eh->tls_mask |= tls_type;
5113             }
5114           else
5115             /* This is a global offset table entry for a local symbol.  */
5116             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5117                                         rel->r_addend, tls_type))
5118               return FALSE;
5119           break;
5120
5121         case R_PPC64_PLT16_HA:
5122         case R_PPC64_PLT16_HI:
5123         case R_PPC64_PLT16_LO:
5124         case R_PPC64_PLT32:
5125         case R_PPC64_PLT64:
5126           /* This symbol requires a procedure linkage table entry.  We
5127              actually build the entry in adjust_dynamic_symbol,
5128              because this might be a case of linking PIC code without
5129              linking in any dynamic objects, in which case we don't
5130              need to generate a procedure linkage table after all.  */
5131           if (h == NULL)
5132             {
5133               /* It does not make sense to have a procedure linkage
5134                  table entry for a local symbol.  */
5135               bfd_set_error (bfd_error_bad_value);
5136               return FALSE;
5137             }
5138           else
5139             {
5140               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5141                 return FALSE;
5142               h->needs_plt = 1;
5143               if (h->root.root.string[0] == '.'
5144                   && h->root.root.string[1] != '\0')
5145                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5146             }
5147           break;
5148
5149           /* The following relocations don't need to propagate the
5150              relocation if linking a shared object since they are
5151              section relative.  */
5152         case R_PPC64_SECTOFF:
5153         case R_PPC64_SECTOFF_LO:
5154         case R_PPC64_SECTOFF_HI:
5155         case R_PPC64_SECTOFF_HA:
5156         case R_PPC64_SECTOFF_DS:
5157         case R_PPC64_SECTOFF_LO_DS:
5158         case R_PPC64_DTPREL16:
5159         case R_PPC64_DTPREL16_LO:
5160         case R_PPC64_DTPREL16_HI:
5161         case R_PPC64_DTPREL16_HA:
5162         case R_PPC64_DTPREL16_DS:
5163         case R_PPC64_DTPREL16_LO_DS:
5164         case R_PPC64_DTPREL16_HIGHER:
5165         case R_PPC64_DTPREL16_HIGHERA:
5166         case R_PPC64_DTPREL16_HIGHEST:
5167         case R_PPC64_DTPREL16_HIGHESTA:
5168           break;
5169
5170           /* Nor do these.  */
5171         case R_PPC64_REL16:
5172         case R_PPC64_REL16_LO:
5173         case R_PPC64_REL16_HI:
5174         case R_PPC64_REL16_HA:
5175           break;
5176
5177         case R_PPC64_TOC16:
5178         case R_PPC64_TOC16_DS:
5179           htab->do_multi_toc = 1;
5180           ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5181         case R_PPC64_TOC16_LO:
5182         case R_PPC64_TOC16_HI:
5183         case R_PPC64_TOC16_HA:
5184         case R_PPC64_TOC16_LO_DS:
5185           sec->has_toc_reloc = 1;
5186           break;
5187
5188           /* This relocation describes the C++ object vtable hierarchy.
5189              Reconstruct it for later use during GC.  */
5190         case R_PPC64_GNU_VTINHERIT:
5191           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5192             return FALSE;
5193           break;
5194
5195           /* This relocation describes which C++ vtable entries are actually
5196              used.  Record for later use during GC.  */
5197         case R_PPC64_GNU_VTENTRY:
5198           BFD_ASSERT (h != NULL);
5199           if (h != NULL
5200               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5201             return FALSE;
5202           break;
5203
5204         case R_PPC64_REL14:
5205         case R_PPC64_REL14_BRTAKEN:
5206         case R_PPC64_REL14_BRNTAKEN:
5207           {
5208             asection *dest = NULL;
5209
5210             /* Heuristic: If jumping outside our section, chances are
5211                we are going to need a stub.  */
5212             if (h != NULL)
5213               {
5214                 /* If the sym is weak it may be overridden later, so
5215                    don't assume we know where a weak sym lives.  */
5216                 if (h->root.type == bfd_link_hash_defined)
5217                   dest = h->root.u.def.section;
5218               }
5219             else
5220               {
5221                 Elf_Internal_Sym *isym;
5222
5223                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5224                                               abfd, r_symndx);
5225                 if (isym == NULL)
5226                   return FALSE;
5227
5228                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5229               }
5230
5231             if (dest != sec)
5232               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5233           }
5234           /* Fall through.  */
5235
5236         case R_PPC64_REL24:
5237           if (h != NULL && ifunc == NULL)
5238             {
5239               /* We may need a .plt entry if the function this reloc
5240                  refers to is in a shared lib.  */
5241               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5242                 return FALSE;
5243               h->needs_plt = 1;
5244               if (h->root.root.string[0] == '.'
5245                   && h->root.root.string[1] != '\0')
5246                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5247               if (h == tga || h == dottga)
5248                 sec->has_tls_reloc = 1;
5249             }
5250           break;
5251
5252         case R_PPC64_TPREL64:
5253           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5254           if (!info->executable)
5255             info->flags |= DF_STATIC_TLS;
5256           goto dotlstoc;
5257
5258         case R_PPC64_DTPMOD64:
5259           if (rel + 1 < rel_end
5260               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5261               && rel[1].r_offset == rel->r_offset + 8)
5262             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5263           else
5264             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5265           goto dotlstoc;
5266
5267         case R_PPC64_DTPREL64:
5268           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5269           if (rel != relocs
5270               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5271               && rel[-1].r_offset == rel->r_offset - 8)
5272             /* This is the second reloc of a dtpmod, dtprel pair.
5273                Don't mark with TLS_DTPREL.  */
5274             goto dodyn;
5275
5276         dotlstoc:
5277           sec->has_tls_reloc = 1;
5278           if (h != NULL)
5279             {
5280               struct ppc_link_hash_entry *eh;
5281               eh = (struct ppc_link_hash_entry *) h;
5282               eh->tls_mask |= tls_type;
5283             }
5284           else
5285             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5286                                         rel->r_addend, tls_type))
5287               return FALSE;
5288
5289           ppc64_sec = ppc64_elf_section_data (sec);
5290           if (ppc64_sec->sec_type != sec_toc)
5291             {
5292               bfd_size_type amt;
5293
5294               /* One extra to simplify get_tls_mask.  */
5295               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5296               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5297               if (ppc64_sec->u.toc.symndx == NULL)
5298                 return FALSE;
5299               amt = sec->size * sizeof (bfd_vma) / 8;
5300               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5301               if (ppc64_sec->u.toc.add == NULL)
5302                 return FALSE;
5303               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5304               ppc64_sec->sec_type = sec_toc;
5305             }
5306           BFD_ASSERT (rel->r_offset % 8 == 0);
5307           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5308           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5309
5310           /* Mark the second slot of a GD or LD entry.
5311              -1 to indicate GD and -2 to indicate LD.  */
5312           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5313             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5314           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5315             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5316           goto dodyn;
5317
5318         case R_PPC64_TPREL16:
5319         case R_PPC64_TPREL16_LO:
5320         case R_PPC64_TPREL16_HI:
5321         case R_PPC64_TPREL16_HA:
5322         case R_PPC64_TPREL16_DS:
5323         case R_PPC64_TPREL16_LO_DS:
5324         case R_PPC64_TPREL16_HIGHER:
5325         case R_PPC64_TPREL16_HIGHERA:
5326         case R_PPC64_TPREL16_HIGHEST:
5327         case R_PPC64_TPREL16_HIGHESTA:
5328           if (info->shared)
5329             {
5330               if (!info->executable)
5331                 info->flags |= DF_STATIC_TLS;
5332               goto dodyn;
5333             }
5334           break;
5335
5336         case R_PPC64_ADDR64:
5337           if (opd_sym_map != NULL
5338               && rel + 1 < rel_end
5339               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5340             {
5341               if (h != NULL)
5342                 {
5343                   if (h->root.root.string[0] == '.'
5344                       && h->root.root.string[1] != 0
5345                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5346                     ;
5347                   else
5348                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5349                 }
5350               else
5351                 {
5352                   asection *s;
5353                   Elf_Internal_Sym *isym;
5354
5355                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5356                                                 abfd, r_symndx);
5357                   if (isym == NULL)
5358                     return FALSE;
5359
5360                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5361                   if (s != NULL && s != sec)
5362                     opd_sym_map[rel->r_offset / 8] = s;
5363                 }
5364             }
5365           /* Fall through.  */
5366
5367         case R_PPC64_REL30:
5368         case R_PPC64_REL32:
5369         case R_PPC64_REL64:
5370         case R_PPC64_ADDR14:
5371         case R_PPC64_ADDR14_BRNTAKEN:
5372         case R_PPC64_ADDR14_BRTAKEN:
5373         case R_PPC64_ADDR16:
5374         case R_PPC64_ADDR16_DS:
5375         case R_PPC64_ADDR16_HA:
5376         case R_PPC64_ADDR16_HI:
5377         case R_PPC64_ADDR16_HIGHER:
5378         case R_PPC64_ADDR16_HIGHERA:
5379         case R_PPC64_ADDR16_HIGHEST:
5380         case R_PPC64_ADDR16_HIGHESTA:
5381         case R_PPC64_ADDR16_LO:
5382         case R_PPC64_ADDR16_LO_DS:
5383         case R_PPC64_ADDR24:
5384         case R_PPC64_ADDR32:
5385         case R_PPC64_UADDR16:
5386         case R_PPC64_UADDR32:
5387         case R_PPC64_UADDR64:
5388         case R_PPC64_TOC:
5389           if (h != NULL && !info->shared)
5390             /* We may need a copy reloc.  */
5391             h->non_got_ref = 1;
5392
5393           /* Don't propagate .opd relocs.  */
5394           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5395             break;
5396
5397           /* If we are creating a shared library, and this is a reloc
5398              against a global symbol, or a non PC relative reloc
5399              against a local symbol, then we need to copy the reloc
5400              into the shared library.  However, if we are linking with
5401              -Bsymbolic, we do not need to copy a reloc against a
5402              global symbol which is defined in an object we are
5403              including in the link (i.e., DEF_REGULAR is set).  At
5404              this point we have not seen all the input files, so it is
5405              possible that DEF_REGULAR is not set now but will be set
5406              later (it is never cleared).  In case of a weak definition,
5407              DEF_REGULAR may be cleared later by a strong definition in
5408              a shared library.  We account for that possibility below by
5409              storing information in the dyn_relocs field of the hash
5410              table entry.  A similar situation occurs when creating
5411              shared libraries and symbol visibility changes render the
5412              symbol local.
5413
5414              If on the other hand, we are creating an executable, we
5415              may need to keep relocations for symbols satisfied by a
5416              dynamic library if we manage to avoid copy relocs for the
5417              symbol.  */
5418         dodyn:
5419           if ((info->shared
5420                && (must_be_dyn_reloc (info, r_type)
5421                    || (h != NULL
5422                        && (! info->symbolic
5423                            || h->root.type == bfd_link_hash_defweak
5424                            || !h->def_regular))))
5425               || (ELIMINATE_COPY_RELOCS
5426                   && !info->shared
5427                   && h != NULL
5428                   && (h->root.type == bfd_link_hash_defweak
5429                       || !h->def_regular))
5430               || (!info->shared
5431                   && ifunc != NULL))
5432             {
5433               struct elf_dyn_relocs *p;
5434               struct elf_dyn_relocs **head;
5435
5436               /* We must copy these reloc types into the output file.
5437                  Create a reloc section in dynobj and make room for
5438                  this reloc.  */
5439               if (sreloc == NULL)
5440                 {
5441                   sreloc = _bfd_elf_make_dynamic_reloc_section
5442                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5443
5444                   if (sreloc == NULL)
5445                     return FALSE;
5446                 }
5447
5448               /* If this is a global symbol, we count the number of
5449                  relocations we need for this symbol.  */
5450               if (h != NULL)
5451                 {
5452                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5453                 }
5454               else
5455                 {
5456                   /* Track dynamic relocs needed for local syms too.
5457                      We really need local syms available to do this
5458                      easily.  Oh well.  */
5459                   asection *s;
5460                   void *vpp;
5461                   Elf_Internal_Sym *isym;
5462
5463                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5464                                                 abfd, r_symndx);
5465                   if (isym == NULL)
5466                     return FALSE;
5467
5468                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5469                   if (s == NULL)
5470                     s = sec;
5471
5472                   vpp = &elf_section_data (s)->local_dynrel;
5473                   head = (struct elf_dyn_relocs **) vpp;
5474                 }
5475
5476               p = *head;
5477               if (p == NULL || p->sec != sec)
5478                 {
5479                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5480                   if (p == NULL)
5481                     return FALSE;
5482                   p->next = *head;
5483                   *head = p;
5484                   p->sec = sec;
5485                   p->count = 0;
5486                   p->pc_count = 0;
5487                 }
5488
5489               p->count += 1;
5490               if (!must_be_dyn_reloc (info, r_type))
5491                 p->pc_count += 1;
5492             }
5493           break;
5494
5495         default:
5496           break;
5497         }
5498     }
5499
5500   return TRUE;
5501 }
5502
5503 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5504    of the code entry point, and its section.  */
5505
5506 static bfd_vma
5507 opd_entry_value (asection *opd_sec,
5508                  bfd_vma offset,
5509                  asection **code_sec,
5510                  bfd_vma *code_off)
5511 {
5512   bfd *opd_bfd = opd_sec->owner;
5513   Elf_Internal_Rela *relocs;
5514   Elf_Internal_Rela *lo, *hi, *look;
5515   bfd_vma val;
5516
5517   /* No relocs implies we are linking a --just-symbols object.  */
5518   if (opd_sec->reloc_count == 0)
5519     {
5520       char buf[8];
5521
5522       if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5523         return (bfd_vma) -1;
5524
5525       val = bfd_get_64 (opd_bfd, buf);
5526       if (code_sec != NULL)
5527         {
5528           asection *sec, *likely = NULL;
5529           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5530             if (sec->vma <= val
5531                 && (sec->flags & SEC_LOAD) != 0
5532                 && (sec->flags & SEC_ALLOC) != 0)
5533               likely = sec;
5534           if (likely != NULL)
5535             {
5536               *code_sec = likely;
5537               if (code_off != NULL)
5538                 *code_off = val - likely->vma;
5539             }
5540         }
5541       return val;
5542     }
5543
5544   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5545
5546   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5547   if (relocs == NULL)
5548     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5549
5550   /* Go find the opd reloc at the sym address.  */
5551   lo = relocs;
5552   BFD_ASSERT (lo != NULL);
5553   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5554   val = (bfd_vma) -1;
5555   while (lo < hi)
5556     {
5557       look = lo + (hi - lo) / 2;
5558       if (look->r_offset < offset)
5559         lo = look + 1;
5560       else if (look->r_offset > offset)
5561         hi = look;
5562       else
5563         {
5564           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5565
5566           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5567               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5568             {
5569               unsigned long symndx = ELF64_R_SYM (look->r_info);
5570               asection *sec;
5571
5572               if (symndx < symtab_hdr->sh_info)
5573                 {
5574                   Elf_Internal_Sym *sym;
5575
5576                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5577                   if (sym == NULL)
5578                     {
5579                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5580                                                   symtab_hdr->sh_info,
5581                                                   0, NULL, NULL, NULL);
5582                       if (sym == NULL)
5583                         break;
5584                       symtab_hdr->contents = (bfd_byte *) sym;
5585                     }
5586
5587                   sym += symndx;
5588                   val = sym->st_value;
5589                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5590                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5591                 }
5592               else
5593                 {
5594                   struct elf_link_hash_entry **sym_hashes;
5595                   struct elf_link_hash_entry *rh;
5596
5597                   sym_hashes = elf_sym_hashes (opd_bfd);
5598                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5599                   rh = elf_follow_link (rh);
5600                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5601                               || rh->root.type == bfd_link_hash_defweak);
5602                   val = rh->root.u.def.value;
5603                   sec = rh->root.u.def.section;
5604                 }
5605               val += look->r_addend;
5606               if (code_off != NULL)
5607                 *code_off = val;
5608               if (code_sec != NULL)
5609                 *code_sec = sec;
5610               if (sec != NULL && sec->output_section != NULL)
5611                 val += sec->output_section->vma + sec->output_offset;
5612             }
5613           break;
5614         }
5615     }
5616
5617   return val;
5618 }
5619
5620 /* Return true if symbol is defined in a regular object file.  */
5621
5622 static bfd_boolean
5623 is_static_defined (struct elf_link_hash_entry *h)
5624 {
5625   return ((h->root.type == bfd_link_hash_defined
5626            || h->root.type == bfd_link_hash_defweak)
5627           && h->root.u.def.section != NULL
5628           && h->root.u.def.section->output_section != NULL);
5629 }
5630
5631 /* If FDH is a function descriptor symbol, return the associated code
5632    entry symbol if it is defined.  Return NULL otherwise.  */
5633
5634 static struct ppc_link_hash_entry *
5635 defined_code_entry (struct ppc_link_hash_entry *fdh)
5636 {
5637   if (fdh->is_func_descriptor)
5638     {
5639       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5640       if (fh->elf.root.type == bfd_link_hash_defined
5641           || fh->elf.root.type == bfd_link_hash_defweak)
5642         return fh;
5643     }
5644   return NULL;
5645 }
5646
5647 /* If FH is a function code entry symbol, return the associated
5648    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5649
5650 static struct ppc_link_hash_entry *
5651 defined_func_desc (struct ppc_link_hash_entry *fh)
5652 {
5653   if (fh->oh != NULL
5654       && fh->oh->is_func_descriptor)
5655     {
5656       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5657       if (fdh->elf.root.type == bfd_link_hash_defined
5658           || fdh->elf.root.type == bfd_link_hash_defweak)
5659         return fdh;
5660     }
5661   return NULL;
5662 }
5663
5664 /* Mark all our entry sym sections, both opd and code section.  */
5665
5666 static void
5667 ppc64_elf_gc_keep (struct bfd_link_info *info)
5668 {
5669   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5670   struct bfd_sym_chain *sym;
5671
5672   if (htab == NULL)
5673     return;
5674
5675   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5676     {
5677       struct ppc_link_hash_entry *eh, *fh;
5678       asection *sec;
5679
5680       eh = (struct ppc_link_hash_entry *)
5681         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5682       if (eh == NULL)
5683         continue;
5684       if (eh->elf.root.type != bfd_link_hash_defined
5685           && eh->elf.root.type != bfd_link_hash_defweak)
5686         continue;
5687
5688       fh = defined_code_entry (eh);
5689       if (fh != NULL)
5690         {
5691           sec = fh->elf.root.u.def.section;
5692           sec->flags |= SEC_KEEP;
5693         }
5694       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5695                && opd_entry_value (eh->elf.root.u.def.section,
5696                                    eh->elf.root.u.def.value,
5697                                    &sec, NULL) != (bfd_vma) -1)
5698         sec->flags |= SEC_KEEP;
5699
5700       sec = eh->elf.root.u.def.section;
5701       sec->flags |= SEC_KEEP;
5702     }
5703 }
5704
5705 /* Mark sections containing dynamically referenced symbols.  When
5706    building shared libraries, we must assume that any visible symbol is
5707    referenced.  */
5708
5709 static bfd_boolean
5710 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5711 {
5712   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5713   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5714   struct ppc_link_hash_entry *fdh;
5715
5716   /* Dynamic linking info is on the func descriptor sym.  */
5717   fdh = defined_func_desc (eh);
5718   if (fdh != NULL)
5719     eh = fdh;
5720
5721   if ((eh->elf.root.type == bfd_link_hash_defined
5722        || eh->elf.root.type == bfd_link_hash_defweak)
5723       && (eh->elf.ref_dynamic
5724           || (!info->executable
5725               && eh->elf.def_regular
5726               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5727               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5728               && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5729                   || !bfd_hide_sym_by_version (info->version_info,
5730                                                eh->elf.root.root.string)))))
5731     {
5732       asection *code_sec;
5733       struct ppc_link_hash_entry *fh;
5734
5735       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5736
5737       /* Function descriptor syms cause the associated
5738          function code sym section to be marked.  */
5739       fh = defined_code_entry (eh);
5740       if (fh != NULL)
5741         {
5742           code_sec = fh->elf.root.u.def.section;
5743           code_sec->flags |= SEC_KEEP;
5744         }
5745       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5746                && opd_entry_value (eh->elf.root.u.def.section,
5747                                    eh->elf.root.u.def.value,
5748                                    &code_sec, NULL) != (bfd_vma) -1)
5749         code_sec->flags |= SEC_KEEP;
5750     }
5751
5752   return TRUE;
5753 }
5754
5755 /* Return the section that should be marked against GC for a given
5756    relocation.  */
5757
5758 static asection *
5759 ppc64_elf_gc_mark_hook (asection *sec,
5760                         struct bfd_link_info *info,
5761                         Elf_Internal_Rela *rel,
5762                         struct elf_link_hash_entry *h,
5763                         Elf_Internal_Sym *sym)
5764 {
5765   asection *rsec;
5766
5767   /* Syms return NULL if we're marking .opd, so we avoid marking all
5768      function sections, as all functions are referenced in .opd.  */
5769   rsec = NULL;
5770   if (get_opd_info (sec) != NULL)
5771     return rsec;
5772
5773   if (h != NULL)
5774     {
5775       enum elf_ppc64_reloc_type r_type;
5776       struct ppc_link_hash_entry *eh, *fh, *fdh;
5777
5778       r_type = ELF64_R_TYPE (rel->r_info);
5779       switch (r_type)
5780         {
5781         case R_PPC64_GNU_VTINHERIT:
5782         case R_PPC64_GNU_VTENTRY:
5783           break;
5784
5785         default:
5786           switch (h->root.type)
5787             {
5788             case bfd_link_hash_defined:
5789             case bfd_link_hash_defweak:
5790               eh = (struct ppc_link_hash_entry *) h;
5791               fdh = defined_func_desc (eh);
5792               if (fdh != NULL)
5793                 eh = fdh;
5794
5795               /* Function descriptor syms cause the associated
5796                  function code sym section to be marked.  */
5797               fh = defined_code_entry (eh);
5798               if (fh != NULL)
5799                 {
5800                   /* They also mark their opd section.  */
5801                   eh->elf.root.u.def.section->gc_mark = 1;
5802
5803                   rsec = fh->elf.root.u.def.section;
5804                 }
5805               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5806                        && opd_entry_value (eh->elf.root.u.def.section,
5807                                            eh->elf.root.u.def.value,
5808                                            &rsec, NULL) != (bfd_vma) -1)
5809                 eh->elf.root.u.def.section->gc_mark = 1;
5810               else
5811                 rsec = h->root.u.def.section;
5812               break;
5813
5814             case bfd_link_hash_common:
5815               rsec = h->root.u.c.p->section;
5816               break;
5817
5818             default:
5819               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5820             }
5821         }
5822     }
5823   else
5824     {
5825       struct _opd_sec_data *opd;
5826
5827       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5828       opd = get_opd_info (rsec);
5829       if (opd != NULL && opd->func_sec != NULL)
5830         {
5831           rsec->gc_mark = 1;
5832
5833           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5834         }
5835     }
5836
5837   return rsec;
5838 }
5839
5840 /* Update the .got, .plt. and dynamic reloc reference counts for the
5841    section being removed.  */
5842
5843 static bfd_boolean
5844 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5845                          asection *sec, const Elf_Internal_Rela *relocs)
5846 {
5847   struct ppc_link_hash_table *htab;
5848   Elf_Internal_Shdr *symtab_hdr;
5849   struct elf_link_hash_entry **sym_hashes;
5850   struct got_entry **local_got_ents;
5851   const Elf_Internal_Rela *rel, *relend;
5852
5853   if (info->relocatable)
5854     return TRUE;
5855
5856   if ((sec->flags & SEC_ALLOC) == 0)
5857     return TRUE;
5858
5859   elf_section_data (sec)->local_dynrel = NULL;
5860
5861   htab = ppc_hash_table (info);
5862   if (htab == NULL)
5863     return FALSE;
5864
5865   symtab_hdr = &elf_symtab_hdr (abfd);
5866   sym_hashes = elf_sym_hashes (abfd);
5867   local_got_ents = elf_local_got_ents (abfd);
5868
5869   relend = relocs + sec->reloc_count;
5870   for (rel = relocs; rel < relend; rel++)
5871     {
5872       unsigned long r_symndx;
5873       enum elf_ppc64_reloc_type r_type;
5874       struct elf_link_hash_entry *h = NULL;
5875       unsigned char tls_type = 0;
5876
5877       r_symndx = ELF64_R_SYM (rel->r_info);
5878       r_type = ELF64_R_TYPE (rel->r_info);
5879       if (r_symndx >= symtab_hdr->sh_info)
5880         {
5881           struct ppc_link_hash_entry *eh;
5882           struct elf_dyn_relocs **pp;
5883           struct elf_dyn_relocs *p;
5884
5885           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5886           h = elf_follow_link (h);
5887           eh = (struct ppc_link_hash_entry *) h;
5888
5889           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5890             if (p->sec == sec)
5891               {
5892                 /* Everything must go for SEC.  */
5893                 *pp = p->next;
5894                 break;
5895               }
5896         }
5897
5898       if (is_branch_reloc (r_type))
5899         {
5900           struct plt_entry **ifunc = NULL;
5901           if (h != NULL)
5902             {
5903               if (h->type == STT_GNU_IFUNC)
5904                 ifunc = &h->plt.plist;
5905             }
5906           else if (local_got_ents != NULL)
5907             {
5908               struct plt_entry **local_plt = (struct plt_entry **)
5909                 (local_got_ents + symtab_hdr->sh_info);
5910               unsigned char *local_got_tls_masks = (unsigned char *)
5911                 (local_plt + symtab_hdr->sh_info);
5912               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5913                 ifunc = local_plt + r_symndx;
5914             }
5915           if (ifunc != NULL)
5916             {
5917               struct plt_entry *ent;
5918
5919               for (ent = *ifunc; ent != NULL; ent = ent->next)
5920                 if (ent->addend == rel->r_addend)
5921                   break;
5922               if (ent == NULL)
5923                 abort ();
5924               if (ent->plt.refcount > 0)
5925                 ent->plt.refcount -= 1;
5926               continue;
5927             }
5928         }
5929
5930       switch (r_type)
5931         {
5932         case R_PPC64_GOT_TLSLD16:
5933         case R_PPC64_GOT_TLSLD16_LO:
5934         case R_PPC64_GOT_TLSLD16_HI:
5935         case R_PPC64_GOT_TLSLD16_HA:
5936           tls_type = TLS_TLS | TLS_LD;
5937           goto dogot;
5938
5939         case R_PPC64_GOT_TLSGD16:
5940         case R_PPC64_GOT_TLSGD16_LO:
5941         case R_PPC64_GOT_TLSGD16_HI:
5942         case R_PPC64_GOT_TLSGD16_HA:
5943           tls_type = TLS_TLS | TLS_GD;
5944           goto dogot;
5945
5946         case R_PPC64_GOT_TPREL16_DS:
5947         case R_PPC64_GOT_TPREL16_LO_DS:
5948         case R_PPC64_GOT_TPREL16_HI:
5949         case R_PPC64_GOT_TPREL16_HA:
5950           tls_type = TLS_TLS | TLS_TPREL;
5951           goto dogot;
5952
5953         case R_PPC64_GOT_DTPREL16_DS:
5954         case R_PPC64_GOT_DTPREL16_LO_DS:
5955         case R_PPC64_GOT_DTPREL16_HI:
5956         case R_PPC64_GOT_DTPREL16_HA:
5957           tls_type = TLS_TLS | TLS_DTPREL;
5958           goto dogot;
5959
5960         case R_PPC64_GOT16:
5961         case R_PPC64_GOT16_DS:
5962         case R_PPC64_GOT16_HA:
5963         case R_PPC64_GOT16_HI:
5964         case R_PPC64_GOT16_LO:
5965         case R_PPC64_GOT16_LO_DS:
5966         dogot:
5967           {
5968             struct got_entry *ent;
5969
5970             if (h != NULL)
5971               ent = h->got.glist;
5972             else
5973               ent = local_got_ents[r_symndx];
5974
5975             for (; ent != NULL; ent = ent->next)
5976               if (ent->addend == rel->r_addend
5977                   && ent->owner == abfd
5978                   && ent->tls_type == tls_type)
5979                 break;
5980             if (ent == NULL)
5981               abort ();
5982             if (ent->got.refcount > 0)
5983               ent->got.refcount -= 1;
5984           }
5985           break;
5986
5987         case R_PPC64_PLT16_HA:
5988         case R_PPC64_PLT16_HI:
5989         case R_PPC64_PLT16_LO:
5990         case R_PPC64_PLT32:
5991         case R_PPC64_PLT64:
5992         case R_PPC64_REL14:
5993         case R_PPC64_REL14_BRNTAKEN:
5994         case R_PPC64_REL14_BRTAKEN:
5995         case R_PPC64_REL24:
5996           if (h != NULL)
5997             {
5998               struct plt_entry *ent;
5999
6000               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6001                 if (ent->addend == rel->r_addend)
6002                   break;
6003               if (ent != NULL && ent->plt.refcount > 0)
6004                 ent->plt.refcount -= 1;
6005             }
6006           break;
6007
6008         default:
6009           break;
6010         }
6011     }
6012   return TRUE;
6013 }
6014
6015 /* The maximum size of .sfpr.  */
6016 #define SFPR_MAX (218*4)
6017
6018 struct sfpr_def_parms
6019 {
6020   const char name[12];
6021   unsigned char lo, hi;
6022   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6023   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6024 };
6025
6026 /* Auto-generate _save*, _rest* functions in .sfpr.  */
6027
6028 static bfd_boolean
6029 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6030 {
6031   struct ppc_link_hash_table *htab = ppc_hash_table (info);
6032   unsigned int i;
6033   size_t len = strlen (parm->name);
6034   bfd_boolean writing = FALSE;
6035   char sym[16];
6036
6037   if (htab == NULL)
6038     return FALSE;
6039
6040   memcpy (sym, parm->name, len);
6041   sym[len + 2] = 0;
6042
6043   for (i = parm->lo; i <= parm->hi; i++)
6044     {
6045       struct elf_link_hash_entry *h;
6046
6047       sym[len + 0] = i / 10 + '0';
6048       sym[len + 1] = i % 10 + '0';
6049       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6050       if (h != NULL
6051           && !h->def_regular)
6052         {
6053           h->root.type = bfd_link_hash_defined;
6054           h->root.u.def.section = htab->sfpr;
6055           h->root.u.def.value = htab->sfpr->size;
6056           h->type = STT_FUNC;
6057           h->def_regular = 1;
6058           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6059           writing = TRUE;
6060           if (htab->sfpr->contents == NULL)
6061             {
6062               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6063               if (htab->sfpr->contents == NULL)
6064                 return FALSE;
6065             }
6066         }
6067       if (writing)
6068         {
6069           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6070           if (i != parm->hi)
6071             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6072           else
6073             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6074           htab->sfpr->size = p - htab->sfpr->contents;
6075         }
6076     }
6077
6078   return TRUE;
6079 }
6080
6081 static bfd_byte *
6082 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6083 {
6084   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6085   return p + 4;
6086 }
6087
6088 static bfd_byte *
6089 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6090 {
6091   p = savegpr0 (abfd, p, r);
6092   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6093   p = p + 4;
6094   bfd_put_32 (abfd, BLR, p);
6095   return p + 4;
6096 }
6097
6098 static bfd_byte *
6099 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6100 {
6101   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6102   return p + 4;
6103 }
6104
6105 static bfd_byte *
6106 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6107 {
6108   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6109   p = p + 4;
6110   p = restgpr0 (abfd, p, r);
6111   bfd_put_32 (abfd, MTLR_R0, p);
6112   p = p + 4;
6113   if (r == 29)
6114     {
6115       p = restgpr0 (abfd, p, 30);
6116       p = restgpr0 (abfd, p, 31);
6117     }
6118   bfd_put_32 (abfd, BLR, p);
6119   return p + 4;
6120 }
6121
6122 static bfd_byte *
6123 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6124 {
6125   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6126   return p + 4;
6127 }
6128
6129 static bfd_byte *
6130 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6131 {
6132   p = savegpr1 (abfd, p, r);
6133   bfd_put_32 (abfd, BLR, p);
6134   return p + 4;
6135 }
6136
6137 static bfd_byte *
6138 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6139 {
6140   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6141   return p + 4;
6142 }
6143
6144 static bfd_byte *
6145 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6146 {
6147   p = restgpr1 (abfd, p, r);
6148   bfd_put_32 (abfd, BLR, p);
6149   return p + 4;
6150 }
6151
6152 static bfd_byte *
6153 savefpr (bfd *abfd, bfd_byte *p, int r)
6154 {
6155   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6156   return p + 4;
6157 }
6158
6159 static bfd_byte *
6160 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6161 {
6162   p = savefpr (abfd, p, r);
6163   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6164   p = p + 4;
6165   bfd_put_32 (abfd, BLR, p);
6166   return p + 4;
6167 }
6168
6169 static bfd_byte *
6170 restfpr (bfd *abfd, bfd_byte *p, int r)
6171 {
6172   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6173   return p + 4;
6174 }
6175
6176 static bfd_byte *
6177 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6178 {
6179   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6180   p = p + 4;
6181   p = restfpr (abfd, p, r);
6182   bfd_put_32 (abfd, MTLR_R0, p);
6183   p = p + 4;
6184   if (r == 29)
6185     {
6186       p = restfpr (abfd, p, 30);
6187       p = restfpr (abfd, p, 31);
6188     }
6189   bfd_put_32 (abfd, BLR, p);
6190   return p + 4;
6191 }
6192
6193 static bfd_byte *
6194 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6195 {
6196   p = savefpr (abfd, p, r);
6197   bfd_put_32 (abfd, BLR, p);
6198   return p + 4;
6199 }
6200
6201 static bfd_byte *
6202 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6203 {
6204   p = restfpr (abfd, p, r);
6205   bfd_put_32 (abfd, BLR, p);
6206   return p + 4;
6207 }
6208
6209 static bfd_byte *
6210 savevr (bfd *abfd, bfd_byte *p, int r)
6211 {
6212   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6213   p = p + 4;
6214   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6215   return p + 4;
6216 }
6217
6218 static bfd_byte *
6219 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6220 {
6221   p = savevr (abfd, p, r);
6222   bfd_put_32 (abfd, BLR, p);
6223   return p + 4;
6224 }
6225
6226 static bfd_byte *
6227 restvr (bfd *abfd, bfd_byte *p, int r)
6228 {
6229   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6230   p = p + 4;
6231   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6232   return p + 4;
6233 }
6234
6235 static bfd_byte *
6236 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6237 {
6238   p = restvr (abfd, p, r);
6239   bfd_put_32 (abfd, BLR, p);
6240   return p + 4;
6241 }
6242
6243 /* Called via elf_link_hash_traverse to transfer dynamic linking
6244    information on function code symbol entries to their corresponding
6245    function descriptor symbol entries.  */
6246
6247 static bfd_boolean
6248 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6249 {
6250   struct bfd_link_info *info;
6251   struct ppc_link_hash_table *htab;
6252   struct plt_entry *ent;
6253   struct ppc_link_hash_entry *fh;
6254   struct ppc_link_hash_entry *fdh;
6255   bfd_boolean force_local;
6256
6257   fh = (struct ppc_link_hash_entry *) h;
6258   if (fh->elf.root.type == bfd_link_hash_indirect)
6259     return TRUE;
6260
6261   info = inf;
6262   htab = ppc_hash_table (info);
6263   if (htab == NULL)
6264     return FALSE;
6265
6266   /* Resolve undefined references to dot-symbols as the value
6267      in the function descriptor, if we have one in a regular object.
6268      This is to satisfy cases like ".quad .foo".  Calls to functions
6269      in dynamic objects are handled elsewhere.  */
6270   if (fh->elf.root.type == bfd_link_hash_undefweak
6271       && fh->was_undefined
6272       && (fdh = defined_func_desc (fh)) != NULL
6273       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6274       && opd_entry_value (fdh->elf.root.u.def.section,
6275                           fdh->elf.root.u.def.value,
6276                           &fh->elf.root.u.def.section,
6277                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6278     {
6279       fh->elf.root.type = fdh->elf.root.type;
6280       fh->elf.forced_local = 1;
6281       fh->elf.def_regular = fdh->elf.def_regular;
6282       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6283     }
6284
6285   /* If this is a function code symbol, transfer dynamic linking
6286      information to the function descriptor symbol.  */
6287   if (!fh->is_func)
6288     return TRUE;
6289
6290   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6291     if (ent->plt.refcount > 0)
6292       break;
6293   if (ent == NULL
6294       || fh->elf.root.root.string[0] != '.'
6295       || fh->elf.root.root.string[1] == '\0')
6296     return TRUE;
6297
6298   /* Find the corresponding function descriptor symbol.  Create it
6299      as undefined if necessary.  */
6300
6301   fdh = lookup_fdh (fh, htab);
6302   if (fdh == NULL
6303       && !info->executable
6304       && (fh->elf.root.type == bfd_link_hash_undefined
6305           || fh->elf.root.type == bfd_link_hash_undefweak))
6306     {
6307       fdh = make_fdh (info, fh);
6308       if (fdh == NULL)
6309         return FALSE;
6310     }
6311
6312   /* Fake function descriptors are made undefweak.  If the function
6313      code symbol is strong undefined, make the fake sym the same.
6314      If the function code symbol is defined, then force the fake
6315      descriptor local;  We can't support overriding of symbols in a
6316      shared library on a fake descriptor.  */
6317
6318   if (fdh != NULL
6319       && fdh->fake
6320       && fdh->elf.root.type == bfd_link_hash_undefweak)
6321     {
6322       if (fh->elf.root.type == bfd_link_hash_undefined)
6323         {
6324           fdh->elf.root.type = bfd_link_hash_undefined;
6325           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6326         }
6327       else if (fh->elf.root.type == bfd_link_hash_defined
6328                || fh->elf.root.type == bfd_link_hash_defweak)
6329         {
6330           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6331         }
6332     }
6333
6334   if (fdh != NULL
6335       && !fdh->elf.forced_local
6336       && (!info->executable
6337           || fdh->elf.def_dynamic
6338           || fdh->elf.ref_dynamic
6339           || (fdh->elf.root.type == bfd_link_hash_undefweak
6340               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6341     {
6342       if (fdh->elf.dynindx == -1)
6343         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6344           return FALSE;
6345       fdh->elf.ref_regular |= fh->elf.ref_regular;
6346       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6347       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6348       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6349       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6350         {
6351           move_plt_plist (fh, fdh);
6352           fdh->elf.needs_plt = 1;
6353         }
6354       fdh->is_func_descriptor = 1;
6355       fdh->oh = fh;
6356       fh->oh = fdh;
6357     }
6358
6359   /* Now that the info is on the function descriptor, clear the
6360      function code sym info.  Any function code syms for which we
6361      don't have a definition in a regular file, we force local.
6362      This prevents a shared library from exporting syms that have
6363      been imported from another library.  Function code syms that
6364      are really in the library we must leave global to prevent the
6365      linker dragging in a definition from a static library.  */
6366   force_local = (!fh->elf.def_regular
6367                  || fdh == NULL
6368                  || !fdh->elf.def_regular
6369                  || fdh->elf.forced_local);
6370   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6371
6372   return TRUE;
6373 }
6374
6375 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6376    this hook to a) provide some gcc support functions, and b) transfer
6377    dynamic linking information gathered so far on function code symbol
6378    entries, to their corresponding function descriptor symbol entries.  */
6379
6380 static bfd_boolean
6381 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6382                             struct bfd_link_info *info)
6383 {
6384   struct ppc_link_hash_table *htab;
6385   unsigned int i;
6386   const struct sfpr_def_parms funcs[] =
6387     {
6388       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6389       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6390       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6391       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6392       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6393       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6394       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6395       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6396       { "._savef", 14, 31, savefpr, savefpr1_tail },
6397       { "._restf", 14, 31, restfpr, restfpr1_tail },
6398       { "_savevr_", 20, 31, savevr, savevr_tail },
6399       { "_restvr_", 20, 31, restvr, restvr_tail }
6400     };
6401
6402   htab = ppc_hash_table (info);
6403   if (htab == NULL)
6404     return FALSE;
6405
6406   if (htab->sfpr == NULL)
6407     /* We don't have any relocs.  */
6408     return TRUE;
6409
6410   /* Provide any missing _save* and _rest* functions.  */
6411   htab->sfpr->size = 0;
6412   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6413     if (!sfpr_define (info, &funcs[i]))
6414       return FALSE;
6415
6416   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6417
6418   if (htab->sfpr->size == 0)
6419     htab->sfpr->flags |= SEC_EXCLUDE;
6420
6421   return TRUE;
6422 }
6423
6424 /* Adjust a symbol defined by a dynamic object and referenced by a
6425    regular object.  The current definition is in some section of the
6426    dynamic object, but we're not including those sections.  We have to
6427    change the definition to something the rest of the link can
6428    understand.  */
6429
6430 static bfd_boolean
6431 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6432                                  struct elf_link_hash_entry *h)
6433 {
6434   struct ppc_link_hash_table *htab;
6435   asection *s;
6436
6437   htab = ppc_hash_table (info);
6438   if (htab == NULL)
6439     return FALSE;
6440
6441   /* Deal with function syms.  */
6442   if (h->type == STT_FUNC
6443       || h->type == STT_GNU_IFUNC
6444       || h->needs_plt)
6445     {
6446       /* Clear procedure linkage table information for any symbol that
6447          won't need a .plt entry.  */
6448       struct plt_entry *ent;
6449       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6450         if (ent->plt.refcount > 0)
6451           break;
6452       if (ent == NULL
6453           || (h->type != STT_GNU_IFUNC
6454               && (SYMBOL_CALLS_LOCAL (info, h)
6455                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6456                       && h->root.type == bfd_link_hash_undefweak))))
6457         {
6458           h->plt.plist = NULL;
6459           h->needs_plt = 0;
6460         }
6461     }
6462   else
6463     h->plt.plist = NULL;
6464
6465   /* If this is a weak symbol, and there is a real definition, the
6466      processor independent code will have arranged for us to see the
6467      real definition first, and we can just use the same value.  */
6468   if (h->u.weakdef != NULL)
6469     {
6470       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6471                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6472       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6473       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6474       if (ELIMINATE_COPY_RELOCS)
6475         h->non_got_ref = h->u.weakdef->non_got_ref;
6476       return TRUE;
6477     }
6478
6479   /* If we are creating a shared library, we must presume that the
6480      only references to the symbol are via the global offset table.
6481      For such cases we need not do anything here; the relocations will
6482      be handled correctly by relocate_section.  */
6483   if (info->shared)
6484     return TRUE;
6485
6486   /* If there are no references to this symbol that do not use the
6487      GOT, we don't need to generate a copy reloc.  */
6488   if (!h->non_got_ref)
6489     return TRUE;
6490
6491   /* Don't generate a copy reloc for symbols defined in the executable.  */
6492   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6493     return TRUE;
6494
6495   if (ELIMINATE_COPY_RELOCS)
6496     {
6497       struct ppc_link_hash_entry * eh;
6498       struct elf_dyn_relocs *p;
6499
6500       eh = (struct ppc_link_hash_entry *) h;
6501       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6502         {
6503           s = p->sec->output_section;
6504           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6505             break;
6506         }
6507
6508       /* If we didn't find any dynamic relocs in read-only sections, then
6509          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6510       if (p == NULL)
6511         {
6512           h->non_got_ref = 0;
6513           return TRUE;
6514         }
6515     }
6516
6517   if (h->plt.plist != NULL)
6518     {
6519       /* We should never get here, but unfortunately there are versions
6520          of gcc out there that improperly (for this ABI) put initialized
6521          function pointers, vtable refs and suchlike in read-only
6522          sections.  Allow them to proceed, but warn that this might
6523          break at runtime.  */
6524       info->callbacks->einfo
6525         (_("%P: copy reloc against `%s' requires lazy plt linking; "
6526            "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6527          h->root.root.string);
6528     }
6529
6530   /* This is a reference to a symbol defined by a dynamic object which
6531      is not a function.  */
6532
6533   if (h->size == 0)
6534     {
6535       info->callbacks->einfo (_("%P: dynamic variable `%s' is zero size\n"),
6536                               h->root.root.string);
6537       return TRUE;
6538     }
6539
6540   /* We must allocate the symbol in our .dynbss section, which will
6541      become part of the .bss section of the executable.  There will be
6542      an entry for this symbol in the .dynsym section.  The dynamic
6543      object will contain position independent code, so all references
6544      from the dynamic object to this symbol will go through the global
6545      offset table.  The dynamic linker will use the .dynsym entry to
6546      determine the address it must put in the global offset table, so
6547      both the dynamic object and the regular object will refer to the
6548      same memory location for the variable.  */
6549
6550   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6551      to copy the initial value out of the dynamic object and into the
6552      runtime process image.  We need to remember the offset into the
6553      .rela.bss section we are going to use.  */
6554   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6555     {
6556       htab->relbss->size += sizeof (Elf64_External_Rela);
6557       h->needs_copy = 1;
6558     }
6559
6560   s = htab->dynbss;
6561
6562   return _bfd_elf_adjust_dynamic_copy (h, s);
6563 }
6564
6565 /* If given a function descriptor symbol, hide both the function code
6566    sym and the descriptor.  */
6567 static void
6568 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6569                        struct elf_link_hash_entry *h,
6570                        bfd_boolean force_local)
6571 {
6572   struct ppc_link_hash_entry *eh;
6573   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6574
6575   eh = (struct ppc_link_hash_entry *) h;
6576   if (eh->is_func_descriptor)
6577     {
6578       struct ppc_link_hash_entry *fh = eh->oh;
6579
6580       if (fh == NULL)
6581         {
6582           const char *p, *q;
6583           struct ppc_link_hash_table *htab;
6584           char save;
6585
6586           /* We aren't supposed to use alloca in BFD because on
6587              systems which do not have alloca the version in libiberty
6588              calls xmalloc, which might cause the program to crash
6589              when it runs out of memory.  This function doesn't have a
6590              return status, so there's no way to gracefully return an
6591              error.  So cheat.  We know that string[-1] can be safely
6592              accessed;  It's either a string in an ELF string table,
6593              or allocated in an objalloc structure.  */
6594
6595           p = eh->elf.root.root.string - 1;
6596           save = *p;
6597           *(char *) p = '.';
6598           htab = ppc_hash_table (info);
6599           if (htab == NULL)
6600             return;
6601
6602           fh = (struct ppc_link_hash_entry *)
6603             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6604           *(char *) p = save;
6605
6606           /* Unfortunately, if it so happens that the string we were
6607              looking for was allocated immediately before this string,
6608              then we overwrote the string terminator.  That's the only
6609              reason the lookup should fail.  */
6610           if (fh == NULL)
6611             {
6612               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6613               while (q >= eh->elf.root.root.string && *q == *p)
6614                 --q, --p;
6615               if (q < eh->elf.root.root.string && *p == '.')
6616                 fh = (struct ppc_link_hash_entry *)
6617                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6618             }
6619           if (fh != NULL)
6620             {
6621               eh->oh = fh;
6622               fh->oh = eh;
6623             }
6624         }
6625       if (fh != NULL)
6626         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6627     }
6628 }
6629
6630 static bfd_boolean
6631 get_sym_h (struct elf_link_hash_entry **hp,
6632            Elf_Internal_Sym **symp,
6633            asection **symsecp,
6634            unsigned char **tls_maskp,
6635            Elf_Internal_Sym **locsymsp,
6636            unsigned long r_symndx,
6637            bfd *ibfd)
6638 {
6639   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6640
6641   if (r_symndx >= symtab_hdr->sh_info)
6642     {
6643       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6644       struct elf_link_hash_entry *h;
6645
6646       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6647       h = elf_follow_link (h);
6648
6649       if (hp != NULL)
6650         *hp = h;
6651
6652       if (symp != NULL)
6653         *symp = NULL;
6654
6655       if (symsecp != NULL)
6656         {
6657           asection *symsec = NULL;
6658           if (h->root.type == bfd_link_hash_defined
6659               || h->root.type == bfd_link_hash_defweak)
6660             symsec = h->root.u.def.section;
6661           *symsecp = symsec;
6662         }
6663
6664       if (tls_maskp != NULL)
6665         {
6666           struct ppc_link_hash_entry *eh;
6667
6668           eh = (struct ppc_link_hash_entry *) h;
6669           *tls_maskp = &eh->tls_mask;
6670         }
6671     }
6672   else
6673     {
6674       Elf_Internal_Sym *sym;
6675       Elf_Internal_Sym *locsyms = *locsymsp;
6676
6677       if (locsyms == NULL)
6678         {
6679           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6680           if (locsyms == NULL)
6681             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6682                                             symtab_hdr->sh_info,
6683                                             0, NULL, NULL, NULL);
6684           if (locsyms == NULL)
6685             return FALSE;
6686           *locsymsp = locsyms;
6687         }
6688       sym = locsyms + r_symndx;
6689
6690       if (hp != NULL)
6691         *hp = NULL;
6692
6693       if (symp != NULL)
6694         *symp = sym;
6695
6696       if (symsecp != NULL)
6697         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6698
6699       if (tls_maskp != NULL)
6700         {
6701           struct got_entry **lgot_ents;
6702           unsigned char *tls_mask;
6703
6704           tls_mask = NULL;
6705           lgot_ents = elf_local_got_ents (ibfd);
6706           if (lgot_ents != NULL)
6707             {
6708               struct plt_entry **local_plt = (struct plt_entry **)
6709                 (lgot_ents + symtab_hdr->sh_info);
6710               unsigned char *lgot_masks = (unsigned char *)
6711                 (local_plt + symtab_hdr->sh_info);
6712               tls_mask = &lgot_masks[r_symndx];
6713             }
6714           *tls_maskp = tls_mask;
6715         }
6716     }
6717   return TRUE;
6718 }
6719
6720 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6721    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6722    type suitable for optimization, and 1 otherwise.  */
6723
6724 static int
6725 get_tls_mask (unsigned char **tls_maskp,
6726               unsigned long *toc_symndx,
6727               bfd_vma *toc_addend,
6728               Elf_Internal_Sym **locsymsp,
6729               const Elf_Internal_Rela *rel,
6730               bfd *ibfd)
6731 {
6732   unsigned long r_symndx;
6733   int next_r;
6734   struct elf_link_hash_entry *h;
6735   Elf_Internal_Sym *sym;
6736   asection *sec;
6737   bfd_vma off;
6738
6739   r_symndx = ELF64_R_SYM (rel->r_info);
6740   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6741     return 0;
6742
6743   if ((*tls_maskp != NULL && **tls_maskp != 0)
6744       || sec == NULL
6745       || ppc64_elf_section_data (sec) == NULL
6746       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6747     return 1;
6748
6749   /* Look inside a TOC section too.  */
6750   if (h != NULL)
6751     {
6752       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6753       off = h->root.u.def.value;
6754     }
6755   else
6756     off = sym->st_value;
6757   off += rel->r_addend;
6758   BFD_ASSERT (off % 8 == 0);
6759   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6760   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6761   if (toc_symndx != NULL)
6762     *toc_symndx = r_symndx;
6763   if (toc_addend != NULL)
6764     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6765   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6766     return 0;
6767   if ((h == NULL || is_static_defined (h))
6768       && (next_r == -1 || next_r == -2))
6769     return 1 - next_r;
6770   return 1;
6771 }
6772
6773 /* Find (or create) an entry in the tocsave hash table.  */
6774
6775 static struct tocsave_entry *
6776 tocsave_find (struct ppc_link_hash_table *htab,
6777               enum insert_option insert,
6778               Elf_Internal_Sym **local_syms,
6779               const Elf_Internal_Rela *irela,
6780               bfd *ibfd)
6781 {
6782   unsigned long r_indx;
6783   struct elf_link_hash_entry *h;
6784   Elf_Internal_Sym *sym;
6785   struct tocsave_entry ent, *p;
6786   hashval_t hash;
6787   struct tocsave_entry **slot;
6788
6789   r_indx = ELF64_R_SYM (irela->r_info);
6790   if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6791     return NULL;
6792   if (ent.sec == NULL || ent.sec->output_section == NULL)
6793     {
6794       (*_bfd_error_handler)
6795         (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6796       return NULL;
6797     }
6798
6799   if (h != NULL)
6800     ent.offset = h->root.u.def.value;
6801   else
6802     ent.offset = sym->st_value;
6803   ent.offset += irela->r_addend;
6804
6805   hash = tocsave_htab_hash (&ent);
6806   slot = ((struct tocsave_entry **)
6807           htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6808   if (slot == NULL)
6809     return NULL;
6810
6811   if (*slot == NULL)
6812     {
6813       p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6814       if (p == NULL)
6815         return NULL;
6816       *p = ent;
6817       *slot = p;
6818     }
6819   return *slot;
6820 }
6821
6822 /* Adjust all global syms defined in opd sections.  In gcc generated
6823    code for the old ABI, these will already have been done.  */
6824
6825 static bfd_boolean
6826 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6827 {
6828   struct ppc_link_hash_entry *eh;
6829   asection *sym_sec;
6830   struct _opd_sec_data *opd;
6831
6832   if (h->root.type == bfd_link_hash_indirect)
6833     return TRUE;
6834
6835   if (h->root.type != bfd_link_hash_defined
6836       && h->root.type != bfd_link_hash_defweak)
6837     return TRUE;
6838
6839   eh = (struct ppc_link_hash_entry *) h;
6840   if (eh->adjust_done)
6841     return TRUE;
6842
6843   sym_sec = eh->elf.root.u.def.section;
6844   opd = get_opd_info (sym_sec);
6845   if (opd != NULL && opd->adjust != NULL)
6846     {
6847       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6848       if (adjust == -1)
6849         {
6850           /* This entry has been deleted.  */
6851           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6852           if (dsec == NULL)
6853             {
6854               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6855                 if (elf_discarded_section (dsec))
6856                   {
6857                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6858                     break;
6859                   }
6860             }
6861           eh->elf.root.u.def.value = 0;
6862           eh->elf.root.u.def.section = dsec;
6863         }
6864       else
6865         eh->elf.root.u.def.value += adjust;
6866       eh->adjust_done = 1;
6867     }
6868   return TRUE;
6869 }
6870
6871 /* Handles decrementing dynamic reloc counts for the reloc specified by
6872    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6873    have already been determined.  */
6874
6875 static bfd_boolean
6876 dec_dynrel_count (bfd_vma r_info,
6877                   asection *sec,
6878                   struct bfd_link_info *info,
6879                   Elf_Internal_Sym **local_syms,
6880                   struct elf_link_hash_entry *h,
6881                   asection *sym_sec)
6882 {
6883   enum elf_ppc64_reloc_type r_type;
6884   struct elf_dyn_relocs *p;
6885   struct elf_dyn_relocs **pp;
6886
6887   /* Can this reloc be dynamic?  This switch, and later tests here
6888      should be kept in sync with the code in check_relocs.  */
6889   r_type = ELF64_R_TYPE (r_info);
6890   switch (r_type)
6891     {
6892     default:
6893       return TRUE;
6894
6895     case R_PPC64_TPREL16:
6896     case R_PPC64_TPREL16_LO:
6897     case R_PPC64_TPREL16_HI:
6898     case R_PPC64_TPREL16_HA:
6899     case R_PPC64_TPREL16_DS:
6900     case R_PPC64_TPREL16_LO_DS:
6901     case R_PPC64_TPREL16_HIGHER:
6902     case R_PPC64_TPREL16_HIGHERA:
6903     case R_PPC64_TPREL16_HIGHEST:
6904     case R_PPC64_TPREL16_HIGHESTA:
6905       if (!info->shared)
6906         return TRUE;
6907
6908     case R_PPC64_TPREL64:
6909     case R_PPC64_DTPMOD64:
6910     case R_PPC64_DTPREL64:
6911     case R_PPC64_ADDR64:
6912     case R_PPC64_REL30:
6913     case R_PPC64_REL32:
6914     case R_PPC64_REL64:
6915     case R_PPC64_ADDR14:
6916     case R_PPC64_ADDR14_BRNTAKEN:
6917     case R_PPC64_ADDR14_BRTAKEN:
6918     case R_PPC64_ADDR16:
6919     case R_PPC64_ADDR16_DS:
6920     case R_PPC64_ADDR16_HA:
6921     case R_PPC64_ADDR16_HI:
6922     case R_PPC64_ADDR16_HIGHER:
6923     case R_PPC64_ADDR16_HIGHERA:
6924     case R_PPC64_ADDR16_HIGHEST:
6925     case R_PPC64_ADDR16_HIGHESTA:
6926     case R_PPC64_ADDR16_LO:
6927     case R_PPC64_ADDR16_LO_DS:
6928     case R_PPC64_ADDR24:
6929     case R_PPC64_ADDR32:
6930     case R_PPC64_UADDR16:
6931     case R_PPC64_UADDR32:
6932     case R_PPC64_UADDR64:
6933     case R_PPC64_TOC:
6934       break;
6935     }
6936
6937   if (local_syms != NULL)
6938     {
6939       unsigned long r_symndx;
6940       Elf_Internal_Sym *sym;
6941       bfd *ibfd = sec->owner;
6942
6943       r_symndx = ELF64_R_SYM (r_info);
6944       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6945         return FALSE;
6946     }
6947
6948   if ((info->shared
6949        && (must_be_dyn_reloc (info, r_type)
6950            || (h != NULL
6951                && (!info->symbolic
6952                    || h->root.type == bfd_link_hash_defweak
6953                    || !h->def_regular))))
6954       || (ELIMINATE_COPY_RELOCS
6955           && !info->shared
6956           && h != NULL
6957           && (h->root.type == bfd_link_hash_defweak
6958               || !h->def_regular)))
6959     ;
6960   else
6961     return TRUE;
6962
6963   if (h != NULL)
6964     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6965   else
6966     {
6967       if (sym_sec != NULL)
6968         {
6969           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6970           pp = (struct elf_dyn_relocs **) vpp;
6971         }
6972       else
6973         {
6974           void *vpp = &elf_section_data (sec)->local_dynrel;
6975           pp = (struct elf_dyn_relocs **) vpp;
6976         }
6977
6978       /* elf_gc_sweep may have already removed all dyn relocs associated
6979          with local syms for a given section.  Don't report a dynreloc
6980          miscount.  */
6981       if (*pp == NULL)
6982         return TRUE;
6983     }
6984
6985   while ((p = *pp) != NULL)
6986     {
6987       if (p->sec == sec)
6988         {
6989           if (!must_be_dyn_reloc (info, r_type))
6990             p->pc_count -= 1;
6991           p->count -= 1;
6992           if (p->count == 0)
6993             *pp = p->next;
6994           return TRUE;
6995         }
6996       pp = &p->next;
6997     }
6998
6999   info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7000                           sec->owner, sec);
7001   bfd_set_error (bfd_error_bad_value);
7002   return FALSE;
7003 }
7004
7005 /* Remove unused Official Procedure Descriptor entries.  Currently we
7006    only remove those associated with functions in discarded link-once
7007    sections, or weakly defined functions that have been overridden.  It
7008    would be possible to remove many more entries for statically linked
7009    applications.  */
7010
7011 bfd_boolean
7012 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7013 {
7014   bfd *ibfd;
7015   bfd_boolean some_edited = FALSE;
7016   asection *need_pad = NULL;
7017
7018   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7019     {
7020       asection *sec;
7021       Elf_Internal_Rela *relstart, *rel, *relend;
7022       Elf_Internal_Shdr *symtab_hdr;
7023       Elf_Internal_Sym *local_syms;
7024       bfd_vma offset;
7025       struct _opd_sec_data *opd;
7026       bfd_boolean need_edit, add_aux_fields;
7027       bfd_size_type cnt_16b = 0;
7028
7029       if (!is_ppc64_elf (ibfd))
7030         continue;
7031
7032       sec = bfd_get_section_by_name (ibfd, ".opd");
7033       if (sec == NULL || sec->size == 0)
7034         continue;
7035
7036       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
7037         continue;
7038
7039       if (sec->output_section == bfd_abs_section_ptr)
7040         continue;
7041
7042       /* Look through the section relocs.  */
7043       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7044         continue;
7045
7046       local_syms = NULL;
7047       symtab_hdr = &elf_symtab_hdr (ibfd);
7048
7049       /* Read the relocations.  */
7050       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7051                                             info->keep_memory);
7052       if (relstart == NULL)
7053         return FALSE;
7054
7055       /* First run through the relocs to check they are sane, and to
7056          determine whether we need to edit this opd section.  */
7057       need_edit = FALSE;
7058       need_pad = sec;
7059       offset = 0;
7060       relend = relstart + sec->reloc_count;
7061       for (rel = relstart; rel < relend; )
7062         {
7063           enum elf_ppc64_reloc_type r_type;
7064           unsigned long r_symndx;
7065           asection *sym_sec;
7066           struct elf_link_hash_entry *h;
7067           Elf_Internal_Sym *sym;
7068
7069           /* .opd contains a regular array of 16 or 24 byte entries.  We're
7070              only interested in the reloc pointing to a function entry
7071              point.  */
7072           if (rel->r_offset != offset
7073               || rel + 1 >= relend
7074               || (rel + 1)->r_offset != offset + 8)
7075             {
7076               /* If someone messes with .opd alignment then after a
7077                  "ld -r" we might have padding in the middle of .opd.
7078                  Also, there's nothing to prevent someone putting
7079                  something silly in .opd with the assembler.  No .opd
7080                  optimization for them!  */
7081             broken_opd:
7082               (*_bfd_error_handler)
7083                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7084               need_edit = FALSE;
7085               break;
7086             }
7087
7088           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7089               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7090             {
7091               (*_bfd_error_handler)
7092                 (_("%B: unexpected reloc type %u in .opd section"),
7093                  ibfd, r_type);
7094               need_edit = FALSE;
7095               break;
7096             }
7097
7098           r_symndx = ELF64_R_SYM (rel->r_info);
7099           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7100                           r_symndx, ibfd))
7101             goto error_ret;
7102
7103           if (sym_sec == NULL || sym_sec->owner == NULL)
7104             {
7105               const char *sym_name;
7106               if (h != NULL)
7107                 sym_name = h->root.root.string;
7108               else
7109                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7110                                              sym_sec);
7111
7112               (*_bfd_error_handler)
7113                 (_("%B: undefined sym `%s' in .opd section"),
7114                  ibfd, sym_name);
7115               need_edit = FALSE;
7116               break;
7117             }
7118
7119           /* opd entries are always for functions defined in the
7120              current input bfd.  If the symbol isn't defined in the
7121              input bfd, then we won't be using the function in this
7122              bfd;  It must be defined in a linkonce section in another
7123              bfd, or is weak.  It's also possible that we are
7124              discarding the function due to a linker script /DISCARD/,
7125              which we test for via the output_section.  */
7126           if (sym_sec->owner != ibfd
7127               || sym_sec->output_section == bfd_abs_section_ptr)
7128             need_edit = TRUE;
7129
7130           rel += 2;
7131           if (rel == relend
7132               || (rel + 1 == relend && rel->r_offset == offset + 16))
7133             {
7134               if (sec->size == offset + 24)
7135                 {
7136                   need_pad = NULL;
7137                   break;
7138                 }
7139               if (rel == relend && sec->size == offset + 16)
7140                 {
7141                   cnt_16b++;
7142                   break;
7143                 }
7144               goto broken_opd;
7145             }
7146
7147           if (rel->r_offset == offset + 24)
7148             offset += 24;
7149           else if (rel->r_offset != offset + 16)
7150             goto broken_opd;
7151           else if (rel + 1 < relend
7152                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7153                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7154             {
7155               offset += 16;
7156               cnt_16b++;
7157             }
7158           else if (rel + 2 < relend
7159                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7160                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7161             {
7162               offset += 24;
7163               rel += 1;
7164             }
7165           else
7166             goto broken_opd;
7167         }
7168
7169       add_aux_fields = non_overlapping && cnt_16b > 0;
7170
7171       if (need_edit || add_aux_fields)
7172         {
7173           Elf_Internal_Rela *write_rel;
7174           Elf_Internal_Shdr *rel_hdr;
7175           bfd_byte *rptr, *wptr;
7176           bfd_byte *new_contents;
7177           bfd_boolean skip;
7178           long opd_ent_size;
7179           bfd_size_type amt;
7180
7181           new_contents = NULL;
7182           amt = sec->size * sizeof (long) / 8;
7183           opd = &ppc64_elf_section_data (sec)->u.opd;
7184           opd->adjust = bfd_zalloc (sec->owner, amt);
7185           if (opd->adjust == NULL)
7186             return FALSE;
7187           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7188
7189           /* This seems a waste of time as input .opd sections are all
7190              zeros as generated by gcc, but I suppose there's no reason
7191              this will always be so.  We might start putting something in
7192              the third word of .opd entries.  */
7193           if ((sec->flags & SEC_IN_MEMORY) == 0)
7194             {
7195               bfd_byte *loc;
7196               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7197                 {
7198                   if (loc != NULL)
7199                     free (loc);
7200                 error_ret:
7201                   if (local_syms != NULL
7202                       && symtab_hdr->contents != (unsigned char *) local_syms)
7203                     free (local_syms);
7204                   if (elf_section_data (sec)->relocs != relstart)
7205                     free (relstart);
7206                   return FALSE;
7207                 }
7208               sec->contents = loc;
7209               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7210             }
7211
7212           elf_section_data (sec)->relocs = relstart;
7213
7214           new_contents = sec->contents;
7215           if (add_aux_fields)
7216             {
7217               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7218               if (new_contents == NULL)
7219                 return FALSE;
7220               need_pad = FALSE;
7221             }
7222           wptr = new_contents;
7223           rptr = sec->contents;
7224
7225           write_rel = relstart;
7226           skip = FALSE;
7227           offset = 0;
7228           opd_ent_size = 0;
7229           for (rel = relstart; rel < relend; rel++)
7230             {
7231               unsigned long r_symndx;
7232               asection *sym_sec;
7233               struct elf_link_hash_entry *h;
7234               Elf_Internal_Sym *sym;
7235
7236               r_symndx = ELF64_R_SYM (rel->r_info);
7237               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7238                               r_symndx, ibfd))
7239                 goto error_ret;
7240
7241               if (rel->r_offset == offset)
7242                 {
7243                   struct ppc_link_hash_entry *fdh = NULL;
7244
7245                   /* See if the .opd entry is full 24 byte or
7246                      16 byte (with fd_aux entry overlapped with next
7247                      fd_func).  */
7248                   opd_ent_size = 24;
7249                   if ((rel + 2 == relend && sec->size == offset + 16)
7250                       || (rel + 3 < relend
7251                           && rel[2].r_offset == offset + 16
7252                           && rel[3].r_offset == offset + 24
7253                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7254                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7255                     opd_ent_size = 16;
7256
7257                   if (h != NULL
7258                       && h->root.root.string[0] == '.')
7259                     {
7260                       struct ppc_link_hash_table *htab;
7261
7262                       htab = ppc_hash_table (info);
7263                       if (htab != NULL)
7264                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7265                                           htab);
7266                       if (fdh != NULL
7267                           && fdh->elf.root.type != bfd_link_hash_defined
7268                           && fdh->elf.root.type != bfd_link_hash_defweak)
7269                         fdh = NULL;
7270                     }
7271
7272                   skip = (sym_sec->owner != ibfd
7273                           || sym_sec->output_section == bfd_abs_section_ptr);
7274                   if (skip)
7275                     {
7276                       if (fdh != NULL && sym_sec->owner == ibfd)
7277                         {
7278                           /* Arrange for the function descriptor sym
7279                              to be dropped.  */
7280                           fdh->elf.root.u.def.value = 0;
7281                           fdh->elf.root.u.def.section = sym_sec;
7282                         }
7283                       opd->adjust[rel->r_offset / 8] = -1;
7284                     }
7285                   else
7286                     {
7287                       /* We'll be keeping this opd entry.  */
7288
7289                       if (fdh != NULL)
7290                         {
7291                           /* Redefine the function descriptor symbol to
7292                              this location in the opd section.  It is
7293                              necessary to update the value here rather
7294                              than using an array of adjustments as we do
7295                              for local symbols, because various places
7296                              in the generic ELF code use the value
7297                              stored in u.def.value.  */
7298                           fdh->elf.root.u.def.value = wptr - new_contents;
7299                           fdh->adjust_done = 1;
7300                         }
7301
7302                       /* Local syms are a bit tricky.  We could
7303                          tweak them as they can be cached, but
7304                          we'd need to look through the local syms
7305                          for the function descriptor sym which we
7306                          don't have at the moment.  So keep an
7307                          array of adjustments.  */
7308                       opd->adjust[rel->r_offset / 8]
7309                         = (wptr - new_contents) - (rptr - sec->contents);
7310
7311                       if (wptr != rptr)
7312                         memcpy (wptr, rptr, opd_ent_size);
7313                       wptr += opd_ent_size;
7314                       if (add_aux_fields && opd_ent_size == 16)
7315                         {
7316                           memset (wptr, '\0', 8);
7317                           wptr += 8;
7318                         }
7319                     }
7320                   rptr += opd_ent_size;
7321                   offset += opd_ent_size;
7322                 }
7323
7324               if (skip)
7325                 {
7326                   if (!NO_OPD_RELOCS
7327                       && !info->relocatable
7328                       && !dec_dynrel_count (rel->r_info, sec, info,
7329                                             NULL, h, sym_sec))
7330                     goto error_ret;
7331                 }
7332               else
7333                 {
7334                   /* We need to adjust any reloc offsets to point to the
7335                      new opd entries.  While we're at it, we may as well
7336                      remove redundant relocs.  */
7337                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7338                   if (write_rel != rel)
7339                     memcpy (write_rel, rel, sizeof (*rel));
7340                   ++write_rel;
7341                 }
7342             }
7343
7344           sec->size = wptr - new_contents;
7345           sec->reloc_count = write_rel - relstart;
7346           if (add_aux_fields)
7347             {
7348               free (sec->contents);
7349               sec->contents = new_contents;
7350             }
7351
7352           /* Fudge the header size too, as this is used later in
7353              elf_bfd_final_link if we are emitting relocs.  */
7354           rel_hdr = _bfd_elf_single_rel_hdr (sec);
7355           rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7356           some_edited = TRUE;
7357         }
7358       else if (elf_section_data (sec)->relocs != relstart)
7359         free (relstart);
7360
7361       if (local_syms != NULL
7362           && symtab_hdr->contents != (unsigned char *) local_syms)
7363         {
7364           if (!info->keep_memory)
7365             free (local_syms);
7366           else
7367             symtab_hdr->contents = (unsigned char *) local_syms;
7368         }
7369     }
7370
7371   if (some_edited)
7372     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7373
7374   /* If we are doing a final link and the last .opd entry is just 16 byte
7375      long, add a 8 byte padding after it.  */
7376   if (need_pad != NULL && !info->relocatable)
7377     {
7378       bfd_byte *p;
7379
7380       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7381         {
7382           BFD_ASSERT (need_pad->size > 0);
7383
7384           p = bfd_malloc (need_pad->size + 8);
7385           if (p == NULL)
7386             return FALSE;
7387
7388           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7389                                           p, 0, need_pad->size))
7390             return FALSE;
7391
7392           need_pad->contents = p;
7393           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7394         }
7395       else
7396         {
7397           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7398           if (p == NULL)
7399             return FALSE;
7400
7401           need_pad->contents = p;
7402         }
7403
7404       memset (need_pad->contents + need_pad->size, 0, 8);
7405       need_pad->size += 8;
7406     }
7407
7408   return TRUE;
7409 }
7410
7411 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7412
7413 asection *
7414 ppc64_elf_tls_setup (struct bfd_link_info *info,
7415                      int no_tls_get_addr_opt,
7416                      int *no_multi_toc)
7417 {
7418   struct ppc_link_hash_table *htab;
7419
7420   htab = ppc_hash_table (info);
7421   if (htab == NULL)
7422     return NULL;
7423
7424   if (*no_multi_toc)
7425     htab->do_multi_toc = 0;
7426   else if (!htab->do_multi_toc)
7427     *no_multi_toc = 1;
7428
7429   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7430                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7431                                               FALSE, FALSE, TRUE));
7432   /* Move dynamic linking info to the function descriptor sym.  */
7433   if (htab->tls_get_addr != NULL)
7434     func_desc_adjust (&htab->tls_get_addr->elf, info);
7435   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7436                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7437                                                  FALSE, FALSE, TRUE));
7438   if (!no_tls_get_addr_opt)
7439     {
7440       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7441
7442       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7443                                   FALSE, FALSE, TRUE);
7444       if (opt != NULL)
7445         func_desc_adjust (opt, info);
7446       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7447                                      FALSE, FALSE, TRUE);
7448       if (opt_fd != NULL
7449           && (opt_fd->root.type == bfd_link_hash_defined
7450               || opt_fd->root.type == bfd_link_hash_defweak))
7451         {
7452           /* If glibc supports an optimized __tls_get_addr call stub,
7453              signalled by the presence of __tls_get_addr_opt, and we'll
7454              be calling __tls_get_addr via a plt call stub, then
7455              make __tls_get_addr point to __tls_get_addr_opt.  */
7456           tga_fd = &htab->tls_get_addr_fd->elf;
7457           if (htab->elf.dynamic_sections_created
7458               && tga_fd != NULL
7459               && (tga_fd->type == STT_FUNC
7460                   || tga_fd->needs_plt)
7461               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7462                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7463                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7464             {
7465               struct plt_entry *ent;
7466
7467               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7468                 if (ent->plt.refcount > 0)
7469                   break;
7470               if (ent != NULL)
7471                 {
7472                   tga_fd->root.type = bfd_link_hash_indirect;
7473                   tga_fd->root.u.i.link = &opt_fd->root;
7474                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7475                   if (opt_fd->dynindx != -1)
7476                     {
7477                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7478                       opt_fd->dynindx = -1;
7479                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7480                                               opt_fd->dynstr_index);
7481                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7482                         return NULL;
7483                     }
7484                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7485                   tga = &htab->tls_get_addr->elf;
7486                   if (opt != NULL && tga != NULL)
7487                     {
7488                       tga->root.type = bfd_link_hash_indirect;
7489                       tga->root.u.i.link = &opt->root;
7490                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7491                       _bfd_elf_link_hash_hide_symbol (info, opt,
7492                                                       tga->forced_local);
7493                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7494                     }
7495                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7496                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7497                   if (htab->tls_get_addr != NULL)
7498                     {
7499                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7500                       htab->tls_get_addr->is_func = 1;
7501                     }
7502                 }
7503             }
7504         }
7505       else
7506         no_tls_get_addr_opt = TRUE;
7507     }
7508   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7509   return _bfd_elf_tls_setup (info->output_bfd, info);
7510 }
7511
7512 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7513    HASH1 or HASH2.  */
7514
7515 static bfd_boolean
7516 branch_reloc_hash_match (const bfd *ibfd,
7517                          const Elf_Internal_Rela *rel,
7518                          const struct ppc_link_hash_entry *hash1,
7519                          const struct ppc_link_hash_entry *hash2)
7520 {
7521   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7522   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7523   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7524
7525   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7526     {
7527       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7528       struct elf_link_hash_entry *h;
7529
7530       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7531       h = elf_follow_link (h);
7532       if (h == &hash1->elf || h == &hash2->elf)
7533         return TRUE;
7534     }
7535   return FALSE;
7536 }
7537
7538 /* Run through all the TLS relocs looking for optimization
7539    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7540    a preliminary section layout so that we know the TLS segment
7541    offsets.  We can't optimize earlier because some optimizations need
7542    to know the tp offset, and we need to optimize before allocating
7543    dynamic relocations.  */
7544
7545 bfd_boolean
7546 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7547 {
7548   bfd *ibfd;
7549   asection *sec;
7550   struct ppc_link_hash_table *htab;
7551   unsigned char *toc_ref;
7552   int pass;
7553
7554   if (info->relocatable || !info->executable)
7555     return TRUE;
7556
7557   htab = ppc_hash_table (info);
7558   if (htab == NULL)
7559     return FALSE;
7560
7561   /* Make two passes over the relocs.  On the first pass, mark toc
7562      entries involved with tls relocs, and check that tls relocs
7563      involved in setting up a tls_get_addr call are indeed followed by
7564      such a call.  If they are not, we can't do any tls optimization.
7565      On the second pass twiddle tls_mask flags to notify
7566      relocate_section that optimization can be done, and adjust got
7567      and plt refcounts.  */
7568   toc_ref = NULL;
7569   for (pass = 0; pass < 2; ++pass)
7570     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7571       {
7572         Elf_Internal_Sym *locsyms = NULL;
7573         asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7574
7575         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7576           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7577             {
7578               Elf_Internal_Rela *relstart, *rel, *relend;
7579               bfd_boolean found_tls_get_addr_arg = 0;
7580
7581               /* Read the relocations.  */
7582               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7583                                                     info->keep_memory);
7584               if (relstart == NULL)
7585                 return FALSE;
7586
7587               relend = relstart + sec->reloc_count;
7588               for (rel = relstart; rel < relend; rel++)
7589                 {
7590                   enum elf_ppc64_reloc_type r_type;
7591                   unsigned long r_symndx;
7592                   struct elf_link_hash_entry *h;
7593                   Elf_Internal_Sym *sym;
7594                   asection *sym_sec;
7595                   unsigned char *tls_mask;
7596                   unsigned char tls_set, tls_clear, tls_type = 0;
7597                   bfd_vma value;
7598                   bfd_boolean ok_tprel, is_local;
7599                   long toc_ref_index = 0;
7600                   int expecting_tls_get_addr = 0;
7601                   bfd_boolean ret = FALSE;
7602
7603                   r_symndx = ELF64_R_SYM (rel->r_info);
7604                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7605                                   r_symndx, ibfd))
7606                     {
7607                     err_free_rel:
7608                       if (elf_section_data (sec)->relocs != relstart)
7609                         free (relstart);
7610                       if (toc_ref != NULL)
7611                         free (toc_ref);
7612                       if (locsyms != NULL
7613                           && (elf_symtab_hdr (ibfd).contents
7614                               != (unsigned char *) locsyms))
7615                         free (locsyms);
7616                       return ret;
7617                     }
7618
7619                   if (h != NULL)
7620                     {
7621                       if (h->root.type == bfd_link_hash_defined
7622                           || h->root.type == bfd_link_hash_defweak)
7623                         value = h->root.u.def.value;
7624                       else if (h->root.type == bfd_link_hash_undefweak)
7625                         value = 0;
7626                       else
7627                         {
7628                           found_tls_get_addr_arg = 0;
7629                           continue;
7630                         }
7631                     }
7632                   else
7633                     /* Symbols referenced by TLS relocs must be of type
7634                        STT_TLS.  So no need for .opd local sym adjust.  */
7635                     value = sym->st_value;
7636
7637                   ok_tprel = FALSE;
7638                   is_local = FALSE;
7639                   if (h == NULL
7640                       || !h->def_dynamic)
7641                     {
7642                       is_local = TRUE;
7643                       if (h != NULL
7644                           && h->root.type == bfd_link_hash_undefweak)
7645                         ok_tprel = TRUE;
7646                       else
7647                         {
7648                           value += sym_sec->output_offset;
7649                           value += sym_sec->output_section->vma;
7650                           value -= htab->elf.tls_sec->vma;
7651                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7652                                       < (bfd_vma) 1 << 32);
7653                         }
7654                     }
7655
7656                   r_type = ELF64_R_TYPE (rel->r_info);
7657                   /* If this section has old-style __tls_get_addr calls
7658                      without marker relocs, then check that each
7659                      __tls_get_addr call reloc is preceded by a reloc
7660                      that conceivably belongs to the __tls_get_addr arg
7661                      setup insn.  If we don't find matching arg setup
7662                      relocs, don't do any tls optimization.  */
7663                   if (pass == 0
7664                       && sec->has_tls_get_addr_call
7665                       && h != NULL
7666                       && (h == &htab->tls_get_addr->elf
7667                           || h == &htab->tls_get_addr_fd->elf)
7668                       && !found_tls_get_addr_arg
7669                       && is_branch_reloc (r_type))
7670                     {
7671                       info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7672                                                 "TLS optimization disabled\n"),
7673                                               ibfd, sec, rel->r_offset);
7674                       ret = TRUE;
7675                       goto err_free_rel;
7676                     }
7677
7678                   found_tls_get_addr_arg = 0;
7679                   switch (r_type)
7680                     {
7681                     case R_PPC64_GOT_TLSLD16:
7682                     case R_PPC64_GOT_TLSLD16_LO:
7683                       expecting_tls_get_addr = 1;
7684                       found_tls_get_addr_arg = 1;
7685                       /* Fall thru */
7686
7687                     case R_PPC64_GOT_TLSLD16_HI:
7688                     case R_PPC64_GOT_TLSLD16_HA:
7689                       /* These relocs should never be against a symbol
7690                          defined in a shared lib.  Leave them alone if
7691                          that turns out to be the case.  */
7692                       if (!is_local)
7693                         continue;
7694
7695                       /* LD -> LE */
7696                       tls_set = 0;
7697                       tls_clear = TLS_LD;
7698                       tls_type = TLS_TLS | TLS_LD;
7699                       break;
7700
7701                     case R_PPC64_GOT_TLSGD16:
7702                     case R_PPC64_GOT_TLSGD16_LO:
7703                       expecting_tls_get_addr = 1;
7704                       found_tls_get_addr_arg = 1;
7705                       /* Fall thru */
7706
7707                     case R_PPC64_GOT_TLSGD16_HI:
7708                     case R_PPC64_GOT_TLSGD16_HA:
7709                       if (ok_tprel)
7710                         /* GD -> LE */
7711                         tls_set = 0;
7712                       else
7713                         /* GD -> IE */
7714                         tls_set = TLS_TLS | TLS_TPRELGD;
7715                       tls_clear = TLS_GD;
7716                       tls_type = TLS_TLS | TLS_GD;
7717                       break;
7718
7719                     case R_PPC64_GOT_TPREL16_DS:
7720                     case R_PPC64_GOT_TPREL16_LO_DS:
7721                     case R_PPC64_GOT_TPREL16_HI:
7722                     case R_PPC64_GOT_TPREL16_HA:
7723                       if (ok_tprel)
7724                         {
7725                           /* IE -> LE */
7726                           tls_set = 0;
7727                           tls_clear = TLS_TPREL;
7728                           tls_type = TLS_TLS | TLS_TPREL;
7729                           break;
7730                         }
7731                       continue;
7732
7733                     case R_PPC64_TLSGD:
7734                     case R_PPC64_TLSLD:
7735                       found_tls_get_addr_arg = 1;
7736                       /* Fall thru */
7737
7738                     case R_PPC64_TLS:
7739                     case R_PPC64_TOC16:
7740                     case R_PPC64_TOC16_LO:
7741                       if (sym_sec == NULL || sym_sec != toc)
7742                         continue;
7743
7744                       /* Mark this toc entry as referenced by a TLS
7745                          code sequence.  We can do that now in the
7746                          case of R_PPC64_TLS, and after checking for
7747                          tls_get_addr for the TOC16 relocs.  */
7748                       if (toc_ref == NULL)
7749                         toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7750                       if (toc_ref == NULL)
7751                         goto err_free_rel;
7752
7753                       if (h != NULL)
7754                         value = h->root.u.def.value;
7755                       else
7756                         value = sym->st_value;
7757                       value += rel->r_addend;
7758                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7759                       toc_ref_index = (value + toc->output_offset) / 8;
7760                       if (r_type == R_PPC64_TLS
7761                           || r_type == R_PPC64_TLSGD
7762                           || r_type == R_PPC64_TLSLD)
7763                         {
7764                           toc_ref[toc_ref_index] = 1;
7765                           continue;
7766                         }
7767
7768                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7769                         continue;
7770
7771                       tls_set = 0;
7772                       tls_clear = 0;
7773                       expecting_tls_get_addr = 2;
7774                       break;
7775
7776                     case R_PPC64_TPREL64:
7777                       if (pass == 0
7778                           || sec != toc
7779                           || toc_ref == NULL
7780                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7781                         continue;
7782                       if (ok_tprel)
7783                         {
7784                           /* IE -> LE */
7785                           tls_set = TLS_EXPLICIT;
7786                           tls_clear = TLS_TPREL;
7787                           break;
7788                         }
7789                       continue;
7790
7791                     case R_PPC64_DTPMOD64:
7792                       if (pass == 0
7793                           || sec != toc
7794                           || toc_ref == NULL
7795                           || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7796                         continue;
7797                       if (rel + 1 < relend
7798                           && (rel[1].r_info
7799                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7800                           && rel[1].r_offset == rel->r_offset + 8)
7801                         {
7802                           if (ok_tprel)
7803                             /* GD -> LE */
7804                             tls_set = TLS_EXPLICIT | TLS_GD;
7805                           else
7806                             /* GD -> IE */
7807                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7808                           tls_clear = TLS_GD;
7809                         }
7810                       else
7811                         {
7812                           if (!is_local)
7813                             continue;
7814
7815                           /* LD -> LE */
7816                           tls_set = TLS_EXPLICIT;
7817                           tls_clear = TLS_LD;
7818                         }
7819                       break;
7820
7821                     default:
7822                       continue;
7823                     }
7824
7825                   if (pass == 0)
7826                     {
7827                       if (!expecting_tls_get_addr
7828                           || !sec->has_tls_get_addr_call)
7829                         continue;
7830
7831                       if (rel + 1 < relend
7832                           && branch_reloc_hash_match (ibfd, rel + 1,
7833                                                       htab->tls_get_addr,
7834                                                       htab->tls_get_addr_fd))
7835                         {
7836                           if (expecting_tls_get_addr == 2)
7837                             {
7838                               /* Check for toc tls entries.  */
7839                               unsigned char *toc_tls;
7840                               int retval;
7841
7842                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7843                                                      &locsyms,
7844                                                      rel, ibfd);
7845                               if (retval == 0)
7846                                 goto err_free_rel;
7847                               if (toc_tls != NULL)
7848                                 {
7849                                   if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7850                                     found_tls_get_addr_arg = 1;
7851                                   if (retval > 1)
7852                                     toc_ref[toc_ref_index] = 1;
7853                                 }
7854                             }
7855                           continue;
7856                         }
7857
7858                       if (expecting_tls_get_addr != 1)
7859                         continue;
7860
7861                       /* Uh oh, we didn't find the expected call.  We
7862                          could just mark this symbol to exclude it
7863                          from tls optimization but it's safer to skip
7864                          the entire optimization.  */
7865                       info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
7866                                                 "TLS optimization disabled\n"),
7867                                               ibfd, sec, rel->r_offset);
7868                       ret = TRUE;
7869                       goto err_free_rel;
7870                     }
7871
7872                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7873                     {
7874                       struct plt_entry *ent;
7875                       for (ent = htab->tls_get_addr->elf.plt.plist;
7876                            ent != NULL;
7877                            ent = ent->next)
7878                         if (ent->addend == 0)
7879                           {
7880                             if (ent->plt.refcount > 0)
7881                               {
7882                                 ent->plt.refcount -= 1;
7883                                 expecting_tls_get_addr = 0;
7884                               }
7885                             break;
7886                           }
7887                     }
7888
7889                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7890                     {
7891                       struct plt_entry *ent;
7892                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7893                            ent != NULL;
7894                            ent = ent->next)
7895                         if (ent->addend == 0)
7896                           {
7897                             if (ent->plt.refcount > 0)
7898                               ent->plt.refcount -= 1;
7899                             break;
7900                           }
7901                     }
7902
7903                   if (tls_clear == 0)
7904                     continue;
7905
7906                   if ((tls_set & TLS_EXPLICIT) == 0)
7907                     {
7908                       struct got_entry *ent;
7909
7910                       /* Adjust got entry for this reloc.  */
7911                       if (h != NULL)
7912                         ent = h->got.glist;
7913                       else
7914                         ent = elf_local_got_ents (ibfd)[r_symndx];
7915
7916                       for (; ent != NULL; ent = ent->next)
7917                         if (ent->addend == rel->r_addend
7918                             && ent->owner == ibfd
7919                             && ent->tls_type == tls_type)
7920                           break;
7921                       if (ent == NULL)
7922                         abort ();
7923
7924                       if (tls_set == 0)
7925                         {
7926                           /* We managed to get rid of a got entry.  */
7927                           if (ent->got.refcount > 0)
7928                             ent->got.refcount -= 1;
7929                         }
7930                     }
7931                   else
7932                     {
7933                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7934                          we'll lose one or two dyn relocs.  */
7935                       if (!dec_dynrel_count (rel->r_info, sec, info,
7936                                              NULL, h, sym_sec))
7937                         return FALSE;
7938
7939                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7940                         {
7941                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7942                                                  NULL, h, sym_sec))
7943                             return FALSE;
7944                         }
7945                     }
7946
7947                   *tls_mask |= tls_set;
7948                   *tls_mask &= ~tls_clear;
7949                 }
7950
7951               if (elf_section_data (sec)->relocs != relstart)
7952                 free (relstart);
7953             }
7954
7955         if (locsyms != NULL
7956             && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7957           {
7958             if (!info->keep_memory)
7959               free (locsyms);
7960             else
7961               elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7962           }
7963       }
7964
7965   if (toc_ref != NULL)
7966     free (toc_ref);
7967   return TRUE;
7968 }
7969
7970 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7971    the values of any global symbols in a toc section that has been
7972    edited.  Globals in toc sections should be a rarity, so this function
7973    sets a flag if any are found in toc sections other than the one just
7974    edited, so that futher hash table traversals can be avoided.  */
7975
7976 struct adjust_toc_info
7977 {
7978   asection *toc;
7979   unsigned long *skip;
7980   bfd_boolean global_toc_syms;
7981 };
7982
7983 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
7984
7985 static bfd_boolean
7986 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7987 {
7988   struct ppc_link_hash_entry *eh;
7989   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7990   unsigned long i;
7991
7992   if (h->root.type != bfd_link_hash_defined
7993       && h->root.type != bfd_link_hash_defweak)
7994     return TRUE;
7995
7996   eh = (struct ppc_link_hash_entry *) h;
7997   if (eh->adjust_done)
7998     return TRUE;
7999
8000   if (eh->elf.root.u.def.section == toc_inf->toc)
8001     {
8002       if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8003         i = toc_inf->toc->rawsize >> 3;
8004       else
8005         i = eh->elf.root.u.def.value >> 3;
8006
8007       if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8008         {
8009           (*_bfd_error_handler)
8010             (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8011           do
8012             ++i;
8013           while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8014           eh->elf.root.u.def.value = (bfd_vma) i << 3;
8015         }
8016
8017       eh->elf.root.u.def.value -= toc_inf->skip[i];
8018       eh->adjust_done = 1;
8019     }
8020   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8021     toc_inf->global_toc_syms = TRUE;
8022
8023   return TRUE;
8024 }
8025
8026 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc.  */
8027
8028 static bfd_boolean
8029 ok_lo_toc_insn (unsigned int insn)
8030 {
8031   return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8032           || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8033           || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8034           || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8035           || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8036           || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8037           || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8038           || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8039           || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8040           || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8041           || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8042           || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8043           || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8044           || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8045           || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8046               && (insn & 3) != 1)
8047           || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8048               && ((insn & 3) == 0 || (insn & 3) == 3))
8049           || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8050 }
8051
8052 /* Examine all relocs referencing .toc sections in order to remove
8053    unused .toc entries.  */
8054
8055 bfd_boolean
8056 ppc64_elf_edit_toc (struct bfd_link_info *info)
8057 {
8058   bfd *ibfd;
8059   struct adjust_toc_info toc_inf;
8060   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8061
8062   htab->do_toc_opt = 1;
8063   toc_inf.global_toc_syms = TRUE;
8064   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8065     {
8066       asection *toc, *sec;
8067       Elf_Internal_Shdr *symtab_hdr;
8068       Elf_Internal_Sym *local_syms;
8069       Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8070       unsigned long *skip, *drop;
8071       unsigned char *used;
8072       unsigned char *keep, last, some_unused;
8073
8074       if (!is_ppc64_elf (ibfd))
8075         continue;
8076
8077       toc = bfd_get_section_by_name (ibfd, ".toc");
8078       if (toc == NULL
8079           || toc->size == 0
8080           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
8081           || elf_discarded_section (toc))
8082         continue;
8083
8084       toc_relocs = NULL;
8085       local_syms = NULL;
8086       symtab_hdr = &elf_symtab_hdr (ibfd);
8087
8088       /* Look at sections dropped from the final link.  */
8089       skip = NULL;
8090       relstart = NULL;
8091       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8092         {
8093           if (sec->reloc_count == 0
8094               || !elf_discarded_section (sec)
8095               || get_opd_info (sec)
8096               || (sec->flags & SEC_ALLOC) == 0
8097               || (sec->flags & SEC_DEBUGGING) != 0)
8098             continue;
8099
8100           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8101           if (relstart == NULL)
8102             goto error_ret;
8103
8104           /* Run through the relocs to see which toc entries might be
8105              unused.  */
8106           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8107             {
8108               enum elf_ppc64_reloc_type r_type;
8109               unsigned long r_symndx;
8110               asection *sym_sec;
8111               struct elf_link_hash_entry *h;
8112               Elf_Internal_Sym *sym;
8113               bfd_vma val;
8114
8115               r_type = ELF64_R_TYPE (rel->r_info);
8116               switch (r_type)
8117                 {
8118                 default:
8119                   continue;
8120
8121                 case R_PPC64_TOC16:
8122                 case R_PPC64_TOC16_LO:
8123                 case R_PPC64_TOC16_HI:
8124                 case R_PPC64_TOC16_HA:
8125                 case R_PPC64_TOC16_DS:
8126                 case R_PPC64_TOC16_LO_DS:
8127                   break;
8128                 }
8129
8130               r_symndx = ELF64_R_SYM (rel->r_info);
8131               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8132                               r_symndx, ibfd))
8133                 goto error_ret;
8134
8135               if (sym_sec != toc)
8136                 continue;
8137
8138               if (h != NULL)
8139                 val = h->root.u.def.value;
8140               else
8141                 val = sym->st_value;
8142               val += rel->r_addend;
8143
8144               if (val >= toc->size)
8145                 continue;
8146
8147               /* Anything in the toc ought to be aligned to 8 bytes.
8148                  If not, don't mark as unused.  */
8149               if (val & 7)
8150                 continue;
8151
8152               if (skip == NULL)
8153                 {
8154                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8155                   if (skip == NULL)
8156                     goto error_ret;
8157                 }
8158
8159               skip[val >> 3] = ref_from_discarded;
8160             }
8161
8162           if (elf_section_data (sec)->relocs != relstart)
8163             free (relstart);
8164         }
8165
8166       /* For largetoc loads of address constants, we can convert
8167          .  addis rx,2,addr@got@ha
8168          .  ld ry,addr@got@l(rx)
8169          to
8170          .  addis rx,2,addr@toc@ha
8171          .  addi ry,rx,addr@toc@l
8172          when addr is within 2G of the toc pointer.  This then means
8173          that the word storing "addr" in the toc is no longer needed.  */
8174
8175       if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8176           && toc->output_section->rawsize < (bfd_vma) 1 << 31
8177           && toc->reloc_count != 0)
8178         {
8179           /* Read toc relocs.  */
8180           toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8181                                                   info->keep_memory);
8182           if (toc_relocs == NULL)
8183             goto error_ret;
8184
8185           for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8186             {
8187               enum elf_ppc64_reloc_type r_type;
8188               unsigned long r_symndx;
8189               asection *sym_sec;
8190               struct elf_link_hash_entry *h;
8191               Elf_Internal_Sym *sym;
8192               bfd_vma val, addr;
8193
8194               r_type = ELF64_R_TYPE (rel->r_info);
8195               if (r_type != R_PPC64_ADDR64)
8196                 continue;
8197
8198               r_symndx = ELF64_R_SYM (rel->r_info);
8199               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8200                               r_symndx, ibfd))
8201                 goto error_ret;
8202
8203               if (sym_sec == NULL
8204                   || elf_discarded_section (sym_sec))
8205                 continue;
8206
8207               if (!SYMBOL_CALLS_LOCAL (info, h))
8208                 continue;
8209
8210               if (h != NULL)
8211                 {
8212                   if (h->type == STT_GNU_IFUNC)
8213                     continue;
8214                   val = h->root.u.def.value;
8215                 }
8216               else
8217                 {
8218                   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8219                     continue;
8220                   val = sym->st_value;
8221                 }
8222               val += rel->r_addend;
8223               val += sym_sec->output_section->vma + sym_sec->output_offset;
8224
8225               /* We don't yet know the exact toc pointer value, but we
8226                  know it will be somewhere in the toc section.  Don't
8227                  optimize if the difference from any possible toc
8228                  pointer is outside [ff..f80008000, 7fff7fff].  */
8229               addr = toc->output_section->vma + TOC_BASE_OFF;
8230               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8231                 continue;
8232
8233               addr = toc->output_section->vma + toc->output_section->rawsize;
8234               if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8235                 continue;
8236
8237               if (skip == NULL)
8238                 {
8239                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8240                   if (skip == NULL)
8241                     goto error_ret;
8242                 }
8243
8244               skip[rel->r_offset >> 3]
8245                 |= can_optimize | ((rel - toc_relocs) << 2);
8246             }
8247         }
8248
8249       if (skip == NULL)
8250         continue;
8251
8252       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8253       if (used == NULL)
8254         {
8255         error_ret:
8256           if (local_syms != NULL
8257               && symtab_hdr->contents != (unsigned char *) local_syms)
8258             free (local_syms);
8259           if (sec != NULL
8260               && relstart != NULL
8261               && elf_section_data (sec)->relocs != relstart)
8262             free (relstart);
8263           if (toc_relocs != NULL
8264               && elf_section_data (toc)->relocs != toc_relocs)
8265             free (toc_relocs);
8266           if (skip != NULL)
8267             free (skip);
8268           return FALSE;
8269         }
8270
8271       /* Now check all kept sections that might reference the toc.
8272          Check the toc itself last.  */
8273       for (sec = (ibfd->sections == toc && toc->next ? toc->next
8274                   : ibfd->sections);
8275            sec != NULL;
8276            sec = (sec == toc ? NULL
8277                   : sec->next == NULL ? toc
8278                   : sec->next == toc && toc->next ? toc->next
8279                   : sec->next))
8280         {
8281           int repeat;
8282
8283           if (sec->reloc_count == 0
8284               || elf_discarded_section (sec)
8285               || get_opd_info (sec)
8286               || (sec->flags & SEC_ALLOC) == 0
8287               || (sec->flags & SEC_DEBUGGING) != 0)
8288             continue;
8289
8290           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8291                                                 info->keep_memory);
8292           if (relstart == NULL)
8293             goto error_ret;
8294
8295           /* Mark toc entries referenced as used.  */
8296           repeat = 0;
8297           do
8298             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8299               {
8300                 enum elf_ppc64_reloc_type r_type;
8301                 unsigned long r_symndx;
8302                 asection *sym_sec;
8303                 struct elf_link_hash_entry *h;
8304                 Elf_Internal_Sym *sym;
8305                 bfd_vma val;
8306                 enum {no_check, check_lo, check_ha} insn_check;
8307
8308                 r_type = ELF64_R_TYPE (rel->r_info);
8309                 switch (r_type)
8310                   {
8311                   default:
8312                     insn_check = no_check;
8313                     break;
8314
8315                   case R_PPC64_GOT_TLSLD16_HA:
8316                   case R_PPC64_GOT_TLSGD16_HA:
8317                   case R_PPC64_GOT_TPREL16_HA:
8318                   case R_PPC64_GOT_DTPREL16_HA:
8319                   case R_PPC64_GOT16_HA:
8320                   case R_PPC64_TOC16_HA:
8321                     insn_check = check_ha;
8322                     break;
8323
8324                   case R_PPC64_GOT_TLSLD16_LO:
8325                   case R_PPC64_GOT_TLSGD16_LO:
8326                   case R_PPC64_GOT_TPREL16_LO_DS:
8327                   case R_PPC64_GOT_DTPREL16_LO_DS:
8328                   case R_PPC64_GOT16_LO:
8329                   case R_PPC64_GOT16_LO_DS:
8330                   case R_PPC64_TOC16_LO:
8331                   case R_PPC64_TOC16_LO_DS:
8332                     insn_check = check_lo;
8333                     break;
8334                   }
8335
8336                 if (insn_check != no_check)
8337                   {
8338                     bfd_vma off = rel->r_offset & ~3;
8339                     unsigned char buf[4];
8340                     unsigned int insn;
8341
8342                     if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8343                       {
8344                         free (used);
8345                         goto error_ret;
8346                       }
8347                     insn = bfd_get_32 (ibfd, buf);
8348                     if (insn_check == check_lo
8349                         ? !ok_lo_toc_insn (insn)
8350                         : ((insn & ((0x3f << 26) | 0x1f << 16))
8351                            != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8352                       {
8353                         char str[12];
8354
8355                         ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8356                         sprintf (str, "%#08x", insn);
8357                         info->callbacks->einfo
8358                           (_("%P: %H: toc optimization is not supported for"
8359                              " %s instruction.\n"),
8360                            ibfd, sec, rel->r_offset & ~3, str);
8361                       }
8362                   }
8363
8364                 switch (r_type)
8365                   {
8366                   case R_PPC64_TOC16:
8367                   case R_PPC64_TOC16_LO:
8368                   case R_PPC64_TOC16_HI:
8369                   case R_PPC64_TOC16_HA:
8370                   case R_PPC64_TOC16_DS:
8371                   case R_PPC64_TOC16_LO_DS:
8372                     /* In case we're taking addresses of toc entries.  */
8373                   case R_PPC64_ADDR64:
8374                     break;
8375
8376                   default:
8377                     continue;
8378                   }
8379
8380                 r_symndx = ELF64_R_SYM (rel->r_info);
8381                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8382                                 r_symndx, ibfd))
8383                   {
8384                     free (used);
8385                     goto error_ret;
8386                   }
8387
8388                 if (sym_sec != toc)
8389                   continue;
8390
8391                 if (h != NULL)
8392                   val = h->root.u.def.value;
8393                 else
8394                   val = sym->st_value;
8395                 val += rel->r_addend;
8396
8397                 if (val >= toc->size)
8398                   continue;
8399
8400                 if ((skip[val >> 3] & can_optimize) != 0)
8401                   {
8402                     bfd_vma off;
8403                     unsigned char opc;
8404
8405                     switch (r_type)
8406                       {
8407                       case R_PPC64_TOC16_HA:
8408                         break;
8409
8410                       case R_PPC64_TOC16_LO_DS:
8411                         off = rel->r_offset + (bfd_big_endian (ibfd) ? -2 : 3);
8412                         if (!bfd_get_section_contents (ibfd, sec, &opc, off, 1))
8413                           {
8414                             free (used);
8415                             goto error_ret;
8416                           }
8417                         if ((opc & (0x3f << 2)) == (58u << 2))
8418                           break;
8419                         /* Fall thru */
8420
8421                       default:
8422                         /* Wrong sort of reloc, or not a ld.  We may
8423                            as well clear ref_from_discarded too.  */
8424                         skip[val >> 3] = 0;
8425                       }
8426                   }
8427
8428                 /* For the toc section, we only mark as used if
8429                    this entry itself isn't unused.  */
8430                 if (sec == toc
8431                     && !used[val >> 3]
8432                     && (used[rel->r_offset >> 3]
8433                         || !(skip[rel->r_offset >> 3] & ref_from_discarded)))
8434                   /* Do all the relocs again, to catch reference
8435                      chains.  */
8436                   repeat = 1;
8437
8438                 used[val >> 3] = 1;
8439               }
8440           while (repeat);
8441
8442           if (elf_section_data (sec)->relocs != relstart)
8443             free (relstart);
8444         }
8445
8446       /* Merge the used and skip arrays.  Assume that TOC
8447          doublewords not appearing as either used or unused belong
8448          to to an entry more than one doubleword in size.  */
8449       for (drop = skip, keep = used, last = 0, some_unused = 0;
8450            drop < skip + (toc->size + 7) / 8;
8451            ++drop, ++keep)
8452         {
8453           if (*keep)
8454             {
8455               *drop &= ~ref_from_discarded;
8456               if ((*drop & can_optimize) != 0)
8457                 some_unused = 1;
8458               last = 0;
8459             }
8460           else if ((*drop & ref_from_discarded) != 0)
8461             {
8462               some_unused = 1;
8463               last = ref_from_discarded;
8464             }
8465           else
8466             *drop = last;
8467         }
8468
8469       free (used);
8470
8471       if (some_unused)
8472         {
8473           bfd_byte *contents, *src;
8474           unsigned long off;
8475           Elf_Internal_Sym *sym;
8476           bfd_boolean local_toc_syms = FALSE;
8477
8478           /* Shuffle the toc contents, and at the same time convert the
8479              skip array from booleans into offsets.  */
8480           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8481             goto error_ret;
8482
8483           elf_section_data (toc)->this_hdr.contents = contents;
8484
8485           for (src = contents, off = 0, drop = skip;
8486                src < contents + toc->size;
8487                src += 8, ++drop)
8488             {
8489               if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8490                 off += 8;
8491               else if (off != 0)
8492                 {
8493                   *drop = off;
8494                   memcpy (src - off, src, 8);
8495                 }
8496             }
8497           *drop = off;
8498           toc->rawsize = toc->size;
8499           toc->size = src - contents - off;
8500
8501           /* Adjust addends for relocs against the toc section sym,
8502              and optimize any accesses we can.  */
8503           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8504             {
8505               if (sec->reloc_count == 0
8506                   || elf_discarded_section (sec))
8507                 continue;
8508
8509               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8510                                                     info->keep_memory);
8511               if (relstart == NULL)
8512                 goto error_ret;
8513
8514               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8515                 {
8516                   enum elf_ppc64_reloc_type r_type;
8517                   unsigned long r_symndx;
8518                   asection *sym_sec;
8519                   struct elf_link_hash_entry *h;
8520                   bfd_vma val;
8521
8522                   r_type = ELF64_R_TYPE (rel->r_info);
8523                   switch (r_type)
8524                     {
8525                     default:
8526                       continue;
8527
8528                     case R_PPC64_TOC16:
8529                     case R_PPC64_TOC16_LO:
8530                     case R_PPC64_TOC16_HI:
8531                     case R_PPC64_TOC16_HA:
8532                     case R_PPC64_TOC16_DS:
8533                     case R_PPC64_TOC16_LO_DS:
8534                     case R_PPC64_ADDR64:
8535                       break;
8536                     }
8537
8538                   r_symndx = ELF64_R_SYM (rel->r_info);
8539                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8540                                   r_symndx, ibfd))
8541                     goto error_ret;
8542
8543                   if (sym_sec != toc)
8544                     continue;
8545
8546                   if (h != NULL)
8547                     val = h->root.u.def.value;
8548                   else
8549                     {
8550                       val = sym->st_value;
8551                       if (val != 0)
8552                         local_toc_syms = TRUE;
8553                     }
8554
8555                   val += rel->r_addend;
8556
8557                   if (val > toc->rawsize)
8558                     val = toc->rawsize;
8559                   else if ((skip[val >> 3] & ref_from_discarded) != 0)
8560                     continue;
8561                   else if ((skip[val >> 3] & can_optimize) != 0)
8562                     {
8563                       Elf_Internal_Rela *tocrel
8564                         = toc_relocs + (skip[val >> 3] >> 2);
8565                       unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8566
8567                       switch (r_type)
8568                         {
8569                         case R_PPC64_TOC16_HA:
8570                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8571                           break;
8572
8573                         case R_PPC64_TOC16_LO_DS:
8574                           rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8575                           break;
8576
8577                         default:
8578                           if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8579                             ppc_howto_init ();
8580                           info->callbacks->einfo
8581                             (_("%P: %H: %s relocation references "
8582                                "optimized away TOC entry\n"),
8583                              ibfd, sec, rel->r_offset,
8584                              ppc64_elf_howto_table[r_type]->name);
8585                           bfd_set_error (bfd_error_bad_value);
8586                           goto error_ret;
8587                         }
8588                       rel->r_addend = tocrel->r_addend;
8589                       elf_section_data (sec)->relocs = relstart;
8590                       continue;
8591                     }
8592
8593                   if (h != NULL || sym->st_value != 0)
8594                     continue;
8595
8596                   rel->r_addend -= skip[val >> 3];
8597                   elf_section_data (sec)->relocs = relstart;
8598                 }
8599
8600               if (elf_section_data (sec)->relocs != relstart)
8601                 free (relstart);
8602             }
8603
8604           /* We shouldn't have local or global symbols defined in the TOC,
8605              but handle them anyway.  */
8606           if (local_syms != NULL)
8607             for (sym = local_syms;
8608                  sym < local_syms + symtab_hdr->sh_info;
8609                  ++sym)
8610               if (sym->st_value != 0
8611                   && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8612                 {
8613                   unsigned long i;
8614
8615                   if (sym->st_value > toc->rawsize)
8616                     i = toc->rawsize >> 3;
8617                   else
8618                     i = sym->st_value >> 3;
8619
8620                   if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8621                     {
8622                       if (local_toc_syms)
8623                         (*_bfd_error_handler)
8624                           (_("%s defined on removed toc entry"),
8625                            bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8626                       do
8627                         ++i;
8628                       while ((skip[i] & (ref_from_discarded | can_optimize)));
8629                       sym->st_value = (bfd_vma) i << 3;
8630                     }
8631
8632                   sym->st_value -= skip[i];
8633                   symtab_hdr->contents = (unsigned char *) local_syms;
8634                 }
8635
8636           /* Adjust any global syms defined in this toc input section.  */
8637           if (toc_inf.global_toc_syms)
8638             {
8639               toc_inf.toc = toc;
8640               toc_inf.skip = skip;
8641               toc_inf.global_toc_syms = FALSE;
8642               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8643                                       &toc_inf);
8644             }
8645
8646           if (toc->reloc_count != 0)
8647             {
8648               Elf_Internal_Shdr *rel_hdr;
8649               Elf_Internal_Rela *wrel;
8650               bfd_size_type sz;
8651
8652               /* Remove unused toc relocs, and adjust those we keep.  */
8653               if (toc_relocs == NULL)
8654                 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8655                                                         info->keep_memory);
8656               if (toc_relocs == NULL)
8657                 goto error_ret;
8658
8659               wrel = toc_relocs;
8660               for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8661                 if ((skip[rel->r_offset >> 3]
8662                      & (ref_from_discarded | can_optimize)) == 0)
8663                   {
8664                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8665                     wrel->r_info = rel->r_info;
8666                     wrel->r_addend = rel->r_addend;
8667                     ++wrel;
8668                   }
8669                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8670                                             &local_syms, NULL, NULL))
8671                   goto error_ret;
8672
8673               elf_section_data (toc)->relocs = toc_relocs;
8674               toc->reloc_count = wrel - toc_relocs;
8675               rel_hdr = _bfd_elf_single_rel_hdr (toc);
8676               sz = rel_hdr->sh_entsize;
8677               rel_hdr->sh_size = toc->reloc_count * sz;
8678             }
8679         }
8680       else if (toc_relocs != NULL
8681                && elf_section_data (toc)->relocs != toc_relocs)
8682         free (toc_relocs);
8683
8684       if (local_syms != NULL
8685           && symtab_hdr->contents != (unsigned char *) local_syms)
8686         {
8687           if (!info->keep_memory)
8688             free (local_syms);
8689           else
8690             symtab_hdr->contents = (unsigned char *) local_syms;
8691         }
8692       free (skip);
8693     }
8694
8695   return TRUE;
8696 }
8697
8698 /* Return true iff input section I references the TOC using
8699    instructions limited to +/-32k offsets.  */
8700
8701 bfd_boolean
8702 ppc64_elf_has_small_toc_reloc (asection *i)
8703 {
8704   return (is_ppc64_elf (i->owner)
8705           && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8706 }
8707
8708 /* Allocate space for one GOT entry.  */
8709
8710 static void
8711 allocate_got (struct elf_link_hash_entry *h,
8712               struct bfd_link_info *info,
8713               struct got_entry *gent)
8714 {
8715   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8716   bfd_boolean dyn;
8717   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8718   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8719                  ? 16 : 8);
8720   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8721                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8722   asection *got = ppc64_elf_tdata (gent->owner)->got;
8723
8724   gent->got.offset = got->size;
8725   got->size += entsize;
8726
8727   dyn = htab->elf.dynamic_sections_created;
8728   if ((info->shared
8729        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8730             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8731                 || h->root.type != bfd_link_hash_undefweak))
8732     {
8733       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8734       relgot->size += rentsize;
8735     }
8736   else if (h->type == STT_GNU_IFUNC)
8737     {
8738       asection *relgot = htab->reliplt;
8739       relgot->size += rentsize;
8740       htab->got_reli_size += rentsize;
8741     }
8742 }
8743
8744 /* This function merges got entries in the same toc group.  */
8745
8746 static void
8747 merge_got_entries (struct got_entry **pent)
8748 {
8749   struct got_entry *ent, *ent2;
8750
8751   for (ent = *pent; ent != NULL; ent = ent->next)
8752     if (!ent->is_indirect)
8753       for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8754         if (!ent2->is_indirect
8755             && ent2->addend == ent->addend
8756             && ent2->tls_type == ent->tls_type
8757             && elf_gp (ent2->owner) == elf_gp (ent->owner))
8758           {
8759             ent2->is_indirect = TRUE;
8760             ent2->got.ent = ent;
8761           }
8762 }
8763
8764 /* Allocate space in .plt, .got and associated reloc sections for
8765    dynamic relocs.  */
8766
8767 static bfd_boolean
8768 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8769 {
8770   struct bfd_link_info *info;
8771   struct ppc_link_hash_table *htab;
8772   asection *s;
8773   struct ppc_link_hash_entry *eh;
8774   struct elf_dyn_relocs *p;
8775   struct got_entry **pgent, *gent;
8776
8777   if (h->root.type == bfd_link_hash_indirect)
8778     return TRUE;
8779
8780   info = (struct bfd_link_info *) inf;
8781   htab = ppc_hash_table (info);
8782   if (htab == NULL)
8783     return FALSE;
8784
8785   if ((htab->elf.dynamic_sections_created
8786        && h->dynindx != -1
8787        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8788       || h->type == STT_GNU_IFUNC)
8789     {
8790       struct plt_entry *pent;
8791       bfd_boolean doneone = FALSE;
8792       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8793         if (pent->plt.refcount > 0)
8794           {
8795             if (!htab->elf.dynamic_sections_created
8796                 || h->dynindx == -1)
8797               {
8798                 s = htab->iplt;
8799                 pent->plt.offset = s->size;
8800                 s->size += PLT_ENTRY_SIZE;
8801                 s = htab->reliplt;
8802               }
8803             else
8804               {
8805                 /* If this is the first .plt entry, make room for the special
8806                    first entry.  */
8807                 s = htab->plt;
8808                 if (s->size == 0)
8809                   s->size += PLT_INITIAL_ENTRY_SIZE;
8810
8811                 pent->plt.offset = s->size;
8812
8813                 /* Make room for this entry.  */
8814                 s->size += PLT_ENTRY_SIZE;
8815
8816                 /* Make room for the .glink code.  */
8817                 s = htab->glink;
8818                 if (s->size == 0)
8819                   s->size += GLINK_CALL_STUB_SIZE;
8820                 /* We need bigger stubs past index 32767.  */
8821                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8822                   s->size += 4;
8823                 s->size += 2*4;
8824
8825                 /* We also need to make an entry in the .rela.plt section.  */
8826                 s = htab->relplt;
8827               }
8828             s->size += sizeof (Elf64_External_Rela);
8829             doneone = TRUE;
8830           }
8831         else
8832           pent->plt.offset = (bfd_vma) -1;
8833       if (!doneone)
8834         {
8835           h->plt.plist = NULL;
8836           h->needs_plt = 0;
8837         }
8838     }
8839   else
8840     {
8841       h->plt.plist = NULL;
8842       h->needs_plt = 0;
8843     }
8844
8845   eh = (struct ppc_link_hash_entry *) h;
8846   /* Run through the TLS GD got entries first if we're changing them
8847      to TPREL.  */
8848   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8849     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8850       if (gent->got.refcount > 0
8851           && (gent->tls_type & TLS_GD) != 0)
8852         {
8853           /* This was a GD entry that has been converted to TPREL.  If
8854              there happens to be a TPREL entry we can use that one.  */
8855           struct got_entry *ent;
8856           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8857             if (ent->got.refcount > 0
8858                 && (ent->tls_type & TLS_TPREL) != 0
8859                 && ent->addend == gent->addend
8860                 && ent->owner == gent->owner)
8861               {
8862                 gent->got.refcount = 0;
8863                 break;
8864               }
8865
8866           /* If not, then we'll be using our own TPREL entry.  */
8867           if (gent->got.refcount != 0)
8868             gent->tls_type = TLS_TLS | TLS_TPREL;
8869         }
8870
8871   /* Remove any list entry that won't generate a word in the GOT before
8872      we call merge_got_entries.  Otherwise we risk merging to empty
8873      entries.  */
8874   pgent = &h->got.glist;
8875   while ((gent = *pgent) != NULL)
8876     if (gent->got.refcount > 0)
8877       {
8878         if ((gent->tls_type & TLS_LD) != 0
8879             && !h->def_dynamic)
8880           {
8881             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8882             *pgent = gent->next;
8883           }
8884         else
8885           pgent = &gent->next;
8886       }
8887     else
8888       *pgent = gent->next;
8889
8890   if (!htab->do_multi_toc)
8891     merge_got_entries (&h->got.glist);
8892
8893   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8894     if (!gent->is_indirect)
8895       {
8896         /* Make sure this symbol is output as a dynamic symbol.
8897            Undefined weak syms won't yet be marked as dynamic,
8898            nor will all TLS symbols.  */
8899         if (h->dynindx == -1
8900             && !h->forced_local
8901             && h->type != STT_GNU_IFUNC
8902             && htab->elf.dynamic_sections_created)
8903           {
8904             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8905               return FALSE;
8906           }
8907
8908         if (!is_ppc64_elf (gent->owner))
8909           abort ();
8910
8911         allocate_got (h, info, gent);
8912       }
8913
8914   if (eh->dyn_relocs == NULL
8915       || (!htab->elf.dynamic_sections_created
8916           && h->type != STT_GNU_IFUNC))
8917     return TRUE;
8918
8919   /* In the shared -Bsymbolic case, discard space allocated for
8920      dynamic pc-relative relocs against symbols which turn out to be
8921      defined in regular objects.  For the normal shared case, discard
8922      space for relocs that have become local due to symbol visibility
8923      changes.  */
8924
8925   if (info->shared)
8926     {
8927       /* Relocs that use pc_count are those that appear on a call insn,
8928          or certain REL relocs (see must_be_dyn_reloc) that can be
8929          generated via assembly.  We want calls to protected symbols to
8930          resolve directly to the function rather than going via the plt.
8931          If people want function pointer comparisons to work as expected
8932          then they should avoid writing weird assembly.  */
8933       if (SYMBOL_CALLS_LOCAL (info, h))
8934         {
8935           struct elf_dyn_relocs **pp;
8936
8937           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8938             {
8939               p->count -= p->pc_count;
8940               p->pc_count = 0;
8941               if (p->count == 0)
8942                 *pp = p->next;
8943               else
8944                 pp = &p->next;
8945             }
8946         }
8947
8948       /* Also discard relocs on undefined weak syms with non-default
8949          visibility.  */
8950       if (eh->dyn_relocs != NULL
8951           && h->root.type == bfd_link_hash_undefweak)
8952         {
8953           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8954             eh->dyn_relocs = NULL;
8955
8956           /* Make sure this symbol is output as a dynamic symbol.
8957              Undefined weak syms won't yet be marked as dynamic.  */
8958           else if (h->dynindx == -1
8959                    && !h->forced_local)
8960             {
8961               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8962                 return FALSE;
8963             }
8964         }
8965     }
8966   else if (h->type == STT_GNU_IFUNC)
8967     {
8968       if (!h->non_got_ref)
8969         eh->dyn_relocs = NULL;
8970     }
8971   else if (ELIMINATE_COPY_RELOCS)
8972     {
8973       /* For the non-shared case, discard space for relocs against
8974          symbols which turn out to need copy relocs or are not
8975          dynamic.  */
8976
8977       if (!h->non_got_ref
8978           && !h->def_regular)
8979         {
8980           /* Make sure this symbol is output as a dynamic symbol.
8981              Undefined weak syms won't yet be marked as dynamic.  */
8982           if (h->dynindx == -1
8983               && !h->forced_local)
8984             {
8985               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8986                 return FALSE;
8987             }
8988
8989           /* If that succeeded, we know we'll be keeping all the
8990              relocs.  */
8991           if (h->dynindx != -1)
8992             goto keep;
8993         }
8994
8995       eh->dyn_relocs = NULL;
8996
8997     keep: ;
8998     }
8999
9000   /* Finally, allocate space.  */
9001   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9002     {
9003       asection *sreloc = elf_section_data (p->sec)->sreloc;
9004       if (!htab->elf.dynamic_sections_created)
9005         sreloc = htab->reliplt;
9006       sreloc->size += p->count * sizeof (Elf64_External_Rela);
9007     }
9008
9009   return TRUE;
9010 }
9011
9012 /* Find any dynamic relocs that apply to read-only sections.  */
9013
9014 static bfd_boolean
9015 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9016 {
9017   struct ppc_link_hash_entry *eh;
9018   struct elf_dyn_relocs *p;
9019
9020   eh = (struct ppc_link_hash_entry *) h;
9021   for (p = eh->dyn_relocs; p != NULL; p = p->next)
9022     {
9023       asection *s = p->sec->output_section;
9024
9025       if (s != NULL && (s->flags & SEC_READONLY) != 0)
9026         {
9027           struct bfd_link_info *info = inf;
9028
9029           info->flags |= DF_TEXTREL;
9030
9031           /* Not an error, just cut short the traversal.  */
9032           return FALSE;
9033         }
9034     }
9035   return TRUE;
9036 }
9037
9038 /* Set the sizes of the dynamic sections.  */
9039
9040 static bfd_boolean
9041 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9042                                  struct bfd_link_info *info)
9043 {
9044   struct ppc_link_hash_table *htab;
9045   bfd *dynobj;
9046   asection *s;
9047   bfd_boolean relocs;
9048   bfd *ibfd;
9049   struct got_entry *first_tlsld;
9050
9051   htab = ppc_hash_table (info);
9052   if (htab == NULL)
9053     return FALSE;
9054
9055   dynobj = htab->elf.dynobj;
9056   if (dynobj == NULL)
9057     abort ();
9058
9059   if (htab->elf.dynamic_sections_created)
9060     {
9061       /* Set the contents of the .interp section to the interpreter.  */
9062       if (info->executable)
9063         {
9064           s = bfd_get_section_by_name (dynobj, ".interp");
9065           if (s == NULL)
9066             abort ();
9067           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9068           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9069         }
9070     }
9071
9072   /* Set up .got offsets for local syms, and space for local dynamic
9073      relocs.  */
9074   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9075     {
9076       struct got_entry **lgot_ents;
9077       struct got_entry **end_lgot_ents;
9078       struct plt_entry **local_plt;
9079       struct plt_entry **end_local_plt;
9080       unsigned char *lgot_masks;
9081       bfd_size_type locsymcount;
9082       Elf_Internal_Shdr *symtab_hdr;
9083       asection *srel;
9084
9085       if (!is_ppc64_elf (ibfd))
9086         continue;
9087
9088       for (s = ibfd->sections; s != NULL; s = s->next)
9089         {
9090           struct elf_dyn_relocs *p;
9091
9092           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9093             {
9094               if (!bfd_is_abs_section (p->sec)
9095                   && bfd_is_abs_section (p->sec->output_section))
9096                 {
9097                   /* Input section has been discarded, either because
9098                      it is a copy of a linkonce section or due to
9099                      linker script /DISCARD/, so we'll be discarding
9100                      the relocs too.  */
9101                 }
9102               else if (p->count != 0)
9103                 {
9104                   srel = elf_section_data (p->sec)->sreloc;
9105                   if (!htab->elf.dynamic_sections_created)
9106                     srel = htab->reliplt;
9107                   srel->size += p->count * sizeof (Elf64_External_Rela);
9108                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9109                     info->flags |= DF_TEXTREL;
9110                 }
9111             }
9112         }
9113
9114       lgot_ents = elf_local_got_ents (ibfd);
9115       if (!lgot_ents)
9116         continue;
9117
9118       symtab_hdr = &elf_symtab_hdr (ibfd);
9119       locsymcount = symtab_hdr->sh_info;
9120       end_lgot_ents = lgot_ents + locsymcount;
9121       local_plt = (struct plt_entry **) end_lgot_ents;
9122       end_local_plt = local_plt + locsymcount;
9123       lgot_masks = (unsigned char *) end_local_plt;
9124       s = ppc64_elf_tdata (ibfd)->got;
9125       srel = ppc64_elf_tdata (ibfd)->relgot;
9126       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9127         {
9128           struct got_entry **pent, *ent;
9129
9130           pent = lgot_ents;
9131           while ((ent = *pent) != NULL)
9132             if (ent->got.refcount > 0)
9133               {
9134                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9135                   {
9136                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
9137                     *pent = ent->next;
9138                   }
9139                 else
9140                   {
9141                     unsigned int num = 1;
9142                     ent->got.offset = s->size;
9143                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9144                       num = 2;
9145                     s->size += num * 8;
9146                     if (info->shared)
9147                       srel->size += num * sizeof (Elf64_External_Rela);
9148                     else if ((*lgot_masks & PLT_IFUNC) != 0)
9149                       {
9150                         htab->reliplt->size
9151                           += num * sizeof (Elf64_External_Rela);
9152                         htab->got_reli_size
9153                           += num * sizeof (Elf64_External_Rela);
9154                       }
9155                     pent = &ent->next;
9156                   }
9157               }
9158             else
9159               *pent = ent->next;
9160         }
9161
9162       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
9163       for (; local_plt < end_local_plt; ++local_plt)
9164         {
9165           struct plt_entry *ent;
9166
9167           for (ent = *local_plt; ent != NULL; ent = ent->next)
9168             if (ent->plt.refcount > 0)
9169               {
9170                 s = htab->iplt;
9171                 ent->plt.offset = s->size;
9172                 s->size += PLT_ENTRY_SIZE;
9173
9174                 htab->reliplt->size += sizeof (Elf64_External_Rela);
9175               }
9176             else
9177               ent->plt.offset = (bfd_vma) -1;
9178         }
9179     }
9180
9181   /* Allocate global sym .plt and .got entries, and space for global
9182      sym dynamic relocs.  */
9183   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9184
9185   first_tlsld = NULL;
9186   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9187     {
9188       struct got_entry *ent;
9189
9190       if (!is_ppc64_elf (ibfd))
9191         continue;
9192
9193       ent = ppc64_tlsld_got (ibfd);
9194       if (ent->got.refcount > 0)
9195         {
9196           if (!htab->do_multi_toc && first_tlsld != NULL)
9197             {
9198               ent->is_indirect = TRUE;
9199               ent->got.ent = first_tlsld;
9200             }
9201           else
9202             {
9203               if (first_tlsld == NULL)
9204                 first_tlsld = ent;
9205               s = ppc64_elf_tdata (ibfd)->got;
9206               ent->got.offset = s->size;
9207               ent->owner = ibfd;
9208               s->size += 16;
9209               if (info->shared)
9210                 {
9211                   asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9212                   srel->size += sizeof (Elf64_External_Rela);
9213                 }
9214             }
9215         }
9216       else
9217         ent->got.offset = (bfd_vma) -1;
9218     }
9219
9220   /* We now have determined the sizes of the various dynamic sections.
9221      Allocate memory for them.  */
9222   relocs = FALSE;
9223   for (s = dynobj->sections; s != NULL; s = s->next)
9224     {
9225       if ((s->flags & SEC_LINKER_CREATED) == 0)
9226         continue;
9227
9228       if (s == htab->brlt || s == htab->relbrlt)
9229         /* These haven't been allocated yet;  don't strip.  */
9230         continue;
9231       else if (s == htab->got
9232                || s == htab->plt
9233                || s == htab->iplt
9234                || s == htab->glink
9235                || s == htab->dynbss)
9236         {
9237           /* Strip this section if we don't need it; see the
9238              comment below.  */
9239         }
9240       else if (s == htab->glink_eh_frame)
9241         {
9242           if (!bfd_is_abs_section (s->output_section))
9243             /* Not sized yet.  */
9244             continue;
9245         }
9246       else if (CONST_STRNEQ (s->name, ".rela"))
9247         {
9248           if (s->size != 0)
9249             {
9250               if (s != htab->relplt)
9251                 relocs = TRUE;
9252
9253               /* We use the reloc_count field as a counter if we need
9254                  to copy relocs into the output file.  */
9255               s->reloc_count = 0;
9256             }
9257         }
9258       else
9259         {
9260           /* It's not one of our sections, so don't allocate space.  */
9261           continue;
9262         }
9263
9264       if (s->size == 0)
9265         {
9266           /* If we don't need this section, strip it from the
9267              output file.  This is mostly to handle .rela.bss and
9268              .rela.plt.  We must create both sections in
9269              create_dynamic_sections, because they must be created
9270              before the linker maps input sections to output
9271              sections.  The linker does that before
9272              adjust_dynamic_symbol is called, and it is that
9273              function which decides whether anything needs to go
9274              into these sections.  */
9275           s->flags |= SEC_EXCLUDE;
9276           continue;
9277         }
9278
9279       if ((s->flags & SEC_HAS_CONTENTS) == 0)
9280         continue;
9281
9282       /* Allocate memory for the section contents.  We use bfd_zalloc
9283          here in case unused entries are not reclaimed before the
9284          section's contents are written out.  This should not happen,
9285          but this way if it does we get a R_PPC64_NONE reloc in .rela
9286          sections instead of garbage.
9287          We also rely on the section contents being zero when writing
9288          the GOT.  */
9289       s->contents = bfd_zalloc (dynobj, s->size);
9290       if (s->contents == NULL)
9291         return FALSE;
9292     }
9293
9294   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9295     {
9296       if (!is_ppc64_elf (ibfd))
9297         continue;
9298
9299       s = ppc64_elf_tdata (ibfd)->got;
9300       if (s != NULL && s != htab->got)
9301         {
9302           if (s->size == 0)
9303             s->flags |= SEC_EXCLUDE;
9304           else
9305             {
9306               s->contents = bfd_zalloc (ibfd, s->size);
9307               if (s->contents == NULL)
9308                 return FALSE;
9309             }
9310         }
9311       s = ppc64_elf_tdata (ibfd)->relgot;
9312       if (s != NULL)
9313         {
9314           if (s->size == 0)
9315             s->flags |= SEC_EXCLUDE;
9316           else
9317             {
9318               s->contents = bfd_zalloc (ibfd, s->size);
9319               if (s->contents == NULL)
9320                 return FALSE;
9321               relocs = TRUE;
9322               s->reloc_count = 0;
9323             }
9324         }
9325     }
9326
9327   if (htab->elf.dynamic_sections_created)
9328     {
9329       /* Add some entries to the .dynamic section.  We fill in the
9330          values later, in ppc64_elf_finish_dynamic_sections, but we
9331          must add the entries now so that we get the correct size for
9332          the .dynamic section.  The DT_DEBUG entry is filled in by the
9333          dynamic linker and used by the debugger.  */
9334 #define add_dynamic_entry(TAG, VAL) \
9335   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9336
9337       if (info->executable)
9338         {
9339           if (!add_dynamic_entry (DT_DEBUG, 0))
9340             return FALSE;
9341         }
9342
9343       if (htab->plt != NULL && htab->plt->size != 0)
9344         {
9345           if (!add_dynamic_entry (DT_PLTGOT, 0)
9346               || !add_dynamic_entry (DT_PLTRELSZ, 0)
9347               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9348               || !add_dynamic_entry (DT_JMPREL, 0)
9349               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9350             return FALSE;
9351         }
9352
9353       if (NO_OPD_RELOCS)
9354         {
9355           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9356               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9357             return FALSE;
9358         }
9359
9360       if (!htab->no_tls_get_addr_opt
9361           && htab->tls_get_addr_fd != NULL
9362           && htab->tls_get_addr_fd->elf.plt.plist != NULL
9363           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9364         return FALSE;
9365
9366       if (relocs)
9367         {
9368           if (!add_dynamic_entry (DT_RELA, 0)
9369               || !add_dynamic_entry (DT_RELASZ, 0)
9370               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9371             return FALSE;
9372
9373           /* If any dynamic relocs apply to a read-only section,
9374              then we need a DT_TEXTREL entry.  */
9375           if ((info->flags & DF_TEXTREL) == 0)
9376             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9377
9378           if ((info->flags & DF_TEXTREL) != 0)
9379             {
9380               if (!add_dynamic_entry (DT_TEXTREL, 0))
9381                 return FALSE;
9382             }
9383         }
9384     }
9385 #undef add_dynamic_entry
9386
9387   return TRUE;
9388 }
9389
9390 /* Determine the type of stub needed, if any, for a call.  */
9391
9392 static inline enum ppc_stub_type
9393 ppc_type_of_stub (asection *input_sec,
9394                   const Elf_Internal_Rela *rel,
9395                   struct ppc_link_hash_entry **hash,
9396                   struct plt_entry **plt_ent,
9397                   bfd_vma destination)
9398 {
9399   struct ppc_link_hash_entry *h = *hash;
9400   bfd_vma location;
9401   bfd_vma branch_offset;
9402   bfd_vma max_branch_offset;
9403   enum elf_ppc64_reloc_type r_type;
9404
9405   if (h != NULL)
9406     {
9407       struct plt_entry *ent;
9408       struct ppc_link_hash_entry *fdh = h;
9409       if (h->oh != NULL
9410           && h->oh->is_func_descriptor)
9411         {
9412           fdh = ppc_follow_link (h->oh);
9413           *hash = fdh;
9414         }
9415
9416       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9417         if (ent->addend == rel->r_addend
9418             && ent->plt.offset != (bfd_vma) -1)
9419           {
9420             *plt_ent = ent;
9421             return ppc_stub_plt_call;
9422           }
9423
9424       /* Here, we know we don't have a plt entry.  If we don't have a
9425          either a defined function descriptor or a defined entry symbol
9426          in a regular object file, then it is pointless trying to make
9427          any other type of stub.  */
9428       if (!is_static_defined (&fdh->elf)
9429           && !is_static_defined (&h->elf))
9430         return ppc_stub_none;
9431     }
9432   else if (elf_local_got_ents (input_sec->owner) != NULL)
9433     {
9434       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9435       struct plt_entry **local_plt = (struct plt_entry **)
9436         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9437       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9438
9439       if (local_plt[r_symndx] != NULL)
9440         {
9441           struct plt_entry *ent;
9442
9443           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9444             if (ent->addend == rel->r_addend
9445                 && ent->plt.offset != (bfd_vma) -1)
9446               {
9447                 *plt_ent = ent;
9448                 return ppc_stub_plt_call;
9449               }
9450         }
9451     }
9452
9453   /* Determine where the call point is.  */
9454   location = (input_sec->output_offset
9455               + input_sec->output_section->vma
9456               + rel->r_offset);
9457
9458   branch_offset = destination - location;
9459   r_type = ELF64_R_TYPE (rel->r_info);
9460
9461   /* Determine if a long branch stub is needed.  */
9462   max_branch_offset = 1 << 25;
9463   if (r_type != R_PPC64_REL24)
9464     max_branch_offset = 1 << 15;
9465
9466   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9467     /* We need a stub.  Figure out whether a long_branch or plt_branch
9468        is needed later.  */
9469     return ppc_stub_long_branch;
9470
9471   return ppc_stub_none;
9472 }
9473
9474 /* Build a .plt call stub.  */
9475
9476 static inline bfd_byte *
9477 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r,
9478                 bfd_boolean plt_static_chain)
9479 {
9480 #define PPC_LO(v) ((v) & 0xffff)
9481 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9482 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9483
9484   if (PPC_HA (offset) != 0)
9485     {
9486       if (r != NULL)
9487         {
9488           r[0].r_offset += 4;
9489           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9490           r[1].r_offset = r[0].r_offset + 4;
9491           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9492           r[1].r_addend = r[0].r_addend;
9493           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9494             {
9495               r[2].r_offset = r[1].r_offset + 4;
9496               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9497               r[2].r_addend = r[0].r_addend;
9498             }
9499           else
9500             {
9501               r[2].r_offset = r[1].r_offset + 8;
9502               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9503               r[2].r_addend = r[0].r_addend + 8;
9504               if (plt_static_chain)
9505                 {
9506                   r[3].r_offset = r[2].r_offset + 4;
9507                   r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9508                   r[3].r_addend = r[0].r_addend + 16;
9509                 }
9510             }
9511         }
9512       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9513       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
9514       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
9515       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9516         {
9517           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9518           offset = 0;
9519         }
9520       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9521       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9522       if (plt_static_chain)
9523         bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9524       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9525     }
9526   else
9527     {
9528       if (r != NULL)
9529         {
9530           r[0].r_offset += 4;
9531           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9532           if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9533             {
9534               r[1].r_offset = r[0].r_offset + 4;
9535               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9536               r[1].r_addend = r[0].r_addend;
9537             }
9538           else
9539             {
9540               r[1].r_offset = r[0].r_offset + 8;
9541               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9542               r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9543               if (plt_static_chain)
9544                 {
9545                   r[2].r_offset = r[1].r_offset + 4;
9546                   r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9547                   r[2].r_addend = r[0].r_addend + 8;
9548                 }
9549             }
9550         }
9551       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9552       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9553       if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9554         {
9555           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9556           offset = 0;
9557         }
9558       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9559       if (plt_static_chain)
9560         bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9561       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9562       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9563     }
9564   return p;
9565 }
9566
9567 /* Build a special .plt call stub for __tls_get_addr.  */
9568
9569 #define LD_R11_0R3      0xe9630000
9570 #define LD_R12_0R3      0xe9830000
9571 #define MR_R0_R3        0x7c601b78
9572 #define CMPDI_R11_0     0x2c2b0000
9573 #define ADD_R3_R12_R13  0x7c6c6a14
9574 #define BEQLR           0x4d820020
9575 #define MR_R3_R0        0x7c030378
9576 #define MFLR_R11        0x7d6802a6
9577 #define STD_R11_0R1     0xf9610000
9578 #define BCTRL           0x4e800421
9579 #define LD_R11_0R1      0xe9610000
9580 #define LD_R2_0R1       0xe8410000
9581 #define MTLR_R11        0x7d6803a6
9582
9583 static inline bfd_byte *
9584 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9585                          Elf_Internal_Rela *r, bfd_boolean plt_static_chain)
9586 {
9587   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9588   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9589   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9590   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9591   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9592   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9593   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9594   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9595   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9596
9597   if (r != NULL)
9598     r[0].r_offset += 9 * 4;
9599   p = build_plt_stub (obfd, p, offset, r, plt_static_chain);
9600   bfd_put_32 (obfd, BCTRL, p - 4);
9601
9602   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9603   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9604   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9605   bfd_put_32 (obfd, BLR, p),                    p += 4;
9606
9607   return p;
9608 }
9609
9610 static Elf_Internal_Rela *
9611 get_relocs (asection *sec, int count)
9612 {
9613   Elf_Internal_Rela *relocs;
9614   struct bfd_elf_section_data *elfsec_data;
9615
9616   elfsec_data = elf_section_data (sec);
9617   relocs = elfsec_data->relocs;
9618   if (relocs == NULL)
9619     {
9620       bfd_size_type relsize;
9621       relsize = sec->reloc_count * sizeof (*relocs);
9622       relocs = bfd_alloc (sec->owner, relsize);
9623       if (relocs == NULL)
9624         return NULL;
9625       elfsec_data->relocs = relocs;
9626       elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9627                                           sizeof (Elf_Internal_Shdr));
9628       if (elfsec_data->rela.hdr == NULL)
9629         return NULL;
9630       elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9631                                         * sizeof (Elf64_External_Rela));
9632       elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9633       sec->reloc_count = 0;
9634     }
9635   relocs += sec->reloc_count;
9636   sec->reloc_count += count;
9637   return relocs;
9638 }
9639
9640 static bfd_vma
9641 get_r2off (struct bfd_link_info *info,
9642            struct ppc_stub_hash_entry *stub_entry)
9643 {
9644   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9645   bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9646
9647   if (r2off == 0)
9648     {
9649       /* Support linking -R objects.  Get the toc pointer from the
9650          opd entry.  */
9651       char buf[8];
9652       asection *opd = stub_entry->h->elf.root.u.def.section;
9653       bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9654
9655       if (strcmp (opd->name, ".opd") != 0
9656           || opd->reloc_count != 0)
9657         {
9658           info->callbacks->einfo (_("%P: cannot find opd entry toc for %s\n"),
9659                                   stub_entry->h->elf.root.root.string);
9660           bfd_set_error (bfd_error_bad_value);
9661           return 0;
9662         }
9663       if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9664         return 0;
9665       r2off = bfd_get_64 (opd->owner, buf);
9666       r2off -= elf_gp (info->output_bfd);
9667     }
9668   r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9669   return r2off;
9670 }
9671
9672 static bfd_boolean
9673 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9674 {
9675   struct ppc_stub_hash_entry *stub_entry;
9676   struct ppc_branch_hash_entry *br_entry;
9677   struct bfd_link_info *info;
9678   struct ppc_link_hash_table *htab;
9679   bfd_byte *loc;
9680   bfd_byte *p;
9681   bfd_vma dest, off;
9682   int size;
9683   Elf_Internal_Rela *r;
9684   asection *plt;
9685
9686   /* Massage our args to the form they really have.  */
9687   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9688   info = in_arg;
9689
9690   htab = ppc_hash_table (info);
9691   if (htab == NULL)
9692     return FALSE;
9693
9694   /* Make a note of the offset within the stubs for this entry.  */
9695   stub_entry->stub_offset = stub_entry->stub_sec->size;
9696   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9697
9698   htab->stub_count[stub_entry->stub_type - 1] += 1;
9699   switch (stub_entry->stub_type)
9700     {
9701     case ppc_stub_long_branch:
9702     case ppc_stub_long_branch_r2off:
9703       /* Branches are relative.  This is where we are going to.  */
9704       off = dest = (stub_entry->target_value
9705                     + stub_entry->target_section->output_offset
9706                     + stub_entry->target_section->output_section->vma);
9707
9708       /* And this is where we are coming from.  */
9709       off -= (stub_entry->stub_offset
9710               + stub_entry->stub_sec->output_offset
9711               + stub_entry->stub_sec->output_section->vma);
9712
9713       size = 4;
9714       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9715         {
9716           bfd_vma r2off = get_r2off (info, stub_entry);
9717
9718           if (r2off == 0)
9719             {
9720               htab->stub_error = TRUE;
9721               return FALSE;
9722             }
9723           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9724           loc += 4;
9725           size = 12;
9726           if (PPC_HA (r2off) != 0)
9727             {
9728               size = 16;
9729               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9730               loc += 4;
9731             }
9732           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9733           loc += 4;
9734           off -= size - 4;
9735         }
9736       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9737
9738       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9739         {
9740           info->callbacks->einfo (_("%P: long branch stub `%s' offset overflow\n"),
9741                                   stub_entry->root.string);
9742           htab->stub_error = TRUE;
9743           return FALSE;
9744         }
9745
9746       if (info->emitrelocations)
9747         {
9748           r = get_relocs (stub_entry->stub_sec, 1);
9749           if (r == NULL)
9750             return FALSE;
9751           r->r_offset = loc - stub_entry->stub_sec->contents;
9752           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9753           r->r_addend = dest;
9754           if (stub_entry->h != NULL)
9755             {
9756               struct elf_link_hash_entry **hashes;
9757               unsigned long symndx;
9758               struct ppc_link_hash_entry *h;
9759
9760               hashes = elf_sym_hashes (htab->stub_bfd);
9761               if (hashes == NULL)
9762                 {
9763                   bfd_size_type hsize;
9764
9765                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9766                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9767                   if (hashes == NULL)
9768                     return FALSE;
9769                   elf_sym_hashes (htab->stub_bfd) = hashes;
9770                   htab->stub_globals = 1;
9771                 }
9772               symndx = htab->stub_globals++;
9773               h = stub_entry->h;
9774               hashes[symndx] = &h->elf;
9775               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9776               if (h->oh != NULL && h->oh->is_func)
9777                 h = ppc_follow_link (h->oh);
9778               if (h->elf.root.u.def.section != stub_entry->target_section)
9779                 /* H is an opd symbol.  The addend must be zero.  */
9780                 r->r_addend = 0;
9781               else
9782                 {
9783                   off = (h->elf.root.u.def.value
9784                          + h->elf.root.u.def.section->output_offset
9785                          + h->elf.root.u.def.section->output_section->vma);
9786                   r->r_addend -= off;
9787                 }
9788             }
9789         }
9790       break;
9791
9792     case ppc_stub_plt_branch:
9793     case ppc_stub_plt_branch_r2off:
9794       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9795                                          stub_entry->root.string + 9,
9796                                          FALSE, FALSE);
9797       if (br_entry == NULL)
9798         {
9799           info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
9800                                   stub_entry->root.string);
9801           htab->stub_error = TRUE;
9802           return FALSE;
9803         }
9804
9805       dest = (stub_entry->target_value
9806               + stub_entry->target_section->output_offset
9807               + stub_entry->target_section->output_section->vma);
9808
9809       bfd_put_64 (htab->brlt->owner, dest,
9810                   htab->brlt->contents + br_entry->offset);
9811
9812       if (br_entry->iter == htab->stub_iteration)
9813         {
9814           br_entry->iter = 0;
9815
9816           if (htab->relbrlt != NULL)
9817             {
9818               /* Create a reloc for the branch lookup table entry.  */
9819               Elf_Internal_Rela rela;
9820               bfd_byte *rl;
9821
9822               rela.r_offset = (br_entry->offset
9823                                + htab->brlt->output_offset
9824                                + htab->brlt->output_section->vma);
9825               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9826               rela.r_addend = dest;
9827
9828               rl = htab->relbrlt->contents;
9829               rl += (htab->relbrlt->reloc_count++
9830                      * sizeof (Elf64_External_Rela));
9831               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9832             }
9833           else if (info->emitrelocations)
9834             {
9835               r = get_relocs (htab->brlt, 1);
9836               if (r == NULL)
9837                 return FALSE;
9838               /* brlt, being SEC_LINKER_CREATED does not go through the
9839                  normal reloc processing.  Symbols and offsets are not
9840                  translated from input file to output file form, so
9841                  set up the offset per the output file.  */
9842               r->r_offset = (br_entry->offset
9843                              + htab->brlt->output_offset
9844                              + htab->brlt->output_section->vma);
9845               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9846               r->r_addend = dest;
9847             }
9848         }
9849
9850       dest = (br_entry->offset
9851               + htab->brlt->output_offset
9852               + htab->brlt->output_section->vma);
9853
9854       off = (dest
9855              - elf_gp (htab->brlt->output_section->owner)
9856              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9857
9858       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9859         {
9860           info->callbacks->einfo
9861             (_("%P: linkage table error against `%s'\n"),
9862              stub_entry->root.string);
9863           bfd_set_error (bfd_error_bad_value);
9864           htab->stub_error = TRUE;
9865           return FALSE;
9866         }
9867
9868       if (info->emitrelocations)
9869         {
9870           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9871           if (r == NULL)
9872             return FALSE;
9873           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9874           if (bfd_big_endian (info->output_bfd))
9875             r[0].r_offset += 2;
9876           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9877             r[0].r_offset += 4;
9878           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9879           r[0].r_addend = dest;
9880           if (PPC_HA (off) != 0)
9881             {
9882               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9883               r[1].r_offset = r[0].r_offset + 4;
9884               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9885               r[1].r_addend = r[0].r_addend;
9886             }
9887         }
9888
9889       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9890         {
9891           if (PPC_HA (off) != 0)
9892             {
9893               size = 16;
9894               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9895               loc += 4;
9896               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9897             }
9898           else
9899             {
9900               size = 12;
9901               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9902             }
9903         }
9904       else
9905         {
9906           bfd_vma r2off = get_r2off (info, stub_entry);
9907
9908           if (r2off == 0)
9909             {
9910               htab->stub_error = TRUE;
9911               return FALSE;
9912             }
9913
9914           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9915           loc += 4;
9916           size = 20;
9917           if (PPC_HA (off) != 0)
9918             {
9919               size += 4;
9920               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9921               loc += 4;
9922               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9923               loc += 4;
9924             }
9925           else
9926             {
9927               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9928               loc += 4;
9929             }
9930
9931           if (PPC_HA (r2off) != 0)
9932             {
9933               size += 4;
9934               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9935               loc += 4;
9936             }
9937           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9938         }
9939       loc += 4;
9940       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9941       loc += 4;
9942       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9943       break;
9944
9945     case ppc_stub_plt_call:
9946       if (stub_entry->h != NULL
9947           && stub_entry->h->is_func_descriptor
9948           && stub_entry->h->oh != NULL)
9949         {
9950           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9951
9952           /* If the old-ABI "dot-symbol" is undefined make it weak so
9953              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9954              FIXME: We used to define the symbol on one of the call
9955              stubs instead, which is why we test symbol section id
9956              against htab->top_id in various places.  Likely all
9957              these checks could now disappear.  */
9958           if (fh->elf.root.type == bfd_link_hash_undefined)
9959             fh->elf.root.type = bfd_link_hash_undefweak;
9960           /* Stop undo_symbol_twiddle changing it back to undefined.  */
9961           fh->was_undefined = 0;
9962         }
9963
9964       /* Now build the stub.  */
9965       dest = stub_entry->plt_ent->plt.offset & ~1;
9966       if (dest >= (bfd_vma) -2)
9967         abort ();
9968
9969       plt = htab->plt;
9970       if (!htab->elf.dynamic_sections_created
9971           || stub_entry->h == NULL
9972           || stub_entry->h->elf.dynindx == -1)
9973         plt = htab->iplt;
9974
9975       dest += plt->output_offset + plt->output_section->vma;
9976
9977       if (stub_entry->h == NULL
9978           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9979         {
9980           Elf_Internal_Rela rela;
9981           bfd_byte *rl;
9982
9983           rela.r_offset = dest;
9984           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9985           rela.r_addend = (stub_entry->target_value
9986                            + stub_entry->target_section->output_offset
9987                            + stub_entry->target_section->output_section->vma);
9988
9989           rl = (htab->reliplt->contents
9990                 + (htab->reliplt->reloc_count++
9991                    * sizeof (Elf64_External_Rela)));
9992           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9993           stub_entry->plt_ent->plt.offset |= 1;
9994         }
9995
9996       off = (dest
9997              - elf_gp (plt->output_section->owner)
9998              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9999
10000       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10001         {
10002           info->callbacks->einfo
10003             (_("%P: linkage table error against `%s'\n"),
10004              stub_entry->h != NULL
10005              ? stub_entry->h->elf.root.root.string
10006              : "<local sym>");
10007           bfd_set_error (bfd_error_bad_value);
10008           htab->stub_error = TRUE;
10009           return FALSE;
10010         }
10011
10012       r = NULL;
10013       if (info->emitrelocations)
10014         {
10015           r = get_relocs (stub_entry->stub_sec,
10016                           (2
10017                            + (PPC_HA (off) != 0)
10018                            + (htab->plt_static_chain
10019                               && PPC_HA (off + 16) == PPC_HA (off))));
10020           if (r == NULL)
10021             return FALSE;
10022           r[0].r_offset = loc - stub_entry->stub_sec->contents;
10023           if (bfd_big_endian (info->output_bfd))
10024             r[0].r_offset += 2;
10025           r[0].r_addend = dest;
10026         }
10027       if (stub_entry->h != NULL
10028           && (stub_entry->h == htab->tls_get_addr_fd
10029               || stub_entry->h == htab->tls_get_addr)
10030           && !htab->no_tls_get_addr_opt)
10031         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r,
10032                                      htab->plt_static_chain);
10033       else
10034         p = build_plt_stub (htab->stub_bfd, loc, off, r,
10035                             htab->plt_static_chain);
10036       size = p - loc;
10037       break;
10038
10039     default:
10040       BFD_FAIL ();
10041       return FALSE;
10042     }
10043
10044   stub_entry->stub_sec->size += size;
10045
10046   if (htab->emit_stub_syms)
10047     {
10048       struct elf_link_hash_entry *h;
10049       size_t len1, len2;
10050       char *name;
10051       const char *const stub_str[] = { "long_branch",
10052                                        "long_branch_r2off",
10053                                        "plt_branch",
10054                                        "plt_branch_r2off",
10055                                        "plt_call" };
10056
10057       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10058       len2 = strlen (stub_entry->root.string);
10059       name = bfd_malloc (len1 + len2 + 2);
10060       if (name == NULL)
10061         return FALSE;
10062       memcpy (name, stub_entry->root.string, 9);
10063       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10064       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10065       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10066       if (h == NULL)
10067         return FALSE;
10068       if (h->root.type == bfd_link_hash_new)
10069         {
10070           h->root.type = bfd_link_hash_defined;
10071           h->root.u.def.section = stub_entry->stub_sec;
10072           h->root.u.def.value = stub_entry->stub_offset;
10073           h->ref_regular = 1;
10074           h->def_regular = 1;
10075           h->ref_regular_nonweak = 1;
10076           h->forced_local = 1;
10077           h->non_elf = 0;
10078         }
10079     }
10080
10081   return TRUE;
10082 }
10083
10084 /* As above, but don't actually build the stub.  Just bump offset so
10085    we know stub section sizes, and select plt_branch stubs where
10086    long_branch stubs won't do.  */
10087
10088 static bfd_boolean
10089 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10090 {
10091   struct ppc_stub_hash_entry *stub_entry;
10092   struct bfd_link_info *info;
10093   struct ppc_link_hash_table *htab;
10094   bfd_vma off;
10095   int size;
10096
10097   /* Massage our args to the form they really have.  */
10098   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10099   info = in_arg;
10100
10101   htab = ppc_hash_table (info);
10102   if (htab == NULL)
10103     return FALSE;
10104
10105   if (stub_entry->stub_type == ppc_stub_plt_call)
10106     {
10107       asection *plt;
10108       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10109       if (off >= (bfd_vma) -2)
10110         abort ();
10111       plt = htab->plt;
10112       if (!htab->elf.dynamic_sections_created
10113           || stub_entry->h == NULL
10114           || stub_entry->h->elf.dynindx == -1)
10115         plt = htab->iplt;
10116       off += (plt->output_offset
10117               + plt->output_section->vma
10118               - elf_gp (plt->output_section->owner)
10119               - htab->stub_group[stub_entry->id_sec->id].toc_off);
10120
10121       size = PLT_CALL_STUB_SIZE;
10122       if (!htab->plt_static_chain)
10123         size -= 4;
10124       if (PPC_HA (off) == 0)
10125         size -= 4;
10126       if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10127         size += 4;
10128       if (stub_entry->h != NULL
10129           && (stub_entry->h == htab->tls_get_addr_fd
10130               || stub_entry->h == htab->tls_get_addr)
10131           && !htab->no_tls_get_addr_opt)
10132         size += 13 * 4;
10133       if (info->emitrelocations)
10134         {
10135           stub_entry->stub_sec->reloc_count
10136             += (2
10137                 + (PPC_HA (off) != 0)
10138                 + (htab->plt_static_chain
10139                    && PPC_HA (off + 16) == PPC_HA (off)));
10140           stub_entry->stub_sec->flags |= SEC_RELOC;
10141         }
10142     }
10143   else
10144     {
10145       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10146          variants.  */
10147       bfd_vma r2off = 0;
10148
10149       off = (stub_entry->target_value
10150              + stub_entry->target_section->output_offset
10151              + stub_entry->target_section->output_section->vma);
10152       off -= (stub_entry->stub_sec->size
10153               + stub_entry->stub_sec->output_offset
10154               + stub_entry->stub_sec->output_section->vma);
10155
10156       /* Reset the stub type from the plt variant in case we now
10157          can reach with a shorter stub.  */
10158       if (stub_entry->stub_type >= ppc_stub_plt_branch)
10159         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10160
10161       size = 4;
10162       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10163         {
10164           r2off = get_r2off (info, stub_entry);
10165           if (r2off == 0)
10166             {
10167               htab->stub_error = TRUE;
10168               return FALSE;
10169             }
10170           size = 12;
10171           if (PPC_HA (r2off) != 0)
10172             size = 16;
10173           off -= size - 4;
10174         }
10175
10176       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
10177       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10178         {
10179           struct ppc_branch_hash_entry *br_entry;
10180
10181           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10182                                              stub_entry->root.string + 9,
10183                                              TRUE, FALSE);
10184           if (br_entry == NULL)
10185             {
10186               info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10187                                       stub_entry->root.string);
10188               htab->stub_error = TRUE;
10189               return FALSE;
10190             }
10191
10192           if (br_entry->iter != htab->stub_iteration)
10193             {
10194               br_entry->iter = htab->stub_iteration;
10195               br_entry->offset = htab->brlt->size;
10196               htab->brlt->size += 8;
10197
10198               if (htab->relbrlt != NULL)
10199                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10200               else if (info->emitrelocations)
10201                 {
10202                   htab->brlt->reloc_count += 1;
10203                   htab->brlt->flags |= SEC_RELOC;
10204                 }
10205             }
10206
10207           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10208           off = (br_entry->offset
10209                  + htab->brlt->output_offset
10210                  + htab->brlt->output_section->vma
10211                  - elf_gp (htab->brlt->output_section->owner)
10212                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
10213
10214           if (info->emitrelocations)
10215             {
10216               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10217               stub_entry->stub_sec->flags |= SEC_RELOC;
10218             }
10219
10220           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10221             {
10222               size = 12;
10223               if (PPC_HA (off) != 0)
10224                 size = 16;
10225             }
10226           else
10227             {
10228               size = 20;
10229               if (PPC_HA (off) != 0)
10230                 size += 4;
10231
10232               if (PPC_HA (r2off) != 0)
10233                 size += 4;
10234             }
10235         }
10236       else if (info->emitrelocations)
10237         {
10238           stub_entry->stub_sec->reloc_count += 1;
10239           stub_entry->stub_sec->flags |= SEC_RELOC;
10240         }
10241     }
10242
10243   stub_entry->stub_sec->size += size;
10244   return TRUE;
10245 }
10246
10247 /* Set up various things so that we can make a list of input sections
10248    for each output section included in the link.  Returns -1 on error,
10249    0 when no stubs will be needed, and 1 on success.  */
10250
10251 int
10252 ppc64_elf_setup_section_lists
10253   (struct bfd_link_info *info,
10254    asection *(*add_stub_section) (const char *, asection *),
10255    void (*layout_sections_again) (void))
10256 {
10257   bfd *input_bfd;
10258   int top_id, top_index, id;
10259   asection *section;
10260   asection **input_list;
10261   bfd_size_type amt;
10262   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10263
10264   if (htab == NULL)
10265     return -1;
10266   /* Stash our params away.  */
10267   htab->add_stub_section = add_stub_section;
10268   htab->layout_sections_again = layout_sections_again;
10269
10270   if (htab->brlt == NULL)
10271     return 0;
10272
10273   /* Find the top input section id.  */
10274   for (input_bfd = info->input_bfds, top_id = 3;
10275        input_bfd != NULL;
10276        input_bfd = input_bfd->link_next)
10277     {
10278       for (section = input_bfd->sections;
10279            section != NULL;
10280            section = section->next)
10281         {
10282           if (top_id < section->id)
10283             top_id = section->id;
10284         }
10285     }
10286
10287   htab->top_id = top_id;
10288   amt = sizeof (struct map_stub) * (top_id + 1);
10289   htab->stub_group = bfd_zmalloc (amt);
10290   if (htab->stub_group == NULL)
10291     return -1;
10292
10293   /* Set toc_off for com, und, abs and ind sections.  */
10294   for (id = 0; id < 3; id++)
10295     htab->stub_group[id].toc_off = TOC_BASE_OFF;
10296
10297   /* We can't use output_bfd->section_count here to find the top output
10298      section index as some sections may have been removed, and
10299      strip_excluded_output_sections doesn't renumber the indices.  */
10300   for (section = info->output_bfd->sections, top_index = 0;
10301        section != NULL;
10302        section = section->next)
10303     {
10304       if (top_index < section->index)
10305         top_index = section->index;
10306     }
10307
10308   htab->top_index = top_index;
10309   amt = sizeof (asection *) * (top_index + 1);
10310   input_list = bfd_zmalloc (amt);
10311   htab->input_list = input_list;
10312   if (input_list == NULL)
10313     return -1;
10314
10315   return 1;
10316 }
10317
10318 /* Set up for first pass at multitoc partitioning.  */
10319
10320 void
10321 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10322 {
10323   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10324
10325   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10326   htab->toc_curr = elf_gp (info->output_bfd);
10327   htab->toc_bfd = NULL;
10328   htab->toc_first_sec = NULL;
10329 }
10330
10331 /* The linker repeatedly calls this function for each TOC input section
10332    and linker generated GOT section.  Group input bfds such that the toc
10333    within a group is less than 64k in size.  */
10334
10335 bfd_boolean
10336 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10337 {
10338   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10339   bfd_vma addr, off, limit;
10340
10341   if (htab == NULL)
10342     return FALSE;
10343
10344   if (!htab->second_toc_pass)
10345     {
10346       /* Keep track of the first .toc or .got section for this input bfd.  */
10347       if (htab->toc_bfd != isec->owner)
10348         {
10349           htab->toc_bfd = isec->owner;
10350           htab->toc_first_sec = isec;
10351         }
10352
10353       addr = isec->output_offset + isec->output_section->vma;
10354       off = addr - htab->toc_curr;
10355       limit = 0x80008000;
10356       if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10357         limit = 0x10000;
10358       if (off + isec->size > limit)
10359         {
10360           addr = (htab->toc_first_sec->output_offset
10361                   + htab->toc_first_sec->output_section->vma);
10362           htab->toc_curr = addr;
10363         }
10364
10365       /* toc_curr is the base address of this toc group.  Set elf_gp
10366          for the input section to be the offset relative to the
10367          output toc base plus 0x8000.  Making the input elf_gp an
10368          offset allows us to move the toc as a whole without
10369          recalculating input elf_gp.  */
10370       off = htab->toc_curr - elf_gp (isec->output_section->owner);
10371       off += TOC_BASE_OFF;
10372
10373       /* Die if someone uses a linker script that doesn't keep input
10374          file .toc and .got together.  */
10375       if (elf_gp (isec->owner) != 0
10376           && elf_gp (isec->owner) != off)
10377         return FALSE;
10378
10379       elf_gp (isec->owner) = off;
10380       return TRUE;
10381     }
10382
10383   /* During the second pass toc_first_sec points to the start of
10384      a toc group, and toc_curr is used to track the old elf_gp.
10385      We use toc_bfd to ensure we only look at each bfd once.  */
10386   if (htab->toc_bfd == isec->owner)
10387     return TRUE;
10388   htab->toc_bfd = isec->owner;
10389
10390   if (htab->toc_first_sec == NULL
10391       || htab->toc_curr != elf_gp (isec->owner))
10392     {
10393       htab->toc_curr = elf_gp (isec->owner);
10394       htab->toc_first_sec = isec;
10395     }
10396   addr = (htab->toc_first_sec->output_offset
10397           + htab->toc_first_sec->output_section->vma);
10398   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10399   elf_gp (isec->owner) = off;
10400
10401   return TRUE;
10402 }
10403
10404 /* Called via elf_link_hash_traverse to merge GOT entries for global
10405    symbol H.  */
10406
10407 static bfd_boolean
10408 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10409 {
10410   if (h->root.type == bfd_link_hash_indirect)
10411     return TRUE;
10412
10413   merge_got_entries (&h->got.glist);
10414
10415   return TRUE;
10416 }
10417
10418 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10419    symbol H.  */
10420
10421 static bfd_boolean
10422 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10423 {
10424   struct got_entry *gent;
10425
10426   if (h->root.type == bfd_link_hash_indirect)
10427     return TRUE;
10428
10429   for (gent = h->got.glist; gent != NULL; gent = gent->next)
10430     if (!gent->is_indirect)
10431       allocate_got (h, (struct bfd_link_info *) inf, gent);
10432   return TRUE;
10433 }
10434
10435 /* Called on the first multitoc pass after the last call to
10436    ppc64_elf_next_toc_section.  This function removes duplicate GOT
10437    entries.  */
10438
10439 bfd_boolean
10440 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10441 {
10442   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10443   struct bfd *ibfd, *ibfd2;
10444   bfd_boolean done_something;
10445
10446   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10447
10448   if (!htab->do_multi_toc)
10449     return FALSE;
10450
10451   /* Merge global sym got entries within a toc group.  */
10452   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10453
10454   /* And tlsld_got.  */
10455   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10456     {
10457       struct got_entry *ent, *ent2;
10458
10459       if (!is_ppc64_elf (ibfd))
10460         continue;
10461
10462       ent = ppc64_tlsld_got (ibfd);
10463       if (!ent->is_indirect
10464           && ent->got.offset != (bfd_vma) -1)
10465         {
10466           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10467             {
10468               if (!is_ppc64_elf (ibfd2))
10469                 continue;
10470
10471               ent2 = ppc64_tlsld_got (ibfd2);
10472               if (!ent2->is_indirect
10473                   && ent2->got.offset != (bfd_vma) -1
10474                   && elf_gp (ibfd2) == elf_gp (ibfd))
10475                 {
10476                   ent2->is_indirect = TRUE;
10477                   ent2->got.ent = ent;
10478                 }
10479             }
10480         }
10481     }
10482
10483   /* Zap sizes of got sections.  */
10484   htab->reliplt->rawsize = htab->reliplt->size;
10485   htab->reliplt->size -= htab->got_reli_size;
10486   htab->got_reli_size = 0;
10487
10488   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10489     {
10490       asection *got, *relgot;
10491
10492       if (!is_ppc64_elf (ibfd))
10493         continue;
10494
10495       got = ppc64_elf_tdata (ibfd)->got;
10496       if (got != NULL)
10497         {
10498           got->rawsize = got->size;
10499           got->size = 0;
10500           relgot = ppc64_elf_tdata (ibfd)->relgot;
10501           relgot->rawsize = relgot->size;
10502           relgot->size = 0;
10503         }
10504     }
10505
10506   /* Now reallocate the got, local syms first.  We don't need to
10507      allocate section contents again since we never increase size.  */
10508   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10509     {
10510       struct got_entry **lgot_ents;
10511       struct got_entry **end_lgot_ents;
10512       struct plt_entry **local_plt;
10513       struct plt_entry **end_local_plt;
10514       unsigned char *lgot_masks;
10515       bfd_size_type locsymcount;
10516       Elf_Internal_Shdr *symtab_hdr;
10517       asection *s, *srel;
10518
10519       if (!is_ppc64_elf (ibfd))
10520         continue;
10521
10522       lgot_ents = elf_local_got_ents (ibfd);
10523       if (!lgot_ents)
10524         continue;
10525
10526       symtab_hdr = &elf_symtab_hdr (ibfd);
10527       locsymcount = symtab_hdr->sh_info;
10528       end_lgot_ents = lgot_ents + locsymcount;
10529       local_plt = (struct plt_entry **) end_lgot_ents;
10530       end_local_plt = local_plt + locsymcount;
10531       lgot_masks = (unsigned char *) end_local_plt;
10532       s = ppc64_elf_tdata (ibfd)->got;
10533       srel = ppc64_elf_tdata (ibfd)->relgot;
10534       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10535         {
10536           struct got_entry *ent;
10537
10538           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10539             {
10540               unsigned int num = 1;
10541               ent->got.offset = s->size;
10542               if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10543                 num = 2;
10544               s->size += num * 8;
10545               if (info->shared)
10546                 srel->size += num * sizeof (Elf64_External_Rela);
10547               else if ((*lgot_masks & PLT_IFUNC) != 0)
10548                 {
10549                   htab->reliplt->size
10550                     += num * sizeof (Elf64_External_Rela);
10551                   htab->got_reli_size
10552                     += num * sizeof (Elf64_External_Rela);
10553                 }
10554             }
10555         }
10556     }
10557
10558   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10559
10560   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10561     {
10562       struct got_entry *ent;
10563
10564       if (!is_ppc64_elf (ibfd))
10565         continue;
10566
10567       ent = ppc64_tlsld_got (ibfd);
10568       if (!ent->is_indirect
10569           && ent->got.offset != (bfd_vma) -1)
10570         {
10571           asection *s = ppc64_elf_tdata (ibfd)->got;
10572           ent->got.offset = s->size;
10573           s->size += 16;
10574           if (info->shared)
10575             {
10576               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10577               srel->size += sizeof (Elf64_External_Rela);
10578             }
10579         }
10580     }
10581
10582   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10583   if (!done_something)
10584     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10585       {
10586         asection *got;
10587
10588         if (!is_ppc64_elf (ibfd))
10589           continue;
10590
10591         got = ppc64_elf_tdata (ibfd)->got;
10592         if (got != NULL)
10593           {
10594             done_something = got->rawsize != got->size;
10595             if (done_something)
10596               break;
10597           }
10598       }
10599
10600   if (done_something)
10601     (*htab->layout_sections_again) ();
10602
10603   /* Set up for second pass over toc sections to recalculate elf_gp
10604      on input sections.  */
10605   htab->toc_bfd = NULL;
10606   htab->toc_first_sec = NULL;
10607   htab->second_toc_pass = TRUE;
10608   return done_something;
10609 }
10610
10611 /* Called after second pass of multitoc partitioning.  */
10612
10613 void
10614 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10615 {
10616   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10617
10618   /* After the second pass, toc_curr tracks the TOC offset used
10619      for code sections below in ppc64_elf_next_input_section.  */
10620   htab->toc_curr = TOC_BASE_OFF;
10621 }
10622
10623 /* No toc references were found in ISEC.  If the code in ISEC makes no
10624    calls, then there's no need to use toc adjusting stubs when branching
10625    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10626    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10627    needed, and 2 if a cyclical call-graph was found but no other reason
10628    for a stub was detected.  If called from the top level, a return of
10629    2 means the same as a return of 0.  */
10630
10631 static int
10632 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10633 {
10634   int ret;
10635
10636   /* Mark this section as checked.  */
10637   isec->call_check_done = 1;
10638
10639   /* We know none of our code bearing sections will need toc stubs.  */
10640   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10641     return 0;
10642
10643   if (isec->size == 0)
10644     return 0;
10645
10646   if (isec->output_section == NULL)
10647     return 0;
10648
10649   ret = 0;
10650   if (isec->reloc_count != 0)
10651     {
10652       Elf_Internal_Rela *relstart, *rel;
10653       Elf_Internal_Sym *local_syms;
10654       struct ppc_link_hash_table *htab;
10655
10656       relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10657                                             info->keep_memory);
10658       if (relstart == NULL)
10659         return -1;
10660
10661       /* Look for branches to outside of this section.  */
10662       local_syms = NULL;
10663       htab = ppc_hash_table (info);
10664       if (htab == NULL)
10665         return -1;
10666
10667       for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10668         {
10669           enum elf_ppc64_reloc_type r_type;
10670           unsigned long r_symndx;
10671           struct elf_link_hash_entry *h;
10672           struct ppc_link_hash_entry *eh;
10673           Elf_Internal_Sym *sym;
10674           asection *sym_sec;
10675           struct _opd_sec_data *opd;
10676           bfd_vma sym_value;
10677           bfd_vma dest;
10678
10679           r_type = ELF64_R_TYPE (rel->r_info);
10680           if (r_type != R_PPC64_REL24
10681               && r_type != R_PPC64_REL14
10682               && r_type != R_PPC64_REL14_BRTAKEN
10683               && r_type != R_PPC64_REL14_BRNTAKEN)
10684             continue;
10685
10686           r_symndx = ELF64_R_SYM (rel->r_info);
10687           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10688                           isec->owner))
10689             {
10690               ret = -1;
10691               break;
10692             }
10693
10694           /* Calls to dynamic lib functions go through a plt call stub
10695              that uses r2.  */
10696           eh = (struct ppc_link_hash_entry *) h;
10697           if (eh != NULL
10698               && (eh->elf.plt.plist != NULL
10699                   || (eh->oh != NULL
10700                       && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10701             {
10702               ret = 1;
10703               break;
10704             }
10705
10706           if (sym_sec == NULL)
10707             /* Ignore other undefined symbols.  */
10708             continue;
10709
10710           /* Assume branches to other sections not included in the
10711              link need stubs too, to cover -R and absolute syms.  */
10712           if (sym_sec->output_section == NULL)
10713             {
10714               ret = 1;
10715               break;
10716             }
10717
10718           if (h == NULL)
10719             sym_value = sym->st_value;
10720           else
10721             {
10722               if (h->root.type != bfd_link_hash_defined
10723                   && h->root.type != bfd_link_hash_defweak)
10724                 abort ();
10725               sym_value = h->root.u.def.value;
10726             }
10727           sym_value += rel->r_addend;
10728
10729           /* If this branch reloc uses an opd sym, find the code section.  */
10730           opd = get_opd_info (sym_sec);
10731           if (opd != NULL)
10732             {
10733               if (h == NULL && opd->adjust != NULL)
10734                 {
10735                   long adjust;
10736
10737                   adjust = opd->adjust[sym->st_value / 8];
10738                   if (adjust == -1)
10739                     /* Assume deleted functions won't ever be called.  */
10740                     continue;
10741                   sym_value += adjust;
10742                 }
10743
10744               dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10745               if (dest == (bfd_vma) -1)
10746                 continue;
10747             }
10748           else
10749             dest = (sym_value
10750                     + sym_sec->output_offset
10751                     + sym_sec->output_section->vma);
10752
10753           /* Ignore branch to self.  */
10754           if (sym_sec == isec)
10755             continue;
10756
10757           /* If the called function uses the toc, we need a stub.  */
10758           if (sym_sec->has_toc_reloc
10759               || sym_sec->makes_toc_func_call)
10760             {
10761               ret = 1;
10762               break;
10763             }
10764
10765           /* Assume any branch that needs a long branch stub might in fact
10766              need a plt_branch stub.  A plt_branch stub uses r2.  */
10767           else if (dest - (isec->output_offset
10768                            + isec->output_section->vma
10769                            + rel->r_offset) + (1 << 25) >= (2 << 25))
10770             {
10771               ret = 1;
10772               break;
10773             }
10774
10775           /* If calling back to a section in the process of being
10776              tested, we can't say for sure that no toc adjusting stubs
10777              are needed, so don't return zero.  */
10778           else if (sym_sec->call_check_in_progress)
10779             ret = 2;
10780
10781           /* Branches to another section that itself doesn't have any TOC
10782              references are OK.  Recursively call ourselves to check.  */
10783           else if (!sym_sec->call_check_done)
10784             {
10785               int recur;
10786
10787               /* Mark current section as indeterminate, so that other
10788                  sections that call back to current won't be marked as
10789                  known.  */
10790               isec->call_check_in_progress = 1;
10791               recur = toc_adjusting_stub_needed (info, sym_sec);
10792               isec->call_check_in_progress = 0;
10793
10794               if (recur != 0)
10795                 {
10796                   ret = recur;
10797                   if (recur != 2)
10798                     break;
10799                 }
10800             }
10801         }
10802
10803       if (local_syms != NULL
10804           && (elf_symtab_hdr (isec->owner).contents
10805               != (unsigned char *) local_syms))
10806         free (local_syms);
10807       if (elf_section_data (isec)->relocs != relstart)
10808         free (relstart);
10809     }
10810
10811   if ((ret & 1) == 0
10812       && isec->map_head.s != NULL
10813       && (strcmp (isec->output_section->name, ".init") == 0
10814           || strcmp (isec->output_section->name, ".fini") == 0))
10815     {
10816       if (isec->map_head.s->has_toc_reloc
10817           || isec->map_head.s->makes_toc_func_call)
10818         ret = 1;
10819       else if (!isec->map_head.s->call_check_done)
10820         {
10821           int recur;
10822           isec->call_check_in_progress = 1;
10823           recur = toc_adjusting_stub_needed (info, isec->map_head.s);
10824           isec->call_check_in_progress = 0;
10825           if (recur != 0)
10826             ret = recur;
10827         }
10828     }
10829
10830   if (ret == 1)
10831     isec->makes_toc_func_call = 1;
10832
10833   return ret;
10834 }
10835
10836 /* The linker repeatedly calls this function for each input section,
10837    in the order that input sections are linked into output sections.
10838    Build lists of input sections to determine groupings between which
10839    we may insert linker stubs.  */
10840
10841 bfd_boolean
10842 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10843 {
10844   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10845
10846   if (htab == NULL)
10847     return FALSE;
10848
10849   if ((isec->output_section->flags & SEC_CODE) != 0
10850       && isec->output_section->index <= htab->top_index)
10851     {
10852       asection **list = htab->input_list + isec->output_section->index;
10853       /* Steal the link_sec pointer for our list.  */
10854 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10855       /* This happens to make the list in reverse order,
10856          which is what we want.  */
10857       PREV_SEC (isec) = *list;
10858       *list = isec;
10859     }
10860
10861   if (htab->multi_toc_needed)
10862     {
10863       /* If a code section has a function that uses the TOC then we need
10864          to use the right TOC (obviously).  Also, make sure that .opd gets
10865          the correct TOC value for R_PPC64_TOC relocs that don't have or
10866          can't find their function symbol (shouldn't ever happen now).
10867          Also specially treat .fixup for the linux kernel.  .fixup
10868          contains branches, but only back to the function that hit an
10869          exception.  */
10870       if (isec->has_toc_reloc
10871           || (isec->flags & SEC_CODE) == 0
10872           || strcmp (isec->name, ".fixup") == 0)
10873         {
10874           if (elf_gp (isec->owner) != 0)
10875             htab->toc_curr = elf_gp (isec->owner);
10876         }
10877       else
10878         {
10879           if (!isec->call_check_done
10880               && toc_adjusting_stub_needed (info, isec) < 0)
10881             return FALSE;
10882           /* If we make a local call from this section, ie. a branch
10883              without a following nop, then we have no place to put a
10884              toc restoring insn.  We must use the same toc group as
10885              the callee.
10886              Testing makes_toc_func_call actually tests for *any*
10887              calls to functions that need a good toc pointer.  A more
10888              precise test would be better, as this one will set
10889              incorrect values for pasted .init/.fini fragments.
10890              (Fixed later in check_pasted_section.)  */
10891           if (isec->makes_toc_func_call
10892               && elf_gp (isec->owner) != 0)
10893             htab->toc_curr = elf_gp (isec->owner);
10894         }
10895     }
10896
10897   /* Functions that don't use the TOC can belong in any TOC group.
10898      Use the last TOC base.  */
10899   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10900   return TRUE;
10901 }
10902
10903 /* Check that all .init and .fini sections use the same toc, if they
10904    have toc relocs.  */
10905
10906 static bfd_boolean
10907 check_pasted_section (struct bfd_link_info *info, const char *name)
10908 {
10909   asection *o = bfd_get_section_by_name (info->output_bfd, name);
10910
10911   if (o != NULL)
10912     {
10913       struct ppc_link_hash_table *htab = ppc_hash_table (info);
10914       bfd_vma toc_off = 0;
10915       asection *i;
10916
10917       for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10918         if (i->has_toc_reloc)
10919           {
10920             if (toc_off == 0)
10921               toc_off = htab->stub_group[i->id].toc_off;
10922             else if (toc_off != htab->stub_group[i->id].toc_off)
10923               return FALSE;
10924           }
10925
10926       if (toc_off == 0)
10927         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10928           if (i->makes_toc_func_call)
10929             {
10930               toc_off = htab->stub_group[i->id].toc_off;
10931               break;
10932             }
10933
10934       /* Make sure the whole pasted function uses the same toc offset.  */
10935       if (toc_off != 0)
10936         for (i = o->map_head.s; i != NULL; i = i->map_head.s)
10937           htab->stub_group[i->id].toc_off = toc_off;
10938     }
10939   return TRUE;
10940 }
10941
10942 bfd_boolean
10943 ppc64_elf_check_init_fini (struct bfd_link_info *info)
10944 {
10945   return (check_pasted_section (info, ".init")
10946           & check_pasted_section (info, ".fini"));
10947 }
10948
10949 /* See whether we can group stub sections together.  Grouping stub
10950    sections may result in fewer stubs.  More importantly, we need to
10951    put all .init* and .fini* stubs at the beginning of the .init or
10952    .fini output sections respectively, because glibc splits the
10953    _init and _fini functions into multiple parts.  Putting a stub in
10954    the middle of a function is not a good idea.  */
10955
10956 static void
10957 group_sections (struct ppc_link_hash_table *htab,
10958                 bfd_size_type stub_group_size,
10959                 bfd_boolean stubs_always_before_branch)
10960 {
10961   asection **list;
10962   bfd_size_type stub14_group_size;
10963   bfd_boolean suppress_size_errors;
10964
10965   suppress_size_errors = FALSE;
10966   stub14_group_size = stub_group_size;
10967   if (stub_group_size == 1)
10968     {
10969       /* Default values.  */
10970       if (stubs_always_before_branch)
10971         {
10972           stub_group_size = 0x1e00000;
10973           stub14_group_size = 0x7800;
10974         }
10975       else
10976         {
10977           stub_group_size = 0x1c00000;
10978           stub14_group_size = 0x7000;
10979         }
10980       suppress_size_errors = TRUE;
10981     }
10982
10983   list = htab->input_list + htab->top_index;
10984   do
10985     {
10986       asection *tail = *list;
10987       while (tail != NULL)
10988         {
10989           asection *curr;
10990           asection *prev;
10991           bfd_size_type total;
10992           bfd_boolean big_sec;
10993           bfd_vma curr_toc;
10994
10995           curr = tail;
10996           total = tail->size;
10997           big_sec = total > (ppc64_elf_section_data (tail) != NULL
10998                              && ppc64_elf_section_data (tail)->has_14bit_branch
10999                              ? stub14_group_size : stub_group_size);
11000           if (big_sec && !suppress_size_errors)
11001             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11002                                      tail->owner, tail);
11003           curr_toc = htab->stub_group[tail->id].toc_off;
11004
11005           while ((prev = PREV_SEC (curr)) != NULL
11006                  && ((total += curr->output_offset - prev->output_offset)
11007                      < (ppc64_elf_section_data (prev) != NULL
11008                         && ppc64_elf_section_data (prev)->has_14bit_branch
11009                         ? stub14_group_size : stub_group_size))
11010                  && htab->stub_group[prev->id].toc_off == curr_toc)
11011             curr = prev;
11012
11013           /* OK, the size from the start of CURR to the end is less
11014              than stub_group_size and thus can be handled by one stub
11015              section.  (or the tail section is itself larger than
11016              stub_group_size, in which case we may be toast.)  We
11017              should really be keeping track of the total size of stubs
11018              added here, as stubs contribute to the final output
11019              section size.  That's a little tricky, and this way will
11020              only break if stubs added make the total size more than
11021              2^25, ie. for the default stub_group_size, if stubs total
11022              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
11023           do
11024             {
11025               prev = PREV_SEC (tail);
11026               /* Set up this stub group.  */
11027               htab->stub_group[tail->id].link_sec = curr;
11028             }
11029           while (tail != curr && (tail = prev) != NULL);
11030
11031           /* But wait, there's more!  Input sections up to stub_group_size
11032              bytes before the stub section can be handled by it too.
11033              Don't do this if we have a really large section after the
11034              stubs, as adding more stubs increases the chance that
11035              branches may not reach into the stub section.  */
11036           if (!stubs_always_before_branch && !big_sec)
11037             {
11038               total = 0;
11039               while (prev != NULL
11040                      && ((total += tail->output_offset - prev->output_offset)
11041                          < (ppc64_elf_section_data (prev) != NULL
11042                             && ppc64_elf_section_data (prev)->has_14bit_branch
11043                             ? stub14_group_size : stub_group_size))
11044                      && htab->stub_group[prev->id].toc_off == curr_toc)
11045                 {
11046                   tail = prev;
11047                   prev = PREV_SEC (tail);
11048                   htab->stub_group[tail->id].link_sec = curr;
11049                 }
11050             }
11051           tail = prev;
11052         }
11053     }
11054   while (list-- != htab->input_list);
11055   free (htab->input_list);
11056 #undef PREV_SEC
11057 }
11058
11059 static const unsigned char glink_eh_frame_cie[] =
11060 {
11061   0, 0, 0, 16,                          /* length.  */
11062   0, 0, 0, 0,                           /* id.  */
11063   1,                                    /* CIE version.  */
11064   'z', 'R', 0,                          /* Augmentation string.  */
11065   4,                                    /* Code alignment.  */
11066   0x78,                                 /* Data alignment.  */
11067   65,                                   /* RA reg.  */
11068   1,                                    /* Augmentation size.  */
11069   DW_EH_PE_pcrel | DW_EH_PE_sdata4,     /* FDE encoding.  */
11070   DW_CFA_def_cfa, 1, 0                  /* def_cfa: r1 offset 0.  */
11071 };
11072
11073 /* Stripping output sections is normally done before dynamic section
11074    symbols have been allocated.  This function is called later, and
11075    handles cases like htab->brlt which is mapped to its own output
11076    section.  */
11077
11078 static void
11079 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11080 {
11081   if (isec->size == 0
11082       && isec->output_section->size == 0
11083       && !bfd_section_removed_from_list (info->output_bfd,
11084                                          isec->output_section)
11085       && elf_section_data (isec->output_section)->dynindx == 0)
11086     {
11087       isec->output_section->flags |= SEC_EXCLUDE;
11088       bfd_section_list_remove (info->output_bfd, isec->output_section);
11089       info->output_bfd->section_count--;
11090     }
11091 }
11092
11093 /* Determine and set the size of the stub section for a final link.
11094
11095    The basic idea here is to examine all the relocations looking for
11096    PC-relative calls to a target that is unreachable with a "bl"
11097    instruction.  */
11098
11099 bfd_boolean
11100 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11101                       bfd_boolean plt_static_chain)
11102 {
11103   bfd_size_type stub_group_size;
11104   bfd_boolean stubs_always_before_branch;
11105   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11106
11107   if (htab == NULL)
11108     return FALSE;
11109
11110   htab->plt_static_chain = plt_static_chain;
11111   stubs_always_before_branch = group_size < 0;
11112   if (group_size < 0)
11113     stub_group_size = -group_size;
11114   else
11115     stub_group_size = group_size;
11116
11117   group_sections (htab, stub_group_size, stubs_always_before_branch);
11118
11119   while (1)
11120     {
11121       bfd *input_bfd;
11122       unsigned int bfd_indx;
11123       asection *stub_sec;
11124
11125       htab->stub_iteration += 1;
11126
11127       for (input_bfd = info->input_bfds, bfd_indx = 0;
11128            input_bfd != NULL;
11129            input_bfd = input_bfd->link_next, bfd_indx++)
11130         {
11131           Elf_Internal_Shdr *symtab_hdr;
11132           asection *section;
11133           Elf_Internal_Sym *local_syms = NULL;
11134
11135           if (!is_ppc64_elf (input_bfd))
11136             continue;
11137
11138           /* We'll need the symbol table in a second.  */
11139           symtab_hdr = &elf_symtab_hdr (input_bfd);
11140           if (symtab_hdr->sh_info == 0)
11141             continue;
11142
11143           /* Walk over each section attached to the input bfd.  */
11144           for (section = input_bfd->sections;
11145                section != NULL;
11146                section = section->next)
11147             {
11148               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11149
11150               /* If there aren't any relocs, then there's nothing more
11151                  to do.  */
11152               if ((section->flags & SEC_RELOC) == 0
11153                   || (section->flags & SEC_ALLOC) == 0
11154                   || (section->flags & SEC_LOAD) == 0
11155                   || (section->flags & SEC_CODE) == 0
11156                   || section->reloc_count == 0)
11157                 continue;
11158
11159               /* If this section is a link-once section that will be
11160                  discarded, then don't create any stubs.  */
11161               if (section->output_section == NULL
11162                   || section->output_section->owner != info->output_bfd)
11163                 continue;
11164
11165               /* Get the relocs.  */
11166               internal_relocs
11167                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11168                                              info->keep_memory);
11169               if (internal_relocs == NULL)
11170                 goto error_ret_free_local;
11171
11172               /* Now examine each relocation.  */
11173               irela = internal_relocs;
11174               irelaend = irela + section->reloc_count;
11175               for (; irela < irelaend; irela++)
11176                 {
11177                   enum elf_ppc64_reloc_type r_type;
11178                   unsigned int r_indx;
11179                   enum ppc_stub_type stub_type;
11180                   struct ppc_stub_hash_entry *stub_entry;
11181                   asection *sym_sec, *code_sec;
11182                   bfd_vma sym_value, code_value;
11183                   bfd_vma destination;
11184                   bfd_boolean ok_dest;
11185                   struct ppc_link_hash_entry *hash;
11186                   struct ppc_link_hash_entry *fdh;
11187                   struct elf_link_hash_entry *h;
11188                   Elf_Internal_Sym *sym;
11189                   char *stub_name;
11190                   const asection *id_sec;
11191                   struct _opd_sec_data *opd;
11192                   struct plt_entry *plt_ent;
11193
11194                   r_type = ELF64_R_TYPE (irela->r_info);
11195                   r_indx = ELF64_R_SYM (irela->r_info);
11196
11197                   if (r_type >= R_PPC64_max)
11198                     {
11199                       bfd_set_error (bfd_error_bad_value);
11200                       goto error_ret_free_internal;
11201                     }
11202
11203                   /* Only look for stubs on branch instructions.  */
11204                   if (r_type != R_PPC64_REL24
11205                       && r_type != R_PPC64_REL14
11206                       && r_type != R_PPC64_REL14_BRTAKEN
11207                       && r_type != R_PPC64_REL14_BRNTAKEN)
11208                     continue;
11209
11210                   /* Now determine the call target, its name, value,
11211                      section.  */
11212                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11213                                   r_indx, input_bfd))
11214                     goto error_ret_free_internal;
11215                   hash = (struct ppc_link_hash_entry *) h;
11216
11217                   ok_dest = FALSE;
11218                   fdh = NULL;
11219                   sym_value = 0;
11220                   if (hash == NULL)
11221                     {
11222                       sym_value = sym->st_value;
11223                       ok_dest = TRUE;
11224                     }
11225                   else if (hash->elf.root.type == bfd_link_hash_defined
11226                            || hash->elf.root.type == bfd_link_hash_defweak)
11227                     {
11228                       sym_value = hash->elf.root.u.def.value;
11229                       if (sym_sec->output_section != NULL)
11230                         ok_dest = TRUE;
11231                     }
11232                   else if (hash->elf.root.type == bfd_link_hash_undefweak
11233                            || hash->elf.root.type == bfd_link_hash_undefined)
11234                     {
11235                       /* Recognise an old ABI func code entry sym, and
11236                          use the func descriptor sym instead if it is
11237                          defined.  */
11238                       if (hash->elf.root.root.string[0] == '.'
11239                           && (fdh = lookup_fdh (hash, htab)) != NULL)
11240                         {
11241                           if (fdh->elf.root.type == bfd_link_hash_defined
11242                               || fdh->elf.root.type == bfd_link_hash_defweak)
11243                             {
11244                               sym_sec = fdh->elf.root.u.def.section;
11245                               sym_value = fdh->elf.root.u.def.value;
11246                               if (sym_sec->output_section != NULL)
11247                                 ok_dest = TRUE;
11248                             }
11249                           else
11250                             fdh = NULL;
11251                         }
11252                     }
11253                   else
11254                     {
11255                       bfd_set_error (bfd_error_bad_value);
11256                       goto error_ret_free_internal;
11257                     }
11258
11259                   destination = 0;
11260                   if (ok_dest)
11261                     {
11262                       sym_value += irela->r_addend;
11263                       destination = (sym_value
11264                                      + sym_sec->output_offset
11265                                      + sym_sec->output_section->vma);
11266                     }
11267
11268                   code_sec = sym_sec;
11269                   code_value = sym_value;
11270                   opd = get_opd_info (sym_sec);
11271                   if (opd != NULL)
11272                     {
11273                       bfd_vma dest;
11274
11275                       if (hash == NULL && opd->adjust != NULL)
11276                         {
11277                           long adjust = opd->adjust[sym_value / 8];
11278                           if (adjust == -1)
11279                             continue;
11280                           code_value += adjust;
11281                           sym_value += adjust;
11282                         }
11283                       dest = opd_entry_value (sym_sec, sym_value,
11284                                               &code_sec, &code_value);
11285                       if (dest != (bfd_vma) -1)
11286                         {
11287                           destination = dest;
11288                           if (fdh != NULL)
11289                             {
11290                               /* Fixup old ABI sym to point at code
11291                                  entry.  */
11292                               hash->elf.root.type = bfd_link_hash_defweak;
11293                               hash->elf.root.u.def.section = code_sec;
11294                               hash->elf.root.u.def.value = code_value;
11295                             }
11296                         }
11297                     }
11298
11299                   /* Determine what (if any) linker stub is needed.  */
11300                   plt_ent = NULL;
11301                   stub_type = ppc_type_of_stub (section, irela, &hash,
11302                                                 &plt_ent, destination);
11303
11304                   if (stub_type != ppc_stub_plt_call)
11305                     {
11306                       /* Check whether we need a TOC adjusting stub.
11307                          Since the linker pastes together pieces from
11308                          different object files when creating the
11309                          _init and _fini functions, it may be that a
11310                          call to what looks like a local sym is in
11311                          fact a call needing a TOC adjustment.  */
11312                       if (code_sec != NULL
11313                           && code_sec->output_section != NULL
11314                           && (htab->stub_group[code_sec->id].toc_off
11315                               != htab->stub_group[section->id].toc_off)
11316                           && (code_sec->has_toc_reloc
11317                               || code_sec->makes_toc_func_call))
11318                         stub_type = ppc_stub_long_branch_r2off;
11319                     }
11320
11321                   if (stub_type == ppc_stub_none)
11322                     continue;
11323
11324                   /* __tls_get_addr calls might be eliminated.  */
11325                   if (stub_type != ppc_stub_plt_call
11326                       && hash != NULL
11327                       && (hash == htab->tls_get_addr
11328                           || hash == htab->tls_get_addr_fd)
11329                       && section->has_tls_reloc
11330                       && irela != internal_relocs)
11331                     {
11332                       /* Get tls info.  */
11333                       unsigned char *tls_mask;
11334
11335                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11336                                          irela - 1, input_bfd))
11337                         goto error_ret_free_internal;
11338                       if (*tls_mask != 0)
11339                         continue;
11340                     }
11341
11342                   if (stub_type == ppc_stub_plt_call
11343                       && irela + 1 < irelaend
11344                       && irela[1].r_offset == irela->r_offset + 4
11345                       && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE
11346                       && !tocsave_find (htab, INSERT,
11347                                         &local_syms, irela + 1, input_bfd))
11348                     goto error_ret_free_internal;
11349
11350                   /* Support for grouping stub sections.  */
11351                   id_sec = htab->stub_group[section->id].link_sec;
11352
11353                   /* Get the name of this stub.  */
11354                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11355                   if (!stub_name)
11356                     goto error_ret_free_internal;
11357
11358                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11359                                                      stub_name, FALSE, FALSE);
11360                   if (stub_entry != NULL)
11361                     {
11362                       /* The proper stub has already been created.  */
11363                       free (stub_name);
11364                       continue;
11365                     }
11366
11367                   stub_entry = ppc_add_stub (stub_name, section, info);
11368                   if (stub_entry == NULL)
11369                     {
11370                       free (stub_name);
11371                     error_ret_free_internal:
11372                       if (elf_section_data (section)->relocs == NULL)
11373                         free (internal_relocs);
11374                     error_ret_free_local:
11375                       if (local_syms != NULL
11376                           && (symtab_hdr->contents
11377                               != (unsigned char *) local_syms))
11378                         free (local_syms);
11379                       return FALSE;
11380                     }
11381
11382                   stub_entry->stub_type = stub_type;
11383                   if (stub_type != ppc_stub_plt_call)
11384                     {
11385                       stub_entry->target_value = code_value;
11386                       stub_entry->target_section = code_sec;
11387                     }
11388                   else
11389                     {
11390                       stub_entry->target_value = sym_value;
11391                       stub_entry->target_section = sym_sec;
11392                     }
11393                   stub_entry->h = hash;
11394                   stub_entry->plt_ent = plt_ent;
11395                   stub_entry->addend = irela->r_addend;
11396
11397                   if (stub_entry->h != NULL)
11398                     htab->stub_globals += 1;
11399                 }
11400
11401               /* We're done with the internal relocs, free them.  */
11402               if (elf_section_data (section)->relocs != internal_relocs)
11403                 free (internal_relocs);
11404             }
11405
11406           if (local_syms != NULL
11407               && symtab_hdr->contents != (unsigned char *) local_syms)
11408             {
11409               if (!info->keep_memory)
11410                 free (local_syms);
11411               else
11412                 symtab_hdr->contents = (unsigned char *) local_syms;
11413             }
11414         }
11415
11416       /* We may have added some stubs.  Find out the new size of the
11417          stub sections.  */
11418       for (stub_sec = htab->stub_bfd->sections;
11419            stub_sec != NULL;
11420            stub_sec = stub_sec->next)
11421         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11422           {
11423             stub_sec->rawsize = stub_sec->size;
11424             stub_sec->size = 0;
11425             stub_sec->reloc_count = 0;
11426             stub_sec->flags &= ~SEC_RELOC;
11427           }
11428
11429       htab->brlt->size = 0;
11430       htab->brlt->reloc_count = 0;
11431       htab->brlt->flags &= ~SEC_RELOC;
11432       if (htab->relbrlt != NULL)
11433         htab->relbrlt->size = 0;
11434
11435       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11436
11437       if (info->emitrelocations
11438           && htab->glink != NULL && htab->glink->size != 0)
11439         {
11440           htab->glink->reloc_count = 1;
11441           htab->glink->flags |= SEC_RELOC;
11442         }
11443
11444       if (htab->glink_eh_frame != NULL
11445           && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11446           && (htab->glink_eh_frame->flags & SEC_EXCLUDE) == 0)
11447         {
11448           bfd_size_type size = 0;
11449
11450           for (stub_sec = htab->stub_bfd->sections;
11451                stub_sec != NULL;
11452                stub_sec = stub_sec->next)
11453             if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11454               size += 20;
11455           if (htab->glink != NULL && htab->glink->size != 0)
11456             size += 24;
11457           if (size != 0)
11458             size += sizeof (glink_eh_frame_cie);
11459           htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11460           htab->glink_eh_frame->size = size;
11461         }
11462
11463       for (stub_sec = htab->stub_bfd->sections;
11464            stub_sec != NULL;
11465            stub_sec = stub_sec->next)
11466         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11467             && stub_sec->rawsize != stub_sec->size)
11468           break;
11469
11470       /* Exit from this loop when no stubs have been added, and no stubs
11471          have changed size.  */
11472       if (stub_sec == NULL
11473           && (htab->glink_eh_frame == NULL
11474               || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11475         break;
11476
11477       /* Ask the linker to do its stuff.  */
11478       (*htab->layout_sections_again) ();
11479     }
11480
11481   maybe_strip_output (info, htab->brlt);
11482   if (htab->glink_eh_frame != NULL)
11483     maybe_strip_output (info, htab->glink_eh_frame);
11484
11485   return TRUE;
11486 }
11487
11488 /* Called after we have determined section placement.  If sections
11489    move, we'll be called again.  Provide a value for TOCstart.  */
11490
11491 bfd_vma
11492 ppc64_elf_toc (bfd *obfd)
11493 {
11494   asection *s;
11495   bfd_vma TOCstart;
11496
11497   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11498      order.  The TOC starts where the first of these sections starts.  */
11499   s = bfd_get_section_by_name (obfd, ".got");
11500   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11501     s = bfd_get_section_by_name (obfd, ".toc");
11502   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11503     s = bfd_get_section_by_name (obfd, ".tocbss");
11504   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11505     s = bfd_get_section_by_name (obfd, ".plt");
11506   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11507     {
11508       /* This may happen for
11509          o  references to TOC base (SYM@toc / TOC[tc0]) without a
11510          .toc directive
11511          o  bad linker script
11512          o --gc-sections and empty TOC sections
11513
11514          FIXME: Warn user?  */
11515
11516       /* Look for a likely section.  We probably won't even be
11517          using TOCstart.  */
11518       for (s = obfd->sections; s != NULL; s = s->next)
11519         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11520                          | SEC_EXCLUDE))
11521             == (SEC_ALLOC | SEC_SMALL_DATA))
11522           break;
11523       if (s == NULL)
11524         for (s = obfd->sections; s != NULL; s = s->next)
11525           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11526               == (SEC_ALLOC | SEC_SMALL_DATA))
11527             break;
11528       if (s == NULL)
11529         for (s = obfd->sections; s != NULL; s = s->next)
11530           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11531               == SEC_ALLOC)
11532             break;
11533       if (s == NULL)
11534         for (s = obfd->sections; s != NULL; s = s->next)
11535           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11536             break;
11537     }
11538
11539   TOCstart = 0;
11540   if (s != NULL)
11541     TOCstart = s->output_section->vma + s->output_offset;
11542
11543   return TOCstart;
11544 }
11545
11546 /* Build all the stubs associated with the current output file.
11547    The stubs are kept in a hash table attached to the main linker
11548    hash table.  This function is called via gldelf64ppc_finish.  */
11549
11550 bfd_boolean
11551 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11552                        struct bfd_link_info *info,
11553                        char **stats)
11554 {
11555   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11556   asection *stub_sec;
11557   bfd_byte *p;
11558   int stub_sec_count = 0;
11559
11560   if (htab == NULL)
11561     return FALSE;
11562
11563   htab->emit_stub_syms = emit_stub_syms;
11564
11565   /* Allocate memory to hold the linker stubs.  */
11566   for (stub_sec = htab->stub_bfd->sections;
11567        stub_sec != NULL;
11568        stub_sec = stub_sec->next)
11569     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11570         && stub_sec->size != 0)
11571       {
11572         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11573         if (stub_sec->contents == NULL)
11574           return FALSE;
11575         /* We want to check that built size is the same as calculated
11576            size.  rawsize is a convenient location to use.  */
11577         stub_sec->rawsize = stub_sec->size;
11578         stub_sec->size = 0;
11579       }
11580
11581   if (htab->glink != NULL && htab->glink->size != 0)
11582     {
11583       unsigned int indx;
11584       bfd_vma plt0;
11585
11586       /* Build the .glink plt call stub.  */
11587       if (htab->emit_stub_syms)
11588         {
11589           struct elf_link_hash_entry *h;
11590           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11591                                     TRUE, FALSE, FALSE);
11592           if (h == NULL)
11593             return FALSE;
11594           if (h->root.type == bfd_link_hash_new)
11595             {
11596               h->root.type = bfd_link_hash_defined;
11597               h->root.u.def.section = htab->glink;
11598               h->root.u.def.value = 8;
11599               h->ref_regular = 1;
11600               h->def_regular = 1;
11601               h->ref_regular_nonweak = 1;
11602               h->forced_local = 1;
11603               h->non_elf = 0;
11604             }
11605         }
11606       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11607       if (info->emitrelocations)
11608         {
11609           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11610           if (r == NULL)
11611             return FALSE;
11612           r->r_offset = (htab->glink->output_offset
11613                          + htab->glink->output_section->vma);
11614           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11615           r->r_addend = plt0;
11616         }
11617       p = htab->glink->contents;
11618       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11619       bfd_put_64 (htab->glink->owner, plt0, p);
11620       p += 8;
11621       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11622       p += 4;
11623       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11624       p += 4;
11625       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11626       p += 4;
11627       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11628       p += 4;
11629       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11630       p += 4;
11631       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11632       p += 4;
11633       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11634       p += 4;
11635       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11636       p += 4;
11637       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11638       p += 4;
11639       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11640       p += 4;
11641       bfd_put_32 (htab->glink->owner, BCTR, p);
11642       p += 4;
11643       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11644         {
11645           bfd_put_32 (htab->glink->owner, NOP, p);
11646           p += 4;
11647         }
11648
11649       /* Build the .glink lazy link call stubs.  */
11650       indx = 0;
11651       while (p < htab->glink->contents + htab->glink->size)
11652         {
11653           if (indx < 0x8000)
11654             {
11655               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11656               p += 4;
11657             }
11658           else
11659             {
11660               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11661               p += 4;
11662               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11663               p += 4;
11664             }
11665           bfd_put_32 (htab->glink->owner,
11666                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11667           indx++;
11668           p += 4;
11669         }
11670       htab->glink->rawsize = p - htab->glink->contents;
11671     }
11672
11673   if (htab->brlt->size != 0)
11674     {
11675       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11676                                          htab->brlt->size);
11677       if (htab->brlt->contents == NULL)
11678         return FALSE;
11679     }
11680   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11681     {
11682       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11683                                             htab->relbrlt->size);
11684       if (htab->relbrlt->contents == NULL)
11685         return FALSE;
11686     }
11687
11688   if (htab->glink_eh_frame != NULL
11689       && htab->glink_eh_frame->size != 0)
11690     {
11691       bfd_vma val;
11692
11693       p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
11694       if (p == NULL)
11695         return FALSE;
11696       htab->glink_eh_frame->contents = p;
11697
11698       htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11699
11700       memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
11701       /* CIE length (rewrite in case little-endian).  */
11702       bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p);
11703       p += sizeof (glink_eh_frame_cie);
11704
11705       for (stub_sec = htab->stub_bfd->sections;
11706            stub_sec != NULL;
11707            stub_sec = stub_sec->next)
11708         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11709           {
11710             /* FDE length.  */
11711             bfd_put_32 (htab->elf.dynobj, 16, p);
11712             p += 4;
11713             /* CIE pointer.  */
11714             val = p - htab->glink_eh_frame->contents;
11715             bfd_put_32 (htab->elf.dynobj, val, p);
11716             p += 4;
11717             /* Offset to stub section.  */
11718             val = (stub_sec->output_section->vma
11719                    + stub_sec->output_offset);
11720             val -= (htab->glink_eh_frame->output_section->vma
11721                     + htab->glink_eh_frame->output_offset);
11722             val -= p - htab->glink_eh_frame->contents;
11723             if (val + 0x80000000 > 0xffffffff)
11724               {
11725                 info->callbacks->einfo
11726                   (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11727                    stub_sec->name);
11728                 return FALSE;
11729               }
11730             bfd_put_32 (htab->elf.dynobj, val, p);
11731             p += 4;
11732             /* stub section size.  */
11733             bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
11734             p += 4;
11735             /* Augmentation.  */
11736             p += 1;
11737             /* Pad.  */
11738             p += 3;
11739           }
11740       if (htab->glink != NULL && htab->glink->size != 0)
11741         {
11742           /* FDE length.  */
11743           bfd_put_32 (htab->elf.dynobj, 20, p);
11744           p += 4;
11745           /* CIE pointer.  */
11746           val = p - htab->glink_eh_frame->contents;
11747           bfd_put_32 (htab->elf.dynobj, val, p);
11748           p += 4;
11749           /* Offset to .glink.  */
11750           val = (htab->glink->output_section->vma
11751                  + htab->glink->output_offset
11752                  + 8);
11753           val -= (htab->glink_eh_frame->output_section->vma
11754                   + htab->glink_eh_frame->output_offset);
11755           val -= p - htab->glink_eh_frame->contents;
11756           if (val + 0x80000000 > 0xffffffff)
11757             {
11758               info->callbacks->einfo
11759                 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
11760                  htab->glink->name);
11761               return FALSE;
11762             }
11763           bfd_put_32 (htab->elf.dynobj, val, p);
11764           p += 4;
11765           /* .glink size.  */
11766           bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
11767           p += 4;
11768           /* Augmentation.  */
11769           p += 1;
11770
11771           *p++ = DW_CFA_advance_loc + 1;
11772           *p++ = DW_CFA_register;
11773           *p++ = 65;
11774           *p++ = 12;
11775           *p++ = DW_CFA_advance_loc + 4;
11776           *p++ = DW_CFA_restore_extended;
11777           *p++ = 65;
11778         }
11779       htab->glink_eh_frame->size = p - htab->glink_eh_frame->contents;
11780     }
11781
11782   /* Build the stubs as directed by the stub hash table.  */
11783   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11784
11785   if (htab->relbrlt != NULL)
11786     htab->relbrlt->reloc_count = 0;
11787
11788   for (stub_sec = htab->stub_bfd->sections;
11789        stub_sec != NULL;
11790        stub_sec = stub_sec->next)
11791     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11792       {
11793         stub_sec_count += 1;
11794         if (stub_sec->rawsize != stub_sec->size)
11795           break;
11796       }
11797
11798   if (stub_sec != NULL
11799       || htab->glink->rawsize != htab->glink->size
11800       || (htab->glink_eh_frame != NULL
11801           && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
11802     {
11803       htab->stub_error = TRUE;
11804       info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
11805     }
11806
11807   if (htab->stub_error)
11808     return FALSE;
11809
11810   if (stats != NULL)
11811     {
11812       *stats = bfd_malloc (500);
11813       if (*stats == NULL)
11814         return FALSE;
11815
11816       sprintf (*stats, _("linker stubs in %u group%s\n"
11817                          "  branch       %lu\n"
11818                          "  toc adjust   %lu\n"
11819                          "  long branch  %lu\n"
11820                          "  long toc adj %lu\n"
11821                          "  plt call     %lu"),
11822                stub_sec_count,
11823                stub_sec_count == 1 ? "" : "s",
11824                htab->stub_count[ppc_stub_long_branch - 1],
11825                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11826                htab->stub_count[ppc_stub_plt_branch - 1],
11827                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11828                htab->stub_count[ppc_stub_plt_call - 1]);
11829     }
11830   return TRUE;
11831 }
11832
11833 /* This function undoes the changes made by add_symbol_adjust.  */
11834
11835 static bfd_boolean
11836 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11837 {
11838   struct ppc_link_hash_entry *eh;
11839
11840   if (h->root.type == bfd_link_hash_indirect)
11841     return TRUE;
11842
11843   eh = (struct ppc_link_hash_entry *) h;
11844   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11845     return TRUE;
11846
11847   eh->elf.root.type = bfd_link_hash_undefined;
11848   return TRUE;
11849 }
11850
11851 void
11852 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11853 {
11854   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11855
11856   if (htab != NULL)
11857     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11858 }
11859
11860 /* What to do when ld finds relocations against symbols defined in
11861    discarded sections.  */
11862
11863 static unsigned int
11864 ppc64_elf_action_discarded (asection *sec)
11865 {
11866   if (strcmp (".opd", sec->name) == 0)
11867     return 0;
11868
11869   if (strcmp (".toc", sec->name) == 0)
11870     return 0;
11871
11872   if (strcmp (".toc1", sec->name) == 0)
11873     return 0;
11874
11875   return _bfd_elf_default_action_discarded (sec);
11876 }
11877
11878 /* The RELOCATE_SECTION function is called by the ELF backend linker
11879    to handle the relocations for a section.
11880
11881    The relocs are always passed as Rela structures; if the section
11882    actually uses Rel structures, the r_addend field will always be
11883    zero.
11884
11885    This function is responsible for adjust the section contents as
11886    necessary, and (if using Rela relocs and generating a
11887    relocatable output file) adjusting the reloc addend as
11888    necessary.
11889
11890    This function does not have to worry about setting the reloc
11891    address or the reloc symbol index.
11892
11893    LOCAL_SYMS is a pointer to the swapped in local symbols.
11894
11895    LOCAL_SECTIONS is an array giving the section in the input file
11896    corresponding to the st_shndx field of each local symbol.
11897
11898    The global hash table entry for the global symbols can be found
11899    via elf_sym_hashes (input_bfd).
11900
11901    When generating relocatable output, this function must handle
11902    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11903    going to be the section symbol corresponding to the output
11904    section, which means that the addend must be adjusted
11905    accordingly.  */
11906
11907 static bfd_boolean
11908 ppc64_elf_relocate_section (bfd *output_bfd,
11909                             struct bfd_link_info *info,
11910                             bfd *input_bfd,
11911                             asection *input_section,
11912                             bfd_byte *contents,
11913                             Elf_Internal_Rela *relocs,
11914                             Elf_Internal_Sym *local_syms,
11915                             asection **local_sections)
11916 {
11917   struct ppc_link_hash_table *htab;
11918   Elf_Internal_Shdr *symtab_hdr;
11919   struct elf_link_hash_entry **sym_hashes;
11920   Elf_Internal_Rela *rel;
11921   Elf_Internal_Rela *relend;
11922   Elf_Internal_Rela outrel;
11923   bfd_byte *loc;
11924   struct got_entry **local_got_ents;
11925   bfd_vma TOCstart;
11926   bfd_boolean ret = TRUE;
11927   bfd_boolean is_opd;
11928   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11929   bfd_boolean is_power4 = FALSE;
11930   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11931
11932   /* Initialize howto table if needed.  */
11933   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11934     ppc_howto_init ();
11935
11936   htab = ppc_hash_table (info);
11937   if (htab == NULL)
11938     return FALSE;
11939
11940   /* Don't relocate stub sections.  */
11941   if (input_section->owner == htab->stub_bfd)
11942     return TRUE;
11943
11944   BFD_ASSERT (is_ppc64_elf (input_bfd));
11945
11946   local_got_ents = elf_local_got_ents (input_bfd);
11947   TOCstart = elf_gp (output_bfd);
11948   symtab_hdr = &elf_symtab_hdr (input_bfd);
11949   sym_hashes = elf_sym_hashes (input_bfd);
11950   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11951
11952   rel = relocs;
11953   relend = relocs + input_section->reloc_count;
11954   for (; rel < relend; rel++)
11955     {
11956       enum elf_ppc64_reloc_type r_type;
11957       bfd_vma addend, orig_addend;
11958       bfd_reloc_status_type r;
11959       Elf_Internal_Sym *sym;
11960       asection *sec;
11961       struct elf_link_hash_entry *h_elf;
11962       struct ppc_link_hash_entry *h;
11963       struct ppc_link_hash_entry *fdh;
11964       const char *sym_name;
11965       unsigned long r_symndx, toc_symndx;
11966       bfd_vma toc_addend;
11967       unsigned char tls_mask, tls_gd, tls_type;
11968       unsigned char sym_type;
11969       bfd_vma relocation;
11970       bfd_boolean unresolved_reloc;
11971       bfd_boolean warned;
11972       unsigned int insn;
11973       unsigned int mask;
11974       struct ppc_stub_hash_entry *stub_entry;
11975       bfd_vma max_br_offset;
11976       bfd_vma from;
11977
11978       r_type = ELF64_R_TYPE (rel->r_info);
11979       r_symndx = ELF64_R_SYM (rel->r_info);
11980
11981       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11982          symbol of the previous ADDR64 reloc.  The symbol gives us the
11983          proper TOC base to use.  */
11984       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11985           && rel != relocs
11986           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11987           && is_opd)
11988         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11989
11990       sym = NULL;
11991       sec = NULL;
11992       h_elf = NULL;
11993       sym_name = NULL;
11994       unresolved_reloc = FALSE;
11995       warned = FALSE;
11996       orig_addend = rel->r_addend;
11997
11998       if (r_symndx < symtab_hdr->sh_info)
11999         {
12000           /* It's a local symbol.  */
12001           struct _opd_sec_data *opd;
12002
12003           sym = local_syms + r_symndx;
12004           sec = local_sections[r_symndx];
12005           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12006           sym_type = ELF64_ST_TYPE (sym->st_info);
12007           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12008           opd = get_opd_info (sec);
12009           if (opd != NULL && opd->adjust != NULL)
12010             {
12011               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12012               if (adjust == -1)
12013                 relocation = 0;
12014               else
12015                 {
12016                   /* If this is a relocation against the opd section sym
12017                      and we have edited .opd, adjust the reloc addend so
12018                      that ld -r and ld --emit-relocs output is correct.
12019                      If it is a reloc against some other .opd symbol,
12020                      then the symbol value will be adjusted later.  */
12021                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12022                     rel->r_addend += adjust;
12023                   else
12024                     relocation += adjust;
12025                 }
12026             }
12027         }
12028       else
12029         {
12030           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12031                                    r_symndx, symtab_hdr, sym_hashes,
12032                                    h_elf, sec, relocation,
12033                                    unresolved_reloc, warned);
12034           sym_name = h_elf->root.root.string;
12035           sym_type = h_elf->type;
12036         }
12037       h = (struct ppc_link_hash_entry *) h_elf;
12038
12039       if (sec != NULL && elf_discarded_section (sec))
12040         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12041                                          rel, relend,
12042                                          ppc64_elf_howto_table[r_type],
12043                                          contents);
12044
12045       if (info->relocatable)
12046         continue;
12047
12048       /* TLS optimizations.  Replace instruction sequences and relocs
12049          based on information we collected in tls_optimize.  We edit
12050          RELOCS so that --emit-relocs will output something sensible
12051          for the final instruction stream.  */
12052       tls_mask = 0;
12053       tls_gd = 0;
12054       toc_symndx = 0;
12055       if (h != NULL)
12056         tls_mask = h->tls_mask;
12057       else if (local_got_ents != NULL)
12058         {
12059           struct plt_entry **local_plt = (struct plt_entry **)
12060             (local_got_ents + symtab_hdr->sh_info);
12061           unsigned char *lgot_masks = (unsigned char *)
12062             (local_plt + symtab_hdr->sh_info);
12063           tls_mask = lgot_masks[r_symndx];
12064         }
12065       if (tls_mask == 0
12066           && (r_type == R_PPC64_TLS
12067               || r_type == R_PPC64_TLSGD
12068               || r_type == R_PPC64_TLSLD))
12069         {
12070           /* Check for toc tls entries.  */
12071           unsigned char *toc_tls;
12072
12073           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12074                              &local_syms, rel, input_bfd))
12075             return FALSE;
12076
12077           if (toc_tls)
12078             tls_mask = *toc_tls;
12079         }
12080
12081       /* Check that tls relocs are used with tls syms, and non-tls
12082          relocs are used with non-tls syms.  */
12083       if (r_symndx != STN_UNDEF
12084           && r_type != R_PPC64_NONE
12085           && (h == NULL
12086               || h->elf.root.type == bfd_link_hash_defined
12087               || h->elf.root.type == bfd_link_hash_defweak)
12088           && (IS_PPC64_TLS_RELOC (r_type)
12089               != (sym_type == STT_TLS
12090                   || (sym_type == STT_SECTION
12091                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12092         {
12093           if (tls_mask != 0
12094               && (r_type == R_PPC64_TLS
12095                   || r_type == R_PPC64_TLSGD
12096                   || r_type == R_PPC64_TLSLD))
12097             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
12098             ;
12099           else
12100             info->callbacks->einfo
12101               (!IS_PPC64_TLS_RELOC (r_type)
12102                ? _("%P: %H: %s used with TLS symbol %s\n")
12103                : _("%P: %H: %s used with non-TLS symbol %s\n"),
12104                input_bfd, input_section, rel->r_offset,
12105                ppc64_elf_howto_table[r_type]->name,
12106                sym_name);
12107         }
12108
12109       /* Ensure reloc mapping code below stays sane.  */
12110       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12111           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12112           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
12113           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12114           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12115           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12116           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
12117           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12118           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12119           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12120         abort ();
12121
12122       switch (r_type)
12123         {
12124         default:
12125           break;
12126
12127         case R_PPC64_LO_DS_OPT:
12128           insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12129           if ((insn & (0x3f << 26)) != 58u << 26)
12130             abort ();
12131           insn += (14u << 26) - (58u << 26);
12132           bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12133           r_type = R_PPC64_TOC16_LO;
12134           rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12135           break;
12136
12137         case R_PPC64_TOC16:
12138         case R_PPC64_TOC16_LO:
12139         case R_PPC64_TOC16_DS:
12140         case R_PPC64_TOC16_LO_DS:
12141           {
12142             /* Check for toc tls entries.  */
12143             unsigned char *toc_tls;
12144             int retval;
12145
12146             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12147                                    &local_syms, rel, input_bfd);
12148             if (retval == 0)
12149               return FALSE;
12150
12151             if (toc_tls)
12152               {
12153                 tls_mask = *toc_tls;
12154                 if (r_type == R_PPC64_TOC16_DS
12155                     || r_type == R_PPC64_TOC16_LO_DS)
12156                   {
12157                     if (tls_mask != 0
12158                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12159                       goto toctprel;
12160                   }
12161                 else
12162                   {
12163                     /* If we found a GD reloc pair, then we might be
12164                        doing a GD->IE transition.  */
12165                     if (retval == 2)
12166                       {
12167                         tls_gd = TLS_TPRELGD;
12168                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12169                           goto tls_ldgd_opt;
12170                       }
12171                     else if (retval == 3)
12172                       {
12173                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12174                           goto tls_ldgd_opt;
12175                       }
12176                   }
12177               }
12178           }
12179           break;
12180
12181         case R_PPC64_GOT_TPREL16_HI:
12182         case R_PPC64_GOT_TPREL16_HA:
12183           if (tls_mask != 0
12184               && (tls_mask & TLS_TPREL) == 0)
12185             {
12186               rel->r_offset -= d_offset;
12187               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12188               r_type = R_PPC64_NONE;
12189               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12190             }
12191           break;
12192
12193         case R_PPC64_GOT_TPREL16_DS:
12194         case R_PPC64_GOT_TPREL16_LO_DS:
12195           if (tls_mask != 0
12196               && (tls_mask & TLS_TPREL) == 0)
12197             {
12198             toctprel:
12199               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12200               insn &= 31 << 21;
12201               insn |= 0x3c0d0000;       /* addis 0,13,0 */
12202               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12203               r_type = R_PPC64_TPREL16_HA;
12204               if (toc_symndx != 0)
12205                 {
12206                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12207                   rel->r_addend = toc_addend;
12208                   /* We changed the symbol.  Start over in order to
12209                      get h, sym, sec etc. right.  */
12210                   rel--;
12211                   continue;
12212                 }
12213               else
12214                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12215             }
12216           break;
12217
12218         case R_PPC64_TLS:
12219           if (tls_mask != 0
12220               && (tls_mask & TLS_TPREL) == 0)
12221             {
12222               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12223               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12224               if (insn == 0)
12225                 abort ();
12226               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12227               /* Was PPC64_TLS which sits on insn boundary, now
12228                  PPC64_TPREL16_LO which is at low-order half-word.  */
12229               rel->r_offset += d_offset;
12230               r_type = R_PPC64_TPREL16_LO;
12231               if (toc_symndx != 0)
12232                 {
12233                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12234                   rel->r_addend = toc_addend;
12235                   /* We changed the symbol.  Start over in order to
12236                      get h, sym, sec etc. right.  */
12237                   rel--;
12238                   continue;
12239                 }
12240               else
12241                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12242             }
12243           break;
12244
12245         case R_PPC64_GOT_TLSGD16_HI:
12246         case R_PPC64_GOT_TLSGD16_HA:
12247           tls_gd = TLS_TPRELGD;
12248           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12249             goto tls_gdld_hi;
12250           break;
12251
12252         case R_PPC64_GOT_TLSLD16_HI:
12253         case R_PPC64_GOT_TLSLD16_HA:
12254           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12255             {
12256             tls_gdld_hi:
12257               if ((tls_mask & tls_gd) != 0)
12258                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12259                           + R_PPC64_GOT_TPREL16_DS);
12260               else
12261                 {
12262                   rel->r_offset -= d_offset;
12263                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12264                   r_type = R_PPC64_NONE;
12265                 }
12266               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12267             }
12268           break;
12269
12270         case R_PPC64_GOT_TLSGD16:
12271         case R_PPC64_GOT_TLSGD16_LO:
12272           tls_gd = TLS_TPRELGD;
12273           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12274             goto tls_ldgd_opt;
12275           break;
12276
12277         case R_PPC64_GOT_TLSLD16:
12278         case R_PPC64_GOT_TLSLD16_LO:
12279           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12280             {
12281               unsigned int insn1, insn2, insn3;
12282               bfd_vma offset;
12283
12284             tls_ldgd_opt:
12285               offset = (bfd_vma) -1;
12286               /* If not using the newer R_PPC64_TLSGD/LD to mark
12287                  __tls_get_addr calls, we must trust that the call
12288                  stays with its arg setup insns, ie. that the next
12289                  reloc is the __tls_get_addr call associated with
12290                  the current reloc.  Edit both insns.  */
12291               if (input_section->has_tls_get_addr_call
12292                   && rel + 1 < relend
12293                   && branch_reloc_hash_match (input_bfd, rel + 1,
12294                                               htab->tls_get_addr,
12295                                               htab->tls_get_addr_fd))
12296                 offset = rel[1].r_offset;
12297               if ((tls_mask & tls_gd) != 0)
12298                 {
12299                   /* IE */
12300                   insn1 = bfd_get_32 (output_bfd,
12301                                       contents + rel->r_offset - d_offset);
12302                   insn1 &= (1 << 26) - (1 << 2);
12303                   insn1 |= 58 << 26;    /* ld */
12304                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12305                   if (offset != (bfd_vma) -1)
12306                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12307                   if ((tls_mask & TLS_EXPLICIT) == 0)
12308                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12309                               + R_PPC64_GOT_TPREL16_DS);
12310                   else
12311                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12312                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12313                 }
12314               else
12315                 {
12316                   /* LE */
12317                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
12318                   insn2 = 0x38630000;   /* addi 3,3,0 */
12319                   if (tls_gd == 0)
12320                     {
12321                       /* Was an LD reloc.  */
12322                       if (toc_symndx)
12323                         sec = local_sections[toc_symndx];
12324                       for (r_symndx = 0;
12325                            r_symndx < symtab_hdr->sh_info;
12326                            r_symndx++)
12327                         if (local_sections[r_symndx] == sec)
12328                           break;
12329                       if (r_symndx >= symtab_hdr->sh_info)
12330                         r_symndx = STN_UNDEF;
12331                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12332                       if (r_symndx != STN_UNDEF)
12333                         rel->r_addend -= (local_syms[r_symndx].st_value
12334                                           + sec->output_offset
12335                                           + sec->output_section->vma);
12336                     }
12337                   else if (toc_symndx != 0)
12338                     {
12339                       r_symndx = toc_symndx;
12340                       rel->r_addend = toc_addend;
12341                     }
12342                   r_type = R_PPC64_TPREL16_HA;
12343                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12344                   if (offset != (bfd_vma) -1)
12345                     {
12346                       rel[1].r_info = ELF64_R_INFO (r_symndx,
12347                                                     R_PPC64_TPREL16_LO);
12348                       rel[1].r_offset = offset + d_offset;
12349                       rel[1].r_addend = rel->r_addend;
12350                     }
12351                 }
12352               bfd_put_32 (output_bfd, insn1,
12353                           contents + rel->r_offset - d_offset);
12354               if (offset != (bfd_vma) -1)
12355                 {
12356                   insn3 = bfd_get_32 (output_bfd,
12357                                       contents + offset + 4);
12358                   if (insn3 == NOP
12359                       || insn3 == CROR_151515 || insn3 == CROR_313131)
12360                     {
12361                       rel[1].r_offset += 4;
12362                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12363                       insn2 = NOP;
12364                     }
12365                   bfd_put_32 (output_bfd, insn2, contents + offset);
12366                 }
12367               if ((tls_mask & tls_gd) == 0
12368                   && (tls_gd == 0 || toc_symndx != 0))
12369                 {
12370                   /* We changed the symbol.  Start over in order
12371                      to get h, sym, sec etc. right.  */
12372                   rel--;
12373                   continue;
12374                 }
12375             }
12376           break;
12377
12378         case R_PPC64_TLSGD:
12379           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12380             {
12381               unsigned int insn2, insn3;
12382               bfd_vma offset = rel->r_offset;
12383
12384               if ((tls_mask & TLS_TPRELGD) != 0)
12385                 {
12386                   /* IE */
12387                   r_type = R_PPC64_NONE;
12388                   insn2 = 0x7c636a14;   /* add 3,3,13 */
12389                 }
12390               else
12391                 {
12392                   /* LE */
12393                   if (toc_symndx != 0)
12394                     {
12395                       r_symndx = toc_symndx;
12396                       rel->r_addend = toc_addend;
12397                     }
12398                   r_type = R_PPC64_TPREL16_LO;
12399                   rel->r_offset = offset + d_offset;
12400                   insn2 = 0x38630000;   /* addi 3,3,0 */
12401                 }
12402               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12403               /* Zap the reloc on the _tls_get_addr call too.  */
12404               BFD_ASSERT (offset == rel[1].r_offset);
12405               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12406               insn3 = bfd_get_32 (output_bfd,
12407                                   contents + offset + 4);
12408               if (insn3 == NOP
12409                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12410                 {
12411                   rel->r_offset += 4;
12412                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12413                   insn2 = NOP;
12414                 }
12415               bfd_put_32 (output_bfd, insn2, contents + offset);
12416               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12417                 {
12418                   rel--;
12419                   continue;
12420                 }
12421             }
12422           break;
12423
12424         case R_PPC64_TLSLD:
12425           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12426             {
12427               unsigned int insn2, insn3;
12428               bfd_vma offset = rel->r_offset;
12429
12430               if (toc_symndx)
12431                 sec = local_sections[toc_symndx];
12432               for (r_symndx = 0;
12433                    r_symndx < symtab_hdr->sh_info;
12434                    r_symndx++)
12435                 if (local_sections[r_symndx] == sec)
12436                   break;
12437               if (r_symndx >= symtab_hdr->sh_info)
12438                 r_symndx = STN_UNDEF;
12439               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12440               if (r_symndx != STN_UNDEF)
12441                 rel->r_addend -= (local_syms[r_symndx].st_value
12442                                   + sec->output_offset
12443                                   + sec->output_section->vma);
12444
12445               r_type = R_PPC64_TPREL16_LO;
12446               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12447               rel->r_offset = offset + d_offset;
12448               /* Zap the reloc on the _tls_get_addr call too.  */
12449               BFD_ASSERT (offset == rel[1].r_offset);
12450               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12451               insn2 = 0x38630000;       /* addi 3,3,0 */
12452               insn3 = bfd_get_32 (output_bfd,
12453                                   contents + offset + 4);
12454               if (insn3 == NOP
12455                   || insn3 == CROR_151515 || insn3 == CROR_313131)
12456                 {
12457                   rel->r_offset += 4;
12458                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12459                   insn2 = NOP;
12460                 }
12461               bfd_put_32 (output_bfd, insn2, contents + offset);
12462               rel--;
12463               continue;
12464             }
12465           break;
12466
12467         case R_PPC64_DTPMOD64:
12468           if (rel + 1 < relend
12469               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12470               && rel[1].r_offset == rel->r_offset + 8)
12471             {
12472               if ((tls_mask & TLS_GD) == 0)
12473                 {
12474                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12475                   if ((tls_mask & TLS_TPRELGD) != 0)
12476                     r_type = R_PPC64_TPREL64;
12477                   else
12478                     {
12479                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12480                       r_type = R_PPC64_NONE;
12481                     }
12482                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12483                 }
12484             }
12485           else
12486             {
12487               if ((tls_mask & TLS_LD) == 0)
12488                 {
12489                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12490                   r_type = R_PPC64_NONE;
12491                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12492                 }
12493             }
12494           break;
12495
12496         case R_PPC64_TPREL64:
12497           if ((tls_mask & TLS_TPREL) == 0)
12498             {
12499               r_type = R_PPC64_NONE;
12500               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12501             }
12502           break;
12503         }
12504
12505       /* Handle other relocations that tweak non-addend part of insn.  */
12506       insn = 0;
12507       max_br_offset = 1 << 25;
12508       addend = rel->r_addend;
12509       switch (r_type)
12510         {
12511         default:
12512           break;
12513
12514         case R_PPC64_TOCSAVE:
12515           if (relocation + addend == (rel->r_offset
12516                                       + input_section->output_offset
12517                                       + input_section->output_section->vma)
12518               && tocsave_find (htab, NO_INSERT,
12519                                &local_syms, rel, input_bfd))
12520             {
12521               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12522               if (insn == NOP
12523                   || insn == CROR_151515 || insn == CROR_313131)
12524                 bfd_put_32 (input_bfd, STD_R2_40R1,
12525                             contents + rel->r_offset);
12526             }
12527           break;
12528
12529           /* Branch taken prediction relocations.  */
12530         case R_PPC64_ADDR14_BRTAKEN:
12531         case R_PPC64_REL14_BRTAKEN:
12532           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
12533           /* Fall thru.  */
12534
12535           /* Branch not taken prediction relocations.  */
12536         case R_PPC64_ADDR14_BRNTAKEN:
12537         case R_PPC64_REL14_BRNTAKEN:
12538           insn |= bfd_get_32 (output_bfd,
12539                               contents + rel->r_offset) & ~(0x01 << 21);
12540           /* Fall thru.  */
12541
12542         case R_PPC64_REL14:
12543           max_br_offset = 1 << 15;
12544           /* Fall thru.  */
12545
12546         case R_PPC64_REL24:
12547           /* Calls to functions with a different TOC, such as calls to
12548              shared objects, need to alter the TOC pointer.  This is
12549              done using a linkage stub.  A REL24 branching to these
12550              linkage stubs needs to be followed by a nop, as the nop
12551              will be replaced with an instruction to restore the TOC
12552              base pointer.  */
12553           fdh = h;
12554           if (h != NULL
12555               && h->oh != NULL
12556               && h->oh->is_func_descriptor)
12557             fdh = ppc_follow_link (h->oh);
12558           stub_entry = ppc_get_stub_entry (input_section, sec, fdh, rel, htab);
12559           if (stub_entry != NULL
12560               && (stub_entry->stub_type == ppc_stub_plt_call
12561                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12562                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12563             {
12564               bfd_boolean can_plt_call = FALSE;
12565
12566               if (rel->r_offset + 8 <= input_section->size)
12567                 {
12568                   unsigned long nop;
12569                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12570                   if (nop == NOP
12571                       || nop == CROR_151515 || nop == CROR_313131)
12572                     {
12573                       if (h != NULL
12574                           && (h == htab->tls_get_addr_fd
12575                               || h == htab->tls_get_addr)
12576                           && !htab->no_tls_get_addr_opt)
12577                         {
12578                           /* Special stub used, leave nop alone.  */
12579                         }
12580                       else
12581                         bfd_put_32 (input_bfd, LD_R2_40R1,
12582                                     contents + rel->r_offset + 4);
12583                       can_plt_call = TRUE;
12584                     }
12585                 }
12586
12587               if (!can_plt_call)
12588                 {
12589                   if (stub_entry->stub_type == ppc_stub_plt_call)
12590                     {
12591                       /* If this is a plain branch rather than a branch
12592                          and link, don't require a nop.  However, don't
12593                          allow tail calls in a shared library as they
12594                          will result in r2 being corrupted.  */
12595                       unsigned long br;
12596                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
12597                       if (info->executable && (br & 1) == 0)
12598                         can_plt_call = TRUE;
12599                       else
12600                         stub_entry = NULL;
12601                     }
12602                   else if (h != NULL
12603                            && strcmp (h->elf.root.root.string,
12604                                       ".__libc_start_main") == 0)
12605                     {
12606                       /* Allow crt1 branch to go via a toc adjusting stub.  */
12607                       can_plt_call = TRUE;
12608                     }
12609                   else
12610                     {
12611                       if (strcmp (input_section->output_section->name,
12612                                   ".init") == 0
12613                           || strcmp (input_section->output_section->name,
12614                                      ".fini") == 0)
12615                         info->callbacks->einfo
12616                           (_("%P: %H: automatic multiple TOCs "
12617                              "not supported using your crt files; "
12618                              "recompile with -mminimal-toc or upgrade gcc\n"),
12619                            input_bfd, input_section, rel->r_offset);
12620                       else
12621                         info->callbacks->einfo
12622                           (_("%P: %H: sibling call optimization to `%s' "
12623                              "does not allow automatic multiple TOCs; "
12624                              "recompile with -mminimal-toc or "
12625                              "-fno-optimize-sibling-calls, "
12626                              "or make `%s' extern\n"),
12627                            input_bfd, input_section, rel->r_offset,
12628                            sym_name,
12629                            sym_name);
12630                       bfd_set_error (bfd_error_bad_value);
12631                       ret = FALSE;
12632                     }
12633                 }
12634
12635               if (can_plt_call
12636                   && stub_entry->stub_type == ppc_stub_plt_call)
12637                 unresolved_reloc = FALSE;
12638             }
12639
12640           if ((stub_entry == NULL
12641                || stub_entry->stub_type == ppc_stub_long_branch
12642                || stub_entry->stub_type == ppc_stub_plt_branch)
12643               && get_opd_info (sec) != NULL)
12644             {
12645               /* The branch destination is the value of the opd entry. */
12646               bfd_vma off = (relocation + addend
12647                              - sec->output_section->vma
12648                              - sec->output_offset);
12649               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
12650               if (dest != (bfd_vma) -1)
12651                 {
12652                   relocation = dest;
12653                   addend = 0;
12654                 }
12655             }
12656
12657           /* If the branch is out of reach we ought to have a long
12658              branch stub.  */
12659           from = (rel->r_offset
12660                   + input_section->output_offset
12661                   + input_section->output_section->vma);
12662
12663           if (stub_entry != NULL
12664               && (stub_entry->stub_type == ppc_stub_long_branch
12665                   || stub_entry->stub_type == ppc_stub_plt_branch)
12666               && (r_type == R_PPC64_ADDR14_BRTAKEN
12667                   || r_type == R_PPC64_ADDR14_BRNTAKEN
12668                   || (relocation + addend - from + max_br_offset
12669                       < 2 * max_br_offset)))
12670             /* Don't use the stub if this branch is in range.  */
12671             stub_entry = NULL;
12672
12673           if (stub_entry != NULL)
12674             {
12675               /* Munge up the value and addend so that we call the stub
12676                  rather than the procedure directly.  */
12677               relocation = (stub_entry->stub_offset
12678                             + stub_entry->stub_sec->output_offset
12679                             + stub_entry->stub_sec->output_section->vma);
12680               addend = 0;
12681
12682               if (stub_entry->stub_type == ppc_stub_plt_call
12683                   && rel + 1 < relend
12684                   && rel[1].r_offset == rel->r_offset + 4
12685                   && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
12686                 relocation += 4;
12687             }
12688
12689           if (insn != 0)
12690             {
12691               if (is_power4)
12692                 {
12693                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
12694                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
12695                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
12696                   if ((insn & (0x14 << 21)) == (0x04 << 21))
12697                     insn |= 0x02 << 21;
12698                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
12699                     insn |= 0x08 << 21;
12700                   else
12701                     break;
12702                 }
12703               else
12704                 {
12705                   /* Invert 'y' bit if not the default.  */
12706                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
12707                     insn ^= 0x01 << 21;
12708                 }
12709
12710               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12711             }
12712
12713           /* NOP out calls to undefined weak functions.
12714              We can thus call a weak function without first
12715              checking whether the function is defined.  */
12716           else if (h != NULL
12717                    && h->elf.root.type == bfd_link_hash_undefweak
12718                    && h->elf.dynindx == -1
12719                    && r_type == R_PPC64_REL24
12720                    && relocation == 0
12721                    && addend == 0)
12722             {
12723               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12724               continue;
12725             }
12726           break;
12727         }
12728
12729       /* Set `addend'.  */
12730       tls_type = 0;
12731       switch (r_type)
12732         {
12733         default:
12734           info->callbacks->einfo
12735             (_("%P: %B: unknown relocation type %d for symbol %s\n"),
12736              input_bfd, (int) r_type, sym_name);
12737
12738           bfd_set_error (bfd_error_bad_value);
12739           ret = FALSE;
12740           continue;
12741
12742         case R_PPC64_NONE:
12743         case R_PPC64_TLS:
12744         case R_PPC64_TLSGD:
12745         case R_PPC64_TLSLD:
12746         case R_PPC64_TOCSAVE:
12747         case R_PPC64_GNU_VTINHERIT:
12748         case R_PPC64_GNU_VTENTRY:
12749           continue;
12750
12751           /* GOT16 relocations.  Like an ADDR16 using the symbol's
12752              address in the GOT as relocation value instead of the
12753              symbol's value itself.  Also, create a GOT entry for the
12754              symbol and put the symbol value there.  */
12755         case R_PPC64_GOT_TLSGD16:
12756         case R_PPC64_GOT_TLSGD16_LO:
12757         case R_PPC64_GOT_TLSGD16_HI:
12758         case R_PPC64_GOT_TLSGD16_HA:
12759           tls_type = TLS_TLS | TLS_GD;
12760           goto dogot;
12761
12762         case R_PPC64_GOT_TLSLD16:
12763         case R_PPC64_GOT_TLSLD16_LO:
12764         case R_PPC64_GOT_TLSLD16_HI:
12765         case R_PPC64_GOT_TLSLD16_HA:
12766           tls_type = TLS_TLS | TLS_LD;
12767           goto dogot;
12768
12769         case R_PPC64_GOT_TPREL16_DS:
12770         case R_PPC64_GOT_TPREL16_LO_DS:
12771         case R_PPC64_GOT_TPREL16_HI:
12772         case R_PPC64_GOT_TPREL16_HA:
12773           tls_type = TLS_TLS | TLS_TPREL;
12774           goto dogot;
12775
12776         case R_PPC64_GOT_DTPREL16_DS:
12777         case R_PPC64_GOT_DTPREL16_LO_DS:
12778         case R_PPC64_GOT_DTPREL16_HI:
12779         case R_PPC64_GOT_DTPREL16_HA:
12780           tls_type = TLS_TLS | TLS_DTPREL;
12781           goto dogot;
12782
12783         case R_PPC64_GOT16:
12784         case R_PPC64_GOT16_LO:
12785         case R_PPC64_GOT16_HI:
12786         case R_PPC64_GOT16_HA:
12787         case R_PPC64_GOT16_DS:
12788         case R_PPC64_GOT16_LO_DS:
12789         dogot:
12790           {
12791             /* Relocation is to the entry for this symbol in the global
12792                offset table.  */
12793             asection *got;
12794             bfd_vma *offp;
12795             bfd_vma off;
12796             unsigned long indx = 0;
12797             struct got_entry *ent;
12798
12799             if (tls_type == (TLS_TLS | TLS_LD)
12800                 && (h == NULL
12801                     || !h->elf.def_dynamic))
12802               ent = ppc64_tlsld_got (input_bfd);
12803             else
12804               {
12805
12806                 if (h != NULL)
12807                   {
12808                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12809                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12810                                                           &h->elf)
12811                         || (info->shared
12812                             && SYMBOL_CALLS_LOCAL (info, &h->elf)))
12813                       /* This is actually a static link, or it is a
12814                          -Bsymbolic link and the symbol is defined
12815                          locally, or the symbol was forced to be local
12816                          because of a version file.  */
12817                       ;
12818                     else
12819                       {
12820                         indx = h->elf.dynindx;
12821                         unresolved_reloc = FALSE;
12822                       }
12823                     ent = h->elf.got.glist;
12824                   }
12825                 else
12826                   {
12827                     if (local_got_ents == NULL)
12828                       abort ();
12829                     ent = local_got_ents[r_symndx];
12830                   }
12831
12832                 for (; ent != NULL; ent = ent->next)
12833                   if (ent->addend == orig_addend
12834                       && ent->owner == input_bfd
12835                       && ent->tls_type == tls_type)
12836                     break;
12837               }
12838
12839             if (ent == NULL)
12840               abort ();
12841             if (ent->is_indirect)
12842               ent = ent->got.ent;
12843             offp = &ent->got.offset;
12844             got = ppc64_elf_tdata (ent->owner)->got;
12845             if (got == NULL)
12846               abort ();
12847
12848             /* The offset must always be a multiple of 8.  We use the
12849                least significant bit to record whether we have already
12850                processed this entry.  */
12851             off = *offp;
12852             if ((off & 1) != 0)
12853               off &= ~1;
12854             else
12855               {
12856                 /* Generate relocs for the dynamic linker, except in
12857                    the case of TLSLD where we'll use one entry per
12858                    module.  */
12859                 asection *relgot;
12860                 bfd_boolean ifunc;
12861
12862                 *offp = off | 1;
12863                 relgot = NULL;
12864                 ifunc = (h != NULL
12865                          ? h->elf.type == STT_GNU_IFUNC
12866                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12867                 if ((info->shared || indx != 0)
12868                     && (h == NULL
12869                         || (tls_type == (TLS_TLS | TLS_LD)
12870                             && !h->elf.def_dynamic)
12871                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12872                         || h->elf.root.type != bfd_link_hash_undefweak))
12873                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12874                 else if (ifunc)
12875                   relgot = htab->reliplt;
12876                 if (relgot != NULL)
12877                   {
12878                     outrel.r_offset = (got->output_section->vma
12879                                        + got->output_offset
12880                                        + off);
12881                     outrel.r_addend = addend;
12882                     if (tls_type & (TLS_LD | TLS_GD))
12883                       {
12884                         outrel.r_addend = 0;
12885                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12886                         if (tls_type == (TLS_TLS | TLS_GD))
12887                           {
12888                             loc = relgot->contents;
12889                             loc += (relgot->reloc_count++
12890                                     * sizeof (Elf64_External_Rela));
12891                             bfd_elf64_swap_reloca_out (output_bfd,
12892                                                        &outrel, loc);
12893                             outrel.r_offset += 8;
12894                             outrel.r_addend = addend;
12895                             outrel.r_info
12896                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12897                           }
12898                       }
12899                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12900                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12901                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12902                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12903                     else if (indx != 0)
12904                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12905                     else
12906                       {
12907                         if (ifunc)
12908                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12909                         else
12910                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12911
12912                         /* Write the .got section contents for the sake
12913                            of prelink.  */
12914                         loc = got->contents + off;
12915                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12916                                     loc);
12917                       }
12918
12919                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12920                       {
12921                         outrel.r_addend += relocation;
12922                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12923                           outrel.r_addend -= htab->elf.tls_sec->vma;
12924                       }
12925                     loc = relgot->contents;
12926                     loc += (relgot->reloc_count++
12927                             * sizeof (Elf64_External_Rela));
12928                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12929                   }
12930
12931                 /* Init the .got section contents here if we're not
12932                    emitting a reloc.  */
12933                 else
12934                   {
12935                     relocation += addend;
12936                     if (tls_type == (TLS_TLS | TLS_LD))
12937                       relocation = 1;
12938                     else if (tls_type != 0)
12939                       {
12940                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12941                         if (tls_type == (TLS_TLS | TLS_TPREL))
12942                           relocation += DTP_OFFSET - TP_OFFSET;
12943
12944                         if (tls_type == (TLS_TLS | TLS_GD))
12945                           {
12946                             bfd_put_64 (output_bfd, relocation,
12947                                         got->contents + off + 8);
12948                             relocation = 1;
12949                           }
12950                       }
12951
12952                     bfd_put_64 (output_bfd, relocation,
12953                                 got->contents + off);
12954                   }
12955               }
12956
12957             if (off >= (bfd_vma) -2)
12958               abort ();
12959
12960             relocation = got->output_section->vma + got->output_offset + off;
12961             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12962           }
12963           break;
12964
12965         case R_PPC64_PLT16_HA:
12966         case R_PPC64_PLT16_HI:
12967         case R_PPC64_PLT16_LO:
12968         case R_PPC64_PLT32:
12969         case R_PPC64_PLT64:
12970           /* Relocation is to the entry for this symbol in the
12971              procedure linkage table.  */
12972
12973           /* Resolve a PLT reloc against a local symbol directly,
12974              without using the procedure linkage table.  */
12975           if (h == NULL)
12976             break;
12977
12978           /* It's possible that we didn't make a PLT entry for this
12979              symbol.  This happens when statically linking PIC code,
12980              or when using -Bsymbolic.  Go find a match if there is a
12981              PLT entry.  */
12982           if (htab->plt != NULL)
12983             {
12984               struct plt_entry *ent;
12985               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12986                 if (ent->addend == orig_addend
12987                     && ent->plt.offset != (bfd_vma) -1)
12988                   {
12989                     relocation = (htab->plt->output_section->vma
12990                                   + htab->plt->output_offset
12991                                   + ent->plt.offset);
12992                     unresolved_reloc = FALSE;
12993                   }
12994             }
12995           break;
12996
12997         case R_PPC64_TOC:
12998           /* Relocation value is TOC base.  */
12999           relocation = TOCstart;
13000           if (r_symndx == STN_UNDEF)
13001             relocation += htab->stub_group[input_section->id].toc_off;
13002           else if (unresolved_reloc)
13003             ;
13004           else if (sec != NULL && sec->id <= htab->top_id)
13005             relocation += htab->stub_group[sec->id].toc_off;
13006           else
13007             unresolved_reloc = TRUE;
13008           goto dodyn;
13009
13010           /* TOC16 relocs.  We want the offset relative to the TOC base,
13011              which is the address of the start of the TOC plus 0x8000.
13012              The TOC consists of sections .got, .toc, .tocbss, and .plt,
13013              in this order.  */
13014         case R_PPC64_TOC16:
13015         case R_PPC64_TOC16_LO:
13016         case R_PPC64_TOC16_HI:
13017         case R_PPC64_TOC16_DS:
13018         case R_PPC64_TOC16_LO_DS:
13019         case R_PPC64_TOC16_HA:
13020           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13021           break;
13022
13023           /* Relocate against the beginning of the section.  */
13024         case R_PPC64_SECTOFF:
13025         case R_PPC64_SECTOFF_LO:
13026         case R_PPC64_SECTOFF_HI:
13027         case R_PPC64_SECTOFF_DS:
13028         case R_PPC64_SECTOFF_LO_DS:
13029         case R_PPC64_SECTOFF_HA:
13030           if (sec != NULL)
13031             addend -= sec->output_section->vma;
13032           break;
13033
13034         case R_PPC64_REL16:
13035         case R_PPC64_REL16_LO:
13036         case R_PPC64_REL16_HI:
13037         case R_PPC64_REL16_HA:
13038           break;
13039
13040         case R_PPC64_REL14:
13041         case R_PPC64_REL14_BRNTAKEN:
13042         case R_PPC64_REL14_BRTAKEN:
13043         case R_PPC64_REL24:
13044           break;
13045
13046         case R_PPC64_TPREL16:
13047         case R_PPC64_TPREL16_LO:
13048         case R_PPC64_TPREL16_HI:
13049         case R_PPC64_TPREL16_HA:
13050         case R_PPC64_TPREL16_DS:
13051         case R_PPC64_TPREL16_LO_DS:
13052         case R_PPC64_TPREL16_HIGHER:
13053         case R_PPC64_TPREL16_HIGHERA:
13054         case R_PPC64_TPREL16_HIGHEST:
13055         case R_PPC64_TPREL16_HIGHESTA:
13056           if (h != NULL
13057               && h->elf.root.type == bfd_link_hash_undefweak
13058               && h->elf.dynindx == -1)
13059             {
13060               /* Make this relocation against an undefined weak symbol
13061                  resolve to zero.  This is really just a tweak, since
13062                  code using weak externs ought to check that they are
13063                  defined before using them.  */
13064               bfd_byte *p = contents + rel->r_offset - d_offset;
13065
13066               insn = bfd_get_32 (output_bfd, p);
13067               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13068               if (insn != 0)
13069                 bfd_put_32 (output_bfd, insn, p);
13070               break;
13071             }
13072           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13073           if (info->shared)
13074             /* The TPREL16 relocs shouldn't really be used in shared
13075                libs as they will result in DT_TEXTREL being set, but
13076                support them anyway.  */
13077             goto dodyn;
13078           break;
13079
13080         case R_PPC64_DTPREL16:
13081         case R_PPC64_DTPREL16_LO:
13082         case R_PPC64_DTPREL16_HI:
13083         case R_PPC64_DTPREL16_HA:
13084         case R_PPC64_DTPREL16_DS:
13085         case R_PPC64_DTPREL16_LO_DS:
13086         case R_PPC64_DTPREL16_HIGHER:
13087         case R_PPC64_DTPREL16_HIGHERA:
13088         case R_PPC64_DTPREL16_HIGHEST:
13089         case R_PPC64_DTPREL16_HIGHESTA:
13090           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13091           break;
13092
13093         case R_PPC64_DTPMOD64:
13094           relocation = 1;
13095           addend = 0;
13096           goto dodyn;
13097
13098         case R_PPC64_TPREL64:
13099           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13100           goto dodyn;
13101
13102         case R_PPC64_DTPREL64:
13103           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13104           /* Fall thru */
13105
13106           /* Relocations that may need to be propagated if this is a
13107              dynamic object.  */
13108         case R_PPC64_REL30:
13109         case R_PPC64_REL32:
13110         case R_PPC64_REL64:
13111         case R_PPC64_ADDR14:
13112         case R_PPC64_ADDR14_BRNTAKEN:
13113         case R_PPC64_ADDR14_BRTAKEN:
13114         case R_PPC64_ADDR16:
13115         case R_PPC64_ADDR16_DS:
13116         case R_PPC64_ADDR16_HA:
13117         case R_PPC64_ADDR16_HI:
13118         case R_PPC64_ADDR16_HIGHER:
13119         case R_PPC64_ADDR16_HIGHERA:
13120         case R_PPC64_ADDR16_HIGHEST:
13121         case R_PPC64_ADDR16_HIGHESTA:
13122         case R_PPC64_ADDR16_LO:
13123         case R_PPC64_ADDR16_LO_DS:
13124         case R_PPC64_ADDR24:
13125         case R_PPC64_ADDR32:
13126         case R_PPC64_ADDR64:
13127         case R_PPC64_UADDR16:
13128         case R_PPC64_UADDR32:
13129         case R_PPC64_UADDR64:
13130         dodyn:
13131           if ((input_section->flags & SEC_ALLOC) == 0)
13132             break;
13133
13134           if (NO_OPD_RELOCS && is_opd)
13135             break;
13136
13137           if ((info->shared
13138                && (h == NULL
13139                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13140                    || h->elf.root.type != bfd_link_hash_undefweak)
13141                && (must_be_dyn_reloc (info, r_type)
13142                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13143               || (ELIMINATE_COPY_RELOCS
13144                   && !info->shared
13145                   && h != NULL
13146                   && h->elf.dynindx != -1
13147                   && !h->elf.non_got_ref
13148                   && !h->elf.def_regular)
13149               || (!info->shared
13150                   && (h != NULL
13151                       ? h->elf.type == STT_GNU_IFUNC
13152                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13153             {
13154               bfd_boolean skip, relocate;
13155               asection *sreloc;
13156               bfd_vma out_off;
13157
13158               /* When generating a dynamic object, these relocations
13159                  are copied into the output file to be resolved at run
13160                  time.  */
13161
13162               skip = FALSE;
13163               relocate = FALSE;
13164
13165               out_off = _bfd_elf_section_offset (output_bfd, info,
13166                                                  input_section, rel->r_offset);
13167               if (out_off == (bfd_vma) -1)
13168                 skip = TRUE;
13169               else if (out_off == (bfd_vma) -2)
13170                 skip = TRUE, relocate = TRUE;
13171               out_off += (input_section->output_section->vma
13172                           + input_section->output_offset);
13173               outrel.r_offset = out_off;
13174               outrel.r_addend = rel->r_addend;
13175
13176               /* Optimize unaligned reloc use.  */
13177               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13178                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13179                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13180               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13181                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13182                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13183               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13184                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13185                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13186
13187               if (skip)
13188                 memset (&outrel, 0, sizeof outrel);
13189               else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13190                        && !is_opd
13191                        && r_type != R_PPC64_TOC)
13192                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13193               else
13194                 {
13195                   /* This symbol is local, or marked to become local,
13196                      or this is an opd section reloc which must point
13197                      at a local function.  */
13198                   outrel.r_addend += relocation;
13199                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13200                     {
13201                       if (is_opd && h != NULL)
13202                         {
13203                           /* Lie about opd entries.  This case occurs
13204                              when building shared libraries and we
13205                              reference a function in another shared
13206                              lib.  The same thing happens for a weak
13207                              definition in an application that's
13208                              overridden by a strong definition in a
13209                              shared lib.  (I believe this is a generic
13210                              bug in binutils handling of weak syms.)
13211                              In these cases we won't use the opd
13212                              entry in this lib.  */
13213                           unresolved_reloc = FALSE;
13214                         }
13215                       if (!is_opd
13216                           && r_type == R_PPC64_ADDR64
13217                           && (h != NULL
13218                               ? h->elf.type == STT_GNU_IFUNC
13219                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13220                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13221                       else
13222                         {
13223                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13224
13225                           /* We need to relocate .opd contents for ld.so.
13226                              Prelink also wants simple and consistent rules
13227                              for relocs.  This make all RELATIVE relocs have
13228                              *r_offset equal to r_addend.  */
13229                           relocate = TRUE;
13230                         }
13231                     }
13232                   else
13233                     {
13234                       long indx = 0;
13235
13236                       if (h != NULL
13237                           ? h->elf.type == STT_GNU_IFUNC
13238                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13239                         {
13240                           info->callbacks->einfo
13241                             (_("%P: %H: relocation %s for indirect "
13242                                "function %s unsupported\n"),
13243                              input_bfd, input_section, rel->r_offset,
13244                              ppc64_elf_howto_table[r_type]->name,
13245                              sym_name);
13246                           ret = FALSE;
13247                         }
13248                       else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13249                         ;
13250                       else if (sec == NULL || sec->owner == NULL)
13251                         {
13252                           bfd_set_error (bfd_error_bad_value);
13253                           return FALSE;
13254                         }
13255                       else
13256                         {
13257                           asection *osec;
13258
13259                           osec = sec->output_section;
13260                           indx = elf_section_data (osec)->dynindx;
13261
13262                           if (indx == 0)
13263                             {
13264                               if ((osec->flags & SEC_READONLY) == 0
13265                                   && htab->elf.data_index_section != NULL)
13266                                 osec = htab->elf.data_index_section;
13267                               else
13268                                 osec = htab->elf.text_index_section;
13269                               indx = elf_section_data (osec)->dynindx;
13270                             }
13271                           BFD_ASSERT (indx != 0);
13272
13273                           /* We are turning this relocation into one
13274                              against a section symbol, so subtract out
13275                              the output section's address but not the
13276                              offset of the input section in the output
13277                              section.  */
13278                           outrel.r_addend -= osec->vma;
13279                         }
13280
13281                       outrel.r_info = ELF64_R_INFO (indx, r_type);
13282                     }
13283                 }
13284
13285               sreloc = elf_section_data (input_section)->sreloc;
13286               if (!htab->elf.dynamic_sections_created)
13287                 sreloc = htab->reliplt;
13288               if (sreloc == NULL)
13289                 abort ();
13290
13291               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13292                   >= sreloc->size)
13293                 abort ();
13294               loc = sreloc->contents;
13295               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13296               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13297
13298               /* If this reloc is against an external symbol, it will
13299                  be computed at runtime, so there's no need to do
13300                  anything now.  However, for the sake of prelink ensure
13301                  that the section contents are a known value.  */
13302               if (! relocate)
13303                 {
13304                   unresolved_reloc = FALSE;
13305                   /* The value chosen here is quite arbitrary as ld.so
13306                      ignores section contents except for the special
13307                      case of .opd where the contents might be accessed
13308                      before relocation.  Choose zero, as that won't
13309                      cause reloc overflow.  */
13310                   relocation = 0;
13311                   addend = 0;
13312                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13313                      to improve backward compatibility with older
13314                      versions of ld.  */
13315                   if (r_type == R_PPC64_ADDR64)
13316                     addend = outrel.r_addend;
13317                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
13318                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
13319                     addend = (input_section->output_section->vma
13320                               + input_section->output_offset
13321                               + rel->r_offset);
13322                 }
13323             }
13324           break;
13325
13326         case R_PPC64_COPY:
13327         case R_PPC64_GLOB_DAT:
13328         case R_PPC64_JMP_SLOT:
13329         case R_PPC64_JMP_IREL:
13330         case R_PPC64_RELATIVE:
13331           /* We shouldn't ever see these dynamic relocs in relocatable
13332              files.  */
13333           /* Fall through.  */
13334
13335         case R_PPC64_PLTGOT16:
13336         case R_PPC64_PLTGOT16_DS:
13337         case R_PPC64_PLTGOT16_HA:
13338         case R_PPC64_PLTGOT16_HI:
13339         case R_PPC64_PLTGOT16_LO:
13340         case R_PPC64_PLTGOT16_LO_DS:
13341         case R_PPC64_PLTREL32:
13342         case R_PPC64_PLTREL64:
13343           /* These ones haven't been implemented yet.  */
13344
13345           info->callbacks->einfo
13346             (_("%P: %B: relocation %s is not supported for symbol %s\n"),
13347              input_bfd,
13348              ppc64_elf_howto_table[r_type]->name, sym_name);
13349
13350           bfd_set_error (bfd_error_invalid_operation);
13351           ret = FALSE;
13352           continue;
13353         }
13354
13355       /* Multi-instruction sequences that access the TOC can be
13356          optimized, eg. addis ra,r2,0; addi rb,ra,x;
13357          to             nop;           addi rb,r2,x;  */
13358       switch (r_type)
13359         {
13360         default:
13361           break;
13362
13363         case R_PPC64_GOT_TLSLD16_HI:
13364         case R_PPC64_GOT_TLSGD16_HI:
13365         case R_PPC64_GOT_TPREL16_HI:
13366         case R_PPC64_GOT_DTPREL16_HI:
13367         case R_PPC64_GOT16_HI:
13368         case R_PPC64_TOC16_HI:
13369           /* These relocs would only be useful if building up an
13370              offset to later add to r2, perhaps in an indexed
13371              addressing mode instruction.  Don't try to optimize.
13372              Unfortunately, the possibility of someone building up an
13373              offset like this or even with the HA relocs, means that
13374              we need to check the high insn when optimizing the low
13375              insn.  */
13376           break;
13377
13378         case R_PPC64_GOT_TLSLD16_HA:
13379         case R_PPC64_GOT_TLSGD16_HA:
13380         case R_PPC64_GOT_TPREL16_HA:
13381         case R_PPC64_GOT_DTPREL16_HA:
13382         case R_PPC64_GOT16_HA:
13383         case R_PPC64_TOC16_HA:
13384           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13385               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13386             {
13387               bfd_byte *p = contents + (rel->r_offset & ~3);
13388               bfd_put_32 (input_bfd, NOP, p);
13389             }
13390           break;
13391
13392         case R_PPC64_GOT_TLSLD16_LO:
13393         case R_PPC64_GOT_TLSGD16_LO:
13394         case R_PPC64_GOT_TPREL16_LO_DS:
13395         case R_PPC64_GOT_DTPREL16_LO_DS:
13396         case R_PPC64_GOT16_LO:
13397         case R_PPC64_GOT16_LO_DS:
13398         case R_PPC64_TOC16_LO:
13399         case R_PPC64_TOC16_LO_DS:
13400           if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13401               && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13402             {
13403               bfd_byte *p = contents + (rel->r_offset & ~3);
13404               insn = bfd_get_32 (input_bfd, p);
13405               if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13406                 {
13407                   /* Transform addic to addi when we change reg.  */
13408                   insn &= ~((0x3f << 26) | (0x1f << 16));
13409                   insn |= (14u << 26) | (2 << 16);
13410                 }
13411               else
13412                 {
13413                   insn &= ~(0x1f << 16);
13414                   insn |= 2 << 16;
13415                 }
13416               bfd_put_32 (input_bfd, insn, p);
13417             }
13418           break;
13419         }
13420
13421       /* Do any further special processing.  */
13422       switch (r_type)
13423         {
13424         default:
13425           break;
13426
13427         case R_PPC64_ADDR16_HA:
13428         case R_PPC64_REL16_HA:
13429         case R_PPC64_ADDR16_HIGHERA:
13430         case R_PPC64_ADDR16_HIGHESTA:
13431         case R_PPC64_TOC16_HA:
13432         case R_PPC64_SECTOFF_HA:
13433         case R_PPC64_TPREL16_HA:
13434         case R_PPC64_DTPREL16_HA:
13435         case R_PPC64_TPREL16_HIGHER:
13436         case R_PPC64_TPREL16_HIGHERA:
13437         case R_PPC64_TPREL16_HIGHEST:
13438         case R_PPC64_TPREL16_HIGHESTA:
13439         case R_PPC64_DTPREL16_HIGHER:
13440         case R_PPC64_DTPREL16_HIGHERA:
13441         case R_PPC64_DTPREL16_HIGHEST:
13442         case R_PPC64_DTPREL16_HIGHESTA:
13443           /* It's just possible that this symbol is a weak symbol
13444              that's not actually defined anywhere. In that case,
13445              'sec' would be NULL, and we should leave the symbol
13446              alone (it will be set to zero elsewhere in the link).  */
13447           if (sec == NULL)
13448             break;
13449           /* Fall thru */
13450
13451         case R_PPC64_GOT16_HA:
13452         case R_PPC64_PLTGOT16_HA:
13453         case R_PPC64_PLT16_HA:
13454         case R_PPC64_GOT_TLSGD16_HA:
13455         case R_PPC64_GOT_TLSLD16_HA:
13456         case R_PPC64_GOT_TPREL16_HA:
13457         case R_PPC64_GOT_DTPREL16_HA:
13458           /* Add 0x10000 if sign bit in 0:15 is set.
13459              Bits 0:15 are not used.  */
13460           addend += 0x8000;
13461           break;
13462
13463         case R_PPC64_ADDR16_DS:
13464         case R_PPC64_ADDR16_LO_DS:
13465         case R_PPC64_GOT16_DS:
13466         case R_PPC64_GOT16_LO_DS:
13467         case R_PPC64_PLT16_LO_DS:
13468         case R_PPC64_SECTOFF_DS:
13469         case R_PPC64_SECTOFF_LO_DS:
13470         case R_PPC64_TOC16_DS:
13471         case R_PPC64_TOC16_LO_DS:
13472         case R_PPC64_PLTGOT16_DS:
13473         case R_PPC64_PLTGOT16_LO_DS:
13474         case R_PPC64_GOT_TPREL16_DS:
13475         case R_PPC64_GOT_TPREL16_LO_DS:
13476         case R_PPC64_GOT_DTPREL16_DS:
13477         case R_PPC64_GOT_DTPREL16_LO_DS:
13478         case R_PPC64_TPREL16_DS:
13479         case R_PPC64_TPREL16_LO_DS:
13480         case R_PPC64_DTPREL16_DS:
13481         case R_PPC64_DTPREL16_LO_DS:
13482           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13483           mask = 3;
13484           /* If this reloc is against an lq insn, then the value must be
13485              a multiple of 16.  This is somewhat of a hack, but the
13486              "correct" way to do this by defining _DQ forms of all the
13487              _DS relocs bloats all reloc switches in this file.  It
13488              doesn't seem to make much sense to use any of these relocs
13489              in data, so testing the insn should be safe.  */
13490           if ((insn & (0x3f << 26)) == (56u << 26))
13491             mask = 15;
13492           if (((relocation + addend) & mask) != 0)
13493             {
13494               info->callbacks->einfo
13495                 (_("%P: %H: error: %s not a multiple of %u\n"),
13496                  input_bfd, input_section, rel->r_offset,
13497                  ppc64_elf_howto_table[r_type]->name,
13498                  mask + 1);
13499               bfd_set_error (bfd_error_bad_value);
13500               ret = FALSE;
13501               continue;
13502             }
13503           break;
13504         }
13505
13506       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13507          because such sections are not SEC_ALLOC and thus ld.so will
13508          not process them.  */
13509       if (unresolved_reloc
13510           && !((input_section->flags & SEC_DEBUGGING) != 0
13511                && h->elf.def_dynamic)
13512           && _bfd_elf_section_offset (output_bfd, info, input_section,
13513                                       rel->r_offset) != (bfd_vma) -1)
13514         {
13515           info->callbacks->einfo
13516             (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"),
13517              input_bfd, input_section, rel->r_offset,
13518              ppc64_elf_howto_table[(int) r_type]->name,
13519              h->elf.root.root.string);
13520           ret = FALSE;
13521         }
13522
13523       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13524                                     input_bfd,
13525                                     input_section,
13526                                     contents,
13527                                     rel->r_offset,
13528                                     relocation,
13529                                     addend);
13530
13531       if (r != bfd_reloc_ok)
13532         {
13533           if (sym_name == NULL)
13534             sym_name = "(null)";
13535           if (r == bfd_reloc_overflow)
13536             {
13537               if (warned)
13538                 continue;
13539               if (h != NULL
13540                   && h->elf.root.type == bfd_link_hash_undefweak
13541                   && ppc64_elf_howto_table[r_type]->pc_relative)
13542                 {
13543                   /* Assume this is a call protected by other code that
13544                      detects the symbol is undefined.  If this is the case,
13545                      we can safely ignore the overflow.  If not, the
13546                      program is hosed anyway, and a little warning isn't
13547                      going to help.  */
13548
13549                   continue;
13550                 }
13551
13552               if (!((*info->callbacks->reloc_overflow)
13553                     (info, (h ? &h->elf.root : NULL), sym_name,
13554                      ppc64_elf_howto_table[r_type]->name,
13555                      orig_addend, input_bfd, input_section, rel->r_offset)))
13556                 return FALSE;
13557             }
13558           else
13559             {
13560               info->callbacks->einfo
13561                 (_("%P: %H: %s reloc against `%s': error %d\n"),
13562                  input_bfd, input_section, rel->r_offset,
13563                  ppc64_elf_howto_table[r_type]->name,
13564                  sym_name,
13565                  (int) r);
13566               ret = FALSE;
13567             }
13568         }
13569     }
13570
13571   /* If we're emitting relocations, then shortly after this function
13572      returns, reloc offsets and addends for this section will be
13573      adjusted.  Worse, reloc symbol indices will be for the output
13574      file rather than the input.  Save a copy of the relocs for
13575      opd_entry_value.  */
13576   if (is_opd && (info->emitrelocations || info->relocatable))
13577     {
13578       bfd_size_type amt;
13579       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
13580       rel = bfd_alloc (input_bfd, amt);
13581       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
13582       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
13583       if (rel == NULL)
13584         return FALSE;
13585       memcpy (rel, relocs, amt);
13586     }
13587   return ret;
13588 }
13589
13590 /* Adjust the value of any local symbols in opd sections.  */
13591
13592 static int
13593 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
13594                               const char *name ATTRIBUTE_UNUSED,
13595                               Elf_Internal_Sym *elfsym,
13596                               asection *input_sec,
13597                               struct elf_link_hash_entry *h)
13598 {
13599   struct _opd_sec_data *opd;
13600   long adjust;
13601   bfd_vma value;
13602
13603   if (h != NULL)
13604     return 1;
13605
13606   opd = get_opd_info (input_sec);
13607   if (opd == NULL || opd->adjust == NULL)
13608     return 1;
13609
13610   value = elfsym->st_value - input_sec->output_offset;
13611   if (!info->relocatable)
13612     value -= input_sec->output_section->vma;
13613
13614   adjust = opd->adjust[value / 8];
13615   if (adjust == -1)
13616     return 2;
13617
13618   elfsym->st_value += adjust;
13619   return 1;
13620 }
13621
13622 /* Finish up dynamic symbol handling.  We set the contents of various
13623    dynamic sections here.  */
13624
13625 static bfd_boolean
13626 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
13627                                  struct bfd_link_info *info,
13628                                  struct elf_link_hash_entry *h,
13629                                  Elf_Internal_Sym *sym)
13630 {
13631   struct ppc_link_hash_table *htab;
13632   struct plt_entry *ent;
13633   Elf_Internal_Rela rela;
13634   bfd_byte *loc;
13635
13636   htab = ppc_hash_table (info);
13637   if (htab == NULL)
13638     return FALSE;
13639
13640   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13641     if (ent->plt.offset != (bfd_vma) -1)
13642       {
13643         /* This symbol has an entry in the procedure linkage
13644            table.  Set it up.  */
13645         if (!htab->elf.dynamic_sections_created
13646             || h->dynindx == -1)
13647           {
13648             BFD_ASSERT (h->type == STT_GNU_IFUNC
13649                         && h->def_regular
13650                         && (h->root.type == bfd_link_hash_defined
13651                             || h->root.type == bfd_link_hash_defweak));
13652             rela.r_offset = (htab->iplt->output_section->vma
13653                              + htab->iplt->output_offset
13654                              + ent->plt.offset);
13655             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13656             rela.r_addend = (h->root.u.def.value
13657                              + h->root.u.def.section->output_offset
13658                              + h->root.u.def.section->output_section->vma
13659                              + ent->addend);
13660             loc = (htab->reliplt->contents
13661                    + (htab->reliplt->reloc_count++
13662                       * sizeof (Elf64_External_Rela)));
13663           }
13664         else
13665           {
13666             rela.r_offset = (htab->plt->output_section->vma
13667                              + htab->plt->output_offset
13668                              + ent->plt.offset);
13669             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13670             rela.r_addend = ent->addend;
13671             loc = (htab->relplt->contents
13672                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
13673                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
13674           }
13675         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13676       }
13677
13678   if (h->needs_copy)
13679     {
13680       /* This symbol needs a copy reloc.  Set it up.  */
13681
13682       if (h->dynindx == -1
13683           || (h->root.type != bfd_link_hash_defined
13684               && h->root.type != bfd_link_hash_defweak)
13685           || htab->relbss == NULL)
13686         abort ();
13687
13688       rela.r_offset = (h->root.u.def.value
13689                        + h->root.u.def.section->output_section->vma
13690                        + h->root.u.def.section->output_offset);
13691       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
13692       rela.r_addend = 0;
13693       loc = htab->relbss->contents;
13694       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
13695       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
13696     }
13697
13698   /* Mark some specially defined symbols as absolute.  */
13699   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
13700     sym->st_shndx = SHN_ABS;
13701
13702   return TRUE;
13703 }
13704
13705 /* Used to decide how to sort relocs in an optimal manner for the
13706    dynamic linker, before writing them out.  */
13707
13708 static enum elf_reloc_type_class
13709 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
13710 {
13711   enum elf_ppc64_reloc_type r_type;
13712
13713   r_type = ELF64_R_TYPE (rela->r_info);
13714   switch (r_type)
13715     {
13716     case R_PPC64_RELATIVE:
13717       return reloc_class_relative;
13718     case R_PPC64_JMP_SLOT:
13719       return reloc_class_plt;
13720     case R_PPC64_COPY:
13721       return reloc_class_copy;
13722     default:
13723       return reloc_class_normal;
13724     }
13725 }
13726
13727 /* Finish up the dynamic sections.  */
13728
13729 static bfd_boolean
13730 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
13731                                    struct bfd_link_info *info)
13732 {
13733   struct ppc_link_hash_table *htab;
13734   bfd *dynobj;
13735   asection *sdyn;
13736
13737   htab = ppc_hash_table (info);
13738   if (htab == NULL)
13739     return FALSE;
13740
13741   dynobj = htab->elf.dynobj;
13742   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13743
13744   if (htab->elf.dynamic_sections_created)
13745     {
13746       Elf64_External_Dyn *dyncon, *dynconend;
13747
13748       if (sdyn == NULL || htab->got == NULL)
13749         abort ();
13750
13751       dyncon = (Elf64_External_Dyn *) sdyn->contents;
13752       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
13753       for (; dyncon < dynconend; dyncon++)
13754         {
13755           Elf_Internal_Dyn dyn;
13756           asection *s;
13757
13758           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
13759
13760           switch (dyn.d_tag)
13761             {
13762             default:
13763               continue;
13764
13765             case DT_PPC64_GLINK:
13766               s = htab->glink;
13767               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13768               /* We stupidly defined DT_PPC64_GLINK to be the start
13769                  of glink rather than the first entry point, which is
13770                  what ld.so needs, and now have a bigger stub to
13771                  support automatic multiple TOCs.  */
13772               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
13773               break;
13774
13775             case DT_PPC64_OPD:
13776               s = bfd_get_section_by_name (output_bfd, ".opd");
13777               if (s == NULL)
13778                 continue;
13779               dyn.d_un.d_ptr = s->vma;
13780               break;
13781
13782             case DT_PPC64_OPDSZ:
13783               s = bfd_get_section_by_name (output_bfd, ".opd");
13784               if (s == NULL)
13785                 continue;
13786               dyn.d_un.d_val = s->size;
13787               break;
13788
13789             case DT_PLTGOT:
13790               s = htab->plt;
13791               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13792               break;
13793
13794             case DT_JMPREL:
13795               s = htab->relplt;
13796               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
13797               break;
13798
13799             case DT_PLTRELSZ:
13800               dyn.d_un.d_val = htab->relplt->size;
13801               break;
13802
13803             case DT_RELASZ:
13804               /* Don't count procedure linkage table relocs in the
13805                  overall reloc count.  */
13806               s = htab->relplt;
13807               if (s == NULL)
13808                 continue;
13809               dyn.d_un.d_val -= s->size;
13810               break;
13811
13812             case DT_RELA:
13813               /* We may not be using the standard ELF linker script.
13814                  If .rela.plt is the first .rela section, we adjust
13815                  DT_RELA to not include it.  */
13816               s = htab->relplt;
13817               if (s == NULL)
13818                 continue;
13819               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
13820                 continue;
13821               dyn.d_un.d_ptr += s->size;
13822               break;
13823             }
13824
13825           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
13826         }
13827     }
13828
13829   if (htab->got != NULL && htab->got->size != 0)
13830     {
13831       /* Fill in the first entry in the global offset table.
13832          We use it to hold the link-time TOCbase.  */
13833       bfd_put_64 (output_bfd,
13834                   elf_gp (output_bfd) + TOC_BASE_OFF,
13835                   htab->got->contents);
13836
13837       /* Set .got entry size.  */
13838       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13839     }
13840
13841   if (htab->plt != NULL && htab->plt->size != 0)
13842     {
13843       /* Set .plt entry size.  */
13844       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13845         = PLT_ENTRY_SIZE;
13846     }
13847
13848   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13849      brlt ourselves if emitrelocations.  */
13850   if (htab->brlt != NULL
13851       && htab->brlt->reloc_count != 0
13852       && !_bfd_elf_link_output_relocs (output_bfd,
13853                                        htab->brlt,
13854                                        elf_section_data (htab->brlt)->rela.hdr,
13855                                        elf_section_data (htab->brlt)->relocs,
13856                                        NULL))
13857     return FALSE;
13858
13859   if (htab->glink != NULL
13860       && htab->glink->reloc_count != 0
13861       && !_bfd_elf_link_output_relocs (output_bfd,
13862                                        htab->glink,
13863                                        elf_section_data (htab->glink)->rela.hdr,
13864                                        elf_section_data (htab->glink)->relocs,
13865                                        NULL))
13866     return FALSE;
13867
13868
13869   if (htab->glink_eh_frame != NULL
13870       && htab->glink_eh_frame->sec_info_type == ELF_INFO_TYPE_EH_FRAME
13871       && !_bfd_elf_write_section_eh_frame (output_bfd, info,
13872                                            htab->glink_eh_frame,
13873                                            htab->glink_eh_frame->contents))
13874     return FALSE;
13875
13876   /* We need to handle writing out multiple GOT sections ourselves,
13877      since we didn't add them to DYNOBJ.  We know dynobj is the first
13878      bfd.  */
13879   while ((dynobj = dynobj->link_next) != NULL)
13880     {
13881       asection *s;
13882
13883       if (!is_ppc64_elf (dynobj))
13884         continue;
13885
13886       s = ppc64_elf_tdata (dynobj)->got;
13887       if (s != NULL
13888           && s->size != 0
13889           && s->output_section != bfd_abs_section_ptr
13890           && !bfd_set_section_contents (output_bfd, s->output_section,
13891                                         s->contents, s->output_offset,
13892                                         s->size))
13893         return FALSE;
13894       s = ppc64_elf_tdata (dynobj)->relgot;
13895       if (s != NULL
13896           && s->size != 0
13897           && s->output_section != bfd_abs_section_ptr
13898           && !bfd_set_section_contents (output_bfd, s->output_section,
13899                                         s->contents, s->output_offset,
13900                                         s->size))
13901         return FALSE;
13902     }
13903
13904   return TRUE;
13905 }
13906
13907 #include "elf64-target.h"
13908
13909 /* FreeBSD support */
13910
13911 #undef  TARGET_LITTLE_SYM
13912 #undef  TARGET_LITTLE_NAME
13913
13914 #undef  TARGET_BIG_SYM
13915 #define TARGET_BIG_SYM  bfd_elf64_powerpc_freebsd_vec
13916 #undef  TARGET_BIG_NAME
13917 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
13918
13919 #undef  ELF_OSABI
13920 #define ELF_OSABI       ELFOSABI_FREEBSD
13921
13922 #undef  elf64_bed
13923 #define elf64_bed       elf64_powerpc_fbsd_bed
13924
13925 #include "elf64-target.h"
13926