bfd/elf64-ppc.c

   1 /* PowerPC64-specific support for 64-bit ELF.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010 Free Software Foundation, Inc.
   4    Written by Linus Nordberg, Swox AB <info@swox.com>,
   5    based on elf32-ppc.c by Ian Lance Taylor.
   6    Largely rewritten by Alan Modra.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  23
  24
  25 /* The 64-bit PowerPC ELF ABI may be found at
  26    http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
  27    http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html  */
  28
  29 #include "sysdep.h"
  30 #include <stdarg.h>
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/ppc64.h"
  36 #include "elf64-ppc.h"
  37
  38 static bfd_reloc_status_type ppc64_elf_ha_reloc
  39   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  40 static bfd_reloc_status_type ppc64_elf_branch_reloc
  41   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
  43   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type ppc64_elf_toc_reloc
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_vma opd_entry_value
  57   (asection *, bfd_vma, asection **, bfd_vma *);
  58
  59 #define TARGET_LITTLE_SYM       bfd_elf64_powerpcle_vec
  60 #define TARGET_LITTLE_NAME      "elf64-powerpcle"
  61 #define TARGET_BIG_SYM          bfd_elf64_powerpc_vec
  62 #define TARGET_BIG_NAME         "elf64-powerpc"
  63 #define ELF_ARCH                bfd_arch_powerpc
  64 #define ELF_MACHINE_CODE        EM_PPC64
  65 #define ELF_MAXPAGESIZE         0x10000
  66 #define ELF_COMMONPAGESIZE      0x1000
  67 #define elf_info_to_howto       ppc64_elf_info_to_howto
  68
  69 #define elf_backend_want_got_sym 0
  70 #define elf_backend_want_plt_sym 0
  71 #define elf_backend_plt_alignment 3
  72 #define elf_backend_plt_not_loaded 1
  73 #define elf_backend_got_header_size 8
  74 #define elf_backend_can_gc_sections 1
  75 #define elf_backend_can_refcount 1
  76 #define elf_backend_rela_normal 1
  77 #define elf_backend_default_execstack 0
  78
  79 #define bfd_elf64_mkobject                    ppc64_elf_mkobject
  80 #define bfd_elf64_bfd_reloc_type_lookup       ppc64_elf_reloc_type_lookup
  81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
  82 #define bfd_elf64_bfd_merge_private_bfd_data  ppc64_elf_merge_private_bfd_data
  83 #define bfd_elf64_new_section_hook            ppc64_elf_new_section_hook
  84 #define bfd_elf64_bfd_link_hash_table_create  ppc64_elf_link_hash_table_create
  85 #define bfd_elf64_bfd_link_hash_table_free    ppc64_elf_link_hash_table_free
  86 #define bfd_elf64_get_synthetic_symtab        ppc64_elf_get_synthetic_symtab
  87
  88 #define elf_backend_object_p                  ppc64_elf_object_p
  89 #define elf_backend_grok_prstatus             ppc64_elf_grok_prstatus
  90 #define elf_backend_grok_psinfo               ppc64_elf_grok_psinfo
  91 #define elf_backend_write_core_note           ppc64_elf_write_core_note
  92 #define elf_backend_create_dynamic_sections   ppc64_elf_create_dynamic_sections
  93 #define elf_backend_copy_indirect_symbol      ppc64_elf_copy_indirect_symbol
  94 #define elf_backend_add_symbol_hook           ppc64_elf_add_symbol_hook
  95 #define elf_backend_check_directives          ppc64_elf_process_dot_syms
  96 #define elf_backend_as_needed_cleanup         ppc64_elf_as_needed_cleanup
  97 #define elf_backend_archive_symbol_lookup     ppc64_elf_archive_symbol_lookup
  98 #define elf_backend_check_relocs              ppc64_elf_check_relocs
  99 #define elf_backend_gc_keep                   ppc64_elf_gc_keep
 100 #define elf_backend_gc_mark_dynamic_ref       ppc64_elf_gc_mark_dynamic_ref
 101 #define elf_backend_gc_mark_hook              ppc64_elf_gc_mark_hook
 102 #define elf_backend_gc_sweep_hook             ppc64_elf_gc_sweep_hook
 103 #define elf_backend_adjust_dynamic_symbol     ppc64_elf_adjust_dynamic_symbol
 104 #define elf_backend_hide_symbol               ppc64_elf_hide_symbol
 105 #define elf_backend_always_size_sections      ppc64_elf_func_desc_adjust
 106 #define elf_backend_size_dynamic_sections     ppc64_elf_size_dynamic_sections
 107 #define elf_backend_init_index_section        _bfd_elf_init_2_index_sections
 108 #define elf_backend_action_discarded          ppc64_elf_action_discarded
 109 #define elf_backend_relocate_section          ppc64_elf_relocate_section
 110 #define elf_backend_finish_dynamic_symbol     ppc64_elf_finish_dynamic_symbol
 111 #define elf_backend_reloc_type_class          ppc64_elf_reloc_type_class
 112 #define elf_backend_finish_dynamic_sections   ppc64_elf_finish_dynamic_sections
 113 #define elf_backend_link_output_symbol_hook   ppc64_elf_output_symbol_hook
 114 #define elf_backend_special_sections          ppc64_elf_special_sections
 115 #define elf_backend_post_process_headers      _bfd_elf_set_osabi
 116
 117 /* The name of the dynamic interpreter.  This is put in the .interp
 118    section.  */
 119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 120
 121 /* The size in bytes of an entry in the procedure linkage table.  */
 122 #define PLT_ENTRY_SIZE 24
 123
 124 /* The initial size of the plt reserved for the dynamic linker.  */
 125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
 126
 127 /* TOC base pointers offset from start of TOC.  */
 128 #define TOC_BASE_OFF    0x8000
 129
 130 /* Offset of tp and dtp pointers from start of TLS block.  */
 131 #define TP_OFFSET       0x7000
 132 #define DTP_OFFSET      0x8000
 133
 134 /* .plt call stub instructions.  The normal stub is like this, but
 135    sometimes the .plt entry crosses a 64k boundary and we need to
 136    insert an addi to adjust r12.  */
 137 #define PLT_CALL_STUB_SIZE (7*4)
 138 #define ADDIS_R12_R2    0x3d820000      /* addis %r12,%r2,xxx@ha     */
 139 #define STD_R2_40R1     0xf8410028      /* std   %r2,40(%r1)         */
 140 #define LD_R11_0R12     0xe96c0000      /* ld    %r11,xxx+0@l(%r12)  */
 141 #define MTCTR_R11       0x7d6903a6      /* mtctr %r11                */
 142 #define LD_R2_0R12      0xe84c0000      /* ld    %r2,xxx+8@l(%r12)   */
 143                                         /* ld    %r11,xxx+16@l(%r12) */
 144 #define BCTR            0x4e800420      /* bctr                      */
 145
 146
 147 #define ADDIS_R12_R12   0x3d8c0000      /* addis %r12,%r12,off@ha  */
 148 #define ADDI_R12_R12    0x398c0000      /* addi %r12,%r12,off@l  */
 149 #define ADDIS_R2_R2     0x3c420000      /* addis %r2,%r2,off@ha  */
 150 #define ADDI_R2_R2      0x38420000      /* addi  %r2,%r2,off@l   */
 151
 152 #define LD_R11_0R2      0xe9620000      /* ld    %r11,xxx+0(%r2) */
 153 #define LD_R2_0R2       0xe8420000      /* ld    %r2,xxx+0(%r2)  */
 154
 155 #define LD_R2_40R1      0xe8410028      /* ld    %r2,40(%r1)     */
 156
 157 /* glink call stub instructions.  We enter with the index in R0.  */
 158 #define GLINK_CALL_STUB_SIZE (16*4)
 159                                         /* 0:                           */
 160                                         /*  .quad plt0-1f               */
 161                                         /* __glink:                     */
 162 #define MFLR_R12        0x7d8802a6      /*  mflr %12                    */
 163 #define BCL_20_31       0x429f0005      /*  bcl 20,31,1f                */
 164                                         /* 1:                           */
 165 #define MFLR_R11        0x7d6802a6      /*  mflr %11                    */
 166 #define LD_R2_M16R11    0xe84bfff0      /*  ld %2,(0b-1b)(%11)          */
 167 #define MTLR_R12        0x7d8803a6      /*  mtlr %12                    */
 168 #define ADD_R12_R2_R11  0x7d825a14      /*  add %12,%2,%11              */
 169                                         /*  ld %11,0(%12)               */
 170                                         /*  ld %2,8(%12)                */
 171                                         /*  mtctr %11                   */
 172                                         /*  ld %11,16(%12)              */
 173                                         /*  bctr                        */
 174
 175 /* Pad with this.  */
 176 #define NOP             0x60000000
 177
 178 /* Some other nops.  */
 179 #define CROR_151515     0x4def7b82
 180 #define CROR_313131     0x4ffffb82
 181
 182 /* .glink entries for the first 32k functions are two instructions.  */
 183 #define LI_R0_0         0x38000000      /* li    %r0,0          */
 184 #define B_DOT           0x48000000      /* b     .              */
 185
 186 /* After that, we need two instructions to load the index, followed by
 187    a branch.  */
 188 #define LIS_R0_0        0x3c000000      /* lis   %r0,0          */
 189 #define ORI_R0_R0_0     0x60000000      /* ori   %r0,%r0,0      */
 190
 191 /* Instructions used by the save and restore reg functions.  */
 192 #define STD_R0_0R1      0xf8010000      /* std   %r0,0(%r1)     */
 193 #define STD_R0_0R12     0xf80c0000      /* std   %r0,0(%r12)    */
 194 #define LD_R0_0R1       0xe8010000      /* ld    %r0,0(%r1)     */
 195 #define LD_R0_0R12      0xe80c0000      /* ld    %r0,0(%r12)    */
 196 #define STFD_FR0_0R1    0xd8010000      /* stfd  %fr0,0(%r1)    */
 197 #define LFD_FR0_0R1     0xc8010000      /* lfd   %fr0,0(%r1)    */
 198 #define LI_R12_0        0x39800000      /* li    %r12,0         */
 199 #define STVX_VR0_R12_R0 0x7c0c01ce      /* stvx  %v0,%r12,%r0   */
 200 #define LVX_VR0_R12_R0  0x7c0c00ce      /* lvx   %v0,%r12,%r0   */
 201 #define MTLR_R0         0x7c0803a6      /* mtlr  %r0            */
 202 #define BLR             0x4e800020      /* blr                  */
 203
 204 /* Since .opd is an array of descriptors and each entry will end up
 205    with identical R_PPC64_RELATIVE relocs, there is really no need to
 206    propagate .opd relocs;  The dynamic linker should be taught to
 207    relocate .opd without reloc entries.  */
 208 #ifndef NO_OPD_RELOCS
 209 #define NO_OPD_RELOCS 0
 210 #endif
 211 \f
 212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
 213
 214 /* Relocation HOWTO's.  */
 215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
 216
 217 static reloc_howto_type ppc64_elf_howto_raw[] = {
 218   /* This reloc does nothing.  */
 219   HOWTO (R_PPC64_NONE,          /* type */
 220          0,                     /* rightshift */
 221          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          FALSE,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_dont, /* complain_on_overflow */
 226          bfd_elf_generic_reloc, /* special_function */
 227          "R_PPC64_NONE",        /* name */
 228          FALSE,                 /* partial_inplace */
 229          0,                     /* src_mask */
 230          0,                     /* dst_mask */
 231          FALSE),                /* pcrel_offset */
 232
 233   /* A standard 32 bit relocation.  */
 234   HOWTO (R_PPC64_ADDR32,        /* type */
 235          0,                     /* rightshift */
 236          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 237          32,                    /* bitsize */
 238          FALSE,                 /* pc_relative */
 239          0,                     /* bitpos */
 240          complain_overflow_bitfield, /* complain_on_overflow */
 241          bfd_elf_generic_reloc, /* special_function */
 242          "R_PPC64_ADDR32",      /* name */
 243          FALSE,                 /* partial_inplace */
 244          0,                     /* src_mask */
 245          0xffffffff,            /* dst_mask */
 246          FALSE),                /* pcrel_offset */
 247
 248   /* An absolute 26 bit branch; the lower two bits must be zero.
 249      FIXME: we don't check that, we just clear them.  */
 250   HOWTO (R_PPC64_ADDR24,        /* type */
 251          0,                     /* rightshift */
 252          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          26,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_bitfield, /* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_PPC64_ADDR24",      /* name */
 259          FALSE,                 /* partial_inplace */
 260          0,                     /* src_mask */
 261          0x03fffffc,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   /* A standard 16 bit relocation.  */
 265   HOWTO (R_PPC64_ADDR16,        /* type */
 266          0,                     /* rightshift */
 267          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 268          16,                    /* bitsize */
 269          FALSE,                 /* pc_relative */
 270          0,                     /* bitpos */
 271          complain_overflow_bitfield, /* complain_on_overflow */
 272          bfd_elf_generic_reloc, /* special_function */
 273          "R_PPC64_ADDR16",      /* name */
 274          FALSE,                 /* partial_inplace */
 275          0,                     /* src_mask */
 276          0xffff,                /* dst_mask */
 277          FALSE),                /* pcrel_offset */
 278
 279   /* A 16 bit relocation without overflow.  */
 280   HOWTO (R_PPC64_ADDR16_LO,     /* type */
 281          0,                     /* rightshift */
 282          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          16,                    /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_dont,/* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_PPC64_ADDR16_LO",   /* name */
 289          FALSE,                 /* partial_inplace */
 290          0,                     /* src_mask */
 291          0xffff,                /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* Bits 16-31 of an address.  */
 295   HOWTO (R_PPC64_ADDR16_HI,     /* type */
 296          16,                    /* rightshift */
 297          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          16,                    /* bitsize */
 299          FALSE,                 /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_dont, /* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_PPC64_ADDR16_HI",   /* name */
 304          FALSE,                 /* partial_inplace */
 305          0,                     /* src_mask */
 306          0xffff,                /* dst_mask */
 307          FALSE),                /* pcrel_offset */
 308
 309   /* Bits 16-31 of an address, plus 1 if the contents of the low 16
 310      bits, treated as a signed number, is negative.  */
 311   HOWTO (R_PPC64_ADDR16_HA,     /* type */
 312          16,                    /* rightshift */
 313          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 314          16,                    /* bitsize */
 315          FALSE,                 /* pc_relative */
 316          0,                     /* bitpos */
 317          complain_overflow_dont, /* complain_on_overflow */
 318          ppc64_elf_ha_reloc,    /* special_function */
 319          "R_PPC64_ADDR16_HA",   /* name */
 320          FALSE,                 /* partial_inplace */
 321          0,                     /* src_mask */
 322          0xffff,                /* dst_mask */
 323          FALSE),                /* pcrel_offset */
 324
 325   /* An absolute 16 bit branch; the lower two bits must be zero.
 326      FIXME: we don't check that, we just clear them.  */
 327   HOWTO (R_PPC64_ADDR14,        /* type */
 328          0,                     /* rightshift */
 329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 330          16,                    /* bitsize */
 331          FALSE,                 /* pc_relative */
 332          0,                     /* bitpos */
 333          complain_overflow_bitfield, /* complain_on_overflow */
 334          ppc64_elf_branch_reloc, /* special_function */
 335          "R_PPC64_ADDR14",      /* name */
 336          FALSE,                 /* partial_inplace */
 337          0,                     /* src_mask */
 338          0x0000fffc,            /* dst_mask */
 339          FALSE),                /* pcrel_offset */
 340
 341   /* An absolute 16 bit branch, for which bit 10 should be set to
 342      indicate that the branch is expected to be taken.  The lower two
 343      bits must be zero.  */
 344   HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
 345          0,                     /* rightshift */
 346          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 347          16,                    /* bitsize */
 348          FALSE,                 /* pc_relative */
 349          0,                     /* bitpos */
 350          complain_overflow_bitfield, /* complain_on_overflow */
 351          ppc64_elf_brtaken_reloc, /* special_function */
 352          "R_PPC64_ADDR14_BRTAKEN",/* name */
 353          FALSE,                 /* partial_inplace */
 354          0,                     /* src_mask */
 355          0x0000fffc,            /* dst_mask */
 356          FALSE),                /* pcrel_offset */
 357
 358   /* An absolute 16 bit branch, for which bit 10 should be set to
 359      indicate that the branch is not expected to be taken.  The lower
 360      two bits must be zero.  */
 361   HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
 362          0,                     /* rightshift */
 363          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 364          16,                    /* bitsize */
 365          FALSE,                 /* pc_relative */
 366          0,                     /* bitpos */
 367          complain_overflow_bitfield, /* complain_on_overflow */
 368          ppc64_elf_brtaken_reloc, /* special_function */
 369          "R_PPC64_ADDR14_BRNTAKEN",/* name */
 370          FALSE,                 /* partial_inplace */
 371          0,                     /* src_mask */
 372          0x0000fffc,            /* dst_mask */
 373          FALSE),                /* pcrel_offset */
 374
 375   /* A relative 26 bit branch; the lower two bits must be zero.  */
 376   HOWTO (R_PPC64_REL24,         /* type */
 377          0,                     /* rightshift */
 378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 379          26,                    /* bitsize */
 380          TRUE,                  /* pc_relative */
 381          0,                     /* bitpos */
 382          complain_overflow_signed, /* complain_on_overflow */
 383          ppc64_elf_branch_reloc, /* special_function */
 384          "R_PPC64_REL24",       /* name */
 385          FALSE,                 /* partial_inplace */
 386          0,                     /* src_mask */
 387          0x03fffffc,            /* dst_mask */
 388          TRUE),                 /* pcrel_offset */
 389
 390   /* A relative 16 bit branch; the lower two bits must be zero.  */
 391   HOWTO (R_PPC64_REL14,         /* type */
 392          0,                     /* rightshift */
 393          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 394          16,                    /* bitsize */
 395          TRUE,                  /* pc_relative */
 396          0,                     /* bitpos */
 397          complain_overflow_signed, /* complain_on_overflow */
 398          ppc64_elf_branch_reloc, /* special_function */
 399          "R_PPC64_REL14",       /* name */
 400          FALSE,                 /* partial_inplace */
 401          0,                     /* src_mask */
 402          0x0000fffc,            /* dst_mask */
 403          TRUE),                 /* pcrel_offset */
 404
 405   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 406      the branch is expected to be taken.  The lower two bits must be
 407      zero.  */
 408   HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          16,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_signed, /* complain_on_overflow */
 415          ppc64_elf_brtaken_reloc, /* special_function */
 416          "R_PPC64_REL14_BRTAKEN", /* name */
 417          FALSE,                 /* partial_inplace */
 418          0,                     /* src_mask */
 419          0x0000fffc,            /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   /* A relative 16 bit branch.  Bit 10 should be set to indicate that
 423      the branch is not expected to be taken.  The lower two bits must
 424      be zero.  */
 425   HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
 426          0,                     /* rightshift */
 427          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 428          16,                    /* bitsize */
 429          TRUE,                  /* pc_relative */
 430          0,                     /* bitpos */
 431          complain_overflow_signed, /* complain_on_overflow */
 432          ppc64_elf_brtaken_reloc, /* special_function */
 433          "R_PPC64_REL14_BRNTAKEN",/* name */
 434          FALSE,                 /* partial_inplace */
 435          0,                     /* src_mask */
 436          0x0000fffc,            /* dst_mask */
 437          TRUE),                 /* pcrel_offset */
 438
 439   /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
 440      symbol.  */
 441   HOWTO (R_PPC64_GOT16,         /* type */
 442          0,                     /* rightshift */
 443          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 444          16,                    /* bitsize */
 445          FALSE,                 /* pc_relative */
 446          0,                     /* bitpos */
 447          complain_overflow_signed, /* complain_on_overflow */
 448          ppc64_elf_unhandled_reloc, /* special_function */
 449          "R_PPC64_GOT16",       /* name */
 450          FALSE,                 /* partial_inplace */
 451          0,                     /* src_mask */
 452          0xffff,                /* dst_mask */
 453          FALSE),                /* pcrel_offset */
 454
 455   /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
 456      the symbol.  */
 457   HOWTO (R_PPC64_GOT16_LO,      /* type */
 458          0,                     /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          ppc64_elf_unhandled_reloc, /* special_function */
 465          "R_PPC64_GOT16_LO",    /* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
 472      the symbol.  */
 473   HOWTO (R_PPC64_GOT16_HI,      /* type */
 474          16,                    /* rightshift */
 475          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 476          16,                    /* bitsize */
 477          FALSE,                 /* pc_relative */
 478          0,                     /* bitpos */
 479          complain_overflow_dont,/* complain_on_overflow */
 480          ppc64_elf_unhandled_reloc, /* special_function */
 481          "R_PPC64_GOT16_HI",    /* name */
 482          FALSE,                 /* partial_inplace */
 483          0,                     /* src_mask */
 484          0xffff,                /* dst_mask */
 485          FALSE),                /* pcrel_offset */
 486
 487   /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
 488      the symbol.  */
 489   HOWTO (R_PPC64_GOT16_HA,      /* type */
 490          16,                    /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_dont,/* complain_on_overflow */
 496          ppc64_elf_unhandled_reloc, /* special_function */
 497          "R_PPC64_GOT16_HA",    /* name */
 498          FALSE,                 /* partial_inplace */
 499          0,                     /* src_mask */
 500          0xffff,                /* dst_mask */
 501          FALSE),                /* pcrel_offset */
 502
 503   /* This is used only by the dynamic linker.  The symbol should exist
 504      both in the object being run and in some shared library.  The
 505      dynamic linker copies the data addressed by the symbol from the
 506      shared library into the object, because the object being
 507      run has to have the data at some particular address.  */
 508   HOWTO (R_PPC64_COPY,          /* type */
 509          0,                     /* rightshift */
 510          0,                     /* this one is variable size */
 511          0,                     /* bitsize */
 512          FALSE,                 /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_dont, /* complain_on_overflow */
 515          ppc64_elf_unhandled_reloc, /* special_function */
 516          "R_PPC64_COPY",        /* name */
 517          FALSE,                 /* partial_inplace */
 518          0,                     /* src_mask */
 519          0,                     /* dst_mask */
 520          FALSE),                /* pcrel_offset */
 521
 522   /* Like R_PPC64_ADDR64, but used when setting global offset table
 523      entries.  */
 524   HOWTO (R_PPC64_GLOB_DAT,      /* type */
 525          0,                     /* rightshift */
 526          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 527          64,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_dont, /* complain_on_overflow */
 531          ppc64_elf_unhandled_reloc,  /* special_function */
 532          "R_PPC64_GLOB_DAT",    /* name */
 533          FALSE,                 /* partial_inplace */
 534          0,                     /* src_mask */
 535          ONES (64),             /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   /* Created by the link editor.  Marks a procedure linkage table
 539      entry for a symbol.  */
 540   HOWTO (R_PPC64_JMP_SLOT,      /* type */
 541          0,                     /* rightshift */
 542          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          0,                     /* bitsize */
 544          FALSE,                 /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont, /* complain_on_overflow */
 547          ppc64_elf_unhandled_reloc, /* special_function */
 548          "R_PPC64_JMP_SLOT",    /* name */
 549          FALSE,                 /* partial_inplace */
 550          0,                     /* src_mask */
 551          0,                     /* dst_mask */
 552          FALSE),                /* pcrel_offset */
 553
 554   /* Used only by the dynamic linker.  When the object is run, this
 555      doubleword64 is set to the load address of the object, plus the
 556      addend.  */
 557   HOWTO (R_PPC64_RELATIVE,      /* type */
 558          0,                     /* rightshift */
 559          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 560          64,                    /* bitsize */
 561          FALSE,                 /* pc_relative */
 562          0,                     /* bitpos */
 563          complain_overflow_dont, /* complain_on_overflow */
 564          bfd_elf_generic_reloc, /* special_function */
 565          "R_PPC64_RELATIVE",    /* name */
 566          FALSE,                 /* partial_inplace */
 567          0,                     /* src_mask */
 568          ONES (64),             /* dst_mask */
 569          FALSE),                /* pcrel_offset */
 570
 571   /* Like R_PPC64_ADDR32, but may be unaligned.  */
 572   HOWTO (R_PPC64_UADDR32,       /* type */
 573          0,                     /* rightshift */
 574          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 575          32,                    /* bitsize */
 576          FALSE,                 /* pc_relative */
 577          0,                     /* bitpos */
 578          complain_overflow_bitfield, /* complain_on_overflow */
 579          bfd_elf_generic_reloc, /* special_function */
 580          "R_PPC64_UADDR32",     /* name */
 581          FALSE,                 /* partial_inplace */
 582          0,                     /* src_mask */
 583          0xffffffff,            /* dst_mask */
 584          FALSE),                /* pcrel_offset */
 585
 586   /* Like R_PPC64_ADDR16, but may be unaligned.  */
 587   HOWTO (R_PPC64_UADDR16,       /* type */
 588          0,                     /* rightshift */
 589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 590          16,                    /* bitsize */
 591          FALSE,                 /* pc_relative */
 592          0,                     /* bitpos */
 593          complain_overflow_bitfield, /* complain_on_overflow */
 594          bfd_elf_generic_reloc, /* special_function */
 595          "R_PPC64_UADDR16",     /* name */
 596          FALSE,                 /* partial_inplace */
 597          0,                     /* src_mask */
 598          0xffff,                /* dst_mask */
 599          FALSE),                /* pcrel_offset */
 600
 601   /* 32-bit PC relative.  */
 602   HOWTO (R_PPC64_REL32,         /* type */
 603          0,                     /* rightshift */
 604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 605          32,                    /* bitsize */
 606          TRUE,                  /* pc_relative */
 607          0,                     /* bitpos */
 608          /* FIXME: Verify.  Was complain_overflow_bitfield.  */
 609          complain_overflow_signed, /* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_PPC64_REL32",       /* name */
 612          FALSE,                 /* partial_inplace */
 613          0,                     /* src_mask */
 614          0xffffffff,            /* dst_mask */
 615          TRUE),                 /* pcrel_offset */
 616
 617   /* 32-bit relocation to the symbol's procedure linkage table.  */
 618   HOWTO (R_PPC64_PLT32,         /* type */
 619          0,                     /* rightshift */
 620          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 621          32,                    /* bitsize */
 622          FALSE,                 /* pc_relative */
 623          0,                     /* bitpos */
 624          complain_overflow_bitfield, /* complain_on_overflow */
 625          ppc64_elf_unhandled_reloc, /* special_function */
 626          "R_PPC64_PLT32",       /* name */
 627          FALSE,                 /* partial_inplace */
 628          0,                     /* src_mask */
 629          0xffffffff,            /* dst_mask */
 630          FALSE),                /* pcrel_offset */
 631
 632   /* 32-bit PC relative relocation to the symbol's procedure linkage table.
 633      FIXME: R_PPC64_PLTREL32 not supported.  */
 634   HOWTO (R_PPC64_PLTREL32,      /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          TRUE,                  /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_signed, /* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_PPC64_PLTREL32",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0,                     /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          TRUE),                 /* pcrel_offset */
 647
 648   /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
 649      the symbol.  */
 650   HOWTO (R_PPC64_PLT16_LO,      /* type */
 651          0,                     /* rightshift */
 652          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          16,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont, /* complain_on_overflow */
 657          ppc64_elf_unhandled_reloc, /* special_function */
 658          "R_PPC64_PLT16_LO",    /* name */
 659          FALSE,                 /* partial_inplace */
 660          0,                     /* src_mask */
 661          0xffff,                /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
 665      the symbol.  */
 666   HOWTO (R_PPC64_PLT16_HI,      /* type */
 667          16,                    /* rightshift */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          16,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_dont, /* complain_on_overflow */
 673          ppc64_elf_unhandled_reloc, /* special_function */
 674          "R_PPC64_PLT16_HI",    /* name */
 675          FALSE,                 /* partial_inplace */
 676          0,                     /* src_mask */
 677          0xffff,                /* dst_mask */
 678          FALSE),                /* pcrel_offset */
 679
 680   /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
 681      the symbol.  */
 682   HOWTO (R_PPC64_PLT16_HA,      /* type */
 683          16,                    /* rightshift */
 684          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 685          16,                    /* bitsize */
 686          FALSE,                 /* pc_relative */
 687          0,                     /* bitpos */
 688          complain_overflow_dont, /* complain_on_overflow */
 689          ppc64_elf_unhandled_reloc, /* special_function */
 690          "R_PPC64_PLT16_HA",    /* name */
 691          FALSE,                 /* partial_inplace */
 692          0,                     /* src_mask */
 693          0xffff,                /* dst_mask */
 694          FALSE),                /* pcrel_offset */
 695
 696   /* 16-bit section relative relocation.  */
 697   HOWTO (R_PPC64_SECTOFF,       /* type */
 698          0,                     /* rightshift */
 699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 700          16,                    /* bitsize */
 701          FALSE,                 /* pc_relative */
 702          0,                     /* bitpos */
 703          complain_overflow_bitfield, /* complain_on_overflow */
 704          ppc64_elf_sectoff_reloc, /* special_function */
 705          "R_PPC64_SECTOFF",     /* name */
 706          FALSE,                 /* partial_inplace */
 707          0,                     /* src_mask */
 708          0xffff,                /* dst_mask */
 709          FALSE),                /* pcrel_offset */
 710
 711   /* Like R_PPC64_SECTOFF, but no overflow warning.  */
 712   HOWTO (R_PPC64_SECTOFF_LO,    /* type */
 713          0,                     /* rightshift */
 714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 715          16,                    /* bitsize */
 716          FALSE,                 /* pc_relative */
 717          0,                     /* bitpos */
 718          complain_overflow_dont, /* complain_on_overflow */
 719          ppc64_elf_sectoff_reloc, /* special_function */
 720          "R_PPC64_SECTOFF_LO",  /* name */
 721          FALSE,                 /* partial_inplace */
 722          0,                     /* src_mask */
 723          0xffff,                /* dst_mask */
 724          FALSE),                /* pcrel_offset */
 725
 726   /* 16-bit upper half section relative relocation.  */
 727   HOWTO (R_PPC64_SECTOFF_HI,    /* type */
 728          16,                    /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          ppc64_elf_sectoff_reloc, /* special_function */
 735          "R_PPC64_SECTOFF_HI",  /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* 16-bit upper half adjusted section relative relocation.  */
 742   HOWTO (R_PPC64_SECTOFF_HA,    /* type */
 743          16,                    /* rightshift */
 744          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 745          16,                    /* bitsize */
 746          FALSE,                 /* pc_relative */
 747          0,                     /* bitpos */
 748          complain_overflow_dont, /* complain_on_overflow */
 749          ppc64_elf_sectoff_ha_reloc, /* special_function */
 750          "R_PPC64_SECTOFF_HA",  /* name */
 751          FALSE,                 /* partial_inplace */
 752          0,                     /* src_mask */
 753          0xffff,                /* dst_mask */
 754          FALSE),                /* pcrel_offset */
 755
 756   /* Like R_PPC64_REL24 without touching the two least significant bits.  */
 757   HOWTO (R_PPC64_REL30,         /* type */
 758          2,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          30,                    /* bitsize */
 761          TRUE,                  /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_dont, /* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_PPC64_REL30",       /* name */
 766          FALSE,                 /* partial_inplace */
 767          0,                     /* src_mask */
 768          0xfffffffc,            /* dst_mask */
 769          TRUE),                 /* pcrel_offset */
 770
 771   /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI.  */
 772
 773   /* A standard 64-bit relocation.  */
 774   HOWTO (R_PPC64_ADDR64,        /* type */
 775          0,                     /* rightshift */
 776          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 777          64,                    /* bitsize */
 778          FALSE,                 /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_dont, /* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_PPC64_ADDR64",      /* name */
 783          FALSE,                 /* partial_inplace */
 784          0,                     /* src_mask */
 785          ONES (64),             /* dst_mask */
 786          FALSE),                /* pcrel_offset */
 787
 788   /* The bits 32-47 of an address.  */
 789   HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
 790          32,                    /* rightshift */
 791          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 792          16,                    /* bitsize */
 793          FALSE,                 /* pc_relative */
 794          0,                     /* bitpos */
 795          complain_overflow_dont, /* complain_on_overflow */
 796          bfd_elf_generic_reloc, /* special_function */
 797          "R_PPC64_ADDR16_HIGHER", /* name */
 798          FALSE,                 /* partial_inplace */
 799          0,                     /* src_mask */
 800          0xffff,                /* dst_mask */
 801          FALSE),                /* pcrel_offset */
 802
 803   /* The bits 32-47 of an address, plus 1 if the contents of the low
 804      16 bits, treated as a signed number, is negative.  */
 805   HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
 806          32,                    /* rightshift */
 807          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 808          16,                    /* bitsize */
 809          FALSE,                 /* pc_relative */
 810          0,                     /* bitpos */
 811          complain_overflow_dont, /* complain_on_overflow */
 812          ppc64_elf_ha_reloc,    /* special_function */
 813          "R_PPC64_ADDR16_HIGHERA", /* name */
 814          FALSE,                 /* partial_inplace */
 815          0,                     /* src_mask */
 816          0xffff,                /* dst_mask */
 817          FALSE),                /* pcrel_offset */
 818
 819   /* The bits 48-63 of an address.  */
 820   HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
 821          48,                    /* rightshift */
 822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 823          16,                    /* bitsize */
 824          FALSE,                 /* pc_relative */
 825          0,                     /* bitpos */
 826          complain_overflow_dont, /* complain_on_overflow */
 827          bfd_elf_generic_reloc, /* special_function */
 828          "R_PPC64_ADDR16_HIGHEST", /* name */
 829          FALSE,                 /* partial_inplace */
 830          0,                     /* src_mask */
 831          0xffff,                /* dst_mask */
 832          FALSE),                /* pcrel_offset */
 833
 834   /* The bits 48-63 of an address, plus 1 if the contents of the low
 835      16 bits, treated as a signed number, is negative.  */
 836   HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
 837          48,                    /* rightshift */
 838          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 839          16,                    /* bitsize */
 840          FALSE,                 /* pc_relative */
 841          0,                     /* bitpos */
 842          complain_overflow_dont, /* complain_on_overflow */
 843          ppc64_elf_ha_reloc,    /* special_function */
 844          "R_PPC64_ADDR16_HIGHESTA", /* name */
 845          FALSE,                 /* partial_inplace */
 846          0,                     /* src_mask */
 847          0xffff,                /* dst_mask */
 848          FALSE),                /* pcrel_offset */
 849
 850   /* Like ADDR64, but may be unaligned.  */
 851   HOWTO (R_PPC64_UADDR64,       /* type */
 852          0,                     /* rightshift */
 853          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 854          64,                    /* bitsize */
 855          FALSE,                 /* pc_relative */
 856          0,                     /* bitpos */
 857          complain_overflow_dont, /* complain_on_overflow */
 858          bfd_elf_generic_reloc, /* special_function */
 859          "R_PPC64_UADDR64",     /* name */
 860          FALSE,                 /* partial_inplace */
 861          0,                     /* src_mask */
 862          ONES (64),             /* dst_mask */
 863          FALSE),                /* pcrel_offset */
 864
 865   /* 64-bit relative relocation.  */
 866   HOWTO (R_PPC64_REL64,         /* type */
 867          0,                     /* rightshift */
 868          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 869          64,                    /* bitsize */
 870          TRUE,                  /* pc_relative */
 871          0,                     /* bitpos */
 872          complain_overflow_dont, /* complain_on_overflow */
 873          bfd_elf_generic_reloc, /* special_function */
 874          "R_PPC64_REL64",       /* name */
 875          FALSE,                 /* partial_inplace */
 876          0,                     /* src_mask */
 877          ONES (64),             /* dst_mask */
 878          TRUE),                 /* pcrel_offset */
 879
 880   /* 64-bit relocation to the symbol's procedure linkage table.  */
 881   HOWTO (R_PPC64_PLT64,         /* type */
 882          0,                     /* rightshift */
 883          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 884          64,                    /* bitsize */
 885          FALSE,                 /* pc_relative */
 886          0,                     /* bitpos */
 887          complain_overflow_dont, /* complain_on_overflow */
 888          ppc64_elf_unhandled_reloc, /* special_function */
 889          "R_PPC64_PLT64",       /* name */
 890          FALSE,                 /* partial_inplace */
 891          0,                     /* src_mask */
 892          ONES (64),             /* dst_mask */
 893          FALSE),                /* pcrel_offset */
 894
 895   /* 64-bit PC relative relocation to the symbol's procedure linkage
 896      table.  */
 897   /* FIXME: R_PPC64_PLTREL64 not supported.  */
 898   HOWTO (R_PPC64_PLTREL64,      /* type */
 899          0,                     /* rightshift */
 900          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 901          64,                    /* bitsize */
 902          TRUE,                  /* pc_relative */
 903          0,                     /* bitpos */
 904          complain_overflow_dont, /* complain_on_overflow */
 905          ppc64_elf_unhandled_reloc, /* special_function */
 906          "R_PPC64_PLTREL64",    /* name */
 907          FALSE,                 /* partial_inplace */
 908          0,                     /* src_mask */
 909          ONES (64),             /* dst_mask */
 910          TRUE),                 /* pcrel_offset */
 911
 912   /* 16 bit TOC-relative relocation.  */
 913
 914   /* R_PPC64_TOC16        47       half16*      S + A - .TOC.  */
 915   HOWTO (R_PPC64_TOC16,         /* type */
 916          0,                     /* rightshift */
 917          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 918          16,                    /* bitsize */
 919          FALSE,                 /* pc_relative */
 920          0,                     /* bitpos */
 921          complain_overflow_signed, /* complain_on_overflow */
 922          ppc64_elf_toc_reloc,   /* special_function */
 923          "R_PPC64_TOC16",       /* name */
 924          FALSE,                 /* partial_inplace */
 925          0,                     /* src_mask */
 926          0xffff,                /* dst_mask */
 927          FALSE),                /* pcrel_offset */
 928
 929   /* 16 bit TOC-relative relocation without overflow.  */
 930
 931   /* R_PPC64_TOC16_LO     48       half16        #lo (S + A - .TOC.)  */
 932   HOWTO (R_PPC64_TOC16_LO,      /* type */
 933          0,                     /* rightshift */
 934          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 935          16,                    /* bitsize */
 936          FALSE,                 /* pc_relative */
 937          0,                     /* bitpos */
 938          complain_overflow_dont, /* complain_on_overflow */
 939          ppc64_elf_toc_reloc,   /* special_function */
 940          "R_PPC64_TOC16_LO",    /* name */
 941          FALSE,                 /* partial_inplace */
 942          0,                     /* src_mask */
 943          0xffff,                /* dst_mask */
 944          FALSE),                /* pcrel_offset */
 945
 946   /* 16 bit TOC-relative relocation, high 16 bits.  */
 947
 948   /* R_PPC64_TOC16_HI     49       half16        #hi (S + A - .TOC.)  */
 949   HOWTO (R_PPC64_TOC16_HI,      /* type */
 950          16,                    /* rightshift */
 951          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 952          16,                    /* bitsize */
 953          FALSE,                 /* pc_relative */
 954          0,                     /* bitpos */
 955          complain_overflow_dont, /* complain_on_overflow */
 956          ppc64_elf_toc_reloc,   /* special_function */
 957          "R_PPC64_TOC16_HI",    /* name */
 958          FALSE,                 /* partial_inplace */
 959          0,                     /* src_mask */
 960          0xffff,                /* dst_mask */
 961          FALSE),                /* pcrel_offset */
 962
 963   /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
 964      contents of the low 16 bits, treated as a signed number, is
 965      negative.  */
 966
 967   /* R_PPC64_TOC16_HA     50       half16        #ha (S + A - .TOC.)  */
 968   HOWTO (R_PPC64_TOC16_HA,      /* type */
 969          16,                    /* rightshift */
 970          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 971          16,                    /* bitsize */
 972          FALSE,                 /* pc_relative */
 973          0,                     /* bitpos */
 974          complain_overflow_dont, /* complain_on_overflow */
 975          ppc64_elf_toc_ha_reloc, /* special_function */
 976          "R_PPC64_TOC16_HA",    /* name */
 977          FALSE,                 /* partial_inplace */
 978          0,                     /* src_mask */
 979          0xffff,                /* dst_mask */
 980          FALSE),                /* pcrel_offset */
 981
 982   /* 64-bit relocation; insert value of TOC base (.TOC.).  */
 983
 984   /* R_PPC64_TOC                  51       doubleword64  .TOC.  */
 985   HOWTO (R_PPC64_TOC,           /* type */
 986          0,                     /* rightshift */
 987          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
 988          64,                    /* bitsize */
 989          FALSE,                 /* pc_relative */
 990          0,                     /* bitpos */
 991          complain_overflow_bitfield, /* complain_on_overflow */
 992          ppc64_elf_toc64_reloc, /* special_function */
 993          "R_PPC64_TOC",         /* name */
 994          FALSE,                 /* partial_inplace */
 995          0,                     /* src_mask */
 996          ONES (64),             /* dst_mask */
 997          FALSE),                /* pcrel_offset */
 998
 999   /* Like R_PPC64_GOT16, but also informs the link editor that the
1000      value to relocate may (!) refer to a PLT entry which the link
1001      editor (a) may replace with the symbol value.  If the link editor
1002      is unable to fully resolve the symbol, it may (b) create a PLT
1003      entry and store the address to the new PLT entry in the GOT.
1004      This permits lazy resolution of function symbols at run time.
1005      The link editor may also skip all of this and just (c) emit a
1006      R_PPC64_GLOB_DAT to tie the symbol to the GOT entry.  */
1007   /* FIXME: R_PPC64_PLTGOT16 not implemented.  */
1008     HOWTO (R_PPC64_PLTGOT16,    /* type */
1009          0,                     /* rightshift */
1010          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1011          16,                    /* bitsize */
1012          FALSE,                 /* pc_relative */
1013          0,                     /* bitpos */
1014          complain_overflow_signed, /* complain_on_overflow */
1015          ppc64_elf_unhandled_reloc, /* special_function */
1016          "R_PPC64_PLTGOT16",    /* name */
1017          FALSE,                 /* partial_inplace */
1018          0,                     /* src_mask */
1019          0xffff,                /* dst_mask */
1020          FALSE),                /* pcrel_offset */
1021
1022   /* Like R_PPC64_PLTGOT16, but without overflow.  */
1023   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1024   HOWTO (R_PPC64_PLTGOT16_LO,   /* type */
1025          0,                     /* rightshift */
1026          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1027          16,                    /* bitsize */
1028          FALSE,                 /* pc_relative */
1029          0,                     /* bitpos */
1030          complain_overflow_dont, /* complain_on_overflow */
1031          ppc64_elf_unhandled_reloc, /* special_function */
1032          "R_PPC64_PLTGOT16_LO", /* name */
1033          FALSE,                 /* partial_inplace */
1034          0,                     /* src_mask */
1035          0xffff,                /* dst_mask */
1036          FALSE),                /* pcrel_offset */
1037
1038   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address.  */
1039   /* FIXME: R_PPC64_PLTGOT16_HI not implemented.  */
1040   HOWTO (R_PPC64_PLTGOT16_HI,   /* type */
1041          16,                    /* rightshift */
1042          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1043          16,                    /* bitsize */
1044          FALSE,                 /* pc_relative */
1045          0,                     /* bitpos */
1046          complain_overflow_dont, /* complain_on_overflow */
1047          ppc64_elf_unhandled_reloc, /* special_function */
1048          "R_PPC64_PLTGOT16_HI", /* name */
1049          FALSE,                 /* partial_inplace */
1050          0,                     /* src_mask */
1051          0xffff,                /* dst_mask */
1052          FALSE),                /* pcrel_offset */
1053
1054   /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055      1 if the contents of the low 16 bits, treated as a signed number,
1056      is negative.  */
1057   /* FIXME: R_PPC64_PLTGOT16_HA not implemented.  */
1058   HOWTO (R_PPC64_PLTGOT16_HA,   /* type */
1059          16,                    /* rightshift */
1060          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1061          16,                    /* bitsize */
1062          FALSE,                 /* pc_relative */
1063          0,                     /* bitpos */
1064          complain_overflow_dont,/* complain_on_overflow */
1065          ppc64_elf_unhandled_reloc, /* special_function */
1066          "R_PPC64_PLTGOT16_HA", /* name */
1067          FALSE,                 /* partial_inplace */
1068          0,                     /* src_mask */
1069          0xffff,                /* dst_mask */
1070          FALSE),                /* pcrel_offset */
1071
1072   /* Like R_PPC64_ADDR16, but for instructions with a DS field.  */
1073   HOWTO (R_PPC64_ADDR16_DS,     /* type */
1074          0,                     /* rightshift */
1075          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          16,                    /* bitsize */
1077          FALSE,                 /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_bitfield, /* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_PPC64_ADDR16_DS",   /* name */
1082          FALSE,                 /* partial_inplace */
1083          0,                     /* src_mask */
1084          0xfffc,                /* dst_mask */
1085          FALSE),                /* pcrel_offset */
1086
1087   /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field.  */
1088   HOWTO (R_PPC64_ADDR16_LO_DS,  /* type */
1089          0,                     /* rightshift */
1090          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1091          16,                    /* bitsize */
1092          FALSE,                 /* pc_relative */
1093          0,                     /* bitpos */
1094          complain_overflow_dont,/* complain_on_overflow */
1095          bfd_elf_generic_reloc, /* special_function */
1096          "R_PPC64_ADDR16_LO_DS",/* name */
1097          FALSE,                 /* partial_inplace */
1098          0,                     /* src_mask */
1099          0xfffc,                /* dst_mask */
1100          FALSE),                /* pcrel_offset */
1101
1102   /* Like R_PPC64_GOT16, but for instructions with a DS field.  */
1103   HOWTO (R_PPC64_GOT16_DS,      /* type */
1104          0,                     /* rightshift */
1105          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          16,                    /* bitsize */
1107          FALSE,                 /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_signed, /* complain_on_overflow */
1110          ppc64_elf_unhandled_reloc, /* special_function */
1111          "R_PPC64_GOT16_DS",    /* name */
1112          FALSE,                 /* partial_inplace */
1113          0,                     /* src_mask */
1114          0xfffc,                /* dst_mask */
1115          FALSE),                /* pcrel_offset */
1116
1117   /* Like R_PPC64_GOT16_LO, but for instructions with a DS field.  */
1118   HOWTO (R_PPC64_GOT16_LO_DS,   /* type */
1119          0,                     /* rightshift */
1120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1121          16,                    /* bitsize */
1122          FALSE,                 /* pc_relative */
1123          0,                     /* bitpos */
1124          complain_overflow_dont, /* complain_on_overflow */
1125          ppc64_elf_unhandled_reloc, /* special_function */
1126          "R_PPC64_GOT16_LO_DS", /* name */
1127          FALSE,                 /* partial_inplace */
1128          0,                     /* src_mask */
1129          0xfffc,                /* dst_mask */
1130          FALSE),                /* pcrel_offset */
1131
1132   /* Like R_PPC64_PLT16_LO, but for instructions with a DS field.  */
1133   HOWTO (R_PPC64_PLT16_LO_DS,   /* type */
1134          0,                     /* rightshift */
1135          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          16,                    /* bitsize */
1137          FALSE,                 /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont, /* complain_on_overflow */
1140          ppc64_elf_unhandled_reloc, /* special_function */
1141          "R_PPC64_PLT16_LO_DS", /* name */
1142          FALSE,                 /* partial_inplace */
1143          0,                     /* src_mask */
1144          0xfffc,                /* dst_mask */
1145          FALSE),                /* pcrel_offset */
1146
1147   /* Like R_PPC64_SECTOFF, but for instructions with a DS field.  */
1148   HOWTO (R_PPC64_SECTOFF_DS,    /* type */
1149          0,                     /* rightshift */
1150          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1151          16,                    /* bitsize */
1152          FALSE,                 /* pc_relative */
1153          0,                     /* bitpos */
1154          complain_overflow_bitfield, /* complain_on_overflow */
1155          ppc64_elf_sectoff_reloc, /* special_function */
1156          "R_PPC64_SECTOFF_DS",  /* name */
1157          FALSE,                 /* partial_inplace */
1158          0,                     /* src_mask */
1159          0xfffc,                /* dst_mask */
1160          FALSE),                /* pcrel_offset */
1161
1162   /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field.  */
1163   HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164          0,                     /* rightshift */
1165          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1166          16,                    /* bitsize */
1167          FALSE,                 /* pc_relative */
1168          0,                     /* bitpos */
1169          complain_overflow_dont, /* complain_on_overflow */
1170          ppc64_elf_sectoff_reloc, /* special_function */
1171          "R_PPC64_SECTOFF_LO_DS",/* name */
1172          FALSE,                 /* partial_inplace */
1173          0,                     /* src_mask */
1174          0xfffc,                /* dst_mask */
1175          FALSE),                /* pcrel_offset */
1176
1177   /* Like R_PPC64_TOC16, but for instructions with a DS field.  */
1178   HOWTO (R_PPC64_TOC16_DS,      /* type */
1179          0,                     /* rightshift */
1180          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1181          16,                    /* bitsize */
1182          FALSE,                 /* pc_relative */
1183          0,                     /* bitpos */
1184          complain_overflow_signed, /* complain_on_overflow */
1185          ppc64_elf_toc_reloc,   /* special_function */
1186          "R_PPC64_TOC16_DS",    /* name */
1187          FALSE,                 /* partial_inplace */
1188          0,                     /* src_mask */
1189          0xfffc,                /* dst_mask */
1190          FALSE),                /* pcrel_offset */
1191
1192   /* Like R_PPC64_TOC16_LO, but for instructions with a DS field.  */
1193   HOWTO (R_PPC64_TOC16_LO_DS,   /* type */
1194          0,                     /* rightshift */
1195          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1196          16,                    /* bitsize */
1197          FALSE,                 /* pc_relative */
1198          0,                     /* bitpos */
1199          complain_overflow_dont, /* complain_on_overflow */
1200          ppc64_elf_toc_reloc,   /* special_function */
1201          "R_PPC64_TOC16_LO_DS", /* name */
1202          FALSE,                 /* partial_inplace */
1203          0,                     /* src_mask */
1204          0xfffc,                /* dst_mask */
1205          FALSE),                /* pcrel_offset */
1206
1207   /* Like R_PPC64_PLTGOT16, but for instructions with a DS field.  */
1208   /* FIXME: R_PPC64_PLTGOT16_DS not implemented.  */
1209   HOWTO (R_PPC64_PLTGOT16_DS,   /* type */
1210          0,                     /* rightshift */
1211          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1212          16,                    /* bitsize */
1213          FALSE,                 /* pc_relative */
1214          0,                     /* bitpos */
1215          complain_overflow_signed, /* complain_on_overflow */
1216          ppc64_elf_unhandled_reloc, /* special_function */
1217          "R_PPC64_PLTGOT16_DS", /* name */
1218          FALSE,                 /* partial_inplace */
1219          0,                     /* src_mask */
1220          0xfffc,                /* dst_mask */
1221          FALSE),                /* pcrel_offset */
1222
1223   /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field.  */
1224   /* FIXME: R_PPC64_PLTGOT16_LO not implemented.  */
1225   HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226          0,                     /* rightshift */
1227          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1228          16,                    /* bitsize */
1229          FALSE,                 /* pc_relative */
1230          0,                     /* bitpos */
1231          complain_overflow_dont, /* complain_on_overflow */
1232          ppc64_elf_unhandled_reloc, /* special_function */
1233          "R_PPC64_PLTGOT16_LO_DS",/* name */
1234          FALSE,                 /* partial_inplace */
1235          0,                     /* src_mask */
1236          0xfffc,                /* dst_mask */
1237          FALSE),                /* pcrel_offset */
1238
1239   /* Marker relocs for TLS.  */
1240   HOWTO (R_PPC64_TLS,
1241          0,                     /* rightshift */
1242          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1243          32,                    /* bitsize */
1244          FALSE,                 /* pc_relative */
1245          0,                     /* bitpos */
1246          complain_overflow_dont, /* complain_on_overflow */
1247          bfd_elf_generic_reloc, /* special_function */
1248          "R_PPC64_TLS",         /* name */
1249          FALSE,                 /* partial_inplace */
1250          0,                     /* src_mask */
1251          0,                     /* dst_mask */
1252          FALSE),                /* pcrel_offset */
1253
1254   HOWTO (R_PPC64_TLSGD,
1255          0,                     /* rightshift */
1256          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1257          32,                    /* bitsize */
1258          FALSE,                 /* pc_relative */
1259          0,                     /* bitpos */
1260          complain_overflow_dont, /* complain_on_overflow */
1261          bfd_elf_generic_reloc, /* special_function */
1262          "R_PPC64_TLSGD",       /* name */
1263          FALSE,                 /* partial_inplace */
1264          0,                     /* src_mask */
1265          0,                     /* dst_mask */
1266          FALSE),                /* pcrel_offset */
1267
1268   HOWTO (R_PPC64_TLSLD,
1269          0,                     /* rightshift */
1270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1271          32,                    /* bitsize */
1272          FALSE,                 /* pc_relative */
1273          0,                     /* bitpos */
1274          complain_overflow_dont, /* complain_on_overflow */
1275          bfd_elf_generic_reloc, /* special_function */
1276          "R_PPC64_TLSLD",       /* name */
1277          FALSE,                 /* partial_inplace */
1278          0,                     /* src_mask */
1279          0,                     /* dst_mask */
1280          FALSE),                /* pcrel_offset */
1281
1282   /* Computes the load module index of the load module that contains the
1283      definition of its TLS sym.  */
1284   HOWTO (R_PPC64_DTPMOD64,
1285          0,                     /* rightshift */
1286          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1287          64,                    /* bitsize */
1288          FALSE,                 /* pc_relative */
1289          0,                     /* bitpos */
1290          complain_overflow_dont, /* complain_on_overflow */
1291          ppc64_elf_unhandled_reloc, /* special_function */
1292          "R_PPC64_DTPMOD64",    /* name */
1293          FALSE,                 /* partial_inplace */
1294          0,                     /* src_mask */
1295          ONES (64),             /* dst_mask */
1296          FALSE),                /* pcrel_offset */
1297
1298   /* Computes a dtv-relative displacement, the difference between the value
1299      of sym+add and the base address of the thread-local storage block that
1300      contains the definition of sym, minus 0x8000.  */
1301   HOWTO (R_PPC64_DTPREL64,
1302          0,                     /* rightshift */
1303          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          64,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont, /* complain_on_overflow */
1308          ppc64_elf_unhandled_reloc, /* special_function */
1309          "R_PPC64_DTPREL64",    /* name */
1310          FALSE,                 /* partial_inplace */
1311          0,                     /* src_mask */
1312          ONES (64),             /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   /* A 16 bit dtprel reloc.  */
1316   HOWTO (R_PPC64_DTPREL16,
1317          0,                     /* rightshift */
1318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1319          16,                    /* bitsize */
1320          FALSE,                 /* pc_relative */
1321          0,                     /* bitpos */
1322          complain_overflow_signed, /* complain_on_overflow */
1323          ppc64_elf_unhandled_reloc, /* special_function */
1324          "R_PPC64_DTPREL16",    /* name */
1325          FALSE,                 /* partial_inplace */
1326          0,                     /* src_mask */
1327          0xffff,                /* dst_mask */
1328          FALSE),                /* pcrel_offset */
1329
1330   /* Like DTPREL16, but no overflow.  */
1331   HOWTO (R_PPC64_DTPREL16_LO,
1332          0,                     /* rightshift */
1333          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          16,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_dont, /* complain_on_overflow */
1338          ppc64_elf_unhandled_reloc, /* special_function */
1339          "R_PPC64_DTPREL16_LO", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0,                     /* src_mask */
1342          0xffff,                /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   /* Like DTPREL16_LO, but next higher group of 16 bits.  */
1346   HOWTO (R_PPC64_DTPREL16_HI,
1347          16,                    /* rightshift */
1348          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1349          16,                    /* bitsize */
1350          FALSE,                 /* pc_relative */
1351          0,                     /* bitpos */
1352          complain_overflow_dont, /* complain_on_overflow */
1353          ppc64_elf_unhandled_reloc, /* special_function */
1354          "R_PPC64_DTPREL16_HI", /* name */
1355          FALSE,                 /* partial_inplace */
1356          0,                     /* src_mask */
1357          0xffff,                /* dst_mask */
1358          FALSE),                /* pcrel_offset */
1359
1360   /* Like DTPREL16_HI, but adjust for low 16 bits.  */
1361   HOWTO (R_PPC64_DTPREL16_HA,
1362          16,                    /* rightshift */
1363          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1364          16,                    /* bitsize */
1365          FALSE,                 /* pc_relative */
1366          0,                     /* bitpos */
1367          complain_overflow_dont, /* complain_on_overflow */
1368          ppc64_elf_unhandled_reloc, /* special_function */
1369          "R_PPC64_DTPREL16_HA", /* name */
1370          FALSE,                 /* partial_inplace */
1371          0,                     /* src_mask */
1372          0xffff,                /* dst_mask */
1373          FALSE),                /* pcrel_offset */
1374
1375   /* Like DTPREL16_HI, but next higher group of 16 bits.  */
1376   HOWTO (R_PPC64_DTPREL16_HIGHER,
1377          32,                    /* rightshift */
1378          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1379          16,                    /* bitsize */
1380          FALSE,                 /* pc_relative */
1381          0,                     /* bitpos */
1382          complain_overflow_dont, /* complain_on_overflow */
1383          ppc64_elf_unhandled_reloc, /* special_function */
1384          "R_PPC64_DTPREL16_HIGHER", /* name */
1385          FALSE,                 /* partial_inplace */
1386          0,                     /* src_mask */
1387          0xffff,                /* dst_mask */
1388          FALSE),                /* pcrel_offset */
1389
1390   /* Like DTPREL16_HIGHER, but adjust for low 16 bits.  */
1391   HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392          32,                    /* rightshift */
1393          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1394          16,                    /* bitsize */
1395          FALSE,                 /* pc_relative */
1396          0,                     /* bitpos */
1397          complain_overflow_dont, /* complain_on_overflow */
1398          ppc64_elf_unhandled_reloc, /* special_function */
1399          "R_PPC64_DTPREL16_HIGHERA", /* name */
1400          FALSE,                 /* partial_inplace */
1401          0,                     /* src_mask */
1402          0xffff,                /* dst_mask */
1403          FALSE),                /* pcrel_offset */
1404
1405   /* Like DTPREL16_HIGHER, but next higher group of 16 bits.  */
1406   HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407          48,                    /* rightshift */
1408          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1409          16,                    /* bitsize */
1410          FALSE,                 /* pc_relative */
1411          0,                     /* bitpos */
1412          complain_overflow_dont, /* complain_on_overflow */
1413          ppc64_elf_unhandled_reloc, /* special_function */
1414          "R_PPC64_DTPREL16_HIGHEST", /* name */
1415          FALSE,                 /* partial_inplace */
1416          0,                     /* src_mask */
1417          0xffff,                /* dst_mask */
1418          FALSE),                /* pcrel_offset */
1419
1420   /* Like DTPREL16_HIGHEST, but adjust for low 16 bits.  */
1421   HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422          48,                    /* rightshift */
1423          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1424          16,                    /* bitsize */
1425          FALSE,                 /* pc_relative */
1426          0,                     /* bitpos */
1427          complain_overflow_dont, /* complain_on_overflow */
1428          ppc64_elf_unhandled_reloc, /* special_function */
1429          "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430          FALSE,                 /* partial_inplace */
1431          0,                     /* src_mask */
1432          0xffff,                /* dst_mask */
1433          FALSE),                /* pcrel_offset */
1434
1435   /* Like DTPREL16, but for insns with a DS field.  */
1436   HOWTO (R_PPC64_DTPREL16_DS,
1437          0,                     /* rightshift */
1438          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1439          16,                    /* bitsize */
1440          FALSE,                 /* pc_relative */
1441          0,                     /* bitpos */
1442          complain_overflow_signed, /* complain_on_overflow */
1443          ppc64_elf_unhandled_reloc, /* special_function */
1444          "R_PPC64_DTPREL16_DS", /* name */
1445          FALSE,                 /* partial_inplace */
1446          0,                     /* src_mask */
1447          0xfffc,                /* dst_mask */
1448          FALSE),                /* pcrel_offset */
1449
1450   /* Like DTPREL16_DS, but no overflow.  */
1451   HOWTO (R_PPC64_DTPREL16_LO_DS,
1452          0,                     /* rightshift */
1453          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1454          16,                    /* bitsize */
1455          FALSE,                 /* pc_relative */
1456          0,                     /* bitpos */
1457          complain_overflow_dont, /* complain_on_overflow */
1458          ppc64_elf_unhandled_reloc, /* special_function */
1459          "R_PPC64_DTPREL16_LO_DS", /* name */
1460          FALSE,                 /* partial_inplace */
1461          0,                     /* src_mask */
1462          0xfffc,                /* dst_mask */
1463          FALSE),                /* pcrel_offset */
1464
1465   /* Computes a tp-relative displacement, the difference between the value of
1466      sym+add and the value of the thread pointer (r13).  */
1467   HOWTO (R_PPC64_TPREL64,
1468          0,                     /* rightshift */
1469          4,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          64,                    /* bitsize */
1471          FALSE,                 /* pc_relative */
1472          0,                     /* bitpos */
1473          complain_overflow_dont, /* complain_on_overflow */
1474          ppc64_elf_unhandled_reloc, /* special_function */
1475          "R_PPC64_TPREL64",     /* name */
1476          FALSE,                 /* partial_inplace */
1477          0,                     /* src_mask */
1478          ONES (64),             /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   /* A 16 bit tprel reloc.  */
1482   HOWTO (R_PPC64_TPREL16,
1483          0,                     /* rightshift */
1484          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1485          16,                    /* bitsize */
1486          FALSE,                 /* pc_relative */
1487          0,                     /* bitpos */
1488          complain_overflow_signed, /* complain_on_overflow */
1489          ppc64_elf_unhandled_reloc, /* special_function */
1490          "R_PPC64_TPREL16",     /* name */
1491          FALSE,                 /* partial_inplace */
1492          0,                     /* src_mask */
1493          0xffff,                /* dst_mask */
1494          FALSE),                /* pcrel_offset */
1495
1496   /* Like TPREL16, but no overflow.  */
1497   HOWTO (R_PPC64_TPREL16_LO,
1498          0,                     /* rightshift */
1499          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1500          16,                    /* bitsize */
1501          FALSE,                 /* pc_relative */
1502          0,                     /* bitpos */
1503          complain_overflow_dont, /* complain_on_overflow */
1504          ppc64_elf_unhandled_reloc, /* special_function */
1505          "R_PPC64_TPREL16_LO",  /* name */
1506          FALSE,                 /* partial_inplace */
1507          0,                     /* src_mask */
1508          0xffff,                /* dst_mask */
1509          FALSE),                /* pcrel_offset */
1510
1511   /* Like TPREL16_LO, but next higher group of 16 bits.  */
1512   HOWTO (R_PPC64_TPREL16_HI,
1513          16,                    /* rightshift */
1514          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1515          16,                    /* bitsize */
1516          FALSE,                 /* pc_relative */
1517          0,                     /* bitpos */
1518          complain_overflow_dont, /* complain_on_overflow */
1519          ppc64_elf_unhandled_reloc, /* special_function */
1520          "R_PPC64_TPREL16_HI",  /* name */
1521          FALSE,                 /* partial_inplace */
1522          0,                     /* src_mask */
1523          0xffff,                /* dst_mask */
1524          FALSE),                /* pcrel_offset */
1525
1526   /* Like TPREL16_HI, but adjust for low 16 bits.  */
1527   HOWTO (R_PPC64_TPREL16_HA,
1528          16,                    /* rightshift */
1529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1530          16,                    /* bitsize */
1531          FALSE,                 /* pc_relative */
1532          0,                     /* bitpos */
1533          complain_overflow_dont, /* complain_on_overflow */
1534          ppc64_elf_unhandled_reloc, /* special_function */
1535          "R_PPC64_TPREL16_HA",  /* name */
1536          FALSE,                 /* partial_inplace */
1537          0,                     /* src_mask */
1538          0xffff,                /* dst_mask */
1539          FALSE),                /* pcrel_offset */
1540
1541   /* Like TPREL16_HI, but next higher group of 16 bits.  */
1542   HOWTO (R_PPC64_TPREL16_HIGHER,
1543          32,                    /* rightshift */
1544          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1545          16,                    /* bitsize */
1546          FALSE,                 /* pc_relative */
1547          0,                     /* bitpos */
1548          complain_overflow_dont, /* complain_on_overflow */
1549          ppc64_elf_unhandled_reloc, /* special_function */
1550          "R_PPC64_TPREL16_HIGHER",      /* name */
1551          FALSE,                 /* partial_inplace */
1552          0,                     /* src_mask */
1553          0xffff,                /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   /* Like TPREL16_HIGHER, but adjust for low 16 bits.  */
1557   HOWTO (R_PPC64_TPREL16_HIGHERA,
1558          32,                    /* rightshift */
1559          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1560          16,                    /* bitsize */
1561          FALSE,                 /* pc_relative */
1562          0,                     /* bitpos */
1563          complain_overflow_dont, /* complain_on_overflow */
1564          ppc64_elf_unhandled_reloc, /* special_function */
1565          "R_PPC64_TPREL16_HIGHERA", /* name */
1566          FALSE,                 /* partial_inplace */
1567          0,                     /* src_mask */
1568          0xffff,                /* dst_mask */
1569          FALSE),                /* pcrel_offset */
1570
1571   /* Like TPREL16_HIGHER, but next higher group of 16 bits.  */
1572   HOWTO (R_PPC64_TPREL16_HIGHEST,
1573          48,                    /* rightshift */
1574          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1575          16,                    /* bitsize */
1576          FALSE,                 /* pc_relative */
1577          0,                     /* bitpos */
1578          complain_overflow_dont, /* complain_on_overflow */
1579          ppc64_elf_unhandled_reloc, /* special_function */
1580          "R_PPC64_TPREL16_HIGHEST", /* name */
1581          FALSE,                 /* partial_inplace */
1582          0,                     /* src_mask */
1583          0xffff,                /* dst_mask */
1584          FALSE),                /* pcrel_offset */
1585
1586   /* Like TPREL16_HIGHEST, but adjust for low 16 bits.  */
1587   HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588          48,                    /* rightshift */
1589          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1590          16,                    /* bitsize */
1591          FALSE,                 /* pc_relative */
1592          0,                     /* bitpos */
1593          complain_overflow_dont, /* complain_on_overflow */
1594          ppc64_elf_unhandled_reloc, /* special_function */
1595          "R_PPC64_TPREL16_HIGHESTA", /* name */
1596          FALSE,                 /* partial_inplace */
1597          0,                     /* src_mask */
1598          0xffff,                /* dst_mask */
1599          FALSE),                /* pcrel_offset */
1600
1601   /* Like TPREL16, but for insns with a DS field.  */
1602   HOWTO (R_PPC64_TPREL16_DS,
1603          0,                     /* rightshift */
1604          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          16,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_signed, /* complain_on_overflow */
1609          ppc64_elf_unhandled_reloc, /* special_function */
1610          "R_PPC64_TPREL16_DS",  /* name */
1611          FALSE,                 /* partial_inplace */
1612          0,                     /* src_mask */
1613          0xfffc,                /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   /* Like TPREL16_DS, but no overflow.  */
1617   HOWTO (R_PPC64_TPREL16_LO_DS,
1618          0,                     /* rightshift */
1619          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1620          16,                    /* bitsize */
1621          FALSE,                 /* pc_relative */
1622          0,                     /* bitpos */
1623          complain_overflow_dont, /* complain_on_overflow */
1624          ppc64_elf_unhandled_reloc, /* special_function */
1625          "R_PPC64_TPREL16_LO_DS", /* name */
1626          FALSE,                 /* partial_inplace */
1627          0,                     /* src_mask */
1628          0xfffc,                /* dst_mask */
1629          FALSE),                /* pcrel_offset */
1630
1631   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632      with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633      to the first entry relative to the TOC base (r2).  */
1634   HOWTO (R_PPC64_GOT_TLSGD16,
1635          0,                     /* rightshift */
1636          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1637          16,                    /* bitsize */
1638          FALSE,                 /* pc_relative */
1639          0,                     /* bitpos */
1640          complain_overflow_signed, /* complain_on_overflow */
1641          ppc64_elf_unhandled_reloc, /* special_function */
1642          "R_PPC64_GOT_TLSGD16", /* name */
1643          FALSE,                 /* partial_inplace */
1644          0,                     /* src_mask */
1645          0xffff,                /* dst_mask */
1646          FALSE),                /* pcrel_offset */
1647
1648   /* Like GOT_TLSGD16, but no overflow.  */
1649   HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650          0,                     /* rightshift */
1651          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1652          16,                    /* bitsize */
1653          FALSE,                 /* pc_relative */
1654          0,                     /* bitpos */
1655          complain_overflow_dont, /* complain_on_overflow */
1656          ppc64_elf_unhandled_reloc, /* special_function */
1657          "R_PPC64_GOT_TLSGD16_LO", /* name */
1658          FALSE,                 /* partial_inplace */
1659          0,                     /* src_mask */
1660          0xffff,                /* dst_mask */
1661          FALSE),                /* pcrel_offset */
1662
1663   /* Like GOT_TLSGD16_LO, but next higher group of 16 bits.  */
1664   HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665          16,                    /* rightshift */
1666          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1667          16,                    /* bitsize */
1668          FALSE,                 /* pc_relative */
1669          0,                     /* bitpos */
1670          complain_overflow_dont, /* complain_on_overflow */
1671          ppc64_elf_unhandled_reloc, /* special_function */
1672          "R_PPC64_GOT_TLSGD16_HI", /* name */
1673          FALSE,                 /* partial_inplace */
1674          0,                     /* src_mask */
1675          0xffff,                /* dst_mask */
1676          FALSE),                /* pcrel_offset */
1677
1678   /* Like GOT_TLSGD16_HI, but adjust for low 16 bits.  */
1679   HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680          16,                    /* rightshift */
1681          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1682          16,                    /* bitsize */
1683          FALSE,                 /* pc_relative */
1684          0,                     /* bitpos */
1685          complain_overflow_dont, /* complain_on_overflow */
1686          ppc64_elf_unhandled_reloc, /* special_function */
1687          "R_PPC64_GOT_TLSGD16_HA", /* name */
1688          FALSE,                 /* partial_inplace */
1689          0,                     /* src_mask */
1690          0xffff,                /* dst_mask */
1691          FALSE),                /* pcrel_offset */
1692
1693   /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694      with values (sym+add)@dtpmod and zero, and computes the offset to the
1695      first entry relative to the TOC base (r2).  */
1696   HOWTO (R_PPC64_GOT_TLSLD16,
1697          0,                     /* rightshift */
1698          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1699          16,                    /* bitsize */
1700          FALSE,                 /* pc_relative */
1701          0,                     /* bitpos */
1702          complain_overflow_signed, /* complain_on_overflow */
1703          ppc64_elf_unhandled_reloc, /* special_function */
1704          "R_PPC64_GOT_TLSLD16", /* name */
1705          FALSE,                 /* partial_inplace */
1706          0,                     /* src_mask */
1707          0xffff,                /* dst_mask */
1708          FALSE),                /* pcrel_offset */
1709
1710   /* Like GOT_TLSLD16, but no overflow.  */
1711   HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712          0,                     /* rightshift */
1713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1714          16,                    /* bitsize */
1715          FALSE,                 /* pc_relative */
1716          0,                     /* bitpos */
1717          complain_overflow_dont, /* complain_on_overflow */
1718          ppc64_elf_unhandled_reloc, /* special_function */
1719          "R_PPC64_GOT_TLSLD16_LO", /* name */
1720          FALSE,                 /* partial_inplace */
1721          0,                     /* src_mask */
1722          0xffff,                /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   /* Like GOT_TLSLD16_LO, but next higher group of 16 bits.  */
1726   HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727          16,                    /* rightshift */
1728          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1729          16,                    /* bitsize */
1730          FALSE,                 /* pc_relative */
1731          0,                     /* bitpos */
1732          complain_overflow_dont, /* complain_on_overflow */
1733          ppc64_elf_unhandled_reloc, /* special_function */
1734          "R_PPC64_GOT_TLSLD16_HI", /* name */
1735          FALSE,                 /* partial_inplace */
1736          0,                     /* src_mask */
1737          0xffff,                /* dst_mask */
1738          FALSE),                /* pcrel_offset */
1739
1740   /* Like GOT_TLSLD16_HI, but adjust for low 16 bits.  */
1741   HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742          16,                    /* rightshift */
1743          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1744          16,                    /* bitsize */
1745          FALSE,                 /* pc_relative */
1746          0,                     /* bitpos */
1747          complain_overflow_dont, /* complain_on_overflow */
1748          ppc64_elf_unhandled_reloc, /* special_function */
1749          "R_PPC64_GOT_TLSLD16_HA", /* name */
1750          FALSE,                 /* partial_inplace */
1751          0,                     /* src_mask */
1752          0xffff,                /* dst_mask */
1753          FALSE),                /* pcrel_offset */
1754
1755   /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756      the offset to the entry relative to the TOC base (r2).  */
1757   HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758          0,                     /* rightshift */
1759          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1760          16,                    /* bitsize */
1761          FALSE,                 /* pc_relative */
1762          0,                     /* bitpos */
1763          complain_overflow_signed, /* complain_on_overflow */
1764          ppc64_elf_unhandled_reloc, /* special_function */
1765          "R_PPC64_GOT_DTPREL16_DS", /* name */
1766          FALSE,                 /* partial_inplace */
1767          0,                     /* src_mask */
1768          0xfffc,                /* dst_mask */
1769          FALSE),                /* pcrel_offset */
1770
1771   /* Like GOT_DTPREL16_DS, but no overflow.  */
1772   HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773          0,                     /* rightshift */
1774          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1775          16,                    /* bitsize */
1776          FALSE,                 /* pc_relative */
1777          0,                     /* bitpos */
1778          complain_overflow_dont, /* complain_on_overflow */
1779          ppc64_elf_unhandled_reloc, /* special_function */
1780          "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1781          FALSE,                 /* partial_inplace */
1782          0,                     /* src_mask */
1783          0xfffc,                /* dst_mask */
1784          FALSE),                /* pcrel_offset */
1785
1786   /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits.  */
1787   HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788          16,                    /* rightshift */
1789          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1790          16,                    /* bitsize */
1791          FALSE,                 /* pc_relative */
1792          0,                     /* bitpos */
1793          complain_overflow_dont, /* complain_on_overflow */
1794          ppc64_elf_unhandled_reloc, /* special_function */
1795          "R_PPC64_GOT_DTPREL16_HI", /* name */
1796          FALSE,                 /* partial_inplace */
1797          0,                     /* src_mask */
1798          0xffff,                /* dst_mask */
1799          FALSE),                /* pcrel_offset */
1800
1801   /* Like GOT_DTPREL16_HI, but adjust for low 16 bits.  */
1802   HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803          16,                    /* rightshift */
1804          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1805          16,                    /* bitsize */
1806          FALSE,                 /* pc_relative */
1807          0,                     /* bitpos */
1808          complain_overflow_dont, /* complain_on_overflow */
1809          ppc64_elf_unhandled_reloc, /* special_function */
1810          "R_PPC64_GOT_DTPREL16_HA", /* name */
1811          FALSE,                 /* partial_inplace */
1812          0,                     /* src_mask */
1813          0xffff,                /* dst_mask */
1814          FALSE),                /* pcrel_offset */
1815
1816   /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817      offset to the entry relative to the TOC base (r2).  */
1818   HOWTO (R_PPC64_GOT_TPREL16_DS,
1819          0,                     /* rightshift */
1820          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1821          16,                    /* bitsize */
1822          FALSE,                 /* pc_relative */
1823          0,                     /* bitpos */
1824          complain_overflow_signed, /* complain_on_overflow */
1825          ppc64_elf_unhandled_reloc, /* special_function */
1826          "R_PPC64_GOT_TPREL16_DS", /* name */
1827          FALSE,                 /* partial_inplace */
1828          0,                     /* src_mask */
1829          0xfffc,                /* dst_mask */
1830          FALSE),                /* pcrel_offset */
1831
1832   /* Like GOT_TPREL16_DS, but no overflow.  */
1833   HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834          0,                     /* rightshift */
1835          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1836          16,                    /* bitsize */
1837          FALSE,                 /* pc_relative */
1838          0,                     /* bitpos */
1839          complain_overflow_dont, /* complain_on_overflow */
1840          ppc64_elf_unhandled_reloc, /* special_function */
1841          "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1842          FALSE,                 /* partial_inplace */
1843          0,                     /* src_mask */
1844          0xfffc,                /* dst_mask */
1845          FALSE),                /* pcrel_offset */
1846
1847   /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits.  */
1848   HOWTO (R_PPC64_GOT_TPREL16_HI,
1849          16,                    /* rightshift */
1850          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1851          16,                    /* bitsize */
1852          FALSE,                 /* pc_relative */
1853          0,                     /* bitpos */
1854          complain_overflow_dont, /* complain_on_overflow */
1855          ppc64_elf_unhandled_reloc, /* special_function */
1856          "R_PPC64_GOT_TPREL16_HI", /* name */
1857          FALSE,                 /* partial_inplace */
1858          0,                     /* src_mask */
1859          0xffff,                /* dst_mask */
1860          FALSE),                /* pcrel_offset */
1861
1862   /* Like GOT_TPREL16_HI, but adjust for low 16 bits.  */
1863   HOWTO (R_PPC64_GOT_TPREL16_HA,
1864          16,                    /* rightshift */
1865          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1866          16,                    /* bitsize */
1867          FALSE,                 /* pc_relative */
1868          0,                     /* bitpos */
1869          complain_overflow_dont, /* complain_on_overflow */
1870          ppc64_elf_unhandled_reloc, /* special_function */
1871          "R_PPC64_GOT_TPREL16_HA", /* name */
1872          FALSE,                 /* partial_inplace */
1873          0,                     /* src_mask */
1874          0xffff,                /* dst_mask */
1875          FALSE),                /* pcrel_offset */
1876
1877   HOWTO (R_PPC64_JMP_IREL,      /* type */
1878          0,                     /* rightshift */
1879          0,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880          0,                     /* bitsize */
1881          FALSE,                 /* pc_relative */
1882          0,                     /* bitpos */
1883          complain_overflow_dont, /* complain_on_overflow */
1884          ppc64_elf_unhandled_reloc, /* special_function */
1885          "R_PPC64_JMP_IREL",    /* name */
1886          FALSE,                 /* partial_inplace */
1887          0,                     /* src_mask */
1888          0,                     /* dst_mask */
1889          FALSE),                /* pcrel_offset */
1890
1891   HOWTO (R_PPC64_IRELATIVE,     /* type */
1892          0,                     /* rightshift */
1893          4,                     /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1894          64,                    /* bitsize */
1895          FALSE,                 /* pc_relative */
1896          0,                     /* bitpos */
1897          complain_overflow_dont, /* complain_on_overflow */
1898          bfd_elf_generic_reloc, /* special_function */
1899          "R_PPC64_IRELATIVE",   /* name */
1900          FALSE,                 /* partial_inplace */
1901          0,                     /* src_mask */
1902          ONES (64),             /* dst_mask */
1903          FALSE),                /* pcrel_offset */
1904
1905   /* A 16 bit relative relocation.  */
1906   HOWTO (R_PPC64_REL16,         /* type */
1907          0,                     /* rightshift */
1908          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1909          16,                    /* bitsize */
1910          TRUE,                  /* pc_relative */
1911          0,                     /* bitpos */
1912          complain_overflow_bitfield, /* complain_on_overflow */
1913          bfd_elf_generic_reloc, /* special_function */
1914          "R_PPC64_REL16",       /* name */
1915          FALSE,                 /* partial_inplace */
1916          0,                     /* src_mask */
1917          0xffff,                /* dst_mask */
1918          TRUE),                 /* pcrel_offset */
1919
1920   /* A 16 bit relative relocation without overflow.  */
1921   HOWTO (R_PPC64_REL16_LO,      /* type */
1922          0,                     /* rightshift */
1923          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1924          16,                    /* bitsize */
1925          TRUE,                  /* pc_relative */
1926          0,                     /* bitpos */
1927          complain_overflow_dont,/* complain_on_overflow */
1928          bfd_elf_generic_reloc, /* special_function */
1929          "R_PPC64_REL16_LO",    /* name */
1930          FALSE,                 /* partial_inplace */
1931          0,                     /* src_mask */
1932          0xffff,                /* dst_mask */
1933          TRUE),                 /* pcrel_offset */
1934
1935   /* The high order 16 bits of a relative address.  */
1936   HOWTO (R_PPC64_REL16_HI,      /* type */
1937          16,                    /* rightshift */
1938          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1939          16,                    /* bitsize */
1940          TRUE,                  /* pc_relative */
1941          0,                     /* bitpos */
1942          complain_overflow_dont, /* complain_on_overflow */
1943          bfd_elf_generic_reloc, /* special_function */
1944          "R_PPC64_REL16_HI",    /* name */
1945          FALSE,                 /* partial_inplace */
1946          0,                     /* src_mask */
1947          0xffff,                /* dst_mask */
1948          TRUE),                 /* pcrel_offset */
1949
1950   /* The high order 16 bits of a relative address, plus 1 if the contents of
1951      the low 16 bits, treated as a signed number, is negative.  */
1952   HOWTO (R_PPC64_REL16_HA,      /* type */
1953          16,                    /* rightshift */
1954          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1955          16,                    /* bitsize */
1956          TRUE,                  /* pc_relative */
1957          0,                     /* bitpos */
1958          complain_overflow_dont, /* complain_on_overflow */
1959          ppc64_elf_ha_reloc,    /* special_function */
1960          "R_PPC64_REL16_HA",    /* name */
1961          FALSE,                 /* partial_inplace */
1962          0,                     /* src_mask */
1963          0xffff,                /* dst_mask */
1964          TRUE),                 /* pcrel_offset */
1965
1966   /* GNU extension to record C++ vtable hierarchy.  */
1967   HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1968          0,                     /* rightshift */
1969          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1970          0,                     /* bitsize */
1971          FALSE,                 /* pc_relative */
1972          0,                     /* bitpos */
1973          complain_overflow_dont, /* complain_on_overflow */
1974          NULL,                  /* special_function */
1975          "R_PPC64_GNU_VTINHERIT", /* name */
1976          FALSE,                 /* partial_inplace */
1977          0,                     /* src_mask */
1978          0,                     /* dst_mask */
1979          FALSE),                /* pcrel_offset */
1980
1981   /* GNU extension to record C++ vtable member usage.  */
1982   HOWTO (R_PPC64_GNU_VTENTRY,   /* type */
1983          0,                     /* rightshift */
1984          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1985          0,                     /* bitsize */
1986          FALSE,                 /* pc_relative */
1987          0,                     /* bitpos */
1988          complain_overflow_dont, /* complain_on_overflow */
1989          NULL,                  /* special_function */
1990          "R_PPC64_GNU_VTENTRY", /* name */
1991          FALSE,                 /* partial_inplace */
1992          0,                     /* src_mask */
1993          0,                     /* dst_mask */
1994          FALSE),                /* pcrel_offset */
1995 };
1996
1997 \f
1998 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1999    be done.  */
2000
2001 static void
2002 ppc_howto_init (void)
2003 {
2004   unsigned int i, type;
2005
2006   for (i = 0;
2007        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2008        i++)
2009     {
2010       type = ppc64_elf_howto_raw[i].type;
2011       BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2012                           / sizeof (ppc64_elf_howto_table[0])));
2013       ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2014     }
2015 }
2016
2017 static reloc_howto_type *
2018 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2019                              bfd_reloc_code_real_type code)
2020 {
2021   enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2022
2023   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2024     /* Initialize howto table if needed.  */
2025     ppc_howto_init ();
2026
2027   switch (code)
2028     {
2029     default:
2030       return NULL;
2031
2032     case BFD_RELOC_NONE:                        r = R_PPC64_NONE;
2033       break;
2034     case BFD_RELOC_32:                          r = R_PPC64_ADDR32;
2035       break;
2036     case BFD_RELOC_PPC_BA26:                    r = R_PPC64_ADDR24;
2037       break;
2038     case BFD_RELOC_16:                          r = R_PPC64_ADDR16;
2039       break;
2040     case BFD_RELOC_LO16:                        r = R_PPC64_ADDR16_LO;
2041       break;
2042     case BFD_RELOC_HI16:                        r = R_PPC64_ADDR16_HI;
2043       break;
2044     case BFD_RELOC_HI16_S:                      r = R_PPC64_ADDR16_HA;
2045       break;
2046     case BFD_RELOC_PPC_BA16:                    r = R_PPC64_ADDR14;
2047       break;
2048     case BFD_RELOC_PPC_BA16_BRTAKEN:            r = R_PPC64_ADDR14_BRTAKEN;
2049       break;
2050     case BFD_RELOC_PPC_BA16_BRNTAKEN:           r = R_PPC64_ADDR14_BRNTAKEN;
2051       break;
2052     case BFD_RELOC_PPC_B26:                     r = R_PPC64_REL24;
2053       break;
2054     case BFD_RELOC_PPC_B16:                     r = R_PPC64_REL14;
2055       break;
2056     case BFD_RELOC_PPC_B16_BRTAKEN:             r = R_PPC64_REL14_BRTAKEN;
2057       break;
2058     case BFD_RELOC_PPC_B16_BRNTAKEN:            r = R_PPC64_REL14_BRNTAKEN;
2059       break;
2060     case BFD_RELOC_16_GOTOFF:                   r = R_PPC64_GOT16;
2061       break;
2062     case BFD_RELOC_LO16_GOTOFF:                 r = R_PPC64_GOT16_LO;
2063       break;
2064     case BFD_RELOC_HI16_GOTOFF:                 r = R_PPC64_GOT16_HI;
2065       break;
2066     case BFD_RELOC_HI16_S_GOTOFF:               r = R_PPC64_GOT16_HA;
2067       break;
2068     case BFD_RELOC_PPC_COPY:                    r = R_PPC64_COPY;
2069       break;
2070     case BFD_RELOC_PPC_GLOB_DAT:                r = R_PPC64_GLOB_DAT;
2071       break;
2072     case BFD_RELOC_32_PCREL:                    r = R_PPC64_REL32;
2073       break;
2074     case BFD_RELOC_32_PLTOFF:                   r = R_PPC64_PLT32;
2075       break;
2076     case BFD_RELOC_32_PLT_PCREL:                r = R_PPC64_PLTREL32;
2077       break;
2078     case BFD_RELOC_LO16_PLTOFF:                 r = R_PPC64_PLT16_LO;
2079       break;
2080     case BFD_RELOC_HI16_PLTOFF:                 r = R_PPC64_PLT16_HI;
2081       break;
2082     case BFD_RELOC_HI16_S_PLTOFF:               r = R_PPC64_PLT16_HA;
2083       break;
2084     case BFD_RELOC_16_BASEREL:                  r = R_PPC64_SECTOFF;
2085       break;
2086     case BFD_RELOC_LO16_BASEREL:                r = R_PPC64_SECTOFF_LO;
2087       break;
2088     case BFD_RELOC_HI16_BASEREL:                r = R_PPC64_SECTOFF_HI;
2089       break;
2090     case BFD_RELOC_HI16_S_BASEREL:              r = R_PPC64_SECTOFF_HA;
2091       break;
2092     case BFD_RELOC_CTOR:                        r = R_PPC64_ADDR64;
2093       break;
2094     case BFD_RELOC_64:                          r = R_PPC64_ADDR64;
2095       break;
2096     case BFD_RELOC_PPC64_HIGHER:                r = R_PPC64_ADDR16_HIGHER;
2097       break;
2098     case BFD_RELOC_PPC64_HIGHER_S:              r = R_PPC64_ADDR16_HIGHERA;
2099       break;
2100     case BFD_RELOC_PPC64_HIGHEST:               r = R_PPC64_ADDR16_HIGHEST;
2101       break;
2102     case BFD_RELOC_PPC64_HIGHEST_S:             r = R_PPC64_ADDR16_HIGHESTA;
2103       break;
2104     case BFD_RELOC_64_PCREL:                    r = R_PPC64_REL64;
2105       break;
2106     case BFD_RELOC_64_PLTOFF:                   r = R_PPC64_PLT64;
2107       break;
2108     case BFD_RELOC_64_PLT_PCREL:                r = R_PPC64_PLTREL64;
2109       break;
2110     case BFD_RELOC_PPC_TOC16:                   r = R_PPC64_TOC16;
2111       break;
2112     case BFD_RELOC_PPC64_TOC16_LO:              r = R_PPC64_TOC16_LO;
2113       break;
2114     case BFD_RELOC_PPC64_TOC16_HI:              r = R_PPC64_TOC16_HI;
2115       break;
2116     case BFD_RELOC_PPC64_TOC16_HA:              r = R_PPC64_TOC16_HA;
2117       break;
2118     case BFD_RELOC_PPC64_TOC:                   r = R_PPC64_TOC;
2119       break;
2120     case BFD_RELOC_PPC64_PLTGOT16:              r = R_PPC64_PLTGOT16;
2121       break;
2122     case BFD_RELOC_PPC64_PLTGOT16_LO:           r = R_PPC64_PLTGOT16_LO;
2123       break;
2124     case BFD_RELOC_PPC64_PLTGOT16_HI:           r = R_PPC64_PLTGOT16_HI;
2125       break;
2126     case BFD_RELOC_PPC64_PLTGOT16_HA:           r = R_PPC64_PLTGOT16_HA;
2127       break;
2128     case BFD_RELOC_PPC64_ADDR16_DS:             r = R_PPC64_ADDR16_DS;
2129       break;
2130     case BFD_RELOC_PPC64_ADDR16_LO_DS:          r = R_PPC64_ADDR16_LO_DS;
2131       break;
2132     case BFD_RELOC_PPC64_GOT16_DS:              r = R_PPC64_GOT16_DS;
2133       break;
2134     case BFD_RELOC_PPC64_GOT16_LO_DS:           r = R_PPC64_GOT16_LO_DS;
2135       break;
2136     case BFD_RELOC_PPC64_PLT16_LO_DS:           r = R_PPC64_PLT16_LO_DS;
2137       break;
2138     case BFD_RELOC_PPC64_SECTOFF_DS:            r = R_PPC64_SECTOFF_DS;
2139       break;
2140     case BFD_RELOC_PPC64_SECTOFF_LO_DS:         r = R_PPC64_SECTOFF_LO_DS;
2141       break;
2142     case BFD_RELOC_PPC64_TOC16_DS:              r = R_PPC64_TOC16_DS;
2143       break;
2144     case BFD_RELOC_PPC64_TOC16_LO_DS:           r = R_PPC64_TOC16_LO_DS;
2145       break;
2146     case BFD_RELOC_PPC64_PLTGOT16_DS:           r = R_PPC64_PLTGOT16_DS;
2147       break;
2148     case BFD_RELOC_PPC64_PLTGOT16_LO_DS:        r = R_PPC64_PLTGOT16_LO_DS;
2149       break;
2150     case BFD_RELOC_PPC_TLS:                     r = R_PPC64_TLS;
2151       break;
2152     case BFD_RELOC_PPC_TLSGD:                   r = R_PPC64_TLSGD;
2153       break;
2154     case BFD_RELOC_PPC_TLSLD:                   r = R_PPC64_TLSLD;
2155       break;
2156     case BFD_RELOC_PPC_DTPMOD:                  r = R_PPC64_DTPMOD64;
2157       break;
2158     case BFD_RELOC_PPC_TPREL16:                 r = R_PPC64_TPREL16;
2159       break;
2160     case BFD_RELOC_PPC_TPREL16_LO:              r = R_PPC64_TPREL16_LO;
2161       break;
2162     case BFD_RELOC_PPC_TPREL16_HI:              r = R_PPC64_TPREL16_HI;
2163       break;
2164     case BFD_RELOC_PPC_TPREL16_HA:              r = R_PPC64_TPREL16_HA;
2165       break;
2166     case BFD_RELOC_PPC_TPREL:                   r = R_PPC64_TPREL64;
2167       break;
2168     case BFD_RELOC_PPC_DTPREL16:                r = R_PPC64_DTPREL16;
2169       break;
2170     case BFD_RELOC_PPC_DTPREL16_LO:             r = R_PPC64_DTPREL16_LO;
2171       break;
2172     case BFD_RELOC_PPC_DTPREL16_HI:             r = R_PPC64_DTPREL16_HI;
2173       break;
2174     case BFD_RELOC_PPC_DTPREL16_HA:             r = R_PPC64_DTPREL16_HA;
2175       break;
2176     case BFD_RELOC_PPC_DTPREL:                  r = R_PPC64_DTPREL64;
2177       break;
2178     case BFD_RELOC_PPC_GOT_TLSGD16:             r = R_PPC64_GOT_TLSGD16;
2179       break;
2180     case BFD_RELOC_PPC_GOT_TLSGD16_LO:          r = R_PPC64_GOT_TLSGD16_LO;
2181       break;
2182     case BFD_RELOC_PPC_GOT_TLSGD16_HI:          r = R_PPC64_GOT_TLSGD16_HI;
2183       break;
2184     case BFD_RELOC_PPC_GOT_TLSGD16_HA:          r = R_PPC64_GOT_TLSGD16_HA;
2185       break;
2186     case BFD_RELOC_PPC_GOT_TLSLD16:             r = R_PPC64_GOT_TLSLD16;
2187       break;
2188     case BFD_RELOC_PPC_GOT_TLSLD16_LO:          r = R_PPC64_GOT_TLSLD16_LO;
2189       break;
2190     case BFD_RELOC_PPC_GOT_TLSLD16_HI:          r = R_PPC64_GOT_TLSLD16_HI;
2191       break;
2192     case BFD_RELOC_PPC_GOT_TLSLD16_HA:          r = R_PPC64_GOT_TLSLD16_HA;
2193       break;
2194     case BFD_RELOC_PPC_GOT_TPREL16:             r = R_PPC64_GOT_TPREL16_DS;
2195       break;
2196     case BFD_RELOC_PPC_GOT_TPREL16_LO:          r = R_PPC64_GOT_TPREL16_LO_DS;
2197       break;
2198     case BFD_RELOC_PPC_GOT_TPREL16_HI:          r = R_PPC64_GOT_TPREL16_HI;
2199       break;
2200     case BFD_RELOC_PPC_GOT_TPREL16_HA:          r = R_PPC64_GOT_TPREL16_HA;
2201       break;
2202     case BFD_RELOC_PPC_GOT_DTPREL16:            r = R_PPC64_GOT_DTPREL16_DS;
2203       break;
2204     case BFD_RELOC_PPC_GOT_DTPREL16_LO:         r = R_PPC64_GOT_DTPREL16_LO_DS;
2205       break;
2206     case BFD_RELOC_PPC_GOT_DTPREL16_HI:         r = R_PPC64_GOT_DTPREL16_HI;
2207       break;
2208     case BFD_RELOC_PPC_GOT_DTPREL16_HA:         r = R_PPC64_GOT_DTPREL16_HA;
2209       break;
2210     case BFD_RELOC_PPC64_TPREL16_DS:            r = R_PPC64_TPREL16_DS;
2211       break;
2212     case BFD_RELOC_PPC64_TPREL16_LO_DS:         r = R_PPC64_TPREL16_LO_DS;
2213       break;
2214     case BFD_RELOC_PPC64_TPREL16_HIGHER:        r = R_PPC64_TPREL16_HIGHER;
2215       break;
2216     case BFD_RELOC_PPC64_TPREL16_HIGHERA:       r = R_PPC64_TPREL16_HIGHERA;
2217       break;
2218     case BFD_RELOC_PPC64_TPREL16_HIGHEST:       r = R_PPC64_TPREL16_HIGHEST;
2219       break;
2220     case BFD_RELOC_PPC64_TPREL16_HIGHESTA:      r = R_PPC64_TPREL16_HIGHESTA;
2221       break;
2222     case BFD_RELOC_PPC64_DTPREL16_DS:           r = R_PPC64_DTPREL16_DS;
2223       break;
2224     case BFD_RELOC_PPC64_DTPREL16_LO_DS:        r = R_PPC64_DTPREL16_LO_DS;
2225       break;
2226     case BFD_RELOC_PPC64_DTPREL16_HIGHER:       r = R_PPC64_DTPREL16_HIGHER;
2227       break;
2228     case BFD_RELOC_PPC64_DTPREL16_HIGHERA:      r = R_PPC64_DTPREL16_HIGHERA;
2229       break;
2230     case BFD_RELOC_PPC64_DTPREL16_HIGHEST:      r = R_PPC64_DTPREL16_HIGHEST;
2231       break;
2232     case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:     r = R_PPC64_DTPREL16_HIGHESTA;
2233       break;
2234     case BFD_RELOC_16_PCREL:                    r = R_PPC64_REL16;
2235       break;
2236     case BFD_RELOC_LO16_PCREL:                  r = R_PPC64_REL16_LO;
2237       break;
2238     case BFD_RELOC_HI16_PCREL:                  r = R_PPC64_REL16_HI;
2239       break;
2240     case BFD_RELOC_HI16_S_PCREL:                r = R_PPC64_REL16_HA;
2241       break;
2242     case BFD_RELOC_VTABLE_INHERIT:              r = R_PPC64_GNU_VTINHERIT;
2243       break;
2244     case BFD_RELOC_VTABLE_ENTRY:                r = R_PPC64_GNU_VTENTRY;
2245       break;
2246     }
2247
2248   return ppc64_elf_howto_table[r];
2249 };
2250
2251 static reloc_howto_type *
2252 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2253                              const char *r_name)
2254 {
2255   unsigned int i;
2256
2257   for (i = 0;
2258        i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2259        i++)
2260     if (ppc64_elf_howto_raw[i].name != NULL
2261         && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2262       return &ppc64_elf_howto_raw[i];
2263
2264   return NULL;
2265 }
2266
2267 /* Set the howto pointer for a PowerPC ELF reloc.  */
2268
2269 static void
2270 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2271                          Elf_Internal_Rela *dst)
2272 {
2273   unsigned int type;
2274
2275   /* Initialize howto table if needed.  */
2276   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2277     ppc_howto_init ();
2278
2279   type = ELF64_R_TYPE (dst->r_info);
2280   if (type >= (sizeof (ppc64_elf_howto_table)
2281                / sizeof (ppc64_elf_howto_table[0])))
2282     {
2283       (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2284                              abfd, (int) type);
2285       type = R_PPC64_NONE;
2286     }
2287   cache_ptr->howto = ppc64_elf_howto_table[type];
2288 }
2289
2290 /* Handle the R_PPC64_ADDR16_HA and similar relocs.  */
2291
2292 static bfd_reloc_status_type
2293 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2294                     void *data, asection *input_section,
2295                     bfd *output_bfd, char **error_message)
2296 {
2297   /* If this is a relocatable link (output_bfd test tells us), just
2298      call the generic function.  Any adjustment will be done at final
2299      link time.  */
2300   if (output_bfd != NULL)
2301     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2302                                   input_section, output_bfd, error_message);
2303
2304   /* Adjust the addend for sign extension of the low 16 bits.
2305      We won't actually be using the low 16 bits, so trashing them
2306      doesn't matter.  */
2307   reloc_entry->addend += 0x8000;
2308   return bfd_reloc_continue;
2309 }
2310
2311 static bfd_reloc_status_type
2312 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2313                         void *data, asection *input_section,
2314                         bfd *output_bfd, char **error_message)
2315 {
2316   if (output_bfd != NULL)
2317     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2318                                   input_section, output_bfd, error_message);
2319
2320   if (strcmp (symbol->section->name, ".opd") == 0
2321       && (symbol->section->owner->flags & DYNAMIC) == 0)
2322     {
2323       bfd_vma dest = opd_entry_value (symbol->section,
2324                                       symbol->value + reloc_entry->addend,
2325                                       NULL, NULL);
2326       if (dest != (bfd_vma) -1)
2327         reloc_entry->addend = dest - (symbol->value
2328                                       + symbol->section->output_section->vma
2329                                       + symbol->section->output_offset);
2330     }
2331   return bfd_reloc_continue;
2332 }
2333
2334 static bfd_reloc_status_type
2335 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2336                          void *data, asection *input_section,
2337                          bfd *output_bfd, char **error_message)
2338 {
2339   long insn;
2340   enum elf_ppc64_reloc_type r_type;
2341   bfd_size_type octets;
2342   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
2343   bfd_boolean is_power4 = FALSE;
2344
2345   /* If this is a relocatable link (output_bfd test tells us), just
2346      call the generic function.  Any adjustment will be done at final
2347      link time.  */
2348   if (output_bfd != NULL)
2349     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2350                                   input_section, output_bfd, error_message);
2351
2352   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2353   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2354   insn &= ~(0x01 << 21);
2355   r_type = reloc_entry->howto->type;
2356   if (r_type == R_PPC64_ADDR14_BRTAKEN
2357       || r_type == R_PPC64_REL14_BRTAKEN)
2358     insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
2359
2360   if (is_power4)
2361     {
2362       /* Set 'a' bit.  This is 0b00010 in BO field for branch
2363          on CR(BI) insns (BO == 001at or 011at), and 0b01000
2364          for branch on CTR insns (BO == 1a00t or 1a01t).  */
2365       if ((insn & (0x14 << 21)) == (0x04 << 21))
2366         insn |= 0x02 << 21;
2367       else if ((insn & (0x14 << 21)) == (0x10 << 21))
2368         insn |= 0x08 << 21;
2369       else
2370         goto out;
2371     }
2372   else
2373     {
2374       bfd_vma target = 0;
2375       bfd_vma from;
2376
2377       if (!bfd_is_com_section (symbol->section))
2378         target = symbol->value;
2379       target += symbol->section->output_section->vma;
2380       target += symbol->section->output_offset;
2381       target += reloc_entry->addend;
2382
2383       from = (reloc_entry->address
2384               + input_section->output_offset
2385               + input_section->output_section->vma);
2386
2387       /* Invert 'y' bit if not the default.  */
2388       if ((bfd_signed_vma) (target - from) < 0)
2389         insn ^= 0x01 << 21;
2390     }
2391   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2392  out:
2393   return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2394                                  input_section, output_bfd, error_message);
2395 }
2396
2397 static bfd_reloc_status_type
2398 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2399                          void *data, asection *input_section,
2400                          bfd *output_bfd, char **error_message)
2401 {
2402   /* If this is a relocatable link (output_bfd test tells us), just
2403      call the generic function.  Any adjustment will be done at final
2404      link time.  */
2405   if (output_bfd != NULL)
2406     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2407                                   input_section, output_bfd, error_message);
2408
2409   /* Subtract the symbol section base address.  */
2410   reloc_entry->addend -= symbol->section->output_section->vma;
2411   return bfd_reloc_continue;
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416                             void *data, asection *input_section,
2417                             bfd *output_bfd, char **error_message)
2418 {
2419   /* If this is a relocatable link (output_bfd test tells us), just
2420      call the generic function.  Any adjustment will be done at final
2421      link time.  */
2422   if (output_bfd != NULL)
2423     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424                                   input_section, output_bfd, error_message);
2425
2426   /* Subtract the symbol section base address.  */
2427   reloc_entry->addend -= symbol->section->output_section->vma;
2428
2429   /* Adjust the addend for sign extension of the low 16 bits.  */
2430   reloc_entry->addend += 0x8000;
2431   return bfd_reloc_continue;
2432 }
2433
2434 static bfd_reloc_status_type
2435 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2436                      void *data, asection *input_section,
2437                      bfd *output_bfd, char **error_message)
2438 {
2439   bfd_vma TOCstart;
2440
2441   /* If this is a relocatable link (output_bfd test tells us), just
2442      call the generic function.  Any adjustment will be done at final
2443      link time.  */
2444   if (output_bfd != NULL)
2445     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446                                   input_section, output_bfd, error_message);
2447
2448   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2449   if (TOCstart == 0)
2450     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2451
2452   /* Subtract the TOC base address.  */
2453   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2454   return bfd_reloc_continue;
2455 }
2456
2457 static bfd_reloc_status_type
2458 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2459                         void *data, asection *input_section,
2460                         bfd *output_bfd, char **error_message)
2461 {
2462   bfd_vma TOCstart;
2463
2464   /* If this is a relocatable link (output_bfd test tells us), just
2465      call the generic function.  Any adjustment will be done at final
2466      link time.  */
2467   if (output_bfd != NULL)
2468     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2469                                   input_section, output_bfd, error_message);
2470
2471   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2472   if (TOCstart == 0)
2473     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2474
2475   /* Subtract the TOC base address.  */
2476   reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2477
2478   /* Adjust the addend for sign extension of the low 16 bits.  */
2479   reloc_entry->addend += 0x8000;
2480   return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485                        void *data, asection *input_section,
2486                        bfd *output_bfd, char **error_message)
2487 {
2488   bfd_vma TOCstart;
2489   bfd_size_type octets;
2490
2491   /* If this is a relocatable link (output_bfd test tells us), just
2492      call the generic function.  Any adjustment will be done at final
2493      link time.  */
2494   if (output_bfd != NULL)
2495     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496                                   input_section, output_bfd, error_message);
2497
2498   TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2499   if (TOCstart == 0)
2500     TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2501
2502   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2503   bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2504   return bfd_reloc_ok;
2505 }
2506
2507 static bfd_reloc_status_type
2508 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2509                            void *data, asection *input_section,
2510                            bfd *output_bfd, char **error_message)
2511 {
2512   /* If this is a relocatable link (output_bfd test tells us), just
2513      call the generic function.  Any adjustment will be done at final
2514      link time.  */
2515   if (output_bfd != NULL)
2516     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517                                   input_section, output_bfd, error_message);
2518
2519   if (error_message != NULL)
2520     {
2521       static char buf[60];
2522       sprintf (buf, "generic linker can't handle %s",
2523                reloc_entry->howto->name);
2524       *error_message = buf;
2525     }
2526   return bfd_reloc_dangerous;
2527 }
2528
2529 /* Track GOT entries needed for a given symbol.  We might need more
2530    than one got entry per symbol.  */
2531 struct got_entry
2532 {
2533   struct got_entry *next;
2534
2535   /* The symbol addend that we'll be placing in the GOT.  */
2536   bfd_vma addend;
2537
2538   /* Unlike other ELF targets, we use separate GOT entries for the same
2539      symbol referenced from different input files.  This is to support
2540      automatic multiple TOC/GOT sections, where the TOC base can vary
2541      from one input file to another.  After partitioning into TOC groups
2542      we merge entries within the group.
2543
2544      Point to the BFD owning this GOT entry.  */
2545   bfd *owner;
2546
2547   /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2548      TLS_TPREL or TLS_DTPREL for tls entries.  */
2549   char tls_type;
2550
2551   /* Non-zero if got.ent points to real entry.  */
2552   char is_indirect;
2553
2554   /* Reference count until size_dynamic_sections, GOT offset thereafter.  */
2555   union
2556     {
2557       bfd_signed_vma refcount;
2558       bfd_vma offset;
2559       struct got_entry *ent;
2560     } got;
2561 };
2562
2563 /* The same for PLT.  */
2564 struct plt_entry
2565 {
2566   struct plt_entry *next;
2567
2568   bfd_vma addend;
2569
2570   union
2571     {
2572       bfd_signed_vma refcount;
2573       bfd_vma offset;
2574     } plt;
2575 };
2576
2577 struct ppc64_elf_obj_tdata
2578 {
2579   struct elf_obj_tdata elf;
2580
2581   /* Shortcuts to dynamic linker sections.  */
2582   asection *got;
2583   asection *relgot;
2584
2585   /* Used during garbage collection.  We attach global symbols defined
2586      on removed .opd entries to this section so that the sym is removed.  */
2587   asection *deleted_section;
2588
2589   /* TLS local dynamic got entry handling.  Support for multiple GOT
2590      sections means we potentially need one of these for each input bfd.  */
2591   struct got_entry tlsld_got;
2592
2593   /* A copy of relocs before they are modified for --emit-relocs.  */
2594   Elf_Internal_Rela *opd_relocs;
2595 };
2596
2597 #define ppc64_elf_tdata(bfd) \
2598   ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2599
2600 #define ppc64_tlsld_got(bfd) \
2601   (&ppc64_elf_tdata (bfd)->tlsld_got)
2602
2603 #define is_ppc64_elf(bfd) \
2604   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2605    && elf_object_id (bfd) == PPC64_ELF_DATA)
2606
2607 /* Override the generic function because we store some extras.  */
2608
2609 static bfd_boolean
2610 ppc64_elf_mkobject (bfd *abfd)
2611 {
2612   return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2613                                   PPC64_ELF_DATA);
2614 }
2615
2616 /* Fix bad default arch selected for a 64 bit input bfd when the
2617    default is 32 bit.  */
2618
2619 static bfd_boolean
2620 ppc64_elf_object_p (bfd *abfd)
2621 {
2622   if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2623     {
2624       Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2625
2626       if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2627         {
2628           /* Relies on arch after 32 bit default being 64 bit default.  */
2629           abfd->arch_info = abfd->arch_info->next;
2630           BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2631         }
2632     }
2633   return TRUE;
2634 }
2635
2636 /* Support for core dump NOTE sections.  */
2637
2638 static bfd_boolean
2639 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2640 {
2641   size_t offset, size;
2642
2643   if (note->descsz != 504)
2644     return FALSE;
2645
2646   /* pr_cursig */
2647   elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2648
2649   /* pr_pid */
2650   elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2651
2652   /* pr_reg */
2653   offset = 112;
2654   size = 384;
2655
2656   /* Make a ".reg/999" section.  */
2657   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2658                                           size, note->descpos + offset);
2659 }
2660
2661 static bfd_boolean
2662 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2663 {
2664   if (note->descsz != 136)
2665     return FALSE;
2666
2667   elf_tdata (abfd)->core_program
2668     = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2669   elf_tdata (abfd)->core_command
2670     = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2671
2672   return TRUE;
2673 }
2674
2675 static char *
2676 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2677                            ...)
2678 {
2679   switch (note_type)
2680     {
2681     default:
2682       return NULL;
2683
2684     case NT_PRPSINFO:
2685       {
2686         char data[136];
2687         va_list ap;
2688
2689         va_start (ap, note_type);
2690         memset (data, 0, 40);
2691         strncpy (data + 40, va_arg (ap, const char *), 16);
2692         strncpy (data + 56, va_arg (ap, const char *), 80);
2693         va_end (ap);
2694         return elfcore_write_note (abfd, buf, bufsiz,
2695                                    "CORE", note_type, data, sizeof (data));
2696       }
2697
2698     case NT_PRSTATUS:
2699       {
2700         char data[504];
2701         va_list ap;
2702         long pid;
2703         int cursig;
2704         const void *greg;
2705
2706         va_start (ap, note_type);
2707         memset (data, 0, 112);
2708         pid = va_arg (ap, long);
2709         bfd_put_32 (abfd, pid, data + 32);
2710         cursig = va_arg (ap, int);
2711         bfd_put_16 (abfd, cursig, data + 12);
2712         greg = va_arg (ap, const void *);
2713         memcpy (data + 112, greg, 384);
2714         memset (data + 496, 0, 8);
2715         va_end (ap);
2716         return elfcore_write_note (abfd, buf, bufsiz,
2717                                    "CORE", note_type, data, sizeof (data));
2718       }
2719     }
2720 }
2721
2722 /* Merge backend specific data from an object file to the output
2723    object file when linking.  */
2724
2725 static bfd_boolean
2726 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2727 {
2728   /* Check if we have the same endianess.  */
2729   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2730       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2731       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2732     {
2733       const char *msg;
2734
2735       if (bfd_big_endian (ibfd))
2736         msg = _("%B: compiled for a big endian system "
2737                 "and target is little endian");
2738       else
2739         msg = _("%B: compiled for a little endian system "
2740                 "and target is big endian");
2741
2742       (*_bfd_error_handler) (msg, ibfd);
2743
2744       bfd_set_error (bfd_error_wrong_format);
2745       return FALSE;
2746     }
2747
2748   return TRUE;
2749 }
2750
2751 /* Add extra PPC sections.  */
2752
2753 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2754 {
2755   { STRING_COMMA_LEN (".plt"),    0, SHT_NOBITS,   0 },
2756   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2757   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2758   { STRING_COMMA_LEN (".toc"),    0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2759   { STRING_COMMA_LEN (".toc1"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2760   { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2761   { NULL,                     0,  0, 0,            0 }
2762 };
2763
2764 enum _ppc64_sec_type {
2765   sec_normal = 0,
2766   sec_opd = 1,
2767   sec_toc = 2
2768 };
2769
2770 struct _ppc64_elf_section_data
2771 {
2772   struct bfd_elf_section_data elf;
2773
2774   union
2775   {
2776     /* An array with one entry for each opd function descriptor.  */
2777     struct _opd_sec_data
2778     {
2779       /* Points to the function code section for local opd entries.  */
2780       asection **func_sec;
2781
2782       /* After editing .opd, adjust references to opd local syms.  */
2783       long *adjust;
2784     } opd;
2785
2786     /* An array for toc sections, indexed by offset/8.  */
2787     struct _toc_sec_data
2788     {
2789       /* Specifies the relocation symbol index used at a given toc offset.  */
2790       unsigned *symndx;
2791
2792       /* And the relocation addend.  */
2793       bfd_vma *add;
2794     } toc;
2795   } u;
2796
2797   enum _ppc64_sec_type sec_type:2;
2798
2799   /* Flag set when small branches are detected.  Used to
2800      select suitable defaults for the stub group size.  */
2801   unsigned int has_14bit_branch:1;
2802 };
2803
2804 #define ppc64_elf_section_data(sec) \
2805   ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2806
2807 static bfd_boolean
2808 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2809 {
2810   if (!sec->used_by_bfd)
2811     {
2812       struct _ppc64_elf_section_data *sdata;
2813       bfd_size_type amt = sizeof (*sdata);
2814
2815       sdata = bfd_zalloc (abfd, amt);
2816       if (sdata == NULL)
2817         return FALSE;
2818       sec->used_by_bfd = sdata;
2819     }
2820
2821   return _bfd_elf_new_section_hook (abfd, sec);
2822 }
2823
2824 static struct _opd_sec_data *
2825 get_opd_info (asection * sec)
2826 {
2827   if (sec != NULL
2828       && ppc64_elf_section_data (sec) != NULL
2829       && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2830     return &ppc64_elf_section_data (sec)->u.opd;
2831   return NULL;
2832 }
2833 \f
2834 /* Parameters for the qsort hook.  */
2835 static bfd_boolean synthetic_relocatable;
2836
2837 /* qsort comparison function for ppc64_elf_get_synthetic_symtab.  */
2838
2839 static int
2840 compare_symbols (const void *ap, const void *bp)
2841 {
2842   const asymbol *a = * (const asymbol **) ap;
2843   const asymbol *b = * (const asymbol **) bp;
2844
2845   /* Section symbols first.  */
2846   if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2847     return -1;
2848   if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2849     return 1;
2850
2851   /* then .opd symbols.  */
2852   if (strcmp (a->section->name, ".opd") == 0
2853       && strcmp (b->section->name, ".opd") != 0)
2854     return -1;
2855   if (strcmp (a->section->name, ".opd") != 0
2856       && strcmp (b->section->name, ".opd") == 0)
2857     return 1;
2858
2859   /* then other code symbols.  */
2860   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2861       == (SEC_CODE | SEC_ALLOC)
2862       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2863          != (SEC_CODE | SEC_ALLOC))
2864     return -1;
2865
2866   if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867       != (SEC_CODE | SEC_ALLOC)
2868       && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2869          == (SEC_CODE | SEC_ALLOC))
2870     return 1;
2871
2872   if (synthetic_relocatable)
2873     {
2874       if (a->section->id < b->section->id)
2875         return -1;
2876
2877       if (a->section->id > b->section->id)
2878         return 1;
2879     }
2880
2881   if (a->value + a->section->vma < b->value + b->section->vma)
2882     return -1;
2883
2884   if (a->value + a->section->vma > b->value + b->section->vma)
2885     return 1;
2886
2887   /* For syms with the same value, prefer strong dynamic global function
2888      syms over other syms.  */
2889   if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2890     return -1;
2891
2892   if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2893     return 1;
2894
2895   if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2896     return -1;
2897
2898   if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2899     return 1;
2900
2901   if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2902     return -1;
2903
2904   if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2905     return 1;
2906
2907   if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2908     return -1;
2909
2910   if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2911     return 1;
2912
2913   return 0;
2914 }
2915
2916 /* Search SYMS for a symbol of the given VALUE.  */
2917
2918 static asymbol *
2919 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2920 {
2921   long mid;
2922
2923   if (id == -1)
2924     {
2925       while (lo < hi)
2926         {
2927           mid = (lo + hi) >> 1;
2928           if (syms[mid]->value + syms[mid]->section->vma < value)
2929             lo = mid + 1;
2930           else if (syms[mid]->value + syms[mid]->section->vma > value)
2931             hi = mid;
2932           else
2933             return syms[mid];
2934         }
2935     }
2936   else
2937     {
2938       while (lo < hi)
2939         {
2940           mid = (lo + hi) >> 1;
2941           if (syms[mid]->section->id < id)
2942             lo = mid + 1;
2943           else if (syms[mid]->section->id > id)
2944             hi = mid;
2945           else if (syms[mid]->value < value)
2946             lo = mid + 1;
2947           else if (syms[mid]->value > value)
2948             hi = mid;
2949           else
2950             return syms[mid];
2951         }
2952     }
2953   return NULL;
2954 }
2955
2956 static bfd_boolean
2957 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2958 {
2959   bfd_vma vma = *(bfd_vma *) ptr;
2960   return ((section->flags & SEC_ALLOC) != 0
2961           && section->vma <= vma
2962           && vma < section->vma + section->size);
2963 }
2964
2965 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2966    entry syms.  Also generate @plt symbols for the glink branch table.  */
2967
2968 static long
2969 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2970                                 long static_count, asymbol **static_syms,
2971                                 long dyn_count, asymbol **dyn_syms,
2972                                 asymbol **ret)
2973 {
2974   asymbol *s;
2975   long i;
2976   long count;
2977   char *names;
2978   long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2979   asection *opd;
2980   bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2981   asymbol **syms;
2982
2983   *ret = NULL;
2984
2985   opd = bfd_get_section_by_name (abfd, ".opd");
2986   if (opd == NULL)
2987     return 0;
2988
2989   symcount = static_count;
2990   if (!relocatable)
2991     symcount += dyn_count;
2992   if (symcount == 0)
2993     return 0;
2994
2995   syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2996   if (syms == NULL)
2997     return -1;
2998
2999   if (!relocatable && static_count != 0 && dyn_count != 0)
3000     {
3001       /* Use both symbol tables.  */
3002       memcpy (syms, static_syms, static_count * sizeof (*syms));
3003       memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3004     }
3005   else if (!relocatable && static_count == 0)
3006     memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3007   else
3008     memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3009
3010   synthetic_relocatable = relocatable;
3011   qsort (syms, symcount, sizeof (*syms), compare_symbols);
3012
3013   if (!relocatable && symcount > 1)
3014     {
3015       long j;
3016       /* Trim duplicate syms, since we may have merged the normal and
3017          dynamic symbols.  Actually, we only care about syms that have
3018          different values, so trim any with the same value.  */
3019       for (i = 1, j = 1; i < symcount; ++i)
3020         if (syms[i - 1]->value + syms[i - 1]->section->vma
3021             != syms[i]->value + syms[i]->section->vma)
3022           syms[j++] = syms[i];
3023       symcount = j;
3024     }
3025
3026   i = 0;
3027   if (strcmp (syms[i]->section->name, ".opd") == 0)
3028     ++i;
3029   codesecsym = i;
3030
3031   for (; i < symcount; ++i)
3032     if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3033          != (SEC_CODE | SEC_ALLOC))
3034         || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3035       break;
3036   codesecsymend = i;
3037
3038   for (; i < symcount; ++i)
3039     if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3040       break;
3041   secsymend = i;
3042
3043   for (; i < symcount; ++i)
3044     if (strcmp (syms[i]->section->name, ".opd") != 0)
3045       break;
3046   opdsymend = i;
3047
3048   for (; i < symcount; ++i)
3049     if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050         != (SEC_CODE | SEC_ALLOC))
3051       break;
3052   symcount = i;
3053
3054   count = 0;
3055
3056   if (relocatable)
3057     {
3058       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3059       arelent *r;
3060       size_t size;
3061       long relcount;
3062
3063       if (opdsymend == secsymend)
3064         goto done;
3065
3066       slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3067       relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3068       if (relcount == 0)
3069         goto done;
3070
3071       if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3072         {
3073           count = -1;
3074           goto done;
3075         }
3076
3077       size = 0;
3078       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3079         {
3080           asymbol *sym;
3081
3082           while (r < opd->relocation + relcount
3083                  && r->address < syms[i]->value + opd->vma)
3084             ++r;
3085
3086           if (r == opd->relocation + relcount)
3087             break;
3088
3089           if (r->address != syms[i]->value + opd->vma)
3090             continue;
3091
3092           if (r->howto->type != R_PPC64_ADDR64)
3093             continue;
3094
3095           sym = *r->sym_ptr_ptr;
3096           if (!sym_exists_at (syms, opdsymend, symcount,
3097                               sym->section->id, sym->value + r->addend))
3098             {
3099               ++count;
3100               size += sizeof (asymbol);
3101               size += strlen (syms[i]->name) + 2;
3102             }
3103         }
3104
3105       s = *ret = bfd_malloc (size);
3106       if (s == NULL)
3107         {
3108           count = -1;
3109           goto done;
3110         }
3111
3112       names = (char *) (s + count);
3113
3114       for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3115         {
3116           asymbol *sym;
3117
3118           while (r < opd->relocation + relcount
3119                  && r->address < syms[i]->value + opd->vma)
3120             ++r;
3121
3122           if (r == opd->relocation + relcount)
3123             break;
3124
3125           if (r->address != syms[i]->value + opd->vma)
3126             continue;
3127
3128           if (r->howto->type != R_PPC64_ADDR64)
3129             continue;
3130
3131           sym = *r->sym_ptr_ptr;
3132           if (!sym_exists_at (syms, opdsymend, symcount,
3133                               sym->section->id, sym->value + r->addend))
3134             {
3135               size_t len;
3136
3137               *s = *syms[i];
3138               s->flags |= BSF_SYNTHETIC;
3139               s->section = sym->section;
3140               s->value = sym->value + r->addend;
3141               s->name = names;
3142               *names++ = '.';
3143               len = strlen (syms[i]->name);
3144               memcpy (names, syms[i]->name, len + 1);
3145               names += len + 1;
3146               /* Have udata.p point back to the original symbol this
3147                  synthetic symbol was derived from.  */
3148               s->udata.p = syms[i];
3149               s++;
3150             }
3151         }
3152     }
3153   else
3154     {
3155       bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3156       bfd_byte *contents;
3157       size_t size;
3158       long plt_count = 0;
3159       bfd_vma glink_vma = 0, resolv_vma = 0;
3160       asection *dynamic, *glink = NULL, *relplt = NULL;
3161       arelent *p;
3162
3163       if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3164         {
3165           if (contents)
3166             {
3167             free_contents_and_exit:
3168               free (contents);
3169             }
3170           count = -1;
3171           goto done;
3172         }
3173
3174       size = 0;
3175       for (i = secsymend; i < opdsymend; ++i)
3176         {
3177           bfd_vma ent;
3178
3179           /* Ignore bogus symbols.  */
3180           if (syms[i]->value > opd->size - 8)
3181             continue;
3182
3183           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3184           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3185             {
3186               ++count;
3187               size += sizeof (asymbol);
3188               size += strlen (syms[i]->name) + 2;
3189             }
3190         }
3191
3192       /* Get start of .glink stubs from DT_PPC64_GLINK.  */
3193       if (dyn_count != 0
3194           && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3195         {
3196           bfd_byte *dynbuf, *extdyn, *extdynend;
3197           size_t extdynsize;
3198           void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3199
3200           if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3201             goto free_contents_and_exit;
3202
3203           extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3204           swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3205
3206           extdyn = dynbuf;
3207           extdynend = extdyn + dynamic->size;
3208           for (; extdyn < extdynend; extdyn += extdynsize)
3209             {
3210               Elf_Internal_Dyn dyn;
3211               (*swap_dyn_in) (abfd, extdyn, &dyn);
3212
3213               if (dyn.d_tag == DT_NULL)
3214                 break;
3215
3216               if (dyn.d_tag == DT_PPC64_GLINK)
3217                 {
3218                   /* The first glink stub starts at offset 32; see comment in
3219                      ppc64_elf_finish_dynamic_sections. */
3220                   glink_vma = dyn.d_un.d_val + 32;
3221                   /* The .glink section usually does not survive the final
3222                      link; search for the section (usually .text) where the
3223                      glink stubs now reside.  */
3224                   glink = bfd_sections_find_if (abfd, section_covers_vma,
3225                                                 &glink_vma);
3226                   break;
3227                 }
3228             }
3229
3230           free (dynbuf);
3231         }
3232
3233       if (glink != NULL)
3234         {
3235           /* Determine __glink trampoline by reading the relative branch
3236              from the first glink stub.  */
3237           bfd_byte buf[4];
3238           if (bfd_get_section_contents (abfd, glink, buf,
3239                                         glink_vma + 4 - glink->vma, 4))
3240             {
3241               unsigned int insn = bfd_get_32 (abfd, buf);
3242               insn ^= B_DOT;
3243               if ((insn & ~0x3fffffc) == 0)
3244                 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3245             }
3246
3247           if (resolv_vma)
3248             size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3249
3250           relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3251           if (relplt != NULL)
3252             {
3253               slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3254               if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3255                 goto free_contents_and_exit;
3256
3257               plt_count = relplt->size / sizeof (Elf64_External_Rela);
3258               size += plt_count * sizeof (asymbol);
3259
3260               p = relplt->relocation;
3261               for (i = 0; i < plt_count; i++, p++)
3262                 {
3263                   size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3264                   if (p->addend != 0)
3265                     size += sizeof ("+0x") - 1 + 16;
3266                 }
3267             }
3268         }
3269
3270       s = *ret = bfd_malloc (size);
3271       if (s == NULL)
3272         goto free_contents_and_exit;
3273
3274       names = (char *) (s + count + plt_count + (resolv_vma != 0));
3275
3276       for (i = secsymend; i < opdsymend; ++i)
3277         {
3278           bfd_vma ent;
3279
3280           if (syms[i]->value > opd->size - 8)
3281             continue;
3282
3283           ent = bfd_get_64 (abfd, contents + syms[i]->value);
3284           if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3285             {
3286               long lo, hi;
3287               size_t len;
3288               asection *sec = abfd->sections;
3289
3290               *s = *syms[i];
3291               lo = codesecsym;
3292               hi = codesecsymend;
3293               while (lo < hi)
3294                 {
3295                   long mid = (lo + hi) >> 1;
3296                   if (syms[mid]->section->vma < ent)
3297                     lo = mid + 1;
3298                   else if (syms[mid]->section->vma > ent)
3299                     hi = mid;
3300                   else
3301                     {
3302                       sec = syms[mid]->section;
3303                       break;
3304                     }
3305                 }
3306
3307               if (lo >= hi && lo > codesecsym)
3308                 sec = syms[lo - 1]->section;
3309
3310               for (; sec != NULL; sec = sec->next)
3311                 {
3312                   if (sec->vma > ent)
3313                     break;
3314                   if ((sec->flags & SEC_ALLOC) == 0
3315                       || (sec->flags & SEC_LOAD) == 0)
3316                     break;
3317                   if ((sec->flags & SEC_CODE) != 0)
3318                     s->section = sec;
3319                 }
3320               s->flags |= BSF_SYNTHETIC;
3321               s->value = ent - s->section->vma;
3322               s->name = names;
3323               *names++ = '.';
3324               len = strlen (syms[i]->name);
3325               memcpy (names, syms[i]->name, len + 1);
3326               names += len + 1;
3327               /* Have udata.p point back to the original symbol this
3328                  synthetic symbol was derived from.  */
3329               s->udata.p = syms[i];
3330               s++;
3331             }
3332         }
3333       free (contents);
3334
3335       if (glink != NULL && relplt != NULL)
3336         {
3337           if (resolv_vma)
3338             {
3339               /* Add a symbol for the main glink trampoline.  */
3340               memset (s, 0, sizeof *s);
3341               s->the_bfd = abfd;
3342               s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3343               s->section = glink;
3344               s->value = resolv_vma - glink->vma;
3345               s->name = names;
3346               memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3347               names += sizeof ("__glink_PLTresolve");
3348               s++;
3349               count++;
3350             }
3351
3352           /* FIXME: It would be very much nicer to put sym@plt on the
3353              stub rather than on the glink branch table entry.  The
3354              objdump disassembler would then use a sensible symbol
3355              name on plt calls.  The difficulty in doing so is
3356              a) finding the stubs, and,
3357              b) matching stubs against plt entries, and,
3358              c) there can be multiple stubs for a given plt entry.
3359
3360              Solving (a) could be done by code scanning, but older
3361              ppc64 binaries used different stubs to current code.
3362              (b) is the tricky one since you need to known the toc
3363              pointer for at least one function that uses a pic stub to
3364              be able to calculate the plt address referenced.
3365              (c) means gdb would need to set multiple breakpoints (or
3366              find the glink branch itself) when setting breakpoints
3367              for pending shared library loads.  */
3368           p = relplt->relocation;
3369           for (i = 0; i < plt_count; i++, p++)
3370             {
3371               size_t len;
3372
3373               *s = **p->sym_ptr_ptr;
3374               /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
3375                  we are defining a symbol, ensure one of them is set.  */
3376               if ((s->flags & BSF_LOCAL) == 0)
3377                 s->flags |= BSF_GLOBAL;
3378               s->flags |= BSF_SYNTHETIC;
3379               s->section = glink;
3380               s->value = glink_vma - glink->vma;
3381               s->name = names;
3382               s->udata.p = NULL;
3383               len = strlen ((*p->sym_ptr_ptr)->name);
3384               memcpy (names, (*p->sym_ptr_ptr)->name, len);
3385               names += len;
3386               if (p->addend != 0)
3387                 {
3388                   memcpy (names, "+0x", sizeof ("+0x") - 1);
3389                   names += sizeof ("+0x") - 1;
3390                   bfd_sprintf_vma (abfd, names, p->addend);
3391                   names += strlen (names);
3392                 }
3393               memcpy (names, "@plt", sizeof ("@plt"));
3394               names += sizeof ("@plt");
3395               s++;
3396               glink_vma += 8;
3397               if (i >= 0x8000)
3398                 glink_vma += 4;
3399             }
3400           count += plt_count;
3401         }
3402     }
3403
3404  done:
3405   free (syms);
3406   return count;
3407 }
3408 \f
3409 /* The following functions are specific to the ELF linker, while
3410    functions above are used generally.  Those named ppc64_elf_* are
3411    called by the main ELF linker code.  They appear in this file more
3412    or less in the order in which they are called.  eg.
3413    ppc64_elf_check_relocs is called early in the link process,
3414    ppc64_elf_finish_dynamic_sections is one of the last functions
3415    called.
3416
3417    PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3418    functions have both a function code symbol and a function descriptor
3419    symbol.  A call to foo in a relocatable object file looks like:
3420
3421    .            .text
3422    .    x:
3423    .            bl      .foo
3424    .            nop
3425
3426    The function definition in another object file might be:
3427
3428    .            .section .opd
3429    .    foo:    .quad   .foo
3430    .            .quad   .TOC.@tocbase
3431    .            .quad   0
3432    .
3433    .            .text
3434    .    .foo:   blr
3435
3436    When the linker resolves the call during a static link, the branch
3437    unsurprisingly just goes to .foo and the .opd information is unused.
3438    If the function definition is in a shared library, things are a little
3439    different:  The call goes via a plt call stub, the opd information gets
3440    copied to the plt, and the linker patches the nop.
3441
3442    .    x:
3443    .            bl      .foo_stub
3444    .            ld      2,40(1)
3445    .
3446    .
3447    .    .foo_stub:
3448    .            addis   12,2,Lfoo@toc@ha        # in practice, the call stub
3449    .            addi    12,12,Lfoo@toc@l        # is slightly optimized, but
3450    .            std     2,40(1)                 # this is the general idea
3451    .            ld      11,0(12)
3452    .            ld      2,8(12)
3453    .            mtctr   11
3454    .            ld      11,16(12)
3455    .            bctr
3456    .
3457    .            .section .plt
3458    .    Lfoo:   reloc (R_PPC64_JMP_SLOT, foo)
3459
3460    The "reloc ()" notation is supposed to indicate that the linker emits
3461    an R_PPC64_JMP_SLOT reloc against foo.  The dynamic linker does the opd
3462    copying.
3463
3464    What are the difficulties here?  Well, firstly, the relocations
3465    examined by the linker in check_relocs are against the function code
3466    sym .foo, while the dynamic relocation in the plt is emitted against
3467    the function descriptor symbol, foo.  Somewhere along the line, we need
3468    to carefully copy dynamic link information from one symbol to the other.
3469    Secondly, the generic part of the elf linker will make .foo a dynamic
3470    symbol as is normal for most other backends.  We need foo dynamic
3471    instead, at least for an application final link.  However, when
3472    creating a shared library containing foo, we need to have both symbols
3473    dynamic so that references to .foo are satisfied during the early
3474    stages of linking.  Otherwise the linker might decide to pull in a
3475    definition from some other object, eg. a static library.
3476
3477    Update: As of August 2004, we support a new convention.  Function
3478    calls may use the function descriptor symbol, ie. "bl foo".  This
3479    behaves exactly as "bl .foo".  */
3480
3481 /* The linker needs to keep track of the number of relocs that it
3482    decides to copy as dynamic relocs in check_relocs for each symbol.
3483    This is so that it can later discard them if they are found to be
3484    unnecessary.  We store the information in a field extending the
3485    regular ELF linker hash table.  */
3486
3487 struct ppc_dyn_relocs
3488 {
3489   struct ppc_dyn_relocs *next;
3490
3491   /* The input section of the reloc.  */
3492   asection *sec;
3493
3494   /* Total number of relocs copied for the input section.  */
3495   bfd_size_type count;
3496
3497   /* Number of pc-relative relocs copied for the input section.  */
3498   bfd_size_type pc_count;
3499 };
3500
3501 /* Of those relocs that might be copied as dynamic relocs, this function
3502    selects those that must be copied when linking a shared library,
3503    even when the symbol is local.  */
3504
3505 static int
3506 must_be_dyn_reloc (struct bfd_link_info *info,
3507                    enum elf_ppc64_reloc_type r_type)
3508 {
3509   switch (r_type)
3510     {
3511     default:
3512       return 1;
3513
3514     case R_PPC64_REL32:
3515     case R_PPC64_REL64:
3516     case R_PPC64_REL30:
3517       return 0;
3518
3519     case R_PPC64_TPREL16:
3520     case R_PPC64_TPREL16_LO:
3521     case R_PPC64_TPREL16_HI:
3522     case R_PPC64_TPREL16_HA:
3523     case R_PPC64_TPREL16_DS:
3524     case R_PPC64_TPREL16_LO_DS:
3525     case R_PPC64_TPREL16_HIGHER:
3526     case R_PPC64_TPREL16_HIGHERA:
3527     case R_PPC64_TPREL16_HIGHEST:
3528     case R_PPC64_TPREL16_HIGHESTA:
3529     case R_PPC64_TPREL64:
3530       return !info->executable;
3531     }
3532 }
3533
3534 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3535    copying dynamic variables from a shared lib into an app's dynbss
3536    section, and instead use a dynamic relocation to point into the
3537    shared lib.  With code that gcc generates, it's vital that this be
3538    enabled;  In the PowerPC64 ABI, the address of a function is actually
3539    the address of a function descriptor, which resides in the .opd
3540    section.  gcc uses the descriptor directly rather than going via the
3541    GOT as some other ABI's do, which means that initialized function
3542    pointers must reference the descriptor.  Thus, a function pointer
3543    initialized to the address of a function in a shared library will
3544    either require a copy reloc, or a dynamic reloc.  Using a copy reloc
3545    redefines the function descriptor symbol to point to the copy.  This
3546    presents a problem as a plt entry for that function is also
3547    initialized from the function descriptor symbol and the copy reloc
3548    may not be initialized first.  */
3549 #define ELIMINATE_COPY_RELOCS 1
3550
3551 /* Section name for stubs is the associated section name plus this
3552    string.  */
3553 #define STUB_SUFFIX ".stub"
3554
3555 /* Linker stubs.
3556    ppc_stub_long_branch:
3557    Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3558    destination, but a 24 bit branch in a stub section will reach.
3559    .    b       dest
3560
3561    ppc_stub_plt_branch:
3562    Similar to the above, but a 24 bit branch in the stub section won't
3563    reach its destination.
3564    .    addis   %r12,%r2,xxx@toc@ha
3565    .    ld      %r11,xxx@toc@l(%r12)
3566    .    mtctr   %r11
3567    .    bctr
3568
3569    ppc_stub_plt_call:
3570    Used to call a function in a shared library.  If it so happens that
3571    the plt entry referenced crosses a 64k boundary, then an extra
3572    "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3573    .    addis   %r12,%r2,xxx@toc@ha
3574    .    std     %r2,40(%r1)
3575    .    ld      %r11,xxx+0@toc@l(%r12)
3576    .    mtctr   %r11
3577    .    ld      %r2,xxx+8@toc@l(%r12)
3578    .    ld      %r11,xxx+16@toc@l(%r12)
3579    .    bctr
3580
3581    ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3582    code to adjust the value and save r2 to support multiple toc sections.
3583    A ppc_stub_long_branch with an r2 offset looks like:
3584    .    std     %r2,40(%r1)
3585    .    addis   %r2,%r2,off@ha
3586    .    addi    %r2,%r2,off@l
3587    .    b       dest
3588
3589    A ppc_stub_plt_branch with an r2 offset looks like:
3590    .    std     %r2,40(%r1)
3591    .    addis   %r12,%r2,xxx@toc@ha
3592    .    ld      %r11,xxx@toc@l(%r12)
3593    .    addis   %r2,%r2,off@ha
3594    .    addi    %r2,%r2,off@l
3595    .    mtctr   %r11
3596    .    bctr
3597
3598    In cases where the "addis" instruction would add zero, the "addis" is
3599    omitted and following instructions modified slightly in some cases.
3600 */
3601
3602 enum ppc_stub_type {
3603   ppc_stub_none,
3604   ppc_stub_long_branch,
3605   ppc_stub_long_branch_r2off,
3606   ppc_stub_plt_branch,
3607   ppc_stub_plt_branch_r2off,
3608   ppc_stub_plt_call
3609 };
3610
3611 struct ppc_stub_hash_entry {
3612
3613   /* Base hash table entry structure.  */
3614   struct bfd_hash_entry root;
3615
3616   enum ppc_stub_type stub_type;
3617
3618   /* The stub section.  */
3619   asection *stub_sec;
3620
3621   /* Offset within stub_sec of the beginning of this stub.  */
3622   bfd_vma stub_offset;
3623
3624   /* Given the symbol's value and its section we can determine its final
3625      value when building the stubs (so the stub knows where to jump.  */
3626   bfd_vma target_value;
3627   asection *target_section;
3628
3629   /* The symbol table entry, if any, that this was derived from.  */
3630   struct ppc_link_hash_entry *h;
3631   struct plt_entry *plt_ent;
3632
3633   /* And the reloc addend that this was derived from.  */
3634   bfd_vma addend;
3635
3636   /* Where this stub is being called from, or, in the case of combined
3637      stub sections, the first input section in the group.  */
3638   asection *id_sec;
3639 };
3640
3641 struct ppc_branch_hash_entry {
3642
3643   /* Base hash table entry structure.  */
3644   struct bfd_hash_entry root;
3645
3646   /* Offset within branch lookup table.  */
3647   unsigned int offset;
3648
3649   /* Generation marker.  */
3650   unsigned int iter;
3651 };
3652
3653 struct ppc_link_hash_entry
3654 {
3655   struct elf_link_hash_entry elf;
3656
3657   union {
3658     /* A pointer to the most recently used stub hash entry against this
3659        symbol.  */
3660     struct ppc_stub_hash_entry *stub_cache;
3661
3662     /* A pointer to the next symbol starting with a '.'  */
3663     struct ppc_link_hash_entry *next_dot_sym;
3664   } u;
3665
3666   /* Track dynamic relocs copied for this symbol.  */
3667   struct ppc_dyn_relocs *dyn_relocs;
3668
3669   /* Link between function code and descriptor symbols.  */
3670   struct ppc_link_hash_entry *oh;
3671
3672   /* Flag function code and descriptor symbols.  */
3673   unsigned int is_func:1;
3674   unsigned int is_func_descriptor:1;
3675   unsigned int fake:1;
3676
3677   /* Whether global opd/toc sym has been adjusted or not.
3678      After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3679      should be set for all globals defined in any opd/toc section.  */
3680   unsigned int adjust_done:1;
3681
3682   /* Set if we twiddled this symbol to weak at some stage.  */
3683   unsigned int was_undefined:1;
3684
3685   /* Contexts in which symbol is used in the GOT (or TOC).
3686      TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3687      corresponding relocs are encountered during check_relocs.
3688      tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3689      indicate the corresponding GOT entry type is not needed.
3690      tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3691      a TPREL one.  We use a separate flag rather than setting TPREL
3692      just for convenience in distinguishing the two cases.  */
3693 #define TLS_GD           1      /* GD reloc. */
3694 #define TLS_LD           2      /* LD reloc. */
3695 #define TLS_TPREL        4      /* TPREL reloc, => IE. */
3696 #define TLS_DTPREL       8      /* DTPREL reloc, => LD. */
3697 #define TLS_TLS         16      /* Any TLS reloc.  */
3698 #define TLS_EXPLICIT    32      /* Marks TOC section TLS relocs. */
3699 #define TLS_TPRELGD     64      /* TPREL reloc resulting from GD->IE. */
3700 #define PLT_IFUNC      128      /* STT_GNU_IFUNC.  */
3701   char tls_mask;
3702 };
3703
3704 /* ppc64 ELF linker hash table.  */
3705
3706 struct ppc_link_hash_table
3707 {
3708   struct elf_link_hash_table elf;
3709
3710   /* The stub hash table.  */
3711   struct bfd_hash_table stub_hash_table;
3712
3713   /* Another hash table for plt_branch stubs.  */
3714   struct bfd_hash_table branch_hash_table;
3715
3716   /* Linker stub bfd.  */
3717   bfd *stub_bfd;
3718
3719   /* Linker call-backs.  */
3720   asection * (*add_stub_section) (const char *, asection *);
3721   void (*layout_sections_again) (void);
3722
3723   /* Array to keep track of which stub sections have been created, and
3724      information on stub grouping.  */
3725   struct map_stub {
3726     /* This is the section to which stubs in the group will be attached.  */
3727     asection *link_sec;
3728     /* The stub section.  */
3729     asection *stub_sec;
3730     /* Along with elf_gp, specifies the TOC pointer used in this group.  */
3731     bfd_vma toc_off;
3732   } *stub_group;
3733
3734   /* Temp used when calculating TOC pointers.  */
3735   bfd_vma toc_curr;
3736   bfd *toc_bfd;
3737   asection *toc_first_sec;
3738
3739   /* Highest input section id.  */
3740   int top_id;
3741
3742   /* Highest output section index.  */
3743   int top_index;
3744
3745   /* Used when adding symbols.  */
3746   struct ppc_link_hash_entry *dot_syms;
3747
3748   /* List of input sections for each output section.  */
3749   asection **input_list;
3750
3751   /* Short-cuts to get to dynamic linker sections.  */
3752   asection *got;
3753   asection *plt;
3754   asection *relplt;
3755   asection *iplt;
3756   asection *reliplt;
3757   asection *dynbss;
3758   asection *relbss;
3759   asection *glink;
3760   asection *sfpr;
3761   asection *brlt;
3762   asection *relbrlt;
3763
3764   /* Shortcut to .__tls_get_addr and __tls_get_addr.  */
3765   struct ppc_link_hash_entry *tls_get_addr;
3766   struct ppc_link_hash_entry *tls_get_addr_fd;
3767
3768   /* The size of reliplt used by got entry relocs.  */
3769   bfd_size_type got_reli_size;
3770
3771   /* Statistics.  */
3772   unsigned long stub_count[ppc_stub_plt_call];
3773
3774   /* Number of stubs against global syms.  */
3775   unsigned long stub_globals;
3776
3777   /* Set if we should emit symbols for stubs.  */
3778   unsigned int emit_stub_syms:1;
3779
3780   /* Set if __tls_get_addr optimization should not be done.  */
3781   unsigned int no_tls_get_addr_opt:1;
3782
3783   /* Support for multiple toc sections.  */
3784   unsigned int multi_toc_needed:1;
3785   unsigned int second_toc_pass:1;
3786
3787   /* Set on error.  */
3788   unsigned int stub_error:1;
3789
3790   /* Temp used by ppc64_elf_process_dot_syms.  */
3791   unsigned int twiddled_syms:1;
3792
3793   /* Incremented every time we size stubs.  */
3794   unsigned int stub_iteration;
3795
3796   /* Small local sym cache.  */
3797   struct sym_cache sym_cache;
3798 };
3799
3800 /* Rename some of the generic section flags to better document how they
3801    are used here.  */
3802 #define has_toc_reloc has_gp_reloc
3803 #define makes_toc_func_call need_finalize_relax
3804 #define call_check_in_progress reloc_done
3805
3806 /* Get the ppc64 ELF linker hash table from a link_info structure.  */
3807
3808 #define ppc_hash_table(p) \
3809   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3810   == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3811
3812 #define ppc_stub_hash_lookup(table, string, create, copy) \
3813   ((struct ppc_stub_hash_entry *) \
3814    bfd_hash_lookup ((table), (string), (create), (copy)))
3815
3816 #define ppc_branch_hash_lookup(table, string, create, copy) \
3817   ((struct ppc_branch_hash_entry *) \
3818    bfd_hash_lookup ((table), (string), (create), (copy)))
3819
3820 /* Create an entry in the stub hash table.  */
3821
3822 static struct bfd_hash_entry *
3823 stub_hash_newfunc (struct bfd_hash_entry *entry,
3824                    struct bfd_hash_table *table,
3825                    const char *string)
3826 {
3827   /* Allocate the structure if it has not already been allocated by a
3828      subclass.  */
3829   if (entry == NULL)
3830     {
3831       entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3832       if (entry == NULL)
3833         return entry;
3834     }
3835
3836   /* Call the allocation method of the superclass.  */
3837   entry = bfd_hash_newfunc (entry, table, string);
3838   if (entry != NULL)
3839     {
3840       struct ppc_stub_hash_entry *eh;
3841
3842       /* Initialize the local fields.  */
3843       eh = (struct ppc_stub_hash_entry *) entry;
3844       eh->stub_type = ppc_stub_none;
3845       eh->stub_sec = NULL;
3846       eh->stub_offset = 0;
3847       eh->target_value = 0;
3848       eh->target_section = NULL;
3849       eh->h = NULL;
3850       eh->id_sec = NULL;
3851     }
3852
3853   return entry;
3854 }
3855
3856 /* Create an entry in the branch hash table.  */
3857
3858 static struct bfd_hash_entry *
3859 branch_hash_newfunc (struct bfd_hash_entry *entry,
3860                      struct bfd_hash_table *table,
3861                      const char *string)
3862 {
3863   /* Allocate the structure if it has not already been allocated by a
3864      subclass.  */
3865   if (entry == NULL)
3866     {
3867       entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3868       if (entry == NULL)
3869         return entry;
3870     }
3871
3872   /* Call the allocation method of the superclass.  */
3873   entry = bfd_hash_newfunc (entry, table, string);
3874   if (entry != NULL)
3875     {
3876       struct ppc_branch_hash_entry *eh;
3877
3878       /* Initialize the local fields.  */
3879       eh = (struct ppc_branch_hash_entry *) entry;
3880       eh->offset = 0;
3881       eh->iter = 0;
3882     }
3883
3884   return entry;
3885 }
3886
3887 /* Create an entry in a ppc64 ELF linker hash table.  */
3888
3889 static struct bfd_hash_entry *
3890 link_hash_newfunc (struct bfd_hash_entry *entry,
3891                    struct bfd_hash_table *table,
3892                    const char *string)
3893 {
3894   /* Allocate the structure if it has not already been allocated by a
3895      subclass.  */
3896   if (entry == NULL)
3897     {
3898       entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3899       if (entry == NULL)
3900         return entry;
3901     }
3902
3903   /* Call the allocation method of the superclass.  */
3904   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3905   if (entry != NULL)
3906     {
3907       struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3908
3909       memset (&eh->u.stub_cache, 0,
3910               (sizeof (struct ppc_link_hash_entry)
3911                - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3912
3913       /* When making function calls, old ABI code references function entry
3914          points (dot symbols), while new ABI code references the function
3915          descriptor symbol.  We need to make any combination of reference and
3916          definition work together, without breaking archive linking.
3917
3918          For a defined function "foo" and an undefined call to "bar":
3919          An old object defines "foo" and ".foo", references ".bar" (possibly
3920          "bar" too).
3921          A new object defines "foo" and references "bar".
3922
3923          A new object thus has no problem with its undefined symbols being
3924          satisfied by definitions in an old object.  On the other hand, the
3925          old object won't have ".bar" satisfied by a new object.
3926
3927          Keep a list of newly added dot-symbols.  */
3928
3929       if (string[0] == '.')
3930         {
3931           struct ppc_link_hash_table *htab;
3932
3933           htab = (struct ppc_link_hash_table *) table;
3934           eh->u.next_dot_sym = htab->dot_syms;
3935           htab->dot_syms = eh;
3936         }
3937     }
3938
3939   return entry;
3940 }
3941
3942 /* Create a ppc64 ELF linker hash table.  */
3943
3944 static struct bfd_link_hash_table *
3945 ppc64_elf_link_hash_table_create (bfd *abfd)
3946 {
3947   struct ppc_link_hash_table *htab;
3948   bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3949
3950   htab = bfd_zmalloc (amt);
3951   if (htab == NULL)
3952     return NULL;
3953
3954   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3955                                       sizeof (struct ppc_link_hash_entry),
3956                                       PPC64_ELF_DATA))
3957     {
3958       free (htab);
3959       return NULL;
3960     }
3961
3962   /* Init the stub hash table too.  */
3963   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3964                             sizeof (struct ppc_stub_hash_entry)))
3965     return NULL;
3966
3967   /* And the branch hash table.  */
3968   if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3969                             sizeof (struct ppc_branch_hash_entry)))
3970     return NULL;
3971
3972   /* Initializing two fields of the union is just cosmetic.  We really
3973      only care about glist, but when compiled on a 32-bit host the
3974      bfd_vma fields are larger.  Setting the bfd_vma to zero makes
3975      debugger inspection of these fields look nicer.  */
3976   htab->elf.init_got_refcount.refcount = 0;
3977   htab->elf.init_got_refcount.glist = NULL;
3978   htab->elf.init_plt_refcount.refcount = 0;
3979   htab->elf.init_plt_refcount.glist = NULL;
3980   htab->elf.init_got_offset.offset = 0;
3981   htab->elf.init_got_offset.glist = NULL;
3982   htab->elf.init_plt_offset.offset = 0;
3983   htab->elf.init_plt_offset.glist = NULL;
3984
3985   return &htab->elf.root;
3986 }
3987
3988 /* Free the derived linker hash table.  */
3989
3990 static void
3991 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3992 {
3993   struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3994
3995   bfd_hash_table_free (&ret->stub_hash_table);
3996   bfd_hash_table_free (&ret->branch_hash_table);
3997   _bfd_generic_link_hash_table_free (hash);
3998 }
3999
4000 /* Satisfy the ELF linker by filling in some fields in our fake bfd.  */
4001
4002 void
4003 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4004 {
4005   struct ppc_link_hash_table *htab;
4006
4007   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4008
4009 /* Always hook our dynamic sections into the first bfd, which is the
4010    linker created stub bfd.  This ensures that the GOT header is at
4011    the start of the output TOC section.  */
4012   htab = ppc_hash_table (info);
4013   if (htab == NULL)
4014     return;
4015   htab->stub_bfd = abfd;
4016   htab->elf.dynobj = abfd;
4017 }
4018
4019 /* Build a name for an entry in the stub hash table.  */
4020
4021 static char *
4022 ppc_stub_name (const asection *input_section,
4023                const asection *sym_sec,
4024                const struct ppc_link_hash_entry *h,
4025                const Elf_Internal_Rela *rel)
4026 {
4027   char *stub_name;
4028   bfd_size_type len;
4029
4030   /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4031      offsets from a sym as a branch target?  In fact, we could
4032      probably assume the addend is always zero.  */
4033   BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4034
4035   if (h)
4036     {
4037       len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4038       stub_name = bfd_malloc (len);
4039       if (stub_name == NULL)
4040         return stub_name;
4041
4042       sprintf (stub_name, "%08x.%s+%x",
4043                input_section->id & 0xffffffff,
4044                h->elf.root.root.string,
4045                (int) rel->r_addend & 0xffffffff);
4046     }
4047   else
4048     {
4049       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4050       stub_name = bfd_malloc (len);
4051       if (stub_name == NULL)
4052         return stub_name;
4053
4054       sprintf (stub_name, "%08x.%x:%x+%x",
4055                input_section->id & 0xffffffff,
4056                sym_sec->id & 0xffffffff,
4057                (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4058                (int) rel->r_addend & 0xffffffff);
4059     }
4060   if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4061     stub_name[len - 2] = 0;
4062   return stub_name;
4063 }
4064
4065 /* Look up an entry in the stub hash.  Stub entries are cached because
4066    creating the stub name takes a bit of time.  */
4067
4068 static struct ppc_stub_hash_entry *
4069 ppc_get_stub_entry (const asection *input_section,
4070                     const asection *sym_sec,
4071                     struct ppc_link_hash_entry *h,
4072                     const Elf_Internal_Rela *rel,
4073                     struct ppc_link_hash_table *htab)
4074 {
4075   struct ppc_stub_hash_entry *stub_entry;
4076   const asection *id_sec;
4077
4078   /* If this input section is part of a group of sections sharing one
4079      stub section, then use the id of the first section in the group.
4080      Stub names need to include a section id, as there may well be
4081      more than one stub used to reach say, printf, and we need to
4082      distinguish between them.  */
4083   id_sec = htab->stub_group[input_section->id].link_sec;
4084
4085   if (h != NULL && h->u.stub_cache != NULL
4086       && h->u.stub_cache->h == h
4087       && h->u.stub_cache->id_sec == id_sec)
4088     {
4089       stub_entry = h->u.stub_cache;
4090     }
4091   else
4092     {
4093       char *stub_name;
4094
4095       stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4096       if (stub_name == NULL)
4097         return NULL;
4098
4099       stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4100                                          stub_name, FALSE, FALSE);
4101       if (h != NULL)
4102         h->u.stub_cache = stub_entry;
4103
4104       free (stub_name);
4105     }
4106
4107   return stub_entry;
4108 }
4109
4110 /* Add a new stub entry to the stub hash.  Not all fields of the new
4111    stub entry are initialised.  */
4112
4113 static struct ppc_stub_hash_entry *
4114 ppc_add_stub (const char *stub_name,
4115               asection *section,
4116               struct ppc_link_hash_table *htab)
4117 {
4118   asection *link_sec;
4119   asection *stub_sec;
4120   struct ppc_stub_hash_entry *stub_entry;
4121
4122   link_sec = htab->stub_group[section->id].link_sec;
4123   stub_sec = htab->stub_group[section->id].stub_sec;
4124   if (stub_sec == NULL)
4125     {
4126       stub_sec = htab->stub_group[link_sec->id].stub_sec;
4127       if (stub_sec == NULL)
4128         {
4129           size_t namelen;
4130           bfd_size_type len;
4131           char *s_name;
4132
4133           namelen = strlen (link_sec->name);
4134           len = namelen + sizeof (STUB_SUFFIX);
4135           s_name = bfd_alloc (htab->stub_bfd, len);
4136           if (s_name == NULL)
4137             return NULL;
4138
4139           memcpy (s_name, link_sec->name, namelen);
4140           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4141           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4142           if (stub_sec == NULL)
4143             return NULL;
4144           htab->stub_group[link_sec->id].stub_sec = stub_sec;
4145         }
4146       htab->stub_group[section->id].stub_sec = stub_sec;
4147     }
4148
4149   /* Enter this entry into the linker stub hash table.  */
4150   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4151                                      TRUE, FALSE);
4152   if (stub_entry == NULL)
4153     {
4154       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4155                              section->owner, stub_name);
4156       return NULL;
4157     }
4158
4159   stub_entry->stub_sec = stub_sec;
4160   stub_entry->stub_offset = 0;
4161   stub_entry->id_sec = link_sec;
4162   return stub_entry;
4163 }
4164
4165 /* Create sections for linker generated code.  */
4166
4167 static bfd_boolean
4168 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4169 {
4170   struct ppc_link_hash_table *htab;
4171   flagword flags;
4172
4173   htab = ppc_hash_table (info);
4174   if (htab == NULL)
4175     return FALSE;
4176
4177   /* Create .sfpr for code to save and restore fp regs.  */
4178   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4179            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4180   htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4181                                                    flags);
4182   if (htab->sfpr == NULL
4183       || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4184     return FALSE;
4185
4186   /* Create .glink for lazy dynamic linking support.  */
4187   htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4188                                                     flags);
4189   if (htab->glink == NULL
4190       || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4191     return FALSE;
4192
4193   flags = SEC_ALLOC | SEC_LINKER_CREATED;
4194   htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4195   if (htab->iplt == NULL
4196       || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4197     return FALSE;
4198
4199   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4200            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4201   htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4202                                                       ".rela.iplt",
4203                                                       flags);
4204   if (htab->reliplt == NULL
4205       || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4206     return FALSE;
4207
4208   /* Create branch lookup table for plt_branch stubs.  */
4209   flags = (SEC_ALLOC | SEC_LOAD
4210            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4211   htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4212                                                    flags);
4213   if (htab->brlt == NULL
4214       || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4215     return FALSE;
4216
4217   if (!info->shared)
4218     return TRUE;
4219
4220   flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4221            | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4222   htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4223                                                       ".rela.branch_lt",
4224                                                       flags);
4225   if (htab->relbrlt == NULL
4226       || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4227     return FALSE;
4228
4229   return TRUE;
4230 }
4231
4232 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4233    not already done.  */
4234
4235 static bfd_boolean
4236 create_got_section (bfd *abfd, struct bfd_link_info *info)
4237 {
4238   asection *got, *relgot;
4239   flagword flags;
4240   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4241
4242   if (!is_ppc64_elf (abfd))
4243     return FALSE;
4244   if (htab == NULL)
4245     return FALSE;
4246
4247   if (!htab->got)
4248     {
4249       if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4250         return FALSE;
4251
4252       htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4253       if (!htab->got)
4254         abort ();
4255     }
4256
4257   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4258            | SEC_LINKER_CREATED);
4259
4260   got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4261   if (!got
4262       || !bfd_set_section_alignment (abfd, got, 3))
4263     return FALSE;
4264
4265   relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4266                                                flags | SEC_READONLY);
4267   if (!relgot
4268       || ! bfd_set_section_alignment (abfd, relgot, 3))
4269     return FALSE;
4270
4271   ppc64_elf_tdata (abfd)->got = got;
4272   ppc64_elf_tdata (abfd)->relgot = relgot;
4273   return TRUE;
4274 }
4275
4276 /* Create the dynamic sections, and set up shortcuts.  */
4277
4278 static bfd_boolean
4279 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4280 {
4281   struct ppc_link_hash_table *htab;
4282
4283   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4284     return FALSE;
4285
4286   htab = ppc_hash_table (info);
4287   if (htab == NULL)
4288     return FALSE;
4289
4290   if (!htab->got)
4291     htab->got = bfd_get_section_by_name (dynobj, ".got");
4292   htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4293   htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4294   htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4295   if (!info->shared)
4296     htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4297
4298   if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4299       || (!info->shared && !htab->relbss))
4300     abort ();
4301
4302   return TRUE;
4303 }
4304
4305 /* Follow indirect and warning symbol links.  */
4306
4307 static inline struct bfd_link_hash_entry *
4308 follow_link (struct bfd_link_hash_entry *h)
4309 {
4310   while (h->type == bfd_link_hash_indirect
4311          || h->type == bfd_link_hash_warning)
4312     h = h->u.i.link;
4313   return h;
4314 }
4315
4316 static inline struct elf_link_hash_entry *
4317 elf_follow_link (struct elf_link_hash_entry *h)
4318 {
4319   return (struct elf_link_hash_entry *) follow_link (&h->root);
4320 }
4321
4322 static inline struct ppc_link_hash_entry *
4323 ppc_follow_link (struct ppc_link_hash_entry *h)
4324 {
4325   return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4326 }
4327
4328 /* Merge PLT info on FROM with that on TO.  */
4329
4330 static void
4331 move_plt_plist (struct ppc_link_hash_entry *from,
4332                 struct ppc_link_hash_entry *to)
4333 {
4334   if (from->elf.plt.plist != NULL)
4335     {
4336       if (to->elf.plt.plist != NULL)
4337         {
4338           struct plt_entry **entp;
4339           struct plt_entry *ent;
4340
4341           for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4342             {
4343               struct plt_entry *dent;
4344
4345               for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4346                 if (dent->addend == ent->addend)
4347                   {
4348                     dent->plt.refcount += ent->plt.refcount;
4349                     *entp = ent->next;
4350                     break;
4351                   }
4352               if (dent == NULL)
4353                 entp = &ent->next;
4354             }
4355           *entp = to->elf.plt.plist;
4356         }
4357
4358       to->elf.plt.plist = from->elf.plt.plist;
4359       from->elf.plt.plist = NULL;
4360     }
4361 }
4362
4363 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
4364
4365 static void
4366 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4367                                 struct elf_link_hash_entry *dir,
4368                                 struct elf_link_hash_entry *ind)
4369 {
4370   struct ppc_link_hash_entry *edir, *eind;
4371
4372   edir = (struct ppc_link_hash_entry *) dir;
4373   eind = (struct ppc_link_hash_entry *) ind;
4374
4375   /* Copy over any dynamic relocs we may have on the indirect sym.  */
4376   if (eind->dyn_relocs != NULL)
4377     {
4378       if (edir->dyn_relocs != NULL)
4379         {
4380           struct ppc_dyn_relocs **pp;
4381           struct ppc_dyn_relocs *p;
4382
4383           /* Add reloc counts against the indirect sym to the direct sym
4384              list.  Merge any entries against the same section.  */
4385           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4386             {
4387               struct ppc_dyn_relocs *q;
4388
4389               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4390                 if (q->sec == p->sec)
4391                   {
4392                     q->pc_count += p->pc_count;
4393                     q->count += p->count;
4394                     *pp = p->next;
4395                     break;
4396                   }
4397               if (q == NULL)
4398                 pp = &p->next;
4399             }
4400           *pp = edir->dyn_relocs;
4401         }
4402
4403       edir->dyn_relocs = eind->dyn_relocs;
4404       eind->dyn_relocs = NULL;
4405     }
4406
4407   edir->is_func |= eind->is_func;
4408   edir->is_func_descriptor |= eind->is_func_descriptor;
4409   edir->tls_mask |= eind->tls_mask;
4410   if (eind->oh != NULL)
4411     edir->oh = ppc_follow_link (eind->oh);
4412
4413   /* If called to transfer flags for a weakdef during processing
4414      of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4415      We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
4416   if (!(ELIMINATE_COPY_RELOCS
4417         && eind->elf.root.type != bfd_link_hash_indirect
4418         && edir->elf.dynamic_adjusted))
4419     edir->elf.non_got_ref |= eind->elf.non_got_ref;
4420
4421   edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4422   edir->elf.ref_regular |= eind->elf.ref_regular;
4423   edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4424   edir->elf.needs_plt |= eind->elf.needs_plt;
4425
4426   /* If we were called to copy over info for a weak sym, that's all.  */
4427   if (eind->elf.root.type != bfd_link_hash_indirect)
4428     return;
4429
4430   /* Copy over got entries that we may have already seen to the
4431      symbol which just became indirect.  */
4432   if (eind->elf.got.glist != NULL)
4433     {
4434       if (edir->elf.got.glist != NULL)
4435         {
4436           struct got_entry **entp;
4437           struct got_entry *ent;
4438
4439           for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4440             {
4441               struct got_entry *dent;
4442
4443               for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4444                 if (dent->addend == ent->addend
4445                     && dent->owner == ent->owner
4446                     && dent->tls_type == ent->tls_type)
4447                   {
4448                     dent->got.refcount += ent->got.refcount;
4449                     *entp = ent->next;
4450                     break;
4451                   }
4452               if (dent == NULL)
4453                 entp = &ent->next;
4454             }
4455           *entp = edir->elf.got.glist;
4456         }
4457
4458       edir->elf.got.glist = eind->elf.got.glist;
4459       eind->elf.got.glist = NULL;
4460     }
4461
4462   /* And plt entries.  */
4463   move_plt_plist (eind, edir);
4464
4465   if (eind->elf.dynindx != -1)
4466     {
4467       if (edir->elf.dynindx != -1)
4468         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4469                                 edir->elf.dynstr_index);
4470       edir->elf.dynindx = eind->elf.dynindx;
4471       edir->elf.dynstr_index = eind->elf.dynstr_index;
4472       eind->elf.dynindx = -1;
4473       eind->elf.dynstr_index = 0;
4474     }
4475 }
4476
4477 /* Find the function descriptor hash entry from the given function code
4478    hash entry FH.  Link the entries via their OH fields.  */
4479
4480 static struct ppc_link_hash_entry *
4481 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4482 {
4483   struct ppc_link_hash_entry *fdh = fh->oh;
4484
4485   if (fdh == NULL)
4486     {
4487       const char *fd_name = fh->elf.root.root.string + 1;
4488
4489       fdh = (struct ppc_link_hash_entry *)
4490         elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4491       if (fdh == NULL)
4492         return fdh;
4493
4494       fdh->is_func_descriptor = 1;
4495       fdh->oh = fh;
4496       fh->is_func = 1;
4497       fh->oh = fdh;
4498     }
4499
4500   return ppc_follow_link (fdh);
4501 }
4502
4503 /* Make a fake function descriptor sym for the code sym FH.  */
4504
4505 static struct ppc_link_hash_entry *
4506 make_fdh (struct bfd_link_info *info,
4507           struct ppc_link_hash_entry *fh)
4508 {
4509   bfd *abfd;
4510   asymbol *newsym;
4511   struct bfd_link_hash_entry *bh;
4512   struct ppc_link_hash_entry *fdh;
4513
4514   abfd = fh->elf.root.u.undef.abfd;
4515   newsym = bfd_make_empty_symbol (abfd);
4516   newsym->name = fh->elf.root.root.string + 1;
4517   newsym->section = bfd_und_section_ptr;
4518   newsym->value = 0;
4519   newsym->flags = BSF_WEAK;
4520
4521   bh = NULL;
4522   if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4523                                          newsym->flags, newsym->section,
4524                                          newsym->value, NULL, FALSE, FALSE,
4525                                          &bh))
4526     return NULL;
4527
4528   fdh = (struct ppc_link_hash_entry *) bh;
4529   fdh->elf.non_elf = 0;
4530   fdh->fake = 1;
4531   fdh->is_func_descriptor = 1;
4532   fdh->oh = fh;
4533   fh->is_func = 1;
4534   fh->oh = fdh;
4535   return fdh;
4536 }
4537
4538 /* Fix function descriptor symbols defined in .opd sections to be
4539    function type.  */
4540
4541 static bfd_boolean
4542 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4543                            struct bfd_link_info *info,
4544                            Elf_Internal_Sym *isym,
4545                            const char **name ATTRIBUTE_UNUSED,
4546                            flagword *flags ATTRIBUTE_UNUSED,
4547                            asection **sec,
4548                            bfd_vma *value ATTRIBUTE_UNUSED)
4549 {
4550   if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4551     elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4552   else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4553     ;
4554   else if (*sec != NULL
4555            && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4556     isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4557
4558   return TRUE;
4559 }
4560
4561 /* This function makes an old ABI object reference to ".bar" cause the
4562    inclusion of a new ABI object archive that defines "bar".
4563    NAME is a symbol defined in an archive.  Return a symbol in the hash
4564    table that might be satisfied by the archive symbols.  */
4565
4566 static struct elf_link_hash_entry *
4567 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4568                                  struct bfd_link_info *info,
4569                                  const char *name)
4570 {
4571   struct elf_link_hash_entry *h;
4572   char *dot_name;
4573   size_t len;
4574
4575   h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4576   if (h != NULL
4577       /* Don't return this sym if it is a fake function descriptor
4578          created by add_symbol_adjust.  */
4579       && !(h->root.type == bfd_link_hash_undefweak
4580            && ((struct ppc_link_hash_entry *) h)->fake))
4581     return h;
4582
4583   if (name[0] == '.')
4584     return h;
4585
4586   len = strlen (name);
4587   dot_name = bfd_alloc (abfd, len + 2);
4588   if (dot_name == NULL)
4589     return (struct elf_link_hash_entry *) 0 - 1;
4590   dot_name[0] = '.';
4591   memcpy (dot_name + 1, name, len + 1);
4592   h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4593   bfd_release (abfd, dot_name);
4594   return h;
4595 }
4596
4597 /* This function satisfies all old ABI object references to ".bar" if a
4598    new ABI object defines "bar".  Well, at least, undefined dot symbols
4599    are made weak.  This stops later archive searches from including an
4600    object if we already have a function descriptor definition.  It also
4601    prevents the linker complaining about undefined symbols.
4602    We also check and correct mismatched symbol visibility here.  The
4603    most restrictive visibility of the function descriptor and the
4604    function entry symbol is used.  */
4605
4606 static bfd_boolean
4607 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4608 {
4609   struct ppc_link_hash_table *htab;
4610   struct ppc_link_hash_entry *fdh;
4611
4612   if (eh->elf.root.type == bfd_link_hash_indirect)
4613     return TRUE;
4614
4615   if (eh->elf.root.type == bfd_link_hash_warning)
4616     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4617
4618   if (eh->elf.root.root.string[0] != '.')
4619     abort ();
4620
4621   htab = ppc_hash_table (info);
4622   if (htab == NULL)
4623     return FALSE;
4624
4625   fdh = lookup_fdh (eh, htab);
4626   if (fdh == NULL)
4627     {
4628       if (!info->relocatable
4629           && (eh->elf.root.type == bfd_link_hash_undefined
4630               || eh->elf.root.type == bfd_link_hash_undefweak)
4631           && eh->elf.ref_regular)
4632         {
4633           /* Make an undefweak function descriptor sym, which is enough to
4634              pull in an --as-needed shared lib, but won't cause link
4635              errors.  Archives are handled elsewhere.  */
4636           fdh = make_fdh (info, eh);
4637           if (fdh == NULL)
4638             return FALSE;
4639           fdh->elf.ref_regular = 1;
4640         }
4641     }
4642   else
4643     {
4644       unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4645       unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4646       if (entry_vis < descr_vis)
4647         fdh->elf.other += entry_vis - descr_vis;
4648       else if (entry_vis > descr_vis)
4649         eh->elf.other += descr_vis - entry_vis;
4650
4651       if ((fdh->elf.root.type == bfd_link_hash_defined
4652            || fdh->elf.root.type == bfd_link_hash_defweak)
4653           && eh->elf.root.type == bfd_link_hash_undefined)
4654         {
4655           eh->elf.root.type = bfd_link_hash_undefweak;
4656           eh->was_undefined = 1;
4657           htab->twiddled_syms = 1;
4658         }
4659     }
4660
4661   return TRUE;
4662 }
4663
4664 /* Process list of dot-symbols we made in link_hash_newfunc.  */
4665
4666 static bfd_boolean
4667 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4668 {
4669   struct ppc_link_hash_table *htab;
4670   struct ppc_link_hash_entry **p, *eh;
4671
4672   if (!is_ppc64_elf (info->output_bfd))
4673     return TRUE;
4674   htab = ppc_hash_table (info);
4675   if (htab == NULL)
4676     return FALSE;
4677
4678   if (is_ppc64_elf (ibfd))
4679     {
4680       p = &htab->dot_syms;
4681       while ((eh = *p) != NULL)
4682         {
4683           *p = NULL;
4684           if (!add_symbol_adjust (eh, info))
4685             return FALSE;
4686           p = &eh->u.next_dot_sym;
4687         }
4688     }
4689
4690   /* Clear the list for non-ppc64 input files.  */
4691   p = &htab->dot_syms;
4692   while ((eh = *p) != NULL)
4693     {
4694       *p = NULL;
4695       p = &eh->u.next_dot_sym;
4696     }
4697
4698   /* We need to fix the undefs list for any syms we have twiddled to
4699      undef_weak.  */
4700   if (htab->twiddled_syms)
4701     {
4702       bfd_link_repair_undef_list (&htab->elf.root);
4703       htab->twiddled_syms = 0;
4704     }
4705   return TRUE;
4706 }
4707
4708 /* Undo hash table changes when an --as-needed input file is determined
4709    not to be needed.  */
4710
4711 static bfd_boolean
4712 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4713                              struct bfd_link_info *info)
4714 {
4715   struct ppc_link_hash_table *htab = ppc_hash_table (info);
4716
4717   if (htab == NULL)
4718     return FALSE;
4719
4720   htab->dot_syms = NULL;
4721   return TRUE;
4722 }
4723
4724 static struct plt_entry **
4725 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4726                        unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4727 {
4728   struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4729   struct plt_entry **local_plt;
4730   char *local_got_tls_masks;
4731
4732   if (local_got_ents == NULL)
4733     {
4734       bfd_size_type size = symtab_hdr->sh_info;
4735
4736       size *= (sizeof (*local_got_ents)
4737                + sizeof (*local_plt)
4738                + sizeof (*local_got_tls_masks));
4739       local_got_ents = bfd_zalloc (abfd, size);
4740       if (local_got_ents == NULL)
4741         return NULL;
4742       elf_local_got_ents (abfd) = local_got_ents;
4743     }
4744
4745   if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4746     {
4747       struct got_entry *ent;
4748
4749       for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4750         if (ent->addend == r_addend
4751             && ent->owner == abfd
4752             && ent->tls_type == tls_type)
4753           break;
4754       if (ent == NULL)
4755         {
4756           bfd_size_type amt = sizeof (*ent);
4757           ent = bfd_alloc (abfd, amt);
4758           if (ent == NULL)
4759             return FALSE;
4760           ent->next = local_got_ents[r_symndx];
4761           ent->addend = r_addend;
4762           ent->owner = abfd;
4763           ent->tls_type = tls_type;
4764           ent->is_indirect = FALSE;
4765           ent->got.refcount = 0;
4766           local_got_ents[r_symndx] = ent;
4767         }
4768       ent->got.refcount += 1;
4769     }
4770
4771   local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4772   local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
4773   local_got_tls_masks[r_symndx] |= tls_type;
4774
4775   return local_plt + r_symndx;
4776 }
4777
4778 static bfd_boolean
4779 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4780 {
4781   struct plt_entry *ent;
4782
4783   for (ent = *plist; ent != NULL; ent = ent->next)
4784     if (ent->addend == addend)
4785       break;
4786   if (ent == NULL)
4787     {
4788       bfd_size_type amt = sizeof (*ent);
4789       ent = bfd_alloc (abfd, amt);
4790       if (ent == NULL)
4791         return FALSE;
4792       ent->next = *plist;
4793       ent->addend = addend;
4794       ent->plt.refcount = 0;
4795       *plist = ent;
4796     }
4797   ent->plt.refcount += 1;
4798   return TRUE;
4799 }
4800
4801 static bfd_boolean
4802 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4803 {
4804   return (r_type == R_PPC64_REL24
4805           || r_type == R_PPC64_REL14
4806           || r_type == R_PPC64_REL14_BRTAKEN
4807           || r_type == R_PPC64_REL14_BRNTAKEN
4808           || r_type == R_PPC64_ADDR24
4809           || r_type == R_PPC64_ADDR14
4810           || r_type == R_PPC64_ADDR14_BRTAKEN
4811           || r_type == R_PPC64_ADDR14_BRNTAKEN);
4812 }
4813
4814 /* Look through the relocs for a section during the first phase, and
4815    calculate needed space in the global offset table, procedure
4816    linkage table, and dynamic reloc sections.  */
4817
4818 static bfd_boolean
4819 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4820                         asection *sec, const Elf_Internal_Rela *relocs)
4821 {
4822   struct ppc_link_hash_table *htab;
4823   Elf_Internal_Shdr *symtab_hdr;
4824   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4825   const Elf_Internal_Rela *rel;
4826   const Elf_Internal_Rela *rel_end;
4827   asection *sreloc;
4828   asection **opd_sym_map;
4829   struct elf_link_hash_entry *tga, *dottga;
4830
4831   if (info->relocatable)
4832     return TRUE;
4833
4834   /* Don't do anything special with non-loaded, non-alloced sections.
4835      In particular, any relocs in such sections should not affect GOT
4836      and PLT reference counting (ie. we don't allow them to create GOT
4837      or PLT entries), there's no possibility or desire to optimize TLS
4838      relocs, and there's not much point in propagating relocs to shared
4839      libs that the dynamic linker won't relocate.  */
4840   if ((sec->flags & SEC_ALLOC) == 0)
4841     return TRUE;
4842
4843   BFD_ASSERT (is_ppc64_elf (abfd));
4844
4845   htab = ppc_hash_table (info);
4846   if (htab == NULL)
4847     return FALSE;
4848
4849   tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4850                               FALSE, FALSE, TRUE);
4851   dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4852                                  FALSE, FALSE, TRUE);
4853   symtab_hdr = &elf_symtab_hdr (abfd);
4854
4855   sym_hashes = elf_sym_hashes (abfd);
4856   sym_hashes_end = (sym_hashes
4857                     + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4858                     - symtab_hdr->sh_info);
4859
4860   sreloc = NULL;
4861   opd_sym_map = NULL;
4862   if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4863     {
4864       /* Garbage collection needs some extra help with .opd sections.
4865          We don't want to necessarily keep everything referenced by
4866          relocs in .opd, as that would keep all functions.  Instead,
4867          if we reference an .opd symbol (a function descriptor), we
4868          want to keep the function code symbol's section.  This is
4869          easy for global symbols, but for local syms we need to keep
4870          information about the associated function section.  */
4871       bfd_size_type amt;
4872
4873       amt = sec->size * sizeof (*opd_sym_map) / 8;
4874       opd_sym_map = bfd_zalloc (abfd, amt);
4875       if (opd_sym_map == NULL)
4876         return FALSE;
4877       ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4878       BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4879       ppc64_elf_section_data (sec)->sec_type = sec_opd;
4880     }
4881
4882   if (htab->sfpr == NULL
4883       && !create_linkage_sections (htab->elf.dynobj, info))
4884     return FALSE;
4885
4886   rel_end = relocs + sec->reloc_count;
4887   for (rel = relocs; rel < rel_end; rel++)
4888     {
4889       unsigned long r_symndx;
4890       struct elf_link_hash_entry *h;
4891       enum elf_ppc64_reloc_type r_type;
4892       int tls_type;
4893       struct _ppc64_elf_section_data *ppc64_sec;
4894       struct plt_entry **ifunc;
4895
4896       r_symndx = ELF64_R_SYM (rel->r_info);
4897       if (r_symndx < symtab_hdr->sh_info)
4898         h = NULL;
4899       else
4900         {
4901           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4902           h = elf_follow_link (h);
4903         }
4904
4905       tls_type = 0;
4906       ifunc = NULL;
4907       if (h != NULL)
4908         {
4909           if (h->type == STT_GNU_IFUNC)
4910             {
4911               h->needs_plt = 1;
4912               ifunc = &h->plt.plist;
4913             }
4914         }
4915       else
4916         {
4917           Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4918                                                           abfd, r_symndx);
4919           if (isym == NULL)
4920             return FALSE;
4921
4922           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4923             {
4924               ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4925                                              rel->r_addend, PLT_IFUNC);
4926               if (ifunc == NULL)
4927                 return FALSE;
4928             }
4929         }
4930       r_type = ELF64_R_TYPE (rel->r_info);
4931       if (is_branch_reloc (r_type))
4932         {
4933           if (h != NULL && (h == tga || h == dottga))
4934             {
4935               if (rel != relocs
4936                   && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4937                       || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4938                 /* We have a new-style __tls_get_addr call with a marker
4939                    reloc.  */
4940                 ;
4941               else
4942                 /* Mark this section as having an old-style call.  */
4943                 sec->has_tls_get_addr_call = 1;
4944             }
4945
4946           /* STT_GNU_IFUNC symbols must have a PLT entry.  */
4947           if (ifunc != NULL
4948               && !update_plt_info (abfd, ifunc, rel->r_addend))
4949             return FALSE;
4950         }
4951
4952       switch (r_type)
4953         {
4954         case R_PPC64_TLSGD:
4955         case R_PPC64_TLSLD:
4956           /* These special tls relocs tie a call to __tls_get_addr with
4957              its parameter symbol.  */
4958           break;
4959
4960         case R_PPC64_GOT_TLSLD16:
4961         case R_PPC64_GOT_TLSLD16_LO:
4962         case R_PPC64_GOT_TLSLD16_HI:
4963         case R_PPC64_GOT_TLSLD16_HA:
4964           tls_type = TLS_TLS | TLS_LD;
4965           goto dogottls;
4966
4967         case R_PPC64_GOT_TLSGD16:
4968         case R_PPC64_GOT_TLSGD16_LO:
4969         case R_PPC64_GOT_TLSGD16_HI:
4970         case R_PPC64_GOT_TLSGD16_HA:
4971           tls_type = TLS_TLS | TLS_GD;
4972           goto dogottls;
4973
4974         case R_PPC64_GOT_TPREL16_DS:
4975         case R_PPC64_GOT_TPREL16_LO_DS:
4976         case R_PPC64_GOT_TPREL16_HI:
4977         case R_PPC64_GOT_TPREL16_HA:
4978           if (!info->executable)
4979             info->flags |= DF_STATIC_TLS;
4980           tls_type = TLS_TLS | TLS_TPREL;
4981           goto dogottls;
4982
4983         case R_PPC64_GOT_DTPREL16_DS:
4984         case R_PPC64_GOT_DTPREL16_LO_DS:
4985         case R_PPC64_GOT_DTPREL16_HI:
4986         case R_PPC64_GOT_DTPREL16_HA:
4987           tls_type = TLS_TLS | TLS_DTPREL;
4988         dogottls:
4989           sec->has_tls_reloc = 1;
4990           /* Fall thru */
4991
4992         case R_PPC64_GOT16:
4993         case R_PPC64_GOT16_DS:
4994         case R_PPC64_GOT16_HA:
4995         case R_PPC64_GOT16_HI:
4996         case R_PPC64_GOT16_LO:
4997         case R_PPC64_GOT16_LO_DS:
4998           /* This symbol requires a global offset table entry.  */
4999           sec->has_toc_reloc = 1;
5000           if (ppc64_elf_tdata (abfd)->got == NULL
5001               && !create_got_section (abfd, info))
5002             return FALSE;
5003
5004           if (h != NULL)
5005             {
5006               struct ppc_link_hash_entry *eh;
5007               struct got_entry *ent;
5008
5009               eh = (struct ppc_link_hash_entry *) h;
5010               for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5011                 if (ent->addend == rel->r_addend
5012                     && ent->owner == abfd
5013                     && ent->tls_type == tls_type)
5014                   break;
5015               if (ent == NULL)
5016                 {
5017                   bfd_size_type amt = sizeof (*ent);
5018                   ent = bfd_alloc (abfd, amt);
5019                   if (ent == NULL)
5020                     return FALSE;
5021                   ent->next = eh->elf.got.glist;
5022                   ent->addend = rel->r_addend;
5023                   ent->owner = abfd;
5024                   ent->tls_type = tls_type;
5025                   ent->is_indirect = FALSE;
5026                   ent->got.refcount = 0;
5027                   eh->elf.got.glist = ent;
5028                 }
5029               ent->got.refcount += 1;
5030               eh->tls_mask |= tls_type;
5031             }
5032           else
5033             /* This is a global offset table entry for a local symbol.  */
5034             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5035                                         rel->r_addend, tls_type))
5036               return FALSE;
5037           break;
5038
5039         case R_PPC64_PLT16_HA:
5040         case R_PPC64_PLT16_HI:
5041         case R_PPC64_PLT16_LO:
5042         case R_PPC64_PLT32:
5043         case R_PPC64_PLT64:
5044           /* This symbol requires a procedure linkage table entry.  We
5045              actually build the entry in adjust_dynamic_symbol,
5046              because this might be a case of linking PIC code without
5047              linking in any dynamic objects, in which case we don't
5048              need to generate a procedure linkage table after all.  */
5049           if (h == NULL)
5050             {
5051               /* It does not make sense to have a procedure linkage
5052                  table entry for a local symbol.  */
5053               bfd_set_error (bfd_error_bad_value);
5054               return FALSE;
5055             }
5056           else
5057             {
5058               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5059                 return FALSE;
5060               h->needs_plt = 1;
5061               if (h->root.root.string[0] == '.'
5062                   && h->root.root.string[1] != '\0')
5063                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5064             }
5065           break;
5066
5067           /* The following relocations don't need to propagate the
5068              relocation if linking a shared object since they are
5069              section relative.  */
5070         case R_PPC64_SECTOFF:
5071         case R_PPC64_SECTOFF_LO:
5072         case R_PPC64_SECTOFF_HI:
5073         case R_PPC64_SECTOFF_HA:
5074         case R_PPC64_SECTOFF_DS:
5075         case R_PPC64_SECTOFF_LO_DS:
5076         case R_PPC64_DTPREL16:
5077         case R_PPC64_DTPREL16_LO:
5078         case R_PPC64_DTPREL16_HI:
5079         case R_PPC64_DTPREL16_HA:
5080         case R_PPC64_DTPREL16_DS:
5081         case R_PPC64_DTPREL16_LO_DS:
5082         case R_PPC64_DTPREL16_HIGHER:
5083         case R_PPC64_DTPREL16_HIGHERA:
5084         case R_PPC64_DTPREL16_HIGHEST:
5085         case R_PPC64_DTPREL16_HIGHESTA:
5086           break;
5087
5088           /* Nor do these.  */
5089         case R_PPC64_REL16:
5090         case R_PPC64_REL16_LO:
5091         case R_PPC64_REL16_HI:
5092         case R_PPC64_REL16_HA:
5093           break;
5094
5095         case R_PPC64_TOC16:
5096         case R_PPC64_TOC16_LO:
5097         case R_PPC64_TOC16_HI:
5098         case R_PPC64_TOC16_HA:
5099         case R_PPC64_TOC16_DS:
5100         case R_PPC64_TOC16_LO_DS:
5101           sec->has_toc_reloc = 1;
5102           break;
5103
5104           /* This relocation describes the C++ object vtable hierarchy.
5105              Reconstruct it for later use during GC.  */
5106         case R_PPC64_GNU_VTINHERIT:
5107           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5108             return FALSE;
5109           break;
5110
5111           /* This relocation describes which C++ vtable entries are actually
5112              used.  Record for later use during GC.  */
5113         case R_PPC64_GNU_VTENTRY:
5114           BFD_ASSERT (h != NULL);
5115           if (h != NULL
5116               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5117             return FALSE;
5118           break;
5119
5120         case R_PPC64_REL14:
5121         case R_PPC64_REL14_BRTAKEN:
5122         case R_PPC64_REL14_BRNTAKEN:
5123           {
5124             asection *dest = NULL;
5125
5126             /* Heuristic: If jumping outside our section, chances are
5127                we are going to need a stub.  */
5128             if (h != NULL)
5129               {
5130                 /* If the sym is weak it may be overridden later, so
5131                    don't assume we know where a weak sym lives.  */
5132                 if (h->root.type == bfd_link_hash_defined)
5133                   dest = h->root.u.def.section;
5134               }
5135             else
5136               {
5137                 Elf_Internal_Sym *isym;
5138
5139                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5140                                               abfd, r_symndx);
5141                 if (isym == NULL)
5142                   return FALSE;
5143
5144                 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5145               }
5146
5147             if (dest != sec)
5148               ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5149           }
5150           /* Fall through.  */
5151
5152         case R_PPC64_REL24:
5153           if (h != NULL && ifunc == NULL)
5154             {
5155               /* We may need a .plt entry if the function this reloc
5156                  refers to is in a shared lib.  */
5157               if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5158                 return FALSE;
5159               h->needs_plt = 1;
5160               if (h->root.root.string[0] == '.'
5161                   && h->root.root.string[1] != '\0')
5162                 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5163               if (h == tga || h == dottga)
5164                 sec->has_tls_reloc = 1;
5165             }
5166           break;
5167
5168         case R_PPC64_TPREL64:
5169           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5170           if (!info->executable)
5171             info->flags |= DF_STATIC_TLS;
5172           goto dotlstoc;
5173
5174         case R_PPC64_DTPMOD64:
5175           if (rel + 1 < rel_end
5176               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5177               && rel[1].r_offset == rel->r_offset + 8)
5178             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5179           else
5180             tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5181           goto dotlstoc;
5182
5183         case R_PPC64_DTPREL64:
5184           tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5185           if (rel != relocs
5186               && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5187               && rel[-1].r_offset == rel->r_offset - 8)
5188             /* This is the second reloc of a dtpmod, dtprel pair.
5189                Don't mark with TLS_DTPREL.  */
5190             goto dodyn;
5191
5192         dotlstoc:
5193           sec->has_tls_reloc = 1;
5194           if (h != NULL)
5195             {
5196               struct ppc_link_hash_entry *eh;
5197               eh = (struct ppc_link_hash_entry *) h;
5198               eh->tls_mask |= tls_type;
5199             }
5200           else
5201             if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5202                                         rel->r_addend, tls_type))
5203               return FALSE;
5204
5205           ppc64_sec = ppc64_elf_section_data (sec);
5206           if (ppc64_sec->sec_type != sec_toc)
5207             {
5208               bfd_size_type amt;
5209
5210               /* One extra to simplify get_tls_mask.  */
5211               amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5212               ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5213               if (ppc64_sec->u.toc.symndx == NULL)
5214                 return FALSE;
5215               amt = sec->size * sizeof (bfd_vma) / 8;
5216               ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5217               if (ppc64_sec->u.toc.add == NULL)
5218                 return FALSE;
5219               BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5220               ppc64_sec->sec_type = sec_toc;
5221             }
5222           BFD_ASSERT (rel->r_offset % 8 == 0);
5223           ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5224           ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5225
5226           /* Mark the second slot of a GD or LD entry.
5227              -1 to indicate GD and -2 to indicate LD.  */
5228           if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5229             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5230           else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5231             ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5232           goto dodyn;
5233
5234         case R_PPC64_TPREL16:
5235         case R_PPC64_TPREL16_LO:
5236         case R_PPC64_TPREL16_HI:
5237         case R_PPC64_TPREL16_HA:
5238         case R_PPC64_TPREL16_DS:
5239         case R_PPC64_TPREL16_LO_DS:
5240         case R_PPC64_TPREL16_HIGHER:
5241         case R_PPC64_TPREL16_HIGHERA:
5242         case R_PPC64_TPREL16_HIGHEST:
5243         case R_PPC64_TPREL16_HIGHESTA:
5244           if (info->shared)
5245             {
5246               if (!info->executable)
5247                 info->flags |= DF_STATIC_TLS;
5248               goto dodyn;
5249             }
5250           break;
5251
5252         case R_PPC64_ADDR64:
5253           if (opd_sym_map != NULL
5254               && rel + 1 < rel_end
5255               && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5256             {
5257               if (h != NULL)
5258                 {
5259                   if (h->root.root.string[0] == '.'
5260                       && h->root.root.string[1] != 0
5261                       && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5262                     ;
5263                   else
5264                     ((struct ppc_link_hash_entry *) h)->is_func = 1;
5265                 }
5266               else
5267                 {
5268                   asection *s;
5269                   Elf_Internal_Sym *isym;
5270
5271                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5272                                                 abfd, r_symndx);
5273                   if (isym == NULL)
5274                     return FALSE;
5275
5276                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5277                   if (s != NULL && s != sec)
5278                     opd_sym_map[rel->r_offset / 8] = s;
5279                 }
5280             }
5281           /* Fall through.  */
5282
5283         case R_PPC64_REL30:
5284         case R_PPC64_REL32:
5285         case R_PPC64_REL64:
5286         case R_PPC64_ADDR14:
5287         case R_PPC64_ADDR14_BRNTAKEN:
5288         case R_PPC64_ADDR14_BRTAKEN:
5289         case R_PPC64_ADDR16:
5290         case R_PPC64_ADDR16_DS:
5291         case R_PPC64_ADDR16_HA:
5292         case R_PPC64_ADDR16_HI:
5293         case R_PPC64_ADDR16_HIGHER:
5294         case R_PPC64_ADDR16_HIGHERA:
5295         case R_PPC64_ADDR16_HIGHEST:
5296         case R_PPC64_ADDR16_HIGHESTA:
5297         case R_PPC64_ADDR16_LO:
5298         case R_PPC64_ADDR16_LO_DS:
5299         case R_PPC64_ADDR24:
5300         case R_PPC64_ADDR32:
5301         case R_PPC64_UADDR16:
5302         case R_PPC64_UADDR32:
5303         case R_PPC64_UADDR64:
5304         case R_PPC64_TOC:
5305           if (h != NULL && !info->shared)
5306             /* We may need a copy reloc.  */
5307             h->non_got_ref = 1;
5308
5309           /* Don't propagate .opd relocs.  */
5310           if (NO_OPD_RELOCS && opd_sym_map != NULL)
5311             break;
5312
5313           /* If we are creating a shared library, and this is a reloc
5314              against a global symbol, or a non PC relative reloc
5315              against a local symbol, then we need to copy the reloc
5316              into the shared library.  However, if we are linking with
5317              -Bsymbolic, we do not need to copy a reloc against a
5318              global symbol which is defined in an object we are
5319              including in the link (i.e., DEF_REGULAR is set).  At
5320              this point we have not seen all the input files, so it is
5321              possible that DEF_REGULAR is not set now but will be set
5322              later (it is never cleared).  In case of a weak definition,
5323              DEF_REGULAR may be cleared later by a strong definition in
5324              a shared library.  We account for that possibility below by
5325              storing information in the dyn_relocs field of the hash
5326              table entry.  A similar situation occurs when creating
5327              shared libraries and symbol visibility changes render the
5328              symbol local.
5329
5330              If on the other hand, we are creating an executable, we
5331              may need to keep relocations for symbols satisfied by a
5332              dynamic library if we manage to avoid copy relocs for the
5333              symbol.  */
5334         dodyn:
5335           if ((info->shared
5336                && (must_be_dyn_reloc (info, r_type)
5337                    || (h != NULL
5338                        && (! info->symbolic
5339                            || h->root.type == bfd_link_hash_defweak
5340                            || !h->def_regular))))
5341               || (ELIMINATE_COPY_RELOCS
5342                   && !info->shared
5343                   && h != NULL
5344                   && (h->root.type == bfd_link_hash_defweak
5345                       || !h->def_regular))
5346               || (!info->shared
5347                   && ifunc != NULL))
5348             {
5349               struct ppc_dyn_relocs *p;
5350               struct ppc_dyn_relocs **head;
5351
5352               /* We must copy these reloc types into the output file.
5353                  Create a reloc section in dynobj and make room for
5354                  this reloc.  */
5355               if (sreloc == NULL)
5356                 {
5357                   sreloc = _bfd_elf_make_dynamic_reloc_section
5358                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5359
5360                   if (sreloc == NULL)
5361                     return FALSE;
5362                 }
5363
5364               /* If this is a global symbol, we count the number of
5365                  relocations we need for this symbol.  */
5366               if (h != NULL)
5367                 {
5368                   head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5369                 }
5370               else
5371                 {
5372                   /* Track dynamic relocs needed for local syms too.
5373                      We really need local syms available to do this
5374                      easily.  Oh well.  */
5375                   asection *s;
5376                   void *vpp;
5377                   Elf_Internal_Sym *isym;
5378
5379                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5380                                                 abfd, r_symndx);
5381                   if (isym == NULL)
5382                     return FALSE;
5383
5384                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5385                   if (s == NULL)
5386                     s = sec;
5387
5388                   vpp = &elf_section_data (s)->local_dynrel;
5389                   head = (struct ppc_dyn_relocs **) vpp;
5390                 }
5391
5392               p = *head;
5393               if (p == NULL || p->sec != sec)
5394                 {
5395                   p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5396                   if (p == NULL)
5397                     return FALSE;
5398                   p->next = *head;
5399                   *head = p;
5400                   p->sec = sec;
5401                   p->count = 0;
5402                   p->pc_count = 0;
5403                 }
5404
5405               p->count += 1;
5406               if (!must_be_dyn_reloc (info, r_type))
5407                 p->pc_count += 1;
5408             }
5409           break;
5410
5411         default:
5412           break;
5413         }
5414     }
5415
5416   return TRUE;
5417 }
5418
5419 /* OFFSET in OPD_SEC specifies a function descriptor.  Return the address
5420    of the code entry point, and its section.  */
5421
5422 static bfd_vma
5423 opd_entry_value (asection *opd_sec,
5424                  bfd_vma offset,
5425                  asection **code_sec,
5426                  bfd_vma *code_off)
5427 {
5428   bfd *opd_bfd = opd_sec->owner;
5429   Elf_Internal_Rela *relocs;
5430   Elf_Internal_Rela *lo, *hi, *look;
5431   bfd_vma val;
5432
5433   /* No relocs implies we are linking a --just-symbols object.  */
5434   if (opd_sec->reloc_count == 0)
5435     {
5436       if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5437         return (bfd_vma) -1;
5438
5439       if (code_sec != NULL)
5440         {
5441           asection *sec, *likely = NULL;
5442           for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5443             if (sec->vma <= val
5444                 && (sec->flags & SEC_LOAD) != 0
5445                 && (sec->flags & SEC_ALLOC) != 0)
5446               likely = sec;
5447           if (likely != NULL)
5448             {
5449               *code_sec = likely;
5450               if (code_off != NULL)
5451                 *code_off = val - likely->vma;
5452             }
5453         }
5454       return val;
5455     }
5456
5457   BFD_ASSERT (is_ppc64_elf (opd_bfd));
5458
5459   relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5460   if (relocs == NULL)
5461     relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5462
5463   /* Go find the opd reloc at the sym address.  */
5464   lo = relocs;
5465   BFD_ASSERT (lo != NULL);
5466   hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5467   val = (bfd_vma) -1;
5468   while (lo < hi)
5469     {
5470       look = lo + (hi - lo) / 2;
5471       if (look->r_offset < offset)
5472         lo = look + 1;
5473       else if (look->r_offset > offset)
5474         hi = look;
5475       else
5476         {
5477           Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5478
5479           if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5480               && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5481             {
5482               unsigned long symndx = ELF64_R_SYM (look->r_info);
5483               asection *sec;
5484
5485               if (symndx < symtab_hdr->sh_info)
5486                 {
5487                   Elf_Internal_Sym *sym;
5488
5489                   sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5490                   if (sym == NULL)
5491                     {
5492                       sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5493                                                   symtab_hdr->sh_info,
5494                                                   0, NULL, NULL, NULL);
5495                       if (sym == NULL)
5496                         break;
5497                       symtab_hdr->contents = (bfd_byte *) sym;
5498                     }
5499
5500                   sym += symndx;
5501                   val = sym->st_value;
5502                   sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5503                   BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5504                 }
5505               else
5506                 {
5507                   struct elf_link_hash_entry **sym_hashes;
5508                   struct elf_link_hash_entry *rh;
5509
5510                   sym_hashes = elf_sym_hashes (opd_bfd);
5511                   rh = sym_hashes[symndx - symtab_hdr->sh_info];
5512                   rh = elf_follow_link (rh);
5513                   BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5514                               || rh->root.type == bfd_link_hash_defweak);
5515                   val = rh->root.u.def.value;
5516                   sec = rh->root.u.def.section;
5517                 }
5518               val += look->r_addend;
5519               if (code_off != NULL)
5520                 *code_off = val;
5521               if (code_sec != NULL)
5522                 *code_sec = sec;
5523               if (sec != NULL && sec->output_section != NULL)
5524                 val += sec->output_section->vma + sec->output_offset;
5525             }
5526           break;
5527         }
5528     }
5529
5530   return val;
5531 }
5532
5533 /* If FDH is a function descriptor symbol, return the associated code
5534    entry symbol if it is defined.  Return NULL otherwise.  */
5535
5536 static struct ppc_link_hash_entry *
5537 defined_code_entry (struct ppc_link_hash_entry *fdh)
5538 {
5539   if (fdh->is_func_descriptor)
5540     {
5541       struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5542       if (fh->elf.root.type == bfd_link_hash_defined
5543           || fh->elf.root.type == bfd_link_hash_defweak)
5544         return fh;
5545     }
5546   return NULL;
5547 }
5548
5549 /* If FH is a function code entry symbol, return the associated
5550    function descriptor symbol if it is defined.  Return NULL otherwise.  */
5551
5552 static struct ppc_link_hash_entry *
5553 defined_func_desc (struct ppc_link_hash_entry *fh)
5554 {
5555   if (fh->oh != NULL
5556       && fh->oh->is_func_descriptor)
5557     {
5558       struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5559       if (fdh->elf.root.type == bfd_link_hash_defined
5560           || fdh->elf.root.type == bfd_link_hash_defweak)
5561         return fdh;
5562     }
5563   return NULL;
5564 }
5565
5566 /* Mark all our entry sym sections, both opd and code section.  */
5567
5568 static void
5569 ppc64_elf_gc_keep (struct bfd_link_info *info)
5570 {
5571   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5572   struct bfd_sym_chain *sym;
5573
5574   if (htab == NULL)
5575     return;
5576
5577   for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5578     {
5579       struct ppc_link_hash_entry *eh, *fh;
5580       asection *sec;
5581
5582       eh = (struct ppc_link_hash_entry *)
5583         elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5584       if (eh == NULL)
5585         continue;
5586       if (eh->elf.root.type != bfd_link_hash_defined
5587           && eh->elf.root.type != bfd_link_hash_defweak)
5588         continue;
5589
5590       fh = defined_code_entry (eh);
5591       if (fh != NULL)
5592         {
5593           sec = fh->elf.root.u.def.section;
5594           sec->flags |= SEC_KEEP;
5595         }
5596       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5597                && opd_entry_value (eh->elf.root.u.def.section,
5598                                    eh->elf.root.u.def.value,
5599                                    &sec, NULL) != (bfd_vma) -1)
5600         sec->flags |= SEC_KEEP;
5601
5602       sec = eh->elf.root.u.def.section;
5603       sec->flags |= SEC_KEEP;
5604     }
5605 }
5606
5607 /* Mark sections containing dynamically referenced symbols.  When
5608    building shared libraries, we must assume that any visible symbol is
5609    referenced.  */
5610
5611 static bfd_boolean
5612 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5613 {
5614   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5615   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5616   struct ppc_link_hash_entry *fdh;
5617
5618   if (eh->elf.root.type == bfd_link_hash_warning)
5619     eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5620
5621   /* Dynamic linking info is on the func descriptor sym.  */
5622   fdh = defined_func_desc (eh);
5623   if (fdh != NULL)
5624     eh = fdh;
5625
5626   if ((eh->elf.root.type == bfd_link_hash_defined
5627        || eh->elf.root.type == bfd_link_hash_defweak)
5628       && (eh->elf.ref_dynamic
5629           || (!info->executable
5630               && eh->elf.def_regular
5631               && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5632               && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5633     {
5634       asection *code_sec;
5635       struct ppc_link_hash_entry *fh;
5636
5637       eh->elf.root.u.def.section->flags |= SEC_KEEP;
5638
5639       /* Function descriptor syms cause the associated
5640          function code sym section to be marked.  */
5641       fh = defined_code_entry (eh);
5642       if (fh != NULL)
5643         {
5644           code_sec = fh->elf.root.u.def.section;
5645           code_sec->flags |= SEC_KEEP;
5646         }
5647       else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5648                && opd_entry_value (eh->elf.root.u.def.section,
5649                                    eh->elf.root.u.def.value,
5650                                    &code_sec, NULL) != (bfd_vma) -1)
5651         code_sec->flags |= SEC_KEEP;
5652     }
5653
5654   return TRUE;
5655 }
5656
5657 /* Return the section that should be marked against GC for a given
5658    relocation.  */
5659
5660 static asection *
5661 ppc64_elf_gc_mark_hook (asection *sec,
5662                         struct bfd_link_info *info,
5663                         Elf_Internal_Rela *rel,
5664                         struct elf_link_hash_entry *h,
5665                         Elf_Internal_Sym *sym)
5666 {
5667   asection *rsec;
5668
5669   /* Syms return NULL if we're marking .opd, so we avoid marking all
5670      function sections, as all functions are referenced in .opd.  */
5671   rsec = NULL;
5672   if (get_opd_info (sec) != NULL)
5673     return rsec;
5674
5675   if (h != NULL)
5676     {
5677       enum elf_ppc64_reloc_type r_type;
5678       struct ppc_link_hash_entry *eh, *fh, *fdh;
5679
5680       r_type = ELF64_R_TYPE (rel->r_info);
5681       switch (r_type)
5682         {
5683         case R_PPC64_GNU_VTINHERIT:
5684         case R_PPC64_GNU_VTENTRY:
5685           break;
5686
5687         default:
5688           switch (h->root.type)
5689             {
5690             case bfd_link_hash_defined:
5691             case bfd_link_hash_defweak:
5692               eh = (struct ppc_link_hash_entry *) h;
5693               fdh = defined_func_desc (eh);
5694               if (fdh != NULL)
5695                 eh = fdh;
5696
5697               /* Function descriptor syms cause the associated
5698                  function code sym section to be marked.  */
5699               fh = defined_code_entry (eh);
5700               if (fh != NULL)
5701                 {
5702                   /* They also mark their opd section.  */
5703                   eh->elf.root.u.def.section->gc_mark = 1;
5704
5705                   rsec = fh->elf.root.u.def.section;
5706                 }
5707               else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5708                        && opd_entry_value (eh->elf.root.u.def.section,
5709                                            eh->elf.root.u.def.value,
5710                                            &rsec, NULL) != (bfd_vma) -1)
5711                 eh->elf.root.u.def.section->gc_mark = 1;
5712               else
5713                 rsec = h->root.u.def.section;
5714               break;
5715
5716             case bfd_link_hash_common:
5717               rsec = h->root.u.c.p->section;
5718               break;
5719
5720             default:
5721               return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5722             }
5723         }
5724     }
5725   else
5726     {
5727       struct _opd_sec_data *opd;
5728
5729       rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5730       opd = get_opd_info (rsec);
5731       if (opd != NULL && opd->func_sec != NULL)
5732         {
5733           rsec->gc_mark = 1;
5734
5735           rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5736         }
5737     }
5738
5739   return rsec;
5740 }
5741
5742 /* Update the .got, .plt. and dynamic reloc reference counts for the
5743    section being removed.  */
5744
5745 static bfd_boolean
5746 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5747                          asection *sec, const Elf_Internal_Rela *relocs)
5748 {
5749   struct ppc_link_hash_table *htab;
5750   Elf_Internal_Shdr *symtab_hdr;
5751   struct elf_link_hash_entry **sym_hashes;
5752   struct got_entry **local_got_ents;
5753   const Elf_Internal_Rela *rel, *relend;
5754
5755   if (info->relocatable)
5756     return TRUE;
5757
5758   if ((sec->flags & SEC_ALLOC) == 0)
5759     return TRUE;
5760
5761   elf_section_data (sec)->local_dynrel = NULL;
5762
5763   htab = ppc_hash_table (info);
5764   if (htab == NULL)
5765     return FALSE;
5766
5767   symtab_hdr = &elf_symtab_hdr (abfd);
5768   sym_hashes = elf_sym_hashes (abfd);
5769   local_got_ents = elf_local_got_ents (abfd);
5770
5771   relend = relocs + sec->reloc_count;
5772   for (rel = relocs; rel < relend; rel++)
5773     {
5774       unsigned long r_symndx;
5775       enum elf_ppc64_reloc_type r_type;
5776       struct elf_link_hash_entry *h = NULL;
5777       char tls_type = 0;
5778
5779       r_symndx = ELF64_R_SYM (rel->r_info);
5780       r_type = ELF64_R_TYPE (rel->r_info);
5781       if (r_symndx >= symtab_hdr->sh_info)
5782         {
5783           struct ppc_link_hash_entry *eh;
5784           struct ppc_dyn_relocs **pp;
5785           struct ppc_dyn_relocs *p;
5786
5787           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5788           h = elf_follow_link (h);
5789           eh = (struct ppc_link_hash_entry *) h;
5790
5791           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5792             if (p->sec == sec)
5793               {
5794                 /* Everything must go for SEC.  */
5795                 *pp = p->next;
5796                 break;
5797               }
5798         }
5799
5800       if (is_branch_reloc (r_type))
5801         {
5802           struct plt_entry **ifunc = NULL;
5803           if (h != NULL)
5804             {
5805               if (h->type == STT_GNU_IFUNC)
5806                 ifunc = &h->plt.plist;
5807             }
5808           else if (local_got_ents != NULL)
5809             {
5810               struct plt_entry **local_plt = (struct plt_entry **)
5811                 (local_got_ents + symtab_hdr->sh_info);
5812               char *local_got_tls_masks = (char *)
5813                 (local_plt + symtab_hdr->sh_info);
5814               if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5815                 ifunc = local_plt + r_symndx;
5816             }
5817           if (ifunc != NULL)
5818             {
5819               struct plt_entry *ent;
5820
5821               for (ent = *ifunc; ent != NULL; ent = ent->next)
5822                 if (ent->addend == rel->r_addend)
5823                   break;
5824               if (ent == NULL)
5825                 abort ();
5826               if (ent->plt.refcount > 0)
5827                 ent->plt.refcount -= 1;
5828               continue;
5829             }
5830         }
5831
5832       switch (r_type)
5833         {
5834         case R_PPC64_GOT_TLSLD16:
5835         case R_PPC64_GOT_TLSLD16_LO:
5836         case R_PPC64_GOT_TLSLD16_HI:
5837         case R_PPC64_GOT_TLSLD16_HA:
5838           tls_type = TLS_TLS | TLS_LD;
5839           goto dogot;
5840
5841         case R_PPC64_GOT_TLSGD16:
5842         case R_PPC64_GOT_TLSGD16_LO:
5843         case R_PPC64_GOT_TLSGD16_HI:
5844         case R_PPC64_GOT_TLSGD16_HA:
5845           tls_type = TLS_TLS | TLS_GD;
5846           goto dogot;
5847
5848         case R_PPC64_GOT_TPREL16_DS:
5849         case R_PPC64_GOT_TPREL16_LO_DS:
5850         case R_PPC64_GOT_TPREL16_HI:
5851         case R_PPC64_GOT_TPREL16_HA:
5852           tls_type = TLS_TLS | TLS_TPREL;
5853           goto dogot;
5854
5855         case R_PPC64_GOT_DTPREL16_DS:
5856         case R_PPC64_GOT_DTPREL16_LO_DS:
5857         case R_PPC64_GOT_DTPREL16_HI:
5858         case R_PPC64_GOT_DTPREL16_HA:
5859           tls_type = TLS_TLS | TLS_DTPREL;
5860           goto dogot;
5861
5862         case R_PPC64_GOT16:
5863         case R_PPC64_GOT16_DS:
5864         case R_PPC64_GOT16_HA:
5865         case R_PPC64_GOT16_HI:
5866         case R_PPC64_GOT16_LO:
5867         case R_PPC64_GOT16_LO_DS:
5868         dogot:
5869           {
5870             struct got_entry *ent;
5871
5872             if (h != NULL)
5873               ent = h->got.glist;
5874             else
5875               ent = local_got_ents[r_symndx];
5876
5877             for (; ent != NULL; ent = ent->next)
5878               if (ent->addend == rel->r_addend
5879                   && ent->owner == abfd
5880                   && ent->tls_type == tls_type)
5881                 break;
5882             if (ent == NULL)
5883               abort ();
5884             if (ent->got.refcount > 0)
5885               ent->got.refcount -= 1;
5886           }
5887           break;
5888
5889         case R_PPC64_PLT16_HA:
5890         case R_PPC64_PLT16_HI:
5891         case R_PPC64_PLT16_LO:
5892         case R_PPC64_PLT32:
5893         case R_PPC64_PLT64:
5894         case R_PPC64_REL14:
5895         case R_PPC64_REL14_BRNTAKEN:
5896         case R_PPC64_REL14_BRTAKEN:
5897         case R_PPC64_REL24:
5898           if (h != NULL)
5899             {
5900               struct plt_entry *ent;
5901
5902               for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5903                 if (ent->addend == rel->r_addend)
5904                   break;
5905               if (ent != NULL && ent->plt.refcount > 0)
5906                 ent->plt.refcount -= 1;
5907             }
5908           break;
5909
5910         default:
5911           break;
5912         }
5913     }
5914   return TRUE;
5915 }
5916
5917 /* The maximum size of .sfpr.  */
5918 #define SFPR_MAX (218*4)
5919
5920 struct sfpr_def_parms
5921 {
5922   const char name[12];
5923   unsigned char lo, hi;
5924   bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5925   bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5926 };
5927
5928 /* Auto-generate _save*, _rest* functions in .sfpr.  */
5929
5930 static bfd_boolean
5931 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5932 {
5933   struct ppc_link_hash_table *htab = ppc_hash_table (info);
5934   unsigned int i;
5935   size_t len = strlen (parm->name);
5936   bfd_boolean writing = FALSE;
5937   char sym[16];
5938
5939   if (htab == NULL)
5940     return FALSE;
5941
5942   memcpy (sym, parm->name, len);
5943   sym[len + 2] = 0;
5944
5945   for (i = parm->lo; i <= parm->hi; i++)
5946     {
5947       struct elf_link_hash_entry *h;
5948
5949       sym[len + 0] = i / 10 + '0';
5950       sym[len + 1] = i % 10 + '0';
5951       h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5952       if (h != NULL
5953           && !h->def_regular)
5954         {
5955           h->root.type = bfd_link_hash_defined;
5956           h->root.u.def.section = htab->sfpr;
5957           h->root.u.def.value = htab->sfpr->size;
5958           h->type = STT_FUNC;
5959           h->def_regular = 1;
5960           _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5961           writing = TRUE;
5962           if (htab->sfpr->contents == NULL)
5963             {
5964               htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5965               if (htab->sfpr->contents == NULL)
5966                 return FALSE;
5967             }
5968         }
5969       if (writing)
5970         {
5971           bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5972           if (i != parm->hi)
5973             p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5974           else
5975             p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5976           htab->sfpr->size = p - htab->sfpr->contents;
5977         }
5978     }
5979
5980   return TRUE;
5981 }
5982
5983 static bfd_byte *
5984 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5985 {
5986   bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5987   return p + 4;
5988 }
5989
5990 static bfd_byte *
5991 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5992 {
5993   p = savegpr0 (abfd, p, r);
5994   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5995   p = p + 4;
5996   bfd_put_32 (abfd, BLR, p);
5997   return p + 4;
5998 }
5999
6000 static bfd_byte *
6001 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6002 {
6003   bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6004   return p + 4;
6005 }
6006
6007 static bfd_byte *
6008 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6009 {
6010   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6011   p = p + 4;
6012   p = restgpr0 (abfd, p, r);
6013   bfd_put_32 (abfd, MTLR_R0, p);
6014   p = p + 4;
6015   if (r == 29)
6016     {
6017       p = restgpr0 (abfd, p, 30);
6018       p = restgpr0 (abfd, p, 31);
6019     }
6020   bfd_put_32 (abfd, BLR, p);
6021   return p + 4;
6022 }
6023
6024 static bfd_byte *
6025 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6026 {
6027   bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6028   return p + 4;
6029 }
6030
6031 static bfd_byte *
6032 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6033 {
6034   p = savegpr1 (abfd, p, r);
6035   bfd_put_32 (abfd, BLR, p);
6036   return p + 4;
6037 }
6038
6039 static bfd_byte *
6040 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6041 {
6042   bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6043   return p + 4;
6044 }
6045
6046 static bfd_byte *
6047 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6048 {
6049   p = restgpr1 (abfd, p, r);
6050   bfd_put_32 (abfd, BLR, p);
6051   return p + 4;
6052 }
6053
6054 static bfd_byte *
6055 savefpr (bfd *abfd, bfd_byte *p, int r)
6056 {
6057   bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6058   return p + 4;
6059 }
6060
6061 static bfd_byte *
6062 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6063 {
6064   p = savefpr (abfd, p, r);
6065   bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6066   p = p + 4;
6067   bfd_put_32 (abfd, BLR, p);
6068   return p + 4;
6069 }
6070
6071 static bfd_byte *
6072 restfpr (bfd *abfd, bfd_byte *p, int r)
6073 {
6074   bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6075   return p + 4;
6076 }
6077
6078 static bfd_byte *
6079 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6080 {
6081   bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6082   p = p + 4;
6083   p = restfpr (abfd, p, r);
6084   bfd_put_32 (abfd, MTLR_R0, p);
6085   p = p + 4;
6086   if (r == 29)
6087     {
6088       p = restfpr (abfd, p, 30);
6089       p = restfpr (abfd, p, 31);
6090     }
6091   bfd_put_32 (abfd, BLR, p);
6092   return p + 4;
6093 }
6094
6095 static bfd_byte *
6096 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6097 {
6098   p = savefpr (abfd, p, r);
6099   bfd_put_32 (abfd, BLR, p);
6100   return p + 4;
6101 }
6102
6103 static bfd_byte *
6104 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6105 {
6106   p = restfpr (abfd, p, r);
6107   bfd_put_32 (abfd, BLR, p);
6108   return p + 4;
6109 }
6110
6111 static bfd_byte *
6112 savevr (bfd *abfd, bfd_byte *p, int r)
6113 {
6114   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6115   p = p + 4;
6116   bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6117   return p + 4;
6118 }
6119
6120 static bfd_byte *
6121 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6122 {
6123   p = savevr (abfd, p, r);
6124   bfd_put_32 (abfd, BLR, p);
6125   return p + 4;
6126 }
6127
6128 static bfd_byte *
6129 restvr (bfd *abfd, bfd_byte *p, int r)
6130 {
6131   bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6132   p = p + 4;
6133   bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6134   return p + 4;
6135 }
6136
6137 static bfd_byte *
6138 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6139 {
6140   p = restvr (abfd, p, r);
6141   bfd_put_32 (abfd, BLR, p);
6142   return p + 4;
6143 }
6144
6145 /* Called via elf_link_hash_traverse to transfer dynamic linking
6146    information on function code symbol entries to their corresponding
6147    function descriptor symbol entries.  */
6148
6149 static bfd_boolean
6150 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6151 {
6152   struct bfd_link_info *info;
6153   struct ppc_link_hash_table *htab;
6154   struct plt_entry *ent;
6155   struct ppc_link_hash_entry *fh;
6156   struct ppc_link_hash_entry *fdh;
6157   bfd_boolean force_local;
6158
6159   fh = (struct ppc_link_hash_entry *) h;
6160   if (fh->elf.root.type == bfd_link_hash_indirect)
6161     return TRUE;
6162
6163   if (fh->elf.root.type == bfd_link_hash_warning)
6164     fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6165
6166   info = inf;
6167   htab = ppc_hash_table (info);
6168   if (htab == NULL)
6169     return FALSE;
6170
6171   /* Resolve undefined references to dot-symbols as the value
6172      in the function descriptor, if we have one in a regular object.
6173      This is to satisfy cases like ".quad .foo".  Calls to functions
6174      in dynamic objects are handled elsewhere.  */
6175   if (fh->elf.root.type == bfd_link_hash_undefweak
6176       && fh->was_undefined
6177       && (fdh = defined_func_desc (fh)) != NULL
6178       && get_opd_info (fdh->elf.root.u.def.section) != NULL
6179       && opd_entry_value (fdh->elf.root.u.def.section,
6180                           fdh->elf.root.u.def.value,
6181                           &fh->elf.root.u.def.section,
6182                           &fh->elf.root.u.def.value) != (bfd_vma) -1)
6183     {
6184       fh->elf.root.type = fdh->elf.root.type;
6185       fh->elf.forced_local = 1;
6186       fh->elf.def_regular = fdh->elf.def_regular;
6187       fh->elf.def_dynamic = fdh->elf.def_dynamic;
6188     }
6189
6190   /* If this is a function code symbol, transfer dynamic linking
6191      information to the function descriptor symbol.  */
6192   if (!fh->is_func)
6193     return TRUE;
6194
6195   for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6196     if (ent->plt.refcount > 0)
6197       break;
6198   if (ent == NULL
6199       || fh->elf.root.root.string[0] != '.'
6200       || fh->elf.root.root.string[1] == '\0')
6201     return TRUE;
6202
6203   /* Find the corresponding function descriptor symbol.  Create it
6204      as undefined if necessary.  */
6205
6206   fdh = lookup_fdh (fh, htab);
6207   if (fdh == NULL
6208       && !info->executable
6209       && (fh->elf.root.type == bfd_link_hash_undefined
6210           || fh->elf.root.type == bfd_link_hash_undefweak))
6211     {
6212       fdh = make_fdh (info, fh);
6213       if (fdh == NULL)
6214         return FALSE;
6215     }
6216
6217   /* Fake function descriptors are made undefweak.  If the function
6218      code symbol is strong undefined, make the fake sym the same.
6219      If the function code symbol is defined, then force the fake
6220      descriptor local;  We can't support overriding of symbols in a
6221      shared library on a fake descriptor.  */
6222
6223   if (fdh != NULL
6224       && fdh->fake
6225       && fdh->elf.root.type == bfd_link_hash_undefweak)
6226     {
6227       if (fh->elf.root.type == bfd_link_hash_undefined)
6228         {
6229           fdh->elf.root.type = bfd_link_hash_undefined;
6230           bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6231         }
6232       else if (fh->elf.root.type == bfd_link_hash_defined
6233                || fh->elf.root.type == bfd_link_hash_defweak)
6234         {
6235           _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6236         }
6237     }
6238
6239   if (fdh != NULL
6240       && !fdh->elf.forced_local
6241       && (!info->executable
6242           || fdh->elf.def_dynamic
6243           || fdh->elf.ref_dynamic
6244           || (fdh->elf.root.type == bfd_link_hash_undefweak
6245               && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6246     {
6247       if (fdh->elf.dynindx == -1)
6248         if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6249           return FALSE;
6250       fdh->elf.ref_regular |= fh->elf.ref_regular;
6251       fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6252       fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6253       fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6254       if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6255         {
6256           move_plt_plist (fh, fdh);
6257           fdh->elf.needs_plt = 1;
6258         }
6259       fdh->is_func_descriptor = 1;
6260       fdh->oh = fh;
6261       fh->oh = fdh;
6262     }
6263
6264   /* Now that the info is on the function descriptor, clear the
6265      function code sym info.  Any function code syms for which we
6266      don't have a definition in a regular file, we force local.
6267      This prevents a shared library from exporting syms that have
6268      been imported from another library.  Function code syms that
6269      are really in the library we must leave global to prevent the
6270      linker dragging in a definition from a static library.  */
6271   force_local = (!fh->elf.def_regular
6272                  || fdh == NULL
6273                  || !fdh->elf.def_regular
6274                  || fdh->elf.forced_local);
6275   _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6276
6277   return TRUE;
6278 }
6279
6280 /* Called near the start of bfd_elf_size_dynamic_sections.  We use
6281    this hook to a) provide some gcc support functions, and b) transfer
6282    dynamic linking information gathered so far on function code symbol
6283    entries, to their corresponding function descriptor symbol entries.  */
6284
6285 static bfd_boolean
6286 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6287                             struct bfd_link_info *info)
6288 {
6289   struct ppc_link_hash_table *htab;
6290   unsigned int i;
6291   const struct sfpr_def_parms funcs[] =
6292     {
6293       { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6294       { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6295       { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6296       { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6297       { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6298       { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6299       { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6300       { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6301       { "._savef", 14, 31, savefpr, savefpr1_tail },
6302       { "._restf", 14, 31, restfpr, restfpr1_tail },
6303       { "_savevr_", 20, 31, savevr, savevr_tail },
6304       { "_restvr_", 20, 31, restvr, restvr_tail }
6305     };
6306
6307   htab = ppc_hash_table (info);
6308   if (htab == NULL)
6309     return FALSE;
6310
6311   if (htab->sfpr == NULL)
6312     /* We don't have any relocs.  */
6313     return TRUE;
6314
6315   /* Provide any missing _save* and _rest* functions.  */
6316   htab->sfpr->size = 0;
6317   for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6318     if (!sfpr_define (info, &funcs[i]))
6319       return FALSE;
6320
6321   elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6322
6323   if (htab->sfpr->size == 0)
6324     htab->sfpr->flags |= SEC_EXCLUDE;
6325
6326   return TRUE;
6327 }
6328
6329 /* Adjust a symbol defined by a dynamic object and referenced by a
6330    regular object.  The current definition is in some section of the
6331    dynamic object, but we're not including those sections.  We have to
6332    change the definition to something the rest of the link can
6333    understand.  */
6334
6335 static bfd_boolean
6336 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6337                                  struct elf_link_hash_entry *h)
6338 {
6339   struct ppc_link_hash_table *htab;
6340   asection *s;
6341
6342   htab = ppc_hash_table (info);
6343   if (htab == NULL)
6344     return FALSE;
6345
6346   /* Deal with function syms.  */
6347   if (h->type == STT_FUNC
6348       || h->type == STT_GNU_IFUNC
6349       || h->needs_plt)
6350     {
6351       /* Clear procedure linkage table information for any symbol that
6352          won't need a .plt entry.  */
6353       struct plt_entry *ent;
6354       for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6355         if (ent->plt.refcount > 0)
6356           break;
6357       if (ent == NULL
6358           || (h->type != STT_GNU_IFUNC
6359               && (SYMBOL_CALLS_LOCAL (info, h)
6360                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6361                       && h->root.type == bfd_link_hash_undefweak))))
6362         {
6363           h->plt.plist = NULL;
6364           h->needs_plt = 0;
6365         }
6366     }
6367   else
6368     h->plt.plist = NULL;
6369
6370   /* If this is a weak symbol, and there is a real definition, the
6371      processor independent code will have arranged for us to see the
6372      real definition first, and we can just use the same value.  */
6373   if (h->u.weakdef != NULL)
6374     {
6375       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6376                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6377       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6378       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6379       if (ELIMINATE_COPY_RELOCS)
6380         h->non_got_ref = h->u.weakdef->non_got_ref;
6381       return TRUE;
6382     }
6383
6384   /* If we are creating a shared library, we must presume that the
6385      only references to the symbol are via the global offset table.
6386      For such cases we need not do anything here; the relocations will
6387      be handled correctly by relocate_section.  */
6388   if (info->shared)
6389     return TRUE;
6390
6391   /* If there are no references to this symbol that do not use the
6392      GOT, we don't need to generate a copy reloc.  */
6393   if (!h->non_got_ref)
6394     return TRUE;
6395
6396   /* Don't generate a copy reloc for symbols defined in the executable.  */
6397   if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6398     return TRUE;
6399
6400   if (ELIMINATE_COPY_RELOCS)
6401     {
6402       struct ppc_link_hash_entry * eh;
6403       struct ppc_dyn_relocs *p;
6404
6405       eh = (struct ppc_link_hash_entry *) h;
6406       for (p = eh->dyn_relocs; p != NULL; p = p->next)
6407         {
6408           s = p->sec->output_section;
6409           if (s != NULL && (s->flags & SEC_READONLY) != 0)
6410             break;
6411         }
6412
6413       /* If we didn't find any dynamic relocs in read-only sections, then
6414          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
6415       if (p == NULL)
6416         {
6417           h->non_got_ref = 0;
6418           return TRUE;
6419         }
6420     }
6421
6422   if (h->plt.plist != NULL)
6423     {
6424       /* We should never get here, but unfortunately there are versions
6425          of gcc out there that improperly (for this ABI) put initialized
6426          function pointers, vtable refs and suchlike in read-only
6427          sections.  Allow them to proceed, but warn that this might
6428          break at runtime.  */
6429       (*_bfd_error_handler)
6430         (_("copy reloc against `%s' requires lazy plt linking; "
6431            "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6432          h->root.root.string);
6433     }
6434
6435   /* This is a reference to a symbol defined by a dynamic object which
6436      is not a function.  */
6437
6438   if (h->size == 0)
6439     {
6440       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6441                              h->root.root.string);
6442       return TRUE;
6443     }
6444
6445   /* We must allocate the symbol in our .dynbss section, which will
6446      become part of the .bss section of the executable.  There will be
6447      an entry for this symbol in the .dynsym section.  The dynamic
6448      object will contain position independent code, so all references
6449      from the dynamic object to this symbol will go through the global
6450      offset table.  The dynamic linker will use the .dynsym entry to
6451      determine the address it must put in the global offset table, so
6452      both the dynamic object and the regular object will refer to the
6453      same memory location for the variable.  */
6454
6455   /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6456      to copy the initial value out of the dynamic object and into the
6457      runtime process image.  We need to remember the offset into the
6458      .rela.bss section we are going to use.  */
6459   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6460     {
6461       htab->relbss->size += sizeof (Elf64_External_Rela);
6462       h->needs_copy = 1;
6463     }
6464
6465   s = htab->dynbss;
6466
6467   return _bfd_elf_adjust_dynamic_copy (h, s);
6468 }
6469
6470 /* If given a function descriptor symbol, hide both the function code
6471    sym and the descriptor.  */
6472 static void
6473 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6474                        struct elf_link_hash_entry *h,
6475                        bfd_boolean force_local)
6476 {
6477   struct ppc_link_hash_entry *eh;
6478   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6479
6480   eh = (struct ppc_link_hash_entry *) h;
6481   if (eh->is_func_descriptor)
6482     {
6483       struct ppc_link_hash_entry *fh = eh->oh;
6484
6485       if (fh == NULL)
6486         {
6487           const char *p, *q;
6488           struct ppc_link_hash_table *htab;
6489           char save;
6490
6491           /* We aren't supposed to use alloca in BFD because on
6492              systems which do not have alloca the version in libiberty
6493              calls xmalloc, which might cause the program to crash
6494              when it runs out of memory.  This function doesn't have a
6495              return status, so there's no way to gracefully return an
6496              error.  So cheat.  We know that string[-1] can be safely
6497              accessed;  It's either a string in an ELF string table,
6498              or allocated in an objalloc structure.  */
6499
6500           p = eh->elf.root.root.string - 1;
6501           save = *p;
6502           *(char *) p = '.';
6503           htab = ppc_hash_table (info);
6504           if (htab == NULL)
6505             return;
6506
6507           fh = (struct ppc_link_hash_entry *)
6508             elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6509           *(char *) p = save;
6510
6511           /* Unfortunately, if it so happens that the string we were
6512              looking for was allocated immediately before this string,
6513              then we overwrote the string terminator.  That's the only
6514              reason the lookup should fail.  */
6515           if (fh == NULL)
6516             {
6517               q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6518               while (q >= eh->elf.root.root.string && *q == *p)
6519                 --q, --p;
6520               if (q < eh->elf.root.root.string && *p == '.')
6521                 fh = (struct ppc_link_hash_entry *)
6522                   elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6523             }
6524           if (fh != NULL)
6525             {
6526               eh->oh = fh;
6527               fh->oh = eh;
6528             }
6529         }
6530       if (fh != NULL)
6531         _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6532     }
6533 }
6534
6535 static bfd_boolean
6536 get_sym_h (struct elf_link_hash_entry **hp,
6537            Elf_Internal_Sym **symp,
6538            asection **symsecp,
6539            char **tls_maskp,
6540            Elf_Internal_Sym **locsymsp,
6541            unsigned long r_symndx,
6542            bfd *ibfd)
6543 {
6544   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6545
6546   if (r_symndx >= symtab_hdr->sh_info)
6547     {
6548       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6549       struct elf_link_hash_entry *h;
6550
6551       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6552       h = elf_follow_link (h);
6553
6554       if (hp != NULL)
6555         *hp = h;
6556
6557       if (symp != NULL)
6558         *symp = NULL;
6559
6560       if (symsecp != NULL)
6561         {
6562           asection *symsec = NULL;
6563           if (h->root.type == bfd_link_hash_defined
6564               || h->root.type == bfd_link_hash_defweak)
6565             symsec = h->root.u.def.section;
6566           *symsecp = symsec;
6567         }
6568
6569       if (tls_maskp != NULL)
6570         {
6571           struct ppc_link_hash_entry *eh;
6572
6573           eh = (struct ppc_link_hash_entry *) h;
6574           *tls_maskp = &eh->tls_mask;
6575         }
6576     }
6577   else
6578     {
6579       Elf_Internal_Sym *sym;
6580       Elf_Internal_Sym *locsyms = *locsymsp;
6581
6582       if (locsyms == NULL)
6583         {
6584           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6585           if (locsyms == NULL)
6586             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6587                                             symtab_hdr->sh_info,
6588                                             0, NULL, NULL, NULL);
6589           if (locsyms == NULL)
6590             return FALSE;
6591           *locsymsp = locsyms;
6592         }
6593       sym = locsyms + r_symndx;
6594
6595       if (hp != NULL)
6596         *hp = NULL;
6597
6598       if (symp != NULL)
6599         *symp = sym;
6600
6601       if (symsecp != NULL)
6602         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6603
6604       if (tls_maskp != NULL)
6605         {
6606           struct got_entry **lgot_ents;
6607           char *tls_mask;
6608
6609           tls_mask = NULL;
6610           lgot_ents = elf_local_got_ents (ibfd);
6611           if (lgot_ents != NULL)
6612             {
6613               struct plt_entry **local_plt = (struct plt_entry **)
6614                 (lgot_ents + symtab_hdr->sh_info);
6615               char *lgot_masks = (char *)
6616                 (local_plt + symtab_hdr->sh_info);
6617               tls_mask = &lgot_masks[r_symndx];
6618             }
6619           *tls_maskp = tls_mask;
6620         }
6621     }
6622   return TRUE;
6623 }
6624
6625 /* Returns TLS_MASKP for the given REL symbol.  Function return is 0 on
6626    error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6627    type suitable for optimization, and 1 otherwise.  */
6628
6629 static int
6630 get_tls_mask (char **tls_maskp,
6631               unsigned long *toc_symndx,
6632               bfd_vma *toc_addend,
6633               Elf_Internal_Sym **locsymsp,
6634               const Elf_Internal_Rela *rel,
6635               bfd *ibfd)
6636 {
6637   unsigned long r_symndx;
6638   int next_r;
6639   struct elf_link_hash_entry *h;
6640   Elf_Internal_Sym *sym;
6641   asection *sec;
6642   bfd_vma off;
6643
6644   r_symndx = ELF64_R_SYM (rel->r_info);
6645   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6646     return 0;
6647
6648   if ((*tls_maskp != NULL && **tls_maskp != 0)
6649       || sec == NULL
6650       || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6651     return 1;
6652
6653   /* Look inside a TOC section too.  */
6654   if (h != NULL)
6655     {
6656       BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6657       off = h->root.u.def.value;
6658     }
6659   else
6660     off = sym->st_value;
6661   off += rel->r_addend;
6662   BFD_ASSERT (off % 8 == 0);
6663   r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6664   next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6665   if (toc_symndx != NULL)
6666     *toc_symndx = r_symndx;
6667   if (toc_addend != NULL)
6668     *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6669   if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6670     return 0;
6671   if ((h == NULL
6672        || ((h->root.type == bfd_link_hash_defined
6673             || h->root.type == bfd_link_hash_defweak)
6674            && !h->def_dynamic))
6675       && (next_r == -1 || next_r == -2))
6676     return 1 - next_r;
6677   return 1;
6678 }
6679
6680 /* Adjust all global syms defined in opd sections.  In gcc generated
6681    code for the old ABI, these will already have been done.  */
6682
6683 static bfd_boolean
6684 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6685 {
6686   struct ppc_link_hash_entry *eh;
6687   asection *sym_sec;
6688   struct _opd_sec_data *opd;
6689
6690   if (h->root.type == bfd_link_hash_indirect)
6691     return TRUE;
6692
6693   if (h->root.type == bfd_link_hash_warning)
6694     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6695
6696   if (h->root.type != bfd_link_hash_defined
6697       && h->root.type != bfd_link_hash_defweak)
6698     return TRUE;
6699
6700   eh = (struct ppc_link_hash_entry *) h;
6701   if (eh->adjust_done)
6702     return TRUE;
6703
6704   sym_sec = eh->elf.root.u.def.section;
6705   opd = get_opd_info (sym_sec);
6706   if (opd != NULL && opd->adjust != NULL)
6707     {
6708       long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6709       if (adjust == -1)
6710         {
6711           /* This entry has been deleted.  */
6712           asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6713           if (dsec == NULL)
6714             {
6715               for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6716                 if (elf_discarded_section (dsec))
6717                   {
6718                     ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6719                     break;
6720                   }
6721             }
6722           eh->elf.root.u.def.value = 0;
6723           eh->elf.root.u.def.section = dsec;
6724         }
6725       else
6726         eh->elf.root.u.def.value += adjust;
6727       eh->adjust_done = 1;
6728     }
6729   return TRUE;
6730 }
6731
6732 /* Handles decrementing dynamic reloc counts for the reloc specified by
6733    R_INFO in section SEC.  If LOCAL_SYMS is NULL, then H and SYM_SEC
6734    have already been determined.  */
6735
6736 static bfd_boolean
6737 dec_dynrel_count (bfd_vma r_info,
6738                   asection *sec,
6739                   struct bfd_link_info *info,
6740                   Elf_Internal_Sym **local_syms,
6741                   struct elf_link_hash_entry *h,
6742                   asection *sym_sec)
6743 {
6744   enum elf_ppc64_reloc_type r_type;
6745   struct ppc_dyn_relocs *p;
6746   struct ppc_dyn_relocs **pp;
6747
6748   /* Can this reloc be dynamic?  This switch, and later tests here
6749      should be kept in sync with the code in check_relocs.  */
6750   r_type = ELF64_R_TYPE (r_info);
6751   switch (r_type)
6752     {
6753     default:
6754       return TRUE;
6755
6756     case R_PPC64_TPREL16:
6757     case R_PPC64_TPREL16_LO:
6758     case R_PPC64_TPREL16_HI:
6759     case R_PPC64_TPREL16_HA:
6760     case R_PPC64_TPREL16_DS:
6761     case R_PPC64_TPREL16_LO_DS:
6762     case R_PPC64_TPREL16_HIGHER:
6763     case R_PPC64_TPREL16_HIGHERA:
6764     case R_PPC64_TPREL16_HIGHEST:
6765     case R_PPC64_TPREL16_HIGHESTA:
6766       if (!info->shared)
6767         return TRUE;
6768
6769     case R_PPC64_TPREL64:
6770     case R_PPC64_DTPMOD64:
6771     case R_PPC64_DTPREL64:
6772     case R_PPC64_ADDR64:
6773     case R_PPC64_REL30:
6774     case R_PPC64_REL32:
6775     case R_PPC64_REL64:
6776     case R_PPC64_ADDR14:
6777     case R_PPC64_ADDR14_BRNTAKEN:
6778     case R_PPC64_ADDR14_BRTAKEN:
6779     case R_PPC64_ADDR16:
6780     case R_PPC64_ADDR16_DS:
6781     case R_PPC64_ADDR16_HA:
6782     case R_PPC64_ADDR16_HI:
6783     case R_PPC64_ADDR16_HIGHER:
6784     case R_PPC64_ADDR16_HIGHERA:
6785     case R_PPC64_ADDR16_HIGHEST:
6786     case R_PPC64_ADDR16_HIGHESTA:
6787     case R_PPC64_ADDR16_LO:
6788     case R_PPC64_ADDR16_LO_DS:
6789     case R_PPC64_ADDR24:
6790     case R_PPC64_ADDR32:
6791     case R_PPC64_UADDR16:
6792     case R_PPC64_UADDR32:
6793     case R_PPC64_UADDR64:
6794     case R_PPC64_TOC:
6795       break;
6796     }
6797
6798   if (local_syms != NULL)
6799     {
6800       unsigned long r_symndx;
6801       Elf_Internal_Sym *sym;
6802       bfd *ibfd = sec->owner;
6803
6804       r_symndx = ELF64_R_SYM (r_info);
6805       if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6806         return FALSE;
6807     }
6808
6809   if ((info->shared
6810        && (must_be_dyn_reloc (info, r_type)
6811            || (h != NULL
6812                && (!info->symbolic
6813                    || h->root.type == bfd_link_hash_defweak
6814                    || !h->def_regular))))
6815       || (ELIMINATE_COPY_RELOCS
6816           && !info->shared
6817           && h != NULL
6818           && (h->root.type == bfd_link_hash_defweak
6819               || !h->def_regular)))
6820     ;
6821   else
6822     return TRUE;
6823
6824   if (h != NULL)
6825     pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6826   else
6827     {
6828       if (sym_sec != NULL)
6829         {
6830           void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6831           pp = (struct ppc_dyn_relocs **) vpp;
6832         }
6833       else
6834         {
6835           void *vpp = &elf_section_data (sec)->local_dynrel;
6836           pp = (struct ppc_dyn_relocs **) vpp;
6837         }
6838
6839       /* elf_gc_sweep may have already removed all dyn relocs associated
6840          with local syms for a given section.  Don't report a dynreloc
6841          miscount.  */
6842       if (*pp == NULL)
6843         return TRUE;
6844     }
6845
6846   while ((p = *pp) != NULL)
6847     {
6848       if (p->sec == sec)
6849         {
6850           if (!must_be_dyn_reloc (info, r_type))
6851             p->pc_count -= 1;
6852           p->count -= 1;
6853           if (p->count == 0)
6854             *pp = p->next;
6855           return TRUE;
6856         }
6857       pp = &p->next;
6858     }
6859
6860   (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6861                            sec->owner, sec);
6862   bfd_set_error (bfd_error_bad_value);
6863   return FALSE;
6864 }
6865
6866 /* Remove unused Official Procedure Descriptor entries.  Currently we
6867    only remove those associated with functions in discarded link-once
6868    sections, or weakly defined functions that have been overridden.  It
6869    would be possible to remove many more entries for statically linked
6870    applications.  */
6871
6872 bfd_boolean
6873 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6874                     bfd_boolean non_overlapping)
6875 {
6876   bfd *ibfd;
6877   bfd_boolean some_edited = FALSE;
6878   asection *need_pad = NULL;
6879
6880   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6881     {
6882       asection *sec;
6883       Elf_Internal_Rela *relstart, *rel, *relend;
6884       Elf_Internal_Shdr *symtab_hdr;
6885       Elf_Internal_Sym *local_syms;
6886       struct elf_link_hash_entry **sym_hashes;
6887       bfd_vma offset;
6888       struct _opd_sec_data *opd;
6889       bfd_boolean need_edit, add_aux_fields;
6890       bfd_size_type cnt_16b = 0;
6891
6892       sec = bfd_get_section_by_name (ibfd, ".opd");
6893       if (sec == NULL || sec->size == 0)
6894         continue;
6895
6896       if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6897         continue;
6898
6899       if (sec->output_section == bfd_abs_section_ptr)
6900         continue;
6901
6902       /* Look through the section relocs.  */
6903       if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6904         continue;
6905
6906       local_syms = NULL;
6907       symtab_hdr = &elf_symtab_hdr (ibfd);
6908       sym_hashes = elf_sym_hashes (ibfd);
6909
6910       /* Read the relocations.  */
6911       relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6912                                             info->keep_memory);
6913       if (relstart == NULL)
6914         return FALSE;
6915
6916       /* First run through the relocs to check they are sane, and to
6917          determine whether we need to edit this opd section.  */
6918       need_edit = FALSE;
6919       need_pad = sec;
6920       offset = 0;
6921       relend = relstart + sec->reloc_count;
6922       for (rel = relstart; rel < relend; )
6923         {
6924           enum elf_ppc64_reloc_type r_type;
6925           unsigned long r_symndx;
6926           asection *sym_sec;
6927           struct elf_link_hash_entry *h;
6928           Elf_Internal_Sym *sym;
6929
6930           /* .opd contains a regular array of 16 or 24 byte entries.  We're
6931              only interested in the reloc pointing to a function entry
6932              point.  */
6933           if (rel->r_offset != offset
6934               || rel + 1 >= relend
6935               || (rel + 1)->r_offset != offset + 8)
6936             {
6937               /* If someone messes with .opd alignment then after a
6938                  "ld -r" we might have padding in the middle of .opd.
6939                  Also, there's nothing to prevent someone putting
6940                  something silly in .opd with the assembler.  No .opd
6941                  optimization for them!  */
6942             broken_opd:
6943               (*_bfd_error_handler)
6944                 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6945               need_edit = FALSE;
6946               break;
6947             }
6948
6949           if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6950               || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6951             {
6952               (*_bfd_error_handler)
6953                 (_("%B: unexpected reloc type %u in .opd section"),
6954                  ibfd, r_type);
6955               need_edit = FALSE;
6956               break;
6957             }
6958
6959           r_symndx = ELF64_R_SYM (rel->r_info);
6960           if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6961                           r_symndx, ibfd))
6962             goto error_ret;
6963
6964           if (sym_sec == NULL || sym_sec->owner == NULL)
6965             {
6966               const char *sym_name;
6967               if (h != NULL)
6968                 sym_name = h->root.root.string;
6969               else
6970                 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6971                                              sym_sec);
6972
6973               (*_bfd_error_handler)
6974                 (_("%B: undefined sym `%s' in .opd section"),
6975                  ibfd, sym_name);
6976               need_edit = FALSE;
6977               break;
6978             }
6979
6980           /* opd entries are always for functions defined in the
6981              current input bfd.  If the symbol isn't defined in the
6982              input bfd, then we won't be using the function in this
6983              bfd;  It must be defined in a linkonce section in another
6984              bfd, or is weak.  It's also possible that we are
6985              discarding the function due to a linker script /DISCARD/,
6986              which we test for via the output_section.  */
6987           if (sym_sec->owner != ibfd
6988               || sym_sec->output_section == bfd_abs_section_ptr)
6989             need_edit = TRUE;
6990
6991           rel += 2;
6992           if (rel == relend
6993               || (rel + 1 == relend && rel->r_offset == offset + 16))
6994             {
6995               if (sec->size == offset + 24)
6996                 {
6997                   need_pad = NULL;
6998                   break;
6999                 }
7000               if (rel == relend && sec->size == offset + 16)
7001                 {
7002                   cnt_16b++;
7003                   break;
7004                 }
7005               goto broken_opd;
7006             }
7007
7008           if (rel->r_offset == offset + 24)
7009             offset += 24;
7010           else if (rel->r_offset != offset + 16)
7011             goto broken_opd;
7012           else if (rel + 1 < relend
7013                    && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7014                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7015             {
7016               offset += 16;
7017               cnt_16b++;
7018             }
7019           else if (rel + 2 < relend
7020                    && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7021                    && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7022             {
7023               offset += 24;
7024               rel += 1;
7025             }
7026           else
7027             goto broken_opd;
7028         }
7029
7030       add_aux_fields = non_overlapping && cnt_16b > 0;
7031
7032       if (need_edit || add_aux_fields)
7033         {
7034           Elf_Internal_Rela *write_rel;
7035           bfd_byte *rptr, *wptr;
7036           bfd_byte *new_contents;
7037           bfd_boolean skip;
7038           long opd_ent_size;
7039           bfd_size_type amt;
7040
7041           new_contents = NULL;
7042           amt = sec->size * sizeof (long) / 8;
7043           opd = &ppc64_elf_section_data (sec)->u.opd;
7044           opd->adjust = bfd_zalloc (obfd, amt);
7045           if (opd->adjust == NULL)
7046             return FALSE;
7047           ppc64_elf_section_data (sec)->sec_type = sec_opd;
7048
7049           /* This seems a waste of time as input .opd sections are all
7050              zeros as generated by gcc, but I suppose there's no reason
7051              this will always be so.  We might start putting something in
7052              the third word of .opd entries.  */
7053           if ((sec->flags & SEC_IN_MEMORY) == 0)
7054             {
7055               bfd_byte *loc;
7056               if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7057                 {
7058                   if (loc != NULL)
7059                     free (loc);
7060                 error_ret:
7061                   if (local_syms != NULL
7062                       && symtab_hdr->contents != (unsigned char *) local_syms)
7063                     free (local_syms);
7064                   if (elf_section_data (sec)->relocs != relstart)
7065                     free (relstart);
7066                   return FALSE;
7067                 }
7068               sec->contents = loc;
7069               sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7070             }
7071
7072           elf_section_data (sec)->relocs = relstart;
7073
7074           new_contents = sec->contents;
7075           if (add_aux_fields)
7076             {
7077               new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7078               if (new_contents == NULL)
7079                 return FALSE;
7080               need_pad = FALSE;
7081             }
7082           wptr = new_contents;
7083           rptr = sec->contents;
7084
7085           write_rel = relstart;
7086           skip = FALSE;
7087           offset = 0;
7088           opd_ent_size = 0;
7089           for (rel = relstart; rel < relend; rel++)
7090             {
7091               unsigned long r_symndx;
7092               asection *sym_sec;
7093               struct elf_link_hash_entry *h;
7094               Elf_Internal_Sym *sym;
7095
7096               r_symndx = ELF64_R_SYM (rel->r_info);
7097               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7098                               r_symndx, ibfd))
7099                 goto error_ret;
7100
7101               if (rel->r_offset == offset)
7102                 {
7103                   struct ppc_link_hash_entry *fdh = NULL;
7104
7105                   /* See if the .opd entry is full 24 byte or
7106                      16 byte (with fd_aux entry overlapped with next
7107                      fd_func).  */
7108                   opd_ent_size = 24;
7109                   if ((rel + 2 == relend && sec->size == offset + 16)
7110                       || (rel + 3 < relend
7111                           && rel[2].r_offset == offset + 16
7112                           && rel[3].r_offset == offset + 24
7113                           && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7114                           && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7115                     opd_ent_size = 16;
7116
7117                   if (h != NULL
7118                       && h->root.root.string[0] == '.')
7119                     {
7120                       struct ppc_link_hash_table *htab;
7121
7122                       htab = ppc_hash_table (info);
7123                       if (htab != NULL)
7124                         fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7125                                           htab);
7126                       if (fdh != NULL
7127                           && fdh->elf.root.type != bfd_link_hash_defined
7128                           && fdh->elf.root.type != bfd_link_hash_defweak)
7129                         fdh = NULL;
7130                     }
7131
7132                   skip = (sym_sec->owner != ibfd
7133                           || sym_sec->output_section == bfd_abs_section_ptr);
7134                   if (skip)
7135                     {
7136                       if (fdh != NULL && sym_sec->owner == ibfd)
7137                         {
7138                           /* Arrange for the function descriptor sym
7139                              to be dropped.  */
7140                           fdh->elf.root.u.def.value = 0;
7141                           fdh->elf.root.u.def.section = sym_sec;
7142                         }
7143                       opd->adjust[rel->r_offset / 8] = -1;
7144                     }
7145                   else
7146                     {
7147                       /* We'll be keeping this opd entry.  */
7148
7149                       if (fdh != NULL)
7150                         {
7151                           /* Redefine the function descriptor symbol to
7152                              this location in the opd section.  It is
7153                              necessary to update the value here rather
7154                              than using an array of adjustments as we do
7155                              for local symbols, because various places
7156                              in the generic ELF code use the value
7157                              stored in u.def.value.  */
7158                           fdh->elf.root.u.def.value = wptr - new_contents;
7159                           fdh->adjust_done = 1;
7160                         }
7161
7162                       /* Local syms are a bit tricky.  We could
7163                          tweak them as they can be cached, but
7164                          we'd need to look through the local syms
7165                          for the function descriptor sym which we
7166                          don't have at the moment.  So keep an
7167                          array of adjustments.  */
7168                       opd->adjust[rel->r_offset / 8]
7169                         = (wptr - new_contents) - (rptr - sec->contents);
7170
7171                       if (wptr != rptr)
7172                         memcpy (wptr, rptr, opd_ent_size);
7173                       wptr += opd_ent_size;
7174                       if (add_aux_fields && opd_ent_size == 16)
7175                         {
7176                           memset (wptr, '\0', 8);
7177                           wptr += 8;
7178                         }
7179                     }
7180                   rptr += opd_ent_size;
7181                   offset += opd_ent_size;
7182                 }
7183
7184               if (skip)
7185                 {
7186                   if (!NO_OPD_RELOCS
7187                       && !info->relocatable
7188                       && !dec_dynrel_count (rel->r_info, sec, info,
7189                                             NULL, h, sym_sec))
7190                     goto error_ret;
7191                 }
7192               else
7193                 {
7194                   /* We need to adjust any reloc offsets to point to the
7195                      new opd entries.  While we're at it, we may as well
7196                      remove redundant relocs.  */
7197                   rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7198                   if (write_rel != rel)
7199                     memcpy (write_rel, rel, sizeof (*rel));
7200                   ++write_rel;
7201                 }
7202             }
7203
7204           sec->size = wptr - new_contents;
7205           sec->reloc_count = write_rel - relstart;
7206           if (add_aux_fields)
7207             {
7208               free (sec->contents);
7209               sec->contents = new_contents;
7210             }
7211
7212           /* Fudge the header size too, as this is used later in
7213              elf_bfd_final_link if we are emitting relocs.  */
7214           elf_section_data (sec)->rel_hdr.sh_size
7215             = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7216           BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7217           some_edited = TRUE;
7218         }
7219       else if (elf_section_data (sec)->relocs != relstart)
7220         free (relstart);
7221
7222       if (local_syms != NULL
7223           && symtab_hdr->contents != (unsigned char *) local_syms)
7224         {
7225           if (!info->keep_memory)
7226             free (local_syms);
7227           else
7228             symtab_hdr->contents = (unsigned char *) local_syms;
7229         }
7230     }
7231
7232   if (some_edited)
7233     elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7234
7235   /* If we are doing a final link and the last .opd entry is just 16 byte
7236      long, add a 8 byte padding after it.  */
7237   if (need_pad != NULL && !info->relocatable)
7238     {
7239       bfd_byte *p;
7240
7241       if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7242         {
7243           BFD_ASSERT (need_pad->size > 0);
7244
7245           p = bfd_malloc (need_pad->size + 8);
7246           if (p == NULL)
7247             return FALSE;
7248
7249           if (! bfd_get_section_contents (need_pad->owner, need_pad,
7250                                           p, 0, need_pad->size))
7251             return FALSE;
7252
7253           need_pad->contents = p;
7254           need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7255         }
7256       else
7257         {
7258           p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7259           if (p == NULL)
7260             return FALSE;
7261
7262           need_pad->contents = p;
7263         }
7264
7265       memset (need_pad->contents + need_pad->size, 0, 8);
7266       need_pad->size += 8;
7267     }
7268
7269   return TRUE;
7270 }
7271
7272 /* Set htab->tls_get_addr and call the generic ELF tls_setup function.  */
7273
7274 asection *
7275 ppc64_elf_tls_setup (bfd *obfd,
7276                      struct bfd_link_info *info,
7277                      int no_tls_get_addr_opt)
7278 {
7279   struct ppc_link_hash_table *htab;
7280
7281   htab = ppc_hash_table (info);
7282   if (htab == NULL)
7283     return NULL;
7284
7285   htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7286                         elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7287                                               FALSE, FALSE, TRUE));
7288   /* Move dynamic linking info to the function descriptor sym.  */
7289   if (htab->tls_get_addr != NULL)
7290     func_desc_adjust (&htab->tls_get_addr->elf, info);
7291   htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7292                            elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7293                                                  FALSE, FALSE, TRUE));
7294   if (!no_tls_get_addr_opt)
7295     {
7296       struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7297
7298       opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7299                                   FALSE, FALSE, TRUE);
7300       if (opt != NULL)
7301         func_desc_adjust (opt, info);
7302       opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7303                                      FALSE, FALSE, TRUE);
7304       if (opt_fd != NULL
7305           && (opt_fd->root.type == bfd_link_hash_defined
7306               || opt_fd->root.type == bfd_link_hash_defweak))
7307         {
7308           /* If glibc supports an optimized __tls_get_addr call stub,
7309              signalled by the presence of __tls_get_addr_opt, and we'll
7310              be calling __tls_get_addr via a plt call stub, then
7311              make __tls_get_addr point to __tls_get_addr_opt.  */
7312           tga_fd = &htab->tls_get_addr_fd->elf;
7313           if (htab->elf.dynamic_sections_created
7314               && tga_fd != NULL
7315               && (tga_fd->type == STT_FUNC
7316                   || tga_fd->needs_plt)
7317               && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7318                    || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7319                        && tga_fd->root.type == bfd_link_hash_undefweak)))
7320             {
7321               struct plt_entry *ent;
7322
7323               for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7324                 if (ent->plt.refcount > 0)
7325                   break;
7326               if (ent != NULL)
7327                 {
7328                   tga_fd->root.type = bfd_link_hash_indirect;
7329                   tga_fd->root.u.i.link = &opt_fd->root;
7330                   ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7331                   if (opt_fd->dynindx != -1)
7332                     {
7333                       /* Use __tls_get_addr_opt in dynamic relocations.  */
7334                       opt_fd->dynindx = -1;
7335                       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7336                                               opt_fd->dynstr_index);
7337                       if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7338                         return FALSE;
7339                     }
7340                   htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7341                   tga = &htab->tls_get_addr->elf;
7342                   if (opt != NULL && tga != NULL)
7343                     {
7344                       tga->root.type = bfd_link_hash_indirect;
7345                       tga->root.u.i.link = &opt->root;
7346                       ppc64_elf_copy_indirect_symbol (info, opt, tga);
7347                       _bfd_elf_link_hash_hide_symbol (info, opt,
7348                                                       tga->forced_local);
7349                       htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7350                     }
7351                   htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7352                   htab->tls_get_addr_fd->is_func_descriptor = 1;
7353                   if (htab->tls_get_addr != NULL)
7354                     {
7355                       htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7356                       htab->tls_get_addr->is_func = 1;
7357                     }
7358                 }
7359             }
7360         }
7361       else
7362         no_tls_get_addr_opt = TRUE;
7363     }
7364   htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7365   return _bfd_elf_tls_setup (obfd, info);
7366 }
7367
7368 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7369    HASH1 or HASH2.  */
7370
7371 static bfd_boolean
7372 branch_reloc_hash_match (const bfd *ibfd,
7373                          const Elf_Internal_Rela *rel,
7374                          const struct ppc_link_hash_entry *hash1,
7375                          const struct ppc_link_hash_entry *hash2)
7376 {
7377   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7378   enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7379   unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7380
7381   if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7382     {
7383       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7384       struct elf_link_hash_entry *h;
7385
7386       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7387       h = elf_follow_link (h);
7388       if (h == &hash1->elf || h == &hash2->elf)
7389         return TRUE;
7390     }
7391   return FALSE;
7392 }
7393
7394 /* Run through all the TLS relocs looking for optimization
7395    opportunities.  The linker has been hacked (see ppc64elf.em) to do
7396    a preliminary section layout so that we know the TLS segment
7397    offsets.  We can't optimize earlier because some optimizations need
7398    to know the tp offset, and we need to optimize before allocating
7399    dynamic relocations.  */
7400
7401 bfd_boolean
7402 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7403 {
7404   bfd *ibfd;
7405   asection *sec;
7406   struct ppc_link_hash_table *htab;
7407   int pass;
7408
7409   if (info->relocatable || !info->executable)
7410     return TRUE;
7411
7412   htab = ppc_hash_table (info);
7413   if (htab == NULL)
7414     return FALSE;
7415
7416   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7417     {
7418       Elf_Internal_Sym *locsyms = NULL;
7419       asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7420       unsigned char *toc_ref = NULL;
7421
7422       /* Look at all the sections for this file.  Make two passes over
7423          the relocs.  On the first pass, mark toc entries involved
7424          with tls relocs, and check that tls relocs involved in
7425          setting up a tls_get_addr call are indeed followed by such a
7426          call.  If they are not, exclude them from the optimizations
7427          done on the second pass.  */
7428       for (pass = 0; pass < 2; ++pass)
7429         for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7430           if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7431             {
7432               Elf_Internal_Rela *relstart, *rel, *relend;
7433
7434               /* Read the relocations.  */
7435               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7436                                                     info->keep_memory);
7437               if (relstart == NULL)
7438                 return FALSE;
7439
7440               relend = relstart + sec->reloc_count;
7441               for (rel = relstart; rel < relend; rel++)
7442                 {
7443                   enum elf_ppc64_reloc_type r_type;
7444                   unsigned long r_symndx;
7445                   struct elf_link_hash_entry *h;
7446                   Elf_Internal_Sym *sym;
7447                   asection *sym_sec;
7448                   char *tls_mask;
7449                   char tls_set, tls_clear, tls_type = 0;
7450                   bfd_vma value;
7451                   bfd_boolean ok_tprel, is_local;
7452                   long toc_ref_index = 0;
7453                   int expecting_tls_get_addr = 0;
7454
7455                   r_symndx = ELF64_R_SYM (rel->r_info);
7456                   if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7457                                   r_symndx, ibfd))
7458                     {
7459                     err_free_rel:
7460                       if (elf_section_data (sec)->relocs != relstart)
7461                         free (relstart);
7462                       if (toc_ref != NULL)
7463                         free (toc_ref);
7464                       if (locsyms != NULL
7465                           && (elf_symtab_hdr (ibfd).contents
7466                               != (unsigned char *) locsyms))
7467                         free (locsyms);
7468                       return FALSE;
7469                     }
7470
7471                   if (h != NULL)
7472                     {
7473                       if (h->root.type == bfd_link_hash_defined
7474                           || h->root.type == bfd_link_hash_defweak)
7475                         value = h->root.u.def.value;
7476                       else if (h->root.type == bfd_link_hash_undefweak)
7477                         value = 0;
7478                       else
7479                         continue;
7480                     }
7481                   else
7482                     /* Symbols referenced by TLS relocs must be of type
7483                        STT_TLS.  So no need for .opd local sym adjust.  */
7484                     value = sym->st_value;
7485
7486                   ok_tprel = FALSE;
7487                   is_local = FALSE;
7488                   if (h == NULL
7489                       || !h->def_dynamic)
7490                     {
7491                       is_local = TRUE;
7492                       if (h != NULL
7493                           && h->root.type == bfd_link_hash_undefweak)
7494                         ok_tprel = TRUE;
7495                       else
7496                         {
7497                           value += sym_sec->output_offset;
7498                           value += sym_sec->output_section->vma;
7499                           value -= htab->elf.tls_sec->vma;
7500                           ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7501                                       < (bfd_vma) 1 << 32);
7502                         }
7503                     }
7504
7505                   r_type = ELF64_R_TYPE (rel->r_info);
7506                   switch (r_type)
7507                     {
7508                     case R_PPC64_GOT_TLSLD16:
7509                     case R_PPC64_GOT_TLSLD16_LO:
7510                       expecting_tls_get_addr = 1;
7511                       /* Fall thru */
7512
7513                     case R_PPC64_GOT_TLSLD16_HI:
7514                     case R_PPC64_GOT_TLSLD16_HA:
7515                       /* These relocs should never be against a symbol
7516                          defined in a shared lib.  Leave them alone if
7517                          that turns out to be the case.  */
7518                       if (!is_local)
7519                         continue;
7520
7521                       /* LD -> LE */
7522                       tls_set = 0;
7523                       tls_clear = TLS_LD;
7524                       tls_type = TLS_TLS | TLS_LD;
7525                       break;
7526
7527                     case R_PPC64_GOT_TLSGD16:
7528                     case R_PPC64_GOT_TLSGD16_LO:
7529                       expecting_tls_get_addr = 1;
7530                       /* Fall thru */
7531
7532                     case R_PPC64_GOT_TLSGD16_HI:
7533                     case R_PPC64_GOT_TLSGD16_HA:
7534                       if (ok_tprel)
7535                         /* GD -> LE */
7536                         tls_set = 0;
7537                       else
7538                         /* GD -> IE */
7539                         tls_set = TLS_TLS | TLS_TPRELGD;
7540                       tls_clear = TLS_GD;
7541                       tls_type = TLS_TLS | TLS_GD;
7542                       break;
7543
7544                     case R_PPC64_GOT_TPREL16_DS:
7545                     case R_PPC64_GOT_TPREL16_LO_DS:
7546                     case R_PPC64_GOT_TPREL16_HI:
7547                     case R_PPC64_GOT_TPREL16_HA:
7548                       if (ok_tprel)
7549                         {
7550                           /* IE -> LE */
7551                           tls_set = 0;
7552                           tls_clear = TLS_TPREL;
7553                           tls_type = TLS_TLS | TLS_TPREL;
7554                           break;
7555                         }
7556                       continue;
7557
7558                     case R_PPC64_TOC16:
7559                     case R_PPC64_TOC16_LO:
7560                     case R_PPC64_TLS:
7561                     case R_PPC64_TLSGD:
7562                     case R_PPC64_TLSLD:
7563                       if (sym_sec == NULL || sym_sec != toc)
7564                         continue;
7565
7566                       /* Mark this toc entry as referenced by a TLS
7567                          code sequence.  We can do that now in the
7568                          case of R_PPC64_TLS, and after checking for
7569                          tls_get_addr for the TOC16 relocs.  */
7570                       if (toc_ref == NULL)
7571                         {
7572                           toc_ref = bfd_zmalloc (toc->size / 8);
7573                           if (toc_ref == NULL)
7574                             goto err_free_rel;
7575                         }
7576                       if (h != NULL)
7577                         value = h->root.u.def.value;
7578                       else
7579                         value = sym->st_value;
7580                       value += rel->r_addend;
7581                       BFD_ASSERT (value < toc->size && value % 8 == 0);
7582                       toc_ref_index = value / 8;
7583                       if (r_type == R_PPC64_TLS
7584                           || r_type == R_PPC64_TLSGD
7585                           || r_type == R_PPC64_TLSLD)
7586                         {
7587                           toc_ref[toc_ref_index] = 1;
7588                           continue;
7589                         }
7590
7591                       if (pass != 0 && toc_ref[toc_ref_index] == 0)
7592                         continue;
7593
7594                       tls_set = 0;
7595                       tls_clear = 0;
7596                       expecting_tls_get_addr = 2;
7597                       break;
7598
7599                     case R_PPC64_TPREL64:
7600                       if (pass == 0
7601                           || sec != toc
7602                           || toc_ref == NULL
7603                           || !toc_ref[rel->r_offset / 8])
7604                         continue;
7605                       if (ok_tprel)
7606                         {
7607                           /* IE -> LE */
7608                           tls_set = TLS_EXPLICIT;
7609                           tls_clear = TLS_TPREL;
7610                           break;
7611                         }
7612                       continue;
7613
7614                     case R_PPC64_DTPMOD64:
7615                       if (pass == 0
7616                           || sec != toc
7617                           || toc_ref == NULL
7618                           || !toc_ref[rel->r_offset / 8])
7619                         continue;
7620                       if (rel + 1 < relend
7621                           && (rel[1].r_info
7622                               == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7623                           && rel[1].r_offset == rel->r_offset + 8)
7624                         {
7625                           if (ok_tprel)
7626                             /* GD -> LE */
7627                             tls_set = TLS_EXPLICIT | TLS_GD;
7628                           else
7629                             /* GD -> IE */
7630                             tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7631                           tls_clear = TLS_GD;
7632                         }
7633                       else
7634                         {
7635                           if (!is_local)
7636                             continue;
7637
7638                           /* LD -> LE */
7639                           tls_set = TLS_EXPLICIT;
7640                           tls_clear = TLS_LD;
7641                         }
7642                       break;
7643
7644                     default:
7645                       continue;
7646                     }
7647
7648                   if (pass == 0)
7649                     {
7650                       if (!expecting_tls_get_addr
7651                           || !sec->has_tls_get_addr_call)
7652                         continue;
7653
7654                       if (rel + 1 < relend
7655                           && branch_reloc_hash_match (ibfd, rel + 1,
7656                                                       htab->tls_get_addr,
7657                                                       htab->tls_get_addr_fd))
7658                         {
7659                           if (expecting_tls_get_addr == 2)
7660                             {
7661                               /* Check for toc tls entries.  */
7662                               char *toc_tls;
7663                               int retval;
7664
7665                               retval = get_tls_mask (&toc_tls, NULL, NULL,
7666                                                      &locsyms,
7667                                                      rel, ibfd);
7668                               if (retval == 0)
7669                                 goto err_free_rel;
7670                               if (retval > 1 && toc_tls != NULL)
7671                                 toc_ref[toc_ref_index] = 1;
7672                             }
7673                           continue;
7674                         }
7675
7676                       if (expecting_tls_get_addr != 1)
7677                         continue;
7678
7679                       /* Uh oh, we didn't find the expected call.  We
7680                          could just mark this symbol to exclude it
7681                          from tls optimization but it's safer to skip
7682                          the entire section.  */
7683                       sec->has_tls_reloc = 0;
7684                       break;
7685                     }
7686
7687                   if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7688                     {
7689                       struct plt_entry *ent;
7690                       for (ent = htab->tls_get_addr->elf.plt.plist;
7691                            ent != NULL;
7692                            ent = ent->next)
7693                         if (ent->addend == 0)
7694                           {
7695                             if (ent->plt.refcount > 0)
7696                               {
7697                                 ent->plt.refcount -= 1;
7698                                 expecting_tls_get_addr = 0;
7699                               }
7700                             break;
7701                           }
7702                     }
7703
7704                   if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7705                     {
7706                       struct plt_entry *ent;
7707                       for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7708                            ent != NULL;
7709                            ent = ent->next)
7710                         if (ent->addend == 0)
7711                           {
7712                             if (ent->plt.refcount > 0)
7713                               ent->plt.refcount -= 1;
7714                             break;
7715                           }
7716                     }
7717
7718                   if (tls_clear == 0)
7719                     continue;
7720
7721                   if ((tls_set & TLS_EXPLICIT) == 0)
7722                     {
7723                       struct got_entry *ent;
7724
7725                       /* Adjust got entry for this reloc.  */
7726                       if (h != NULL)
7727                         ent = h->got.glist;
7728                       else
7729                         ent = elf_local_got_ents (ibfd)[r_symndx];
7730
7731                       for (; ent != NULL; ent = ent->next)
7732                         if (ent->addend == rel->r_addend
7733                             && ent->owner == ibfd
7734                             && ent->tls_type == tls_type)
7735                           break;
7736                       if (ent == NULL)
7737                         abort ();
7738
7739                       if (tls_set == 0)
7740                         {
7741                           /* We managed to get rid of a got entry.  */
7742                           if (ent->got.refcount > 0)
7743                             ent->got.refcount -= 1;
7744                         }
7745                     }
7746                   else
7747                     {
7748                       /* If we got rid of a DTPMOD/DTPREL reloc pair then
7749                          we'll lose one or two dyn relocs.  */
7750                       if (!dec_dynrel_count (rel->r_info, sec, info,
7751                                              NULL, h, sym_sec))
7752                         return FALSE;
7753
7754                       if (tls_set == (TLS_EXPLICIT | TLS_GD))
7755                         {
7756                           if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7757                                                  NULL, h, sym_sec))
7758                             return FALSE;
7759                         }
7760                     }
7761
7762                   *tls_mask |= tls_set;
7763                   *tls_mask &= ~tls_clear;
7764                 }
7765
7766               if (elf_section_data (sec)->relocs != relstart)
7767                 free (relstart);
7768             }
7769
7770       if (toc_ref != NULL)
7771         free (toc_ref);
7772
7773       if (locsyms != NULL
7774           && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7775         {
7776           if (!info->keep_memory)
7777             free (locsyms);
7778           else
7779             elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7780         }
7781     }
7782   return TRUE;
7783 }
7784
7785 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7786    the values of any global symbols in a toc section that has been
7787    edited.  Globals in toc sections should be a rarity, so this function
7788    sets a flag if any are found in toc sections other than the one just
7789    edited, so that futher hash table traversals can be avoided.  */
7790
7791 struct adjust_toc_info
7792 {
7793   asection *toc;
7794   unsigned long *skip;
7795   bfd_boolean global_toc_syms;
7796 };
7797
7798 static bfd_boolean
7799 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7800 {
7801   struct ppc_link_hash_entry *eh;
7802   struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7803
7804   if (h->root.type == bfd_link_hash_indirect)
7805     return TRUE;
7806
7807   if (h->root.type == bfd_link_hash_warning)
7808     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7809
7810   if (h->root.type != bfd_link_hash_defined
7811       && h->root.type != bfd_link_hash_defweak)
7812     return TRUE;
7813
7814   eh = (struct ppc_link_hash_entry *) h;
7815   if (eh->adjust_done)
7816     return TRUE;
7817
7818   if (eh->elf.root.u.def.section == toc_inf->toc)
7819     {
7820       unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7821       if (skip != (unsigned long) -1)
7822         eh->elf.root.u.def.value -= skip;
7823       else
7824         {
7825           (*_bfd_error_handler)
7826             (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7827           eh->elf.root.u.def.section = &bfd_abs_section;
7828           eh->elf.root.u.def.value = 0;
7829         }
7830       eh->adjust_done = 1;
7831     }
7832   else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7833     toc_inf->global_toc_syms = TRUE;
7834
7835   return TRUE;
7836 }
7837
7838 /* Examine all relocs referencing .toc sections in order to remove
7839    unused .toc entries.  */
7840
7841 bfd_boolean
7842 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7843 {
7844   bfd *ibfd;
7845   struct adjust_toc_info toc_inf;
7846
7847   toc_inf.global_toc_syms = TRUE;
7848   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7849     {
7850       asection *toc, *sec;
7851       Elf_Internal_Shdr *symtab_hdr;
7852       Elf_Internal_Sym *local_syms;
7853       struct elf_link_hash_entry **sym_hashes;
7854       Elf_Internal_Rela *relstart, *rel;
7855       unsigned long *skip, *drop;
7856       unsigned char *used;
7857       unsigned char *keep, last, some_unused;
7858
7859       toc = bfd_get_section_by_name (ibfd, ".toc");
7860       if (toc == NULL
7861           || toc->size == 0
7862           || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7863           || elf_discarded_section (toc))
7864         continue;
7865
7866       local_syms = NULL;
7867       symtab_hdr = &elf_symtab_hdr (ibfd);
7868       sym_hashes = elf_sym_hashes (ibfd);
7869
7870       /* Look at sections dropped from the final link.  */
7871       skip = NULL;
7872       relstart = NULL;
7873       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7874         {
7875           if (sec->reloc_count == 0
7876               || !elf_discarded_section (sec)
7877               || get_opd_info (sec)
7878               || (sec->flags & SEC_ALLOC) == 0
7879               || (sec->flags & SEC_DEBUGGING) != 0)
7880             continue;
7881
7882           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7883           if (relstart == NULL)
7884             goto error_ret;
7885
7886           /* Run through the relocs to see which toc entries might be
7887              unused.  */
7888           for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7889             {
7890               enum elf_ppc64_reloc_type r_type;
7891               unsigned long r_symndx;
7892               asection *sym_sec;
7893               struct elf_link_hash_entry *h;
7894               Elf_Internal_Sym *sym;
7895               bfd_vma val;
7896
7897               r_type = ELF64_R_TYPE (rel->r_info);
7898               switch (r_type)
7899                 {
7900                 default:
7901                   continue;
7902
7903                 case R_PPC64_TOC16:
7904                 case R_PPC64_TOC16_LO:
7905                 case R_PPC64_TOC16_HI:
7906                 case R_PPC64_TOC16_HA:
7907                 case R_PPC64_TOC16_DS:
7908                 case R_PPC64_TOC16_LO_DS:
7909                   break;
7910                 }
7911
7912               r_symndx = ELF64_R_SYM (rel->r_info);
7913               if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7914                               r_symndx, ibfd))
7915                 goto error_ret;
7916
7917               if (sym_sec != toc)
7918                 continue;
7919
7920               if (h != NULL)
7921                 val = h->root.u.def.value;
7922               else
7923                 val = sym->st_value;
7924               val += rel->r_addend;
7925
7926               if (val >= toc->size)
7927                 continue;
7928
7929               /* Anything in the toc ought to be aligned to 8 bytes.
7930                  If not, don't mark as unused.  */
7931               if (val & 7)
7932                 continue;
7933
7934               if (skip == NULL)
7935                 {
7936                   skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7937                   if (skip == NULL)
7938                     goto error_ret;
7939                 }
7940
7941               skip[val >> 3] = 1;
7942             }
7943
7944           if (elf_section_data (sec)->relocs != relstart)
7945             free (relstart);
7946         }
7947
7948       if (skip == NULL)
7949         continue;
7950
7951       used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7952       if (used == NULL)
7953         {
7954         error_ret:
7955           if (local_syms != NULL
7956               && symtab_hdr->contents != (unsigned char *) local_syms)
7957             free (local_syms);
7958           if (sec != NULL
7959               && relstart != NULL
7960               && elf_section_data (sec)->relocs != relstart)
7961             free (relstart);
7962           if (skip != NULL)
7963             free (skip);
7964           return FALSE;
7965         }
7966
7967       /* Now check all kept sections that might reference the toc.
7968          Check the toc itself last.  */
7969       for (sec = (ibfd->sections == toc && toc->next ? toc->next
7970                   : ibfd->sections);
7971            sec != NULL;
7972            sec = (sec == toc ? NULL
7973                   : sec->next == NULL ? toc
7974                   : sec->next == toc && toc->next ? toc->next
7975                   : sec->next))
7976         {
7977           int repeat;
7978
7979           if (sec->reloc_count == 0
7980               || elf_discarded_section (sec)
7981               || get_opd_info (sec)
7982               || (sec->flags & SEC_ALLOC) == 0
7983               || (sec->flags & SEC_DEBUGGING) != 0)
7984             continue;
7985
7986           relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7987           if (relstart == NULL)
7988             goto error_ret;
7989
7990           /* Mark toc entries referenced as used.  */
7991           repeat = 0;
7992           do
7993             for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7994               {
7995                 enum elf_ppc64_reloc_type r_type;
7996                 unsigned long r_symndx;
7997                 asection *sym_sec;
7998                 struct elf_link_hash_entry *h;
7999                 Elf_Internal_Sym *sym;
8000                 bfd_vma val;
8001
8002                 r_type = ELF64_R_TYPE (rel->r_info);
8003                 switch (r_type)
8004                   {
8005                   case R_PPC64_TOC16:
8006                   case R_PPC64_TOC16_LO:
8007                   case R_PPC64_TOC16_HI:
8008                   case R_PPC64_TOC16_HA:
8009                   case R_PPC64_TOC16_DS:
8010                   case R_PPC64_TOC16_LO_DS:
8011                     /* In case we're taking addresses of toc entries.  */
8012                   case R_PPC64_ADDR64:
8013                     break;
8014
8015                   default:
8016                     continue;
8017                   }
8018
8019                 r_symndx = ELF64_R_SYM (rel->r_info);
8020                 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8021                                 r_symndx, ibfd))
8022                   {
8023                     free (used);
8024                     goto error_ret;
8025                   }
8026
8027                 if (sym_sec != toc)
8028                   continue;
8029
8030                 if (h != NULL)
8031                   val = h->root.u.def.value;
8032                 else
8033                   val = sym->st_value;
8034                 val += rel->r_addend;
8035
8036                 if (val >= toc->size)
8037                   continue;
8038
8039                 /* For the toc section, we only mark as used if
8040                    this entry itself isn't unused.  */
8041                 if (sec == toc
8042                     && !used[val >> 3]
8043                     && (used[rel->r_offset >> 3]
8044                         || !skip[rel->r_offset >> 3]))
8045                   /* Do all the relocs again, to catch reference
8046                      chains.  */
8047                   repeat = 1;
8048
8049                 used[val >> 3] = 1;
8050               }
8051           while (repeat);
8052         }
8053
8054       /* Merge the used and skip arrays.  Assume that TOC
8055          doublewords not appearing as either used or unused belong
8056          to to an entry more than one doubleword in size.  */
8057       for (drop = skip, keep = used, last = 0, some_unused = 0;
8058            drop < skip + (toc->size + 7) / 8;
8059            ++drop, ++keep)
8060         {
8061           if (*keep)
8062             {
8063               *drop = 0;
8064               last = 0;
8065             }
8066           else if (*drop)
8067             {
8068               some_unused = 1;
8069               last = 1;
8070             }
8071           else
8072             *drop = last;
8073         }
8074
8075       free (used);
8076
8077       if (some_unused)
8078         {
8079           bfd_byte *contents, *src;
8080           unsigned long off;
8081
8082           /* Shuffle the toc contents, and at the same time convert the
8083              skip array from booleans into offsets.  */
8084           if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8085             goto error_ret;
8086
8087           elf_section_data (toc)->this_hdr.contents = contents;
8088
8089           for (src = contents, off = 0, drop = skip;
8090                src < contents + toc->size;
8091                src += 8, ++drop)
8092             {
8093               if (*drop)
8094                 {
8095                   *drop = (unsigned long) -1;
8096                   off += 8;
8097                 }
8098               else if (off != 0)
8099                 {
8100                   *drop = off;
8101                   memcpy (src - off, src, 8);
8102                 }
8103             }
8104           toc->rawsize = toc->size;
8105           toc->size = src - contents - off;
8106
8107           if (toc->reloc_count != 0)
8108             {
8109               Elf_Internal_Rela *wrel;
8110               bfd_size_type sz;
8111
8112               /* Read toc relocs.  */
8113               relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8114                                                     TRUE);
8115               if (relstart == NULL)
8116                 goto error_ret;
8117
8118               /* Remove unused toc relocs, and adjust those we keep.  */
8119               wrel = relstart;
8120               for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8121                 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
8122                   {
8123                     wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8124                     wrel->r_info = rel->r_info;
8125                     wrel->r_addend = rel->r_addend;
8126                     ++wrel;
8127                   }
8128                 else if (!dec_dynrel_count (rel->r_info, toc, info,
8129                                             &local_syms, NULL, NULL))
8130                   goto error_ret;
8131
8132               toc->reloc_count = wrel - relstart;
8133               sz = elf_section_data (toc)->rel_hdr.sh_entsize;
8134               elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
8135               BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
8136             }
8137
8138           /* Adjust addends for relocs against the toc section sym.  */
8139           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8140             {
8141               if (sec->reloc_count == 0
8142                   || elf_discarded_section (sec))
8143                 continue;
8144
8145               relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8146                                                     TRUE);
8147               if (relstart == NULL)
8148                 goto error_ret;
8149
8150               for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8151                 {
8152                   enum elf_ppc64_reloc_type r_type;
8153                   unsigned long r_symndx;
8154                   asection *sym_sec;
8155                   struct elf_link_hash_entry *h;
8156                   Elf_Internal_Sym *sym;
8157
8158                   r_type = ELF64_R_TYPE (rel->r_info);
8159                   switch (r_type)
8160                     {
8161                     default:
8162                       continue;
8163
8164                     case R_PPC64_TOC16:
8165                     case R_PPC64_TOC16_LO:
8166                     case R_PPC64_TOC16_HI:
8167                     case R_PPC64_TOC16_HA:
8168                     case R_PPC64_TOC16_DS:
8169                     case R_PPC64_TOC16_LO_DS:
8170                     case R_PPC64_ADDR64:
8171                       break;
8172                     }
8173
8174                   r_symndx = ELF64_R_SYM (rel->r_info);
8175                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8176                                   r_symndx, ibfd))
8177                     goto error_ret;
8178
8179                   if (sym_sec != toc || h != NULL || sym->st_value != 0)
8180                     continue;
8181
8182                   rel->r_addend -= skip[rel->r_addend >> 3];
8183                 }
8184             }
8185
8186           /* We shouldn't have local or global symbols defined in the TOC,
8187              but handle them anyway.  */
8188           if (local_syms != NULL)
8189             {
8190               Elf_Internal_Sym *sym;
8191
8192               for (sym = local_syms;
8193                    sym < local_syms + symtab_hdr->sh_info;
8194                    ++sym)
8195                 if (sym->st_value != 0
8196                     && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8197                   {
8198                     if (skip[sym->st_value >> 3] != (unsigned long) -1)
8199                       sym->st_value -= skip[sym->st_value >> 3];
8200                     else
8201                       {
8202                         (*_bfd_error_handler)
8203                           (_("%s defined in removed toc entry"),
8204                            bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8205                                              NULL));
8206                         sym->st_value = 0;
8207                         sym->st_shndx = SHN_ABS;
8208                       }
8209                     symtab_hdr->contents = (unsigned char *) local_syms;
8210                   }
8211             }
8212
8213           /* Finally, adjust any global syms defined in the toc.  */
8214           if (toc_inf.global_toc_syms)
8215             {
8216               toc_inf.toc = toc;
8217               toc_inf.skip = skip;
8218               toc_inf.global_toc_syms = FALSE;
8219               elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8220                                       &toc_inf);
8221             }
8222         }
8223
8224       if (local_syms != NULL
8225           && symtab_hdr->contents != (unsigned char *) local_syms)
8226         {
8227           if (!info->keep_memory)
8228             free (local_syms);
8229           else
8230             symtab_hdr->contents = (unsigned char *) local_syms;
8231         }
8232       free (skip);
8233     }
8234
8235   return TRUE;
8236 }
8237
8238 /* Allocate space for one GOT entry.  */
8239
8240 static void
8241 allocate_got (struct elf_link_hash_entry *h,
8242               struct bfd_link_info *info,
8243               struct got_entry *gent)
8244 {
8245   struct ppc_link_hash_table *htab = ppc_hash_table (info);
8246   bfd_boolean dyn;
8247   struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8248   int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8249                  ? 16 : 8);
8250   int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8251                   ? 2 : 1) * sizeof (Elf64_External_Rela);
8252   asection *got = ppc64_elf_tdata (gent->owner)->got;
8253
8254   gent->got.offset = got->size;
8255   got->size += entsize;
8256
8257   dyn = htab->elf.dynamic_sections_created;
8258   if ((info->shared
8259        || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8260             && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8261                 || h->root.type != bfd_link_hash_undefweak))
8262     {
8263       asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8264       relgot->size += rentsize;
8265     }
8266   else if (h->type == STT_GNU_IFUNC)
8267     {
8268       asection *relgot = htab->reliplt;
8269       relgot->size += rentsize;
8270       htab->got_reli_size += rentsize;
8271     }
8272 }
8273
8274 /* Allocate space in .plt, .got and associated reloc sections for
8275    dynamic relocs.  */
8276
8277 static bfd_boolean
8278 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8279 {
8280   struct bfd_link_info *info;
8281   struct ppc_link_hash_table *htab;
8282   asection *s;
8283   struct ppc_link_hash_entry *eh;
8284   struct ppc_dyn_relocs *p;
8285   struct got_entry *gent;
8286
8287   if (h->root.type == bfd_link_hash_indirect)
8288     return TRUE;
8289
8290   if (h->root.type == bfd_link_hash_warning)
8291     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8292
8293   info = (struct bfd_link_info *) inf;
8294   htab = ppc_hash_table (info);
8295   if (htab == NULL)
8296     return FALSE;
8297
8298   if ((htab->elf.dynamic_sections_created
8299        && h->dynindx != -1
8300        && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8301       || h->type == STT_GNU_IFUNC)
8302     {
8303       struct plt_entry *pent;
8304       bfd_boolean doneone = FALSE;
8305       for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8306         if (pent->plt.refcount > 0)
8307           {
8308             if (!htab->elf.dynamic_sections_created
8309                 || h->dynindx == -1)
8310               {
8311                 s = htab->iplt;
8312                 pent->plt.offset = s->size;
8313                 s->size += PLT_ENTRY_SIZE;
8314                 s = htab->reliplt;
8315               }
8316             else
8317               {
8318                 /* If this is the first .plt entry, make room for the special
8319                    first entry.  */
8320                 s = htab->plt;
8321                 if (s->size == 0)
8322                   s->size += PLT_INITIAL_ENTRY_SIZE;
8323
8324                 pent->plt.offset = s->size;
8325
8326                 /* Make room for this entry.  */
8327                 s->size += PLT_ENTRY_SIZE;
8328
8329                 /* Make room for the .glink code.  */
8330                 s = htab->glink;
8331                 if (s->size == 0)
8332                   s->size += GLINK_CALL_STUB_SIZE;
8333                 /* We need bigger stubs past index 32767.  */
8334                 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8335                   s->size += 4;
8336                 s->size += 2*4;
8337
8338                 /* We also need to make an entry in the .rela.plt section.  */
8339                 s = htab->relplt;
8340               }
8341             s->size += sizeof (Elf64_External_Rela);
8342             doneone = TRUE;
8343           }
8344         else
8345           pent->plt.offset = (bfd_vma) -1;
8346       if (!doneone)
8347         {
8348           h->plt.plist = NULL;
8349           h->needs_plt = 0;
8350         }
8351     }
8352   else
8353     {
8354       h->plt.plist = NULL;
8355       h->needs_plt = 0;
8356     }
8357
8358   eh = (struct ppc_link_hash_entry *) h;
8359   /* Run through the TLS GD got entries first if we're changing them
8360      to TPREL.  */
8361   if ((eh->tls_mask & TLS_TPRELGD) != 0)
8362     for (gent = h->got.glist; gent != NULL; gent = gent->next)
8363       if (gent->got.refcount > 0
8364           && (gent->tls_type & TLS_GD) != 0)
8365         {
8366           /* This was a GD entry that has been converted to TPREL.  If
8367              there happens to be a TPREL entry we can use that one.  */
8368           struct got_entry *ent;
8369           for (ent = h->got.glist; ent != NULL; ent = ent->next)
8370             if (ent->got.refcount > 0
8371                 && (ent->tls_type & TLS_TPREL) != 0
8372                 && ent->addend == gent->addend
8373                 && ent->owner == gent->owner)
8374               {
8375                 gent->got.refcount = 0;
8376                 break;
8377               }
8378
8379           /* If not, then we'll be using our own TPREL entry.  */
8380           if (gent->got.refcount != 0)
8381             gent->tls_type = TLS_TLS | TLS_TPREL;
8382         }
8383
8384   for (gent = h->got.glist; gent != NULL; gent = gent->next)
8385     if (gent->got.refcount > 0)
8386       {
8387         /* Make sure this symbol is output as a dynamic symbol.
8388            Undefined weak syms won't yet be marked as dynamic,
8389            nor will all TLS symbols.  */
8390         if (h->dynindx == -1
8391             && !h->forced_local
8392             && h->type != STT_GNU_IFUNC
8393             && htab->elf.dynamic_sections_created)
8394           {
8395             if (! bfd_elf_link_record_dynamic_symbol (info, h))
8396               return FALSE;
8397           }
8398
8399         if ((gent->tls_type & TLS_LD) != 0
8400             && !h->def_dynamic)
8401           {
8402             ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8403             gent->got.offset = (bfd_vma) -1;
8404             continue;
8405           }
8406
8407         if (!is_ppc64_elf (gent->owner))
8408           abort ();
8409
8410         allocate_got (h, info, gent);
8411       }
8412     else
8413       gent->got.offset = (bfd_vma) -1;
8414
8415   if (eh->dyn_relocs == NULL
8416       || (!htab->elf.dynamic_sections_created
8417           && h->type != STT_GNU_IFUNC))
8418     return TRUE;
8419
8420   /* In the shared -Bsymbolic case, discard space allocated for
8421      dynamic pc-relative relocs against symbols which turn out to be
8422      defined in regular objects.  For the normal shared case, discard
8423      space for relocs that have become local due to symbol visibility
8424      changes.  */
8425
8426   if (info->shared)
8427     {
8428       /* Relocs that use pc_count are those that appear on a call insn,
8429          or certain REL relocs (see must_be_dyn_reloc) that can be
8430          generated via assembly.  We want calls to protected symbols to
8431          resolve directly to the function rather than going via the plt.
8432          If people want function pointer comparisons to work as expected
8433          then they should avoid writing weird assembly.  */
8434       if (SYMBOL_CALLS_LOCAL (info, h))
8435         {
8436           struct ppc_dyn_relocs **pp;
8437
8438           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8439             {
8440               p->count -= p->pc_count;
8441               p->pc_count = 0;
8442               if (p->count == 0)
8443                 *pp = p->next;
8444               else
8445                 pp = &p->next;
8446             }
8447         }
8448
8449       /* Also discard relocs on undefined weak syms with non-default
8450          visibility.  */
8451       if (eh->dyn_relocs != NULL
8452           && h->root.type == bfd_link_hash_undefweak)
8453         {
8454           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8455             eh->dyn_relocs = NULL;
8456
8457           /* Make sure this symbol is output as a dynamic symbol.
8458              Undefined weak syms won't yet be marked as dynamic.  */
8459           else if (h->dynindx == -1
8460                    && !h->forced_local)
8461             {
8462               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8463                 return FALSE;
8464             }
8465         }
8466     }
8467   else if (h->type == STT_GNU_IFUNC)
8468     {
8469       if (!h->non_got_ref)
8470         eh->dyn_relocs = NULL;
8471     }
8472   else if (ELIMINATE_COPY_RELOCS)
8473     {
8474       /* For the non-shared case, discard space for relocs against
8475          symbols which turn out to need copy relocs or are not
8476          dynamic.  */
8477
8478       if (!h->non_got_ref
8479           && !h->def_regular)
8480         {
8481           /* Make sure this symbol is output as a dynamic symbol.
8482              Undefined weak syms won't yet be marked as dynamic.  */
8483           if (h->dynindx == -1
8484               && !h->forced_local)
8485             {
8486               if (! bfd_elf_link_record_dynamic_symbol (info, h))
8487                 return FALSE;
8488             }
8489
8490           /* If that succeeded, we know we'll be keeping all the
8491              relocs.  */
8492           if (h->dynindx != -1)
8493             goto keep;
8494         }
8495
8496       eh->dyn_relocs = NULL;
8497
8498     keep: ;
8499     }
8500
8501   /* Finally, allocate space.  */
8502   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8503     {
8504       asection *sreloc = elf_section_data (p->sec)->sreloc;
8505       if (!htab->elf.dynamic_sections_created)
8506         sreloc = htab->reliplt;
8507       sreloc->size += p->count * sizeof (Elf64_External_Rela);
8508     }
8509
8510   return TRUE;
8511 }
8512
8513 /* Find any dynamic relocs that apply to read-only sections.  */
8514
8515 static bfd_boolean
8516 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8517 {
8518   struct ppc_link_hash_entry *eh;
8519   struct ppc_dyn_relocs *p;
8520
8521   if (h->root.type == bfd_link_hash_warning)
8522     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8523
8524   eh = (struct ppc_link_hash_entry *) h;
8525   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8526     {
8527       asection *s = p->sec->output_section;
8528
8529       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8530         {
8531           struct bfd_link_info *info = inf;
8532
8533           info->flags |= DF_TEXTREL;
8534
8535           /* Not an error, just cut short the traversal.  */
8536           return FALSE;
8537         }
8538     }
8539   return TRUE;
8540 }
8541
8542 /* Set the sizes of the dynamic sections.  */
8543
8544 static bfd_boolean
8545 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8546                                  struct bfd_link_info *info)
8547 {
8548   struct ppc_link_hash_table *htab;
8549   bfd *dynobj;
8550   asection *s;
8551   bfd_boolean relocs;
8552   bfd *ibfd;
8553
8554   htab = ppc_hash_table (info);
8555   if (htab == NULL)
8556     return FALSE;
8557
8558   dynobj = htab->elf.dynobj;
8559   if (dynobj == NULL)
8560     abort ();
8561
8562   if (htab->elf.dynamic_sections_created)
8563     {
8564       /* Set the contents of the .interp section to the interpreter.  */
8565       if (info->executable)
8566         {
8567           s = bfd_get_section_by_name (dynobj, ".interp");
8568           if (s == NULL)
8569             abort ();
8570           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8571           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8572         }
8573     }
8574
8575   /* Set up .got offsets for local syms, and space for local dynamic
8576      relocs.  */
8577   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8578     {
8579       struct got_entry **lgot_ents;
8580       struct got_entry **end_lgot_ents;
8581       struct plt_entry **local_plt;
8582       struct plt_entry **end_local_plt;
8583       char *lgot_masks;
8584       bfd_size_type locsymcount;
8585       Elf_Internal_Shdr *symtab_hdr;
8586       asection *srel;
8587
8588       if (!is_ppc64_elf (ibfd))
8589         continue;
8590
8591       for (s = ibfd->sections; s != NULL; s = s->next)
8592         {
8593           struct ppc_dyn_relocs *p;
8594
8595           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8596             {
8597               if (!bfd_is_abs_section (p->sec)
8598                   && bfd_is_abs_section (p->sec->output_section))
8599                 {
8600                   /* Input section has been discarded, either because
8601                      it is a copy of a linkonce section or due to
8602                      linker script /DISCARD/, so we'll be discarding
8603                      the relocs too.  */
8604                 }
8605               else if (p->count != 0)
8606                 {
8607                   srel = elf_section_data (p->sec)->sreloc;
8608                   if (!htab->elf.dynamic_sections_created)
8609                     srel = htab->reliplt;
8610                   srel->size += p->count * sizeof (Elf64_External_Rela);
8611                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8612                     info->flags |= DF_TEXTREL;
8613                 }
8614             }
8615         }
8616
8617       lgot_ents = elf_local_got_ents (ibfd);
8618       if (!lgot_ents)
8619         continue;
8620
8621       symtab_hdr = &elf_symtab_hdr (ibfd);
8622       locsymcount = symtab_hdr->sh_info;
8623       end_lgot_ents = lgot_ents + locsymcount;
8624       local_plt = (struct plt_entry **) end_lgot_ents;
8625       end_local_plt = local_plt + locsymcount;
8626       lgot_masks = (char *) end_local_plt;
8627       s = ppc64_elf_tdata (ibfd)->got;
8628       srel = ppc64_elf_tdata (ibfd)->relgot;
8629       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8630         {
8631           struct got_entry *ent;
8632
8633           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8634             if (ent->got.refcount > 0)
8635               {
8636                 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8637                   {
8638                     ppc64_tlsld_got (ibfd)->got.refcount += 1;
8639                     ent->got.offset = (bfd_vma) -1;
8640                   }
8641                 else
8642                   {
8643                     unsigned int num = 1;
8644                     ent->got.offset = s->size;
8645                     if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8646                       num = 2;
8647                     s->size += num * 8;
8648                     if (info->shared)
8649                       srel->size += num * sizeof (Elf64_External_Rela);
8650                     else if ((*lgot_masks & PLT_IFUNC) != 0)
8651                       {
8652                         htab->reliplt->size
8653                           += num * sizeof (Elf64_External_Rela);
8654                         htab->got_reli_size
8655                           += num * sizeof (Elf64_External_Rela);
8656                       }
8657                   }
8658               }
8659             else
8660               ent->got.offset = (bfd_vma) -1;
8661         }
8662
8663       /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt.  */
8664       for (; local_plt < end_local_plt; ++local_plt)
8665         {
8666           struct plt_entry *ent;
8667
8668           for (ent = *local_plt; ent != NULL; ent = ent->next)
8669             if (ent->plt.refcount > 0)
8670               {
8671                 s = htab->iplt;
8672                 ent->plt.offset = s->size;
8673                 s->size += PLT_ENTRY_SIZE;
8674
8675                 htab->reliplt->size += sizeof (Elf64_External_Rela);
8676               }
8677             else
8678               ent->plt.offset = (bfd_vma) -1;
8679         }
8680     }
8681
8682   /* Allocate global sym .plt and .got entries, and space for global
8683      sym dynamic relocs.  */
8684   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8685
8686   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8687     {
8688       if (!is_ppc64_elf (ibfd))
8689         continue;
8690
8691       if (ppc64_tlsld_got (ibfd)->got.refcount > 0)
8692         {
8693           s = ppc64_elf_tdata (ibfd)->got;
8694           ppc64_tlsld_got (ibfd)->got.offset = s->size;
8695           ppc64_tlsld_got (ibfd)->owner = ibfd;
8696           s->size += 16;
8697           if (info->shared)
8698             {
8699               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8700               srel->size += sizeof (Elf64_External_Rela);
8701             }
8702         }
8703       else
8704         ppc64_tlsld_got (ibfd)->got.offset = (bfd_vma) -1;
8705     }
8706
8707   /* We now have determined the sizes of the various dynamic sections.
8708      Allocate memory for them.  */
8709   relocs = FALSE;
8710   for (s = dynobj->sections; s != NULL; s = s->next)
8711     {
8712       if ((s->flags & SEC_LINKER_CREATED) == 0)
8713         continue;
8714
8715       if (s == htab->brlt || s == htab->relbrlt)
8716         /* These haven't been allocated yet;  don't strip.  */
8717         continue;
8718       else if (s == htab->got
8719                || s == htab->plt
8720                || s == htab->iplt
8721                || s == htab->glink
8722                || s == htab->dynbss)
8723         {
8724           /* Strip this section if we don't need it; see the
8725              comment below.  */
8726         }
8727       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8728         {
8729           if (s->size != 0)
8730             {
8731               if (s != htab->relplt)
8732                 relocs = TRUE;
8733
8734               /* We use the reloc_count field as a counter if we need
8735                  to copy relocs into the output file.  */
8736               s->reloc_count = 0;
8737             }
8738         }
8739       else
8740         {
8741           /* It's not one of our sections, so don't allocate space.  */
8742           continue;
8743         }
8744
8745       if (s->size == 0)
8746         {
8747           /* If we don't need this section, strip it from the
8748              output file.  This is mostly to handle .rela.bss and
8749              .rela.plt.  We must create both sections in
8750              create_dynamic_sections, because they must be created
8751              before the linker maps input sections to output
8752              sections.  The linker does that before
8753              adjust_dynamic_symbol is called, and it is that
8754              function which decides whether anything needs to go
8755              into these sections.  */
8756           s->flags |= SEC_EXCLUDE;
8757           continue;
8758         }
8759
8760       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8761         continue;
8762
8763       /* Allocate memory for the section contents.  We use bfd_zalloc
8764          here in case unused entries are not reclaimed before the
8765          section's contents are written out.  This should not happen,
8766          but this way if it does we get a R_PPC64_NONE reloc in .rela
8767          sections instead of garbage.
8768          We also rely on the section contents being zero when writing
8769          the GOT.  */
8770       s->contents = bfd_zalloc (dynobj, s->size);
8771       if (s->contents == NULL)
8772         return FALSE;
8773     }
8774
8775   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8776     {
8777       if (!is_ppc64_elf (ibfd))
8778         continue;
8779
8780       s = ppc64_elf_tdata (ibfd)->got;
8781       if (s != NULL && s != htab->got)
8782         {
8783           if (s->size == 0)
8784             s->flags |= SEC_EXCLUDE;
8785           else
8786             {
8787               s->contents = bfd_zalloc (ibfd, s->size);
8788               if (s->contents == NULL)
8789                 return FALSE;
8790             }
8791         }
8792       s = ppc64_elf_tdata (ibfd)->relgot;
8793       if (s != NULL)
8794         {
8795           if (s->size == 0)
8796             s->flags |= SEC_EXCLUDE;
8797           else
8798             {
8799               s->contents = bfd_zalloc (ibfd, s->size);
8800               if (s->contents == NULL)
8801                 return FALSE;
8802               relocs = TRUE;
8803               s->reloc_count = 0;
8804             }
8805         }
8806     }
8807
8808   if (htab->elf.dynamic_sections_created)
8809     {
8810       /* Add some entries to the .dynamic section.  We fill in the
8811          values later, in ppc64_elf_finish_dynamic_sections, but we
8812          must add the entries now so that we get the correct size for
8813          the .dynamic section.  The DT_DEBUG entry is filled in by the
8814          dynamic linker and used by the debugger.  */
8815 #define add_dynamic_entry(TAG, VAL) \
8816   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8817
8818       if (info->executable)
8819         {
8820           if (!add_dynamic_entry (DT_DEBUG, 0))
8821             return FALSE;
8822         }
8823
8824       if (htab->plt != NULL && htab->plt->size != 0)
8825         {
8826           if (!add_dynamic_entry (DT_PLTGOT, 0)
8827               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8828               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8829               || !add_dynamic_entry (DT_JMPREL, 0)
8830               || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8831             return FALSE;
8832         }
8833
8834       if (NO_OPD_RELOCS)
8835         {
8836           if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8837               || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8838             return FALSE;
8839         }
8840
8841       if (!htab->no_tls_get_addr_opt
8842           && htab->tls_get_addr_fd != NULL
8843           && htab->tls_get_addr_fd->elf.plt.plist != NULL
8844           && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
8845         return FALSE;
8846
8847       if (relocs)
8848         {
8849           if (!add_dynamic_entry (DT_RELA, 0)
8850               || !add_dynamic_entry (DT_RELASZ, 0)
8851               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8852             return FALSE;
8853
8854           /* If any dynamic relocs apply to a read-only section,
8855              then we need a DT_TEXTREL entry.  */
8856           if ((info->flags & DF_TEXTREL) == 0)
8857             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8858
8859           if ((info->flags & DF_TEXTREL) != 0)
8860             {
8861               if (!add_dynamic_entry (DT_TEXTREL, 0))
8862                 return FALSE;
8863             }
8864         }
8865     }
8866 #undef add_dynamic_entry
8867
8868   return TRUE;
8869 }
8870
8871 /* Determine the type of stub needed, if any, for a call.  */
8872
8873 static inline enum ppc_stub_type
8874 ppc_type_of_stub (asection *input_sec,
8875                   const Elf_Internal_Rela *rel,
8876                   struct ppc_link_hash_entry **hash,
8877                   struct plt_entry **plt_ent,
8878                   bfd_vma destination)
8879 {
8880   struct ppc_link_hash_entry *h = *hash;
8881   bfd_vma location;
8882   bfd_vma branch_offset;
8883   bfd_vma max_branch_offset;
8884   enum elf_ppc64_reloc_type r_type;
8885
8886   if (h != NULL)
8887     {
8888       struct plt_entry *ent;
8889       struct ppc_link_hash_entry *fdh = h;
8890       if (h->oh != NULL
8891           && h->oh->is_func_descriptor)
8892         fdh = ppc_follow_link (h->oh);
8893
8894       for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8895         if (ent->addend == rel->r_addend
8896             && ent->plt.offset != (bfd_vma) -1)
8897           {
8898             *hash = fdh;
8899             *plt_ent = ent;
8900             return ppc_stub_plt_call;
8901           }
8902
8903       /* Here, we know we don't have a plt entry.  If we don't have a
8904          either a defined function descriptor or a defined entry symbol
8905          in a regular object file, then it is pointless trying to make
8906          any other type of stub.  */
8907       if (!((fdh->elf.root.type == bfd_link_hash_defined
8908             || fdh->elf.root.type == bfd_link_hash_defweak)
8909             && fdh->elf.root.u.def.section->output_section != NULL)
8910           && !((h->elf.root.type == bfd_link_hash_defined
8911                 || h->elf.root.type == bfd_link_hash_defweak)
8912                && h->elf.root.u.def.section->output_section != NULL))
8913         return ppc_stub_none;
8914     }
8915   else if (elf_local_got_ents (input_sec->owner) != NULL)
8916     {
8917       Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
8918       struct plt_entry **local_plt = (struct plt_entry **)
8919         elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
8920       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
8921
8922       if (local_plt[r_symndx] != NULL)
8923         {
8924           struct plt_entry *ent;
8925
8926           for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
8927             if (ent->addend == rel->r_addend
8928                 && ent->plt.offset != (bfd_vma) -1)
8929               {
8930                 *plt_ent = ent;
8931                 return ppc_stub_plt_call;
8932               }
8933         }
8934     }
8935
8936   /* Determine where the call point is.  */
8937   location = (input_sec->output_offset
8938               + input_sec->output_section->vma
8939               + rel->r_offset);
8940
8941   branch_offset = destination - location;
8942   r_type = ELF64_R_TYPE (rel->r_info);
8943
8944   /* Determine if a long branch stub is needed.  */
8945   max_branch_offset = 1 << 25;
8946   if (r_type != R_PPC64_REL24)
8947     max_branch_offset = 1 << 15;
8948
8949   if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8950     /* We need a stub.  Figure out whether a long_branch or plt_branch
8951        is needed later.  */
8952     return ppc_stub_long_branch;
8953
8954   return ppc_stub_none;
8955 }
8956
8957 /* Build a .plt call stub.  */
8958
8959 static inline bfd_byte *
8960 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8961 {
8962 #define PPC_LO(v) ((v) & 0xffff)
8963 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8964 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8965
8966   if (PPC_HA (offset) != 0)
8967     {
8968       if (r != NULL)
8969         {
8970           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8971           r[1].r_offset = r[0].r_offset + 8;
8972           r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8973           r[1].r_addend = r[0].r_addend;
8974           if (PPC_HA (offset + 16) != PPC_HA (offset))
8975             {
8976               r[2].r_offset = r[1].r_offset + 4;
8977               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8978               r[2].r_addend = r[0].r_addend;
8979             }
8980           else
8981             {
8982               r[2].r_offset = r[1].r_offset + 8;
8983               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8984               r[2].r_addend = r[0].r_addend + 8;
8985               r[3].r_offset = r[2].r_offset + 4;
8986               r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8987               r[3].r_addend = r[0].r_addend + 16;
8988             }
8989         }
8990       bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p),     p += 4;
8991       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
8992       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p),      p += 4;
8993       if (PPC_HA (offset + 16) != PPC_HA (offset))
8994         {
8995           bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8996           offset = 0;
8997         }
8998       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
8999       bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p),   p += 4;
9000       bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9001       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9002     }
9003   else
9004     {
9005       if (r != NULL)
9006         {
9007           r[0].r_offset += 4;
9008           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9009           if (PPC_HA (offset + 16) != PPC_HA (offset))
9010             {
9011               r[1].r_offset = r[0].r_offset + 4;
9012               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9013               r[1].r_addend = r[0].r_addend;
9014             }
9015           else
9016             {
9017               r[1].r_offset = r[0].r_offset + 8;
9018               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9019               r[1].r_addend = r[0].r_addend + 16;
9020               r[2].r_offset = r[1].r_offset + 4;
9021               r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9022               r[2].r_addend = r[0].r_addend + 8;
9023             }
9024         }
9025       bfd_put_32 (obfd, STD_R2_40R1, p),                        p += 4;
9026       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p),       p += 4;
9027       if (PPC_HA (offset + 16) != PPC_HA (offset))
9028         {
9029           bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p),   p += 4;
9030           offset = 0;
9031         }
9032       bfd_put_32 (obfd, MTCTR_R11, p),                          p += 4;
9033       bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p),  p += 4;
9034       bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p),    p += 4;
9035       bfd_put_32 (obfd, BCTR, p),                               p += 4;
9036     }
9037   return p;
9038 }
9039
9040 /* Build a special .plt call stub for __tls_get_addr.  */
9041
9042 #define LD_R11_0R3      0xe9630000
9043 #define LD_R12_0R3      0xe9830000
9044 #define MR_R0_R3        0x7c601b78
9045 #define CMPDI_R11_0     0x2c2b0000
9046 #define ADD_R3_R12_R13  0x7c6c6a14
9047 #define BEQLR           0x4d820020
9048 #define MR_R3_R0        0x7c030378
9049 #define MFLR_R11        0x7d6802a6
9050 #define STD_R11_0R1     0xf9610000
9051 #define BCTRL           0x4e800421
9052 #define LD_R11_0R1      0xe9610000
9053 #define LD_R2_0R1       0xe8410000
9054 #define MTLR_R11        0x7d6803a6
9055
9056 static inline bfd_byte *
9057 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9058                          Elf_Internal_Rela *r)
9059 {
9060   bfd_put_32 (obfd, LD_R11_0R3 + 0, p),         p += 4;
9061   bfd_put_32 (obfd, LD_R12_0R3 + 8, p),         p += 4;
9062   bfd_put_32 (obfd, MR_R0_R3, p),               p += 4;
9063   bfd_put_32 (obfd, CMPDI_R11_0, p),            p += 4;
9064   bfd_put_32 (obfd, ADD_R3_R12_R13, p),         p += 4;
9065   bfd_put_32 (obfd, BEQLR, p),                  p += 4;
9066   bfd_put_32 (obfd, MR_R3_R0, p),               p += 4;
9067   bfd_put_32 (obfd, MFLR_R11, p),               p += 4;
9068   bfd_put_32 (obfd, STD_R11_0R1 + 32, p),       p += 4;
9069
9070   if (r != NULL)
9071     r[0].r_offset += 9 * 4;
9072   p = build_plt_stub (obfd, p, offset, r);
9073   bfd_put_32 (obfd, BCTRL, p - 4);
9074
9075   bfd_put_32 (obfd, LD_R11_0R1 + 32, p),        p += 4;
9076   bfd_put_32 (obfd, LD_R2_0R1 + 40, p),         p += 4;
9077   bfd_put_32 (obfd, MTLR_R11, p),               p += 4;
9078   bfd_put_32 (obfd, BLR, p),                    p += 4;
9079
9080   return p;
9081 }
9082
9083 static Elf_Internal_Rela *
9084 get_relocs (asection *sec, int count)
9085 {
9086   Elf_Internal_Rela *relocs;
9087   struct bfd_elf_section_data *elfsec_data;
9088
9089   elfsec_data = elf_section_data (sec);
9090   relocs = elfsec_data->relocs;
9091   if (relocs == NULL)
9092     {
9093       bfd_size_type relsize;
9094       relsize = sec->reloc_count * sizeof (*relocs);
9095       relocs = bfd_alloc (sec->owner, relsize);
9096       if (relocs == NULL)
9097         return NULL;
9098       elfsec_data->relocs = relocs;
9099       elfsec_data->rel_hdr.sh_size = (sec->reloc_count
9100                                       * sizeof (Elf64_External_Rela));
9101       elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
9102       sec->reloc_count = 0;
9103     }
9104   relocs += sec->reloc_count;
9105   sec->reloc_count += count;
9106   return relocs;
9107 }
9108
9109 static bfd_boolean
9110 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9111 {
9112   struct ppc_stub_hash_entry *stub_entry;
9113   struct ppc_branch_hash_entry *br_entry;
9114   struct bfd_link_info *info;
9115   struct ppc_link_hash_table *htab;
9116   bfd_byte *loc;
9117   bfd_byte *p;
9118   bfd_vma dest, off;
9119   int size;
9120   Elf_Internal_Rela *r;
9121   asection *plt;
9122
9123   /* Massage our args to the form they really have.  */
9124   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9125   info = in_arg;
9126
9127   htab = ppc_hash_table (info);
9128   if (htab == NULL)
9129     return FALSE;
9130
9131   /* Make a note of the offset within the stubs for this entry.  */
9132   stub_entry->stub_offset = stub_entry->stub_sec->size;
9133   loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9134
9135   htab->stub_count[stub_entry->stub_type - 1] += 1;
9136   switch (stub_entry->stub_type)
9137     {
9138     case ppc_stub_long_branch:
9139     case ppc_stub_long_branch_r2off:
9140       /* Branches are relative.  This is where we are going to.  */
9141       off = dest = (stub_entry->target_value
9142                     + stub_entry->target_section->output_offset
9143                     + stub_entry->target_section->output_section->vma);
9144
9145       /* And this is where we are coming from.  */
9146       off -= (stub_entry->stub_offset
9147               + stub_entry->stub_sec->output_offset
9148               + stub_entry->stub_sec->output_section->vma);
9149
9150       size = 4;
9151       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9152         {
9153           bfd_vma r2off;
9154
9155           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9156                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9157           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9158           loc += 4;
9159           size = 12;
9160           if (PPC_HA (r2off) != 0)
9161             {
9162               size = 16;
9163               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9164               loc += 4;
9165             }
9166           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9167           loc += 4;
9168           off -= size - 4;
9169         }
9170       bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9171
9172       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9173         {
9174           (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9175                                  stub_entry->root.string);
9176           htab->stub_error = TRUE;
9177           return FALSE;
9178         }
9179
9180       if (info->emitrelocations)
9181         {
9182           r = get_relocs (stub_entry->stub_sec, 1);
9183           if (r == NULL)
9184             return FALSE;
9185           r->r_offset = loc - stub_entry->stub_sec->contents;
9186           r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9187           r->r_addend = dest;
9188           if (stub_entry->h != NULL)
9189             {
9190               struct elf_link_hash_entry **hashes;
9191               unsigned long symndx;
9192               struct ppc_link_hash_entry *h;
9193
9194               hashes = elf_sym_hashes (htab->stub_bfd);
9195               if (hashes == NULL)
9196                 {
9197                   bfd_size_type hsize;
9198
9199                   hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9200                   hashes = bfd_zalloc (htab->stub_bfd, hsize);
9201                   if (hashes == NULL)
9202                     return FALSE;
9203                   elf_sym_hashes (htab->stub_bfd) = hashes;
9204                   htab->stub_globals = 1;
9205                 }
9206               symndx = htab->stub_globals++;
9207               h = stub_entry->h;
9208               hashes[symndx] = &h->elf;
9209               r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9210               if (h->oh != NULL && h->oh->is_func)
9211                 h = ppc_follow_link (h->oh);
9212               if (h->elf.root.u.def.section != stub_entry->target_section)
9213                 /* H is an opd symbol.  The addend must be zero.  */
9214                 r->r_addend = 0;
9215               else
9216                 {
9217                   off = (h->elf.root.u.def.value
9218                          + h->elf.root.u.def.section->output_offset
9219                          + h->elf.root.u.def.section->output_section->vma);
9220                   r->r_addend -= off;
9221                 }
9222             }
9223         }
9224       break;
9225
9226     case ppc_stub_plt_branch:
9227     case ppc_stub_plt_branch_r2off:
9228       br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9229                                          stub_entry->root.string + 9,
9230                                          FALSE, FALSE);
9231       if (br_entry == NULL)
9232         {
9233           (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9234                                  stub_entry->root.string);
9235           htab->stub_error = TRUE;
9236           return FALSE;
9237         }
9238
9239       dest = (stub_entry->target_value
9240               + stub_entry->target_section->output_offset
9241               + stub_entry->target_section->output_section->vma);
9242
9243       bfd_put_64 (htab->brlt->owner, dest,
9244                   htab->brlt->contents + br_entry->offset);
9245
9246       if (br_entry->iter == htab->stub_iteration)
9247         {
9248           br_entry->iter = 0;
9249
9250           if (htab->relbrlt != NULL)
9251             {
9252               /* Create a reloc for the branch lookup table entry.  */
9253               Elf_Internal_Rela rela;
9254               bfd_byte *rl;
9255
9256               rela.r_offset = (br_entry->offset
9257                                + htab->brlt->output_offset
9258                                + htab->brlt->output_section->vma);
9259               rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9260               rela.r_addend = dest;
9261
9262               rl = htab->relbrlt->contents;
9263               rl += (htab->relbrlt->reloc_count++
9264                      * sizeof (Elf64_External_Rela));
9265               bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9266             }
9267           else if (info->emitrelocations)
9268             {
9269               r = get_relocs (htab->brlt, 1);
9270               if (r == NULL)
9271                 return FALSE;
9272               /* brlt, being SEC_LINKER_CREATED does not go through the
9273                  normal reloc processing.  Symbols and offsets are not
9274                  translated from input file to output file form, so
9275                  set up the offset per the output file.  */
9276               r->r_offset = (br_entry->offset
9277                              + htab->brlt->output_offset
9278                              + htab->brlt->output_section->vma);
9279               r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9280               r->r_addend = dest;
9281             }
9282         }
9283
9284       dest = (br_entry->offset
9285               + htab->brlt->output_offset
9286               + htab->brlt->output_section->vma);
9287
9288       off = (dest
9289              - elf_gp (htab->brlt->output_section->owner)
9290              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9291
9292       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9293         {
9294           (*_bfd_error_handler)
9295             (_("linkage table error against `%s'"),
9296              stub_entry->root.string);
9297           bfd_set_error (bfd_error_bad_value);
9298           htab->stub_error = TRUE;
9299           return FALSE;
9300         }
9301
9302       if (info->emitrelocations)
9303         {
9304           r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9305           if (r == NULL)
9306             return FALSE;
9307           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9308           if (bfd_big_endian (info->output_bfd))
9309             r[0].r_offset += 2;
9310           if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9311             r[0].r_offset += 4;
9312           r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9313           r[0].r_addend = dest;
9314           if (PPC_HA (off) != 0)
9315             {
9316               r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9317               r[1].r_offset = r[0].r_offset + 4;
9318               r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9319               r[1].r_addend = r[0].r_addend;
9320             }
9321         }
9322
9323       if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9324         {
9325           if (PPC_HA (off) != 0)
9326             {
9327               size = 16;
9328               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9329               loc += 4;
9330               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9331             }
9332           else
9333             {
9334               size = 12;
9335               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9336             }
9337         }
9338       else
9339         {
9340           bfd_vma r2off;
9341
9342           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9343                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9344           bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9345           loc += 4;
9346           size = 20;
9347           if (PPC_HA (off) != 0)
9348             {
9349               size += 4;
9350               bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9351               loc += 4;
9352               bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9353               loc += 4;
9354             }
9355           else
9356             {
9357               bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9358               loc += 4;
9359             }
9360
9361           if (PPC_HA (r2off) != 0)
9362             {
9363               size += 4;
9364               bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9365               loc += 4;
9366             }
9367           bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9368         }
9369       loc += 4;
9370       bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9371       loc += 4;
9372       bfd_put_32 (htab->stub_bfd, BCTR, loc);
9373       break;
9374
9375     case ppc_stub_plt_call:
9376       if (stub_entry->h != NULL
9377           && stub_entry->h->is_func_descriptor
9378           && stub_entry->h->oh != NULL)
9379         {
9380           struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9381
9382           /* If the old-ABI "dot-symbol" is undefined make it weak so
9383              we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9384              FIXME: We used to define the symbol on one of the call
9385              stubs instead, which is why we test symbol section id
9386              against htab->top_id in various places.  Likely all
9387              these checks could now disappear.  */
9388           if (fh->elf.root.type == bfd_link_hash_undefined)
9389             fh->elf.root.type = bfd_link_hash_undefweak;
9390         }
9391
9392       /* Now build the stub.  */
9393       dest = stub_entry->plt_ent->plt.offset & ~1;
9394       if (dest >= (bfd_vma) -2)
9395         abort ();
9396
9397       plt = htab->plt;
9398       if (!htab->elf.dynamic_sections_created
9399           || stub_entry->h == NULL
9400           || stub_entry->h->elf.dynindx == -1)
9401         plt = htab->iplt;
9402
9403       dest += plt->output_offset + plt->output_section->vma;
9404
9405       if (stub_entry->h == NULL
9406           && (stub_entry->plt_ent->plt.offset & 1) == 0)
9407         {
9408           Elf_Internal_Rela rela;
9409           bfd_byte *rl;
9410
9411           rela.r_offset = dest;
9412           rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9413           rela.r_addend = (stub_entry->target_value
9414                            + stub_entry->target_section->output_offset
9415                            + stub_entry->target_section->output_section->vma);
9416
9417           rl = (htab->reliplt->contents
9418                 + (htab->reliplt->reloc_count++
9419                    * sizeof (Elf64_External_Rela)));
9420           bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9421           stub_entry->plt_ent->plt.offset |= 1;
9422         }
9423
9424       off = (dest
9425              - elf_gp (plt->output_section->owner)
9426              - htab->stub_group[stub_entry->id_sec->id].toc_off);
9427
9428       if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9429         {
9430           (*_bfd_error_handler)
9431             (_("linkage table error against `%s'"),
9432              stub_entry->h != NULL
9433              ? stub_entry->h->elf.root.root.string
9434              : "<local sym>");
9435           bfd_set_error (bfd_error_bad_value);
9436           htab->stub_error = TRUE;
9437           return FALSE;
9438         }
9439
9440       r = NULL;
9441       if (info->emitrelocations)
9442         {
9443           r = get_relocs (stub_entry->stub_sec,
9444                           (2 + (PPC_HA (off) != 0)
9445                            + (PPC_HA (off + 16) == PPC_HA (off))));
9446           if (r == NULL)
9447             return FALSE;
9448           r[0].r_offset = loc - stub_entry->stub_sec->contents;
9449           if (bfd_big_endian (info->output_bfd))
9450             r[0].r_offset += 2;
9451           r[0].r_addend = dest;
9452         }
9453       if (stub_entry->h != NULL
9454           && (stub_entry->h == htab->tls_get_addr_fd
9455               || stub_entry->h == htab->tls_get_addr)
9456           && !htab->no_tls_get_addr_opt)
9457         p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9458       else
9459         p = build_plt_stub (htab->stub_bfd, loc, off, r);
9460       size = p - loc;
9461       break;
9462
9463     default:
9464       BFD_FAIL ();
9465       return FALSE;
9466     }
9467
9468   stub_entry->stub_sec->size += size;
9469
9470   if (htab->emit_stub_syms)
9471     {
9472       struct elf_link_hash_entry *h;
9473       size_t len1, len2;
9474       char *name;
9475       const char *const stub_str[] = { "long_branch",
9476                                        "long_branch_r2off",
9477                                        "plt_branch",
9478                                        "plt_branch_r2off",
9479                                        "plt_call" };
9480
9481       len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9482       len2 = strlen (stub_entry->root.string);
9483       name = bfd_malloc (len1 + len2 + 2);
9484       if (name == NULL)
9485         return FALSE;
9486       memcpy (name, stub_entry->root.string, 9);
9487       memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9488       memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9489       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9490       if (h == NULL)
9491         return FALSE;
9492       if (h->root.type == bfd_link_hash_new)
9493         {
9494           h->root.type = bfd_link_hash_defined;
9495           h->root.u.def.section = stub_entry->stub_sec;
9496           h->root.u.def.value = stub_entry->stub_offset;
9497           h->ref_regular = 1;
9498           h->def_regular = 1;
9499           h->ref_regular_nonweak = 1;
9500           h->forced_local = 1;
9501           h->non_elf = 0;
9502         }
9503     }
9504
9505   return TRUE;
9506 }
9507
9508 /* As above, but don't actually build the stub.  Just bump offset so
9509    we know stub section sizes, and select plt_branch stubs where
9510    long_branch stubs won't do.  */
9511
9512 static bfd_boolean
9513 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9514 {
9515   struct ppc_stub_hash_entry *stub_entry;
9516   struct bfd_link_info *info;
9517   struct ppc_link_hash_table *htab;
9518   bfd_vma off;
9519   int size;
9520
9521   /* Massage our args to the form they really have.  */
9522   stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9523   info = in_arg;
9524
9525   htab = ppc_hash_table (info);
9526   if (htab == NULL)
9527     return FALSE;
9528
9529   if (stub_entry->stub_type == ppc_stub_plt_call)
9530     {
9531       asection *plt;
9532       off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9533       if (off >= (bfd_vma) -2)
9534         abort ();
9535       plt = htab->plt;
9536       if (!htab->elf.dynamic_sections_created
9537           || stub_entry->h == NULL
9538           || stub_entry->h->elf.dynindx == -1)
9539         plt = htab->iplt;
9540       off += (plt->output_offset
9541               + plt->output_section->vma
9542               - elf_gp (plt->output_section->owner)
9543               - htab->stub_group[stub_entry->id_sec->id].toc_off);
9544
9545       size = PLT_CALL_STUB_SIZE;
9546       if (PPC_HA (off) == 0)
9547         size -= 4;
9548       if (PPC_HA (off + 16) != PPC_HA (off))
9549         size += 4;
9550       if (stub_entry->h != NULL
9551           && (stub_entry->h == htab->tls_get_addr_fd
9552               || stub_entry->h == htab->tls_get_addr)
9553           && !htab->no_tls_get_addr_opt)
9554         size += 13 * 4;
9555       if (info->emitrelocations)
9556         {
9557           stub_entry->stub_sec->reloc_count
9558             += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9559           stub_entry->stub_sec->flags |= SEC_RELOC;
9560         }
9561     }
9562   else
9563     {
9564       /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9565          variants.  */
9566       bfd_vma r2off = 0;
9567
9568       off = (stub_entry->target_value
9569              + stub_entry->target_section->output_offset
9570              + stub_entry->target_section->output_section->vma);
9571       off -= (stub_entry->stub_sec->size
9572               + stub_entry->stub_sec->output_offset
9573               + stub_entry->stub_sec->output_section->vma);
9574
9575       /* Reset the stub type from the plt variant in case we now
9576          can reach with a shorter stub.  */
9577       if (stub_entry->stub_type >= ppc_stub_plt_branch)
9578         stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9579
9580       size = 4;
9581       if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9582         {
9583           r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9584                    - htab->stub_group[stub_entry->id_sec->id].toc_off);
9585           size = 12;
9586           if (PPC_HA (r2off) != 0)
9587             size = 16;
9588           off -= size - 4;
9589         }
9590
9591       /* If the branch offset if too big, use a ppc_stub_plt_branch.  */
9592       if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9593         {
9594           struct ppc_branch_hash_entry *br_entry;
9595
9596           br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9597                                              stub_entry->root.string + 9,
9598                                              TRUE, FALSE);
9599           if (br_entry == NULL)
9600             {
9601               (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9602                                      stub_entry->root.string);
9603               htab->stub_error = TRUE;
9604               return FALSE;
9605             }
9606
9607           if (br_entry->iter != htab->stub_iteration)
9608             {
9609               br_entry->iter = htab->stub_iteration;
9610               br_entry->offset = htab->brlt->size;
9611               htab->brlt->size += 8;
9612
9613               if (htab->relbrlt != NULL)
9614                 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9615               else if (info->emitrelocations)
9616                 {
9617                   htab->brlt->reloc_count += 1;
9618                   htab->brlt->flags |= SEC_RELOC;
9619                 }
9620             }
9621
9622           stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9623           off = (br_entry->offset
9624                  + htab->brlt->output_offset
9625                  + htab->brlt->output_section->vma
9626                  - elf_gp (htab->brlt->output_section->owner)
9627                  - htab->stub_group[stub_entry->id_sec->id].toc_off);
9628
9629           if (info->emitrelocations)
9630             {
9631               stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9632               stub_entry->stub_sec->flags |= SEC_RELOC;
9633             }
9634
9635           if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9636             {
9637               size = 12;
9638               if (PPC_HA (off) != 0)
9639                 size = 16;
9640             }
9641           else
9642             {
9643               size = 20;
9644               if (PPC_HA (off) != 0)
9645                 size += 4;
9646
9647               if (PPC_HA (r2off) != 0)
9648                 size += 4;
9649             }
9650         }
9651       else if (info->emitrelocations)
9652         {
9653           stub_entry->stub_sec->reloc_count += 1;
9654           stub_entry->stub_sec->flags |= SEC_RELOC;
9655         }
9656     }
9657
9658   stub_entry->stub_sec->size += size;
9659   return TRUE;
9660 }
9661
9662 /* Set up various things so that we can make a list of input sections
9663    for each output section included in the link.  Returns -1 on error,
9664    0 when no stubs will be needed, and 1 on success.  */
9665
9666 int
9667 ppc64_elf_setup_section_lists
9668   (struct bfd_link_info *info,
9669    asection *(*add_stub_section) (const char *, asection *),
9670    void (*layout_sections_again) (void))
9671 {
9672   bfd *input_bfd;
9673   int top_id, top_index, id;
9674   asection *section;
9675   asection **input_list;
9676   bfd_size_type amt;
9677   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9678
9679   if (htab == NULL)
9680     return -1;
9681   /* Stash our params away.  */
9682   htab->add_stub_section = add_stub_section;
9683   htab->layout_sections_again = layout_sections_again;
9684
9685   if (htab->brlt == NULL)
9686     return 0;
9687
9688   /* Find the top input section id.  */
9689   for (input_bfd = info->input_bfds, top_id = 3;
9690        input_bfd != NULL;
9691        input_bfd = input_bfd->link_next)
9692     {
9693       for (section = input_bfd->sections;
9694            section != NULL;
9695            section = section->next)
9696         {
9697           if (top_id < section->id)
9698             top_id = section->id;
9699         }
9700     }
9701
9702   htab->top_id = top_id;
9703   amt = sizeof (struct map_stub) * (top_id + 1);
9704   htab->stub_group = bfd_zmalloc (amt);
9705   if (htab->stub_group == NULL)
9706     return -1;
9707
9708   /* Set toc_off for com, und, abs and ind sections.  */
9709   for (id = 0; id < 3; id++)
9710     htab->stub_group[id].toc_off = TOC_BASE_OFF;
9711
9712   /* We can't use output_bfd->section_count here to find the top output
9713      section index as some sections may have been removed, and
9714      strip_excluded_output_sections doesn't renumber the indices.  */
9715   for (section = info->output_bfd->sections, top_index = 0;
9716        section != NULL;
9717        section = section->next)
9718     {
9719       if (top_index < section->index)
9720         top_index = section->index;
9721     }
9722
9723   htab->top_index = top_index;
9724   amt = sizeof (asection *) * (top_index + 1);
9725   input_list = bfd_zmalloc (amt);
9726   htab->input_list = input_list;
9727   if (input_list == NULL)
9728     return -1;
9729
9730   return 1;
9731 }
9732
9733 /* Set up for first pass at multitoc partitioning.  */
9734
9735 void
9736 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
9737 {
9738   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9739
9740   elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
9741   htab->toc_curr = elf_gp (info->output_bfd);
9742   htab->toc_bfd = NULL;
9743   htab->toc_first_sec = NULL;
9744 }
9745
9746 /* The linker repeatedly calls this function for each TOC input section
9747    and linker generated GOT section.  Group input bfds such that the toc
9748    within a group is less than 64k in size.  */
9749
9750 bfd_boolean
9751 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9752 {
9753   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9754   bfd_vma addr, off;
9755
9756   if (htab == NULL)
9757     return FALSE;
9758
9759   if (!htab->second_toc_pass)
9760     {
9761       /* Keep track of the first .toc or .got section for this input bfd.  */
9762       if (htab->toc_bfd != isec->owner)
9763         {
9764           htab->toc_bfd = isec->owner;
9765           htab->toc_first_sec = isec;
9766         }
9767
9768       addr = isec->output_offset + isec->output_section->vma;
9769       off = addr - htab->toc_curr;
9770       if (off + isec->size > 0x10000)
9771         {
9772           addr = (htab->toc_first_sec->output_offset
9773                   + htab->toc_first_sec->output_section->vma);
9774           htab->toc_curr = addr;
9775         }
9776
9777       /* toc_curr is the base address of this toc group.  Set elf_gp
9778          for the input section to be the offset relative to the
9779          output toc base plus 0x8000.  Making the input elf_gp an
9780          offset allows us to move the toc as a whole without
9781          recalculating input elf_gp.  */
9782       off = htab->toc_curr - elf_gp (isec->output_section->owner);
9783       off += TOC_BASE_OFF;
9784
9785       /* Die if someone uses a linker script that doesn't keep input
9786          file .toc and .got together.  */
9787       if (elf_gp (isec->owner) != 0
9788           && elf_gp (isec->owner) != off)
9789         return FALSE;
9790
9791       elf_gp (isec->owner) = off;
9792       return TRUE;
9793     }
9794
9795   /* During the second pass toc_first_sec points to the start of
9796      a toc group, and toc_curr is used to track the old elf_gp.
9797      We use toc_bfd to ensure we only look at each bfd once.  */
9798   if (htab->toc_bfd == isec->owner)
9799     return TRUE;
9800   htab->toc_bfd = isec->owner;
9801
9802   if (htab->toc_first_sec == NULL
9803       || htab->toc_curr != elf_gp (isec->owner))
9804     {
9805       htab->toc_curr = elf_gp (isec->owner);
9806       htab->toc_first_sec = isec;
9807     }
9808   addr = (htab->toc_first_sec->output_offset
9809           + htab->toc_first_sec->output_section->vma);
9810   off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
9811   elf_gp (isec->owner) = off;
9812
9813   return TRUE;
9814 }
9815
9816 /* This function removes unneeded got entries (those with got.offset == -1)
9817    and merges entries in the same toc group.  */
9818
9819 static void
9820 merge_got_entries (struct got_entry **pent)
9821 {
9822   struct got_entry *ent, *ent2;
9823
9824   while ((ent = *pent) != NULL)
9825     {
9826       if (!ent->is_indirect)
9827         {
9828           if (ent->got.offset == (bfd_vma) -1)
9829             {
9830               *pent = ent->next;
9831               continue;
9832             }
9833           for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9834             if (!ent2->is_indirect
9835                 && ent2->got.offset != (bfd_vma) -1
9836                 && ent2->addend == ent->addend
9837                 && ent2->tls_type == ent->tls_type
9838                 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9839               {
9840                 ent2->is_indirect = TRUE;
9841                 ent2->got.ent = ent;
9842               }
9843         }
9844       pent = &ent->next;
9845     }
9846 }
9847
9848 /* Called via elf_link_hash_traverse to merge GOT entries for global
9849    symbol H.  */
9850
9851 static bfd_boolean
9852 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9853 {
9854   if (h->root.type == bfd_link_hash_indirect)
9855     return TRUE;
9856
9857   if (h->root.type == bfd_link_hash_warning)
9858     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9859
9860   merge_got_entries (&h->got.glist);
9861
9862   return TRUE;
9863 }
9864
9865 /* Called via elf_link_hash_traverse to allocate GOT entries for global
9866    symbol H.  */
9867
9868 static bfd_boolean
9869 reallocate_got (struct elf_link_hash_entry *h, void *inf)
9870 {
9871   struct got_entry *gent;
9872
9873   if (h->root.type == bfd_link_hash_indirect)
9874     return TRUE;
9875
9876   if (h->root.type == bfd_link_hash_warning)
9877     h = (struct elf_link_hash_entry *) h->root.u.i.link;
9878
9879   for (gent = h->got.glist; gent != NULL; gent = gent->next)
9880     if (!gent->is_indirect)
9881       allocate_got (h, (struct bfd_link_info *) inf, gent);
9882   return TRUE;
9883 }
9884
9885 /* Called on the first multitoc pass after the last call to
9886    ppc64_elf_next_toc_section.  This function removes duplicate GOT
9887    entries.  */
9888
9889 bfd_boolean
9890 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
9891 {
9892   struct ppc_link_hash_table *htab = ppc_hash_table (info);
9893   struct bfd *ibfd, *ibfd2;
9894   bfd_boolean done_something;
9895
9896   htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
9897
9898   /* Merge local got entries within a toc group.  */
9899   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9900     {
9901       struct got_entry **lgot_ents;
9902       struct got_entry **end_lgot_ents;
9903       Elf_Internal_Shdr *symtab_hdr;
9904       bfd_size_type locsymcount;
9905
9906       if (!is_ppc64_elf (ibfd))
9907         continue;
9908
9909       lgot_ents = elf_local_got_ents (ibfd);
9910       if (!lgot_ents)
9911         continue;
9912
9913       symtab_hdr = &elf_symtab_hdr (ibfd);
9914       locsymcount = symtab_hdr->sh_info;
9915       end_lgot_ents = lgot_ents + locsymcount;
9916
9917       for (; lgot_ents < end_lgot_ents; ++lgot_ents)
9918         merge_got_entries (lgot_ents);
9919     }
9920
9921   /* And the same for global sym got entries.  */
9922   elf_link_hash_traverse (&htab->elf, merge_global_got, info);
9923
9924   /* And tlsld_got.  */
9925   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9926     {
9927       struct got_entry *ent, *ent2;
9928
9929       if (!is_ppc64_elf (ibfd))
9930         continue;
9931
9932       ent = ppc64_tlsld_got (ibfd);
9933       if (!ent->is_indirect
9934           && ent->got.offset != (bfd_vma) -1)
9935         {
9936           for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
9937             {
9938               if (!is_ppc64_elf (ibfd2))
9939                 continue;
9940
9941               ent2 = ppc64_tlsld_got (ibfd2);
9942               if (!ent2->is_indirect
9943                   && ent2->got.offset != (bfd_vma) -1
9944                   && elf_gp (ibfd2) == elf_gp (ibfd))
9945                 {
9946                   ent2->is_indirect = TRUE;
9947                   ent2->got.ent = ent;
9948                 }
9949             }
9950         }
9951     }
9952
9953   /* Zap sizes of got sections.  */
9954   htab->reliplt->rawsize = htab->reliplt->size;
9955   htab->reliplt->size -= htab->got_reli_size;
9956   htab->got_reli_size = 0;
9957
9958   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9959     {
9960       asection *got, *relgot;
9961
9962       if (!is_ppc64_elf (ibfd))
9963         continue;
9964
9965       got = ppc64_elf_tdata (ibfd)->got;
9966       if (got != NULL)
9967         {
9968           got->rawsize = got->size;
9969           got->size = 0;
9970           relgot = ppc64_elf_tdata (ibfd)->relgot;
9971           relgot->rawsize = relgot->size;
9972           relgot->size = 0;
9973         }
9974     }
9975
9976   /* Now reallocate the got, local syms first.  We don't need to
9977      allocate section contents again since we never increase size.  */
9978   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9979     {
9980       struct got_entry **lgot_ents;
9981       struct got_entry **end_lgot_ents;
9982       struct plt_entry **local_plt;
9983       struct plt_entry **end_local_plt;
9984       char *lgot_masks;
9985       bfd_size_type locsymcount;
9986       Elf_Internal_Shdr *symtab_hdr;
9987       asection *s, *srel;
9988
9989       if (!is_ppc64_elf (ibfd))
9990         continue;
9991
9992       lgot_ents = elf_local_got_ents (ibfd);
9993       if (!lgot_ents)
9994         continue;
9995
9996       symtab_hdr = &elf_symtab_hdr (ibfd);
9997       locsymcount = symtab_hdr->sh_info;
9998       end_lgot_ents = lgot_ents + locsymcount;
9999       local_plt = (struct plt_entry **) end_lgot_ents;
10000       end_local_plt = local_plt + locsymcount;
10001       lgot_masks = (char *) end_local_plt;
10002       s = ppc64_elf_tdata (ibfd)->got;
10003       srel = ppc64_elf_tdata (ibfd)->relgot;
10004       for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10005         {
10006           struct got_entry *ent;
10007
10008           for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10009             if (!ent->is_indirect)
10010               {
10011                 unsigned int num = 1;
10012                 ent->got.offset = s->size;
10013                 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10014                   num = 2;
10015                 s->size += num * 8;
10016                 if (info->shared)
10017                   srel->size += num * sizeof (Elf64_External_Rela);
10018                 else if ((*lgot_masks & PLT_IFUNC) != 0)
10019                   {
10020                     htab->reliplt->size
10021                       += num * sizeof (Elf64_External_Rela);
10022                     htab->got_reli_size
10023                       += num * sizeof (Elf64_External_Rela);
10024                   }
10025               }
10026         }
10027     }
10028
10029   elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10030
10031   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10032     {
10033       struct got_entry *ent;
10034
10035       if (!is_ppc64_elf (ibfd))
10036         continue;
10037
10038       ent = ppc64_tlsld_got (ibfd);
10039       if (!ent->is_indirect
10040           && ent->got.offset != (bfd_vma) -1)
10041         {
10042           asection *s = ppc64_elf_tdata (ibfd)->got;
10043           ent->got.offset = s->size;
10044           s->size += 16;
10045           if (info->shared)
10046             {
10047               asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10048               srel->size += sizeof (Elf64_External_Rela);
10049             }
10050         }
10051     }
10052
10053   done_something = htab->reliplt->rawsize != htab->reliplt->size;
10054   if (!done_something)
10055     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10056       {
10057         asection *got;
10058
10059         if (!is_ppc64_elf (ibfd))
10060           continue;
10061
10062         got = ppc64_elf_tdata (ibfd)->got;
10063         if (got != NULL)
10064           {
10065             done_something = got->rawsize != got->size;
10066             if (done_something)
10067               break;
10068           }
10069       }
10070
10071   if (done_something)
10072     (*htab->layout_sections_again) ();
10073
10074   /* Set up for second pass over toc sections to recalculate elf_gp
10075      on input sections.  */
10076   htab->toc_bfd = NULL;
10077   htab->toc_first_sec = NULL;
10078   htab->second_toc_pass = TRUE;
10079   return done_something;
10080 }
10081
10082 /* Called after second pass of multitoc partitioning.  */
10083
10084 void
10085 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10086 {
10087   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10088
10089   if (htab == NULL)
10090     return;
10091
10092   /* After the second pass, toc_curr tracks the TOC offset used
10093      for code sections below in ppc64_elf_next_input_section.  */
10094   htab->toc_curr = TOC_BASE_OFF;
10095 }
10096
10097 /* No toc references were found in ISEC.  If the code in ISEC makes no
10098    calls, then there's no need to use toc adjusting stubs when branching
10099    into ISEC.  Actually, indirect calls from ISEC are OK as they will
10100    load r2.  Returns -1 on error, 0 for no stub needed, 1 for stub
10101    needed, and 2 if a cyclical call-graph was found but no other reason
10102    for a stub was detected.  If called from the top level, a return of
10103    2 means the same as a return of 0.  */
10104
10105 static int
10106 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10107 {
10108   Elf_Internal_Rela *relstart, *rel;
10109   Elf_Internal_Sym *local_syms;
10110   int ret;
10111   struct ppc_link_hash_table *htab;
10112
10113   /* We know none of our code bearing sections will need toc stubs.  */
10114   if ((isec->flags & SEC_LINKER_CREATED) != 0)
10115     return 0;
10116
10117   if (isec->size == 0)
10118     return 0;
10119
10120   if (isec->output_section == NULL)
10121     return 0;
10122
10123   if (isec->reloc_count == 0)
10124     return 0;
10125
10126   relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10127                                         info->keep_memory);
10128   if (relstart == NULL)
10129     return -1;
10130
10131   /* Look for branches to outside of this section.  */
10132   local_syms = NULL;
10133   ret = 0;
10134   htab = ppc_hash_table (info);
10135   if (htab == NULL)
10136     return -1;
10137
10138   for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10139     {
10140       enum elf_ppc64_reloc_type r_type;
10141       unsigned long r_symndx;
10142       struct elf_link_hash_entry *h;
10143       struct ppc_link_hash_entry *eh;
10144       Elf_Internal_Sym *sym;
10145       asection *sym_sec;
10146       struct _opd_sec_data *opd;
10147       bfd_vma sym_value;
10148       bfd_vma dest;
10149
10150       r_type = ELF64_R_TYPE (rel->r_info);
10151       if (r_type != R_PPC64_REL24
10152           && r_type != R_PPC64_REL14
10153           && r_type != R_PPC64_REL14_BRTAKEN
10154           && r_type != R_PPC64_REL14_BRNTAKEN)
10155         continue;
10156
10157       r_symndx = ELF64_R_SYM (rel->r_info);
10158       if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10159                       isec->owner))
10160         {
10161           ret = -1;
10162           break;
10163         }
10164
10165       /* Calls to dynamic lib functions go through a plt call stub
10166          that uses r2.  */
10167       eh = (struct ppc_link_hash_entry *) h;
10168       if (eh != NULL
10169           && (eh->elf.plt.plist != NULL
10170               || (eh->oh != NULL
10171                   && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10172         {
10173           ret = 1;
10174           break;
10175         }
10176
10177       if (sym_sec == NULL)
10178         /* Ignore other undefined symbols.  */
10179         continue;
10180
10181       /* Assume branches to other sections not included in the link need
10182          stubs too, to cover -R and absolute syms.  */
10183       if (sym_sec->output_section == NULL)
10184         {
10185           ret = 1;
10186           break;
10187         }
10188
10189       if (h == NULL)
10190         sym_value = sym->st_value;
10191       else
10192         {
10193           if (h->root.type != bfd_link_hash_defined
10194               && h->root.type != bfd_link_hash_defweak)
10195             abort ();
10196           sym_value = h->root.u.def.value;
10197         }
10198       sym_value += rel->r_addend;
10199
10200       /* If this branch reloc uses an opd sym, find the code section.  */
10201       opd = get_opd_info (sym_sec);
10202       if (opd != NULL)
10203         {
10204           if (h == NULL && opd->adjust != NULL)
10205             {
10206               long adjust;
10207
10208               adjust = opd->adjust[sym->st_value / 8];
10209               if (adjust == -1)
10210                 /* Assume deleted functions won't ever be called.  */
10211                 continue;
10212               sym_value += adjust;
10213             }
10214
10215           dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10216           if (dest == (bfd_vma) -1)
10217             continue;
10218         }
10219       else
10220         dest = (sym_value
10221                 + sym_sec->output_offset
10222                 + sym_sec->output_section->vma);
10223
10224       /* Ignore branch to self.  */
10225       if (sym_sec == isec)
10226         continue;
10227
10228       /* If the called function uses the toc, we need a stub.  */
10229       if (sym_sec->has_toc_reloc
10230           || sym_sec->makes_toc_func_call)
10231         {
10232           ret = 1;
10233           break;
10234         }
10235
10236       /* Assume any branch that needs a long branch stub might in fact
10237          need a plt_branch stub.  A plt_branch stub uses r2.  */
10238       else if (dest - (isec->output_offset
10239                        + isec->output_section->vma
10240                        + rel->r_offset) + (1 << 25) >= (2 << 25))
10241         {
10242           ret = 1;
10243           break;
10244         }
10245
10246       /* If calling back to a section in the process of being tested, we
10247          can't say for sure that no toc adjusting stubs are needed, so
10248          don't return zero.  */
10249       else if (sym_sec->call_check_in_progress)
10250         ret = 2;
10251
10252       /* Branches to another section that itself doesn't have any TOC
10253          references are OK.  Recursively call ourselves to check.  */
10254       else if (sym_sec->id <= htab->top_id
10255                && htab->stub_group[sym_sec->id].toc_off == 0)
10256         {
10257           int recur;
10258
10259           /* Mark current section as indeterminate, so that other
10260              sections that call back to current won't be marked as
10261              known.  */
10262           isec->call_check_in_progress = 1;
10263           recur = toc_adjusting_stub_needed (info, sym_sec);
10264           isec->call_check_in_progress = 0;
10265
10266           if (recur < 0)
10267             {
10268               /* An error.  Exit.  */
10269               ret = -1;
10270               break;
10271             }
10272           else if (recur <= 1)
10273             {
10274               /* Known result.  Mark as checked and set section flag.  */
10275               htab->stub_group[sym_sec->id].toc_off = 1;
10276               if (recur != 0)
10277                 {
10278                   sym_sec->makes_toc_func_call = 1;
10279                   ret = 1;
10280                   break;
10281                 }
10282             }
10283           else
10284             {
10285               /* Unknown result.  Continue checking.  */
10286               ret = 2;
10287             }
10288         }
10289     }
10290
10291   if (local_syms != NULL
10292       && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
10293     free (local_syms);
10294   if (elf_section_data (isec)->relocs != relstart)
10295     free (relstart);
10296
10297   return ret;
10298 }
10299
10300 /* The linker repeatedly calls this function for each input section,
10301    in the order that input sections are linked into output sections.
10302    Build lists of input sections to determine groupings between which
10303    we may insert linker stubs.  */
10304
10305 bfd_boolean
10306 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10307 {
10308   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10309
10310   if (htab == NULL)
10311     return FALSE;
10312
10313   if ((isec->output_section->flags & SEC_CODE) != 0
10314       && isec->output_section->index <= htab->top_index)
10315     {
10316       asection **list = htab->input_list + isec->output_section->index;
10317       /* Steal the link_sec pointer for our list.  */
10318 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10319       /* This happens to make the list in reverse order,
10320          which is what we want.  */
10321       PREV_SEC (isec) = *list;
10322       *list = isec;
10323     }
10324
10325   if (htab->multi_toc_needed)
10326     {
10327       /* If a code section has a function that uses the TOC then we need
10328          to use the right TOC (obviously).  Also, make sure that .opd gets
10329          the correct TOC value for R_PPC64_TOC relocs that don't have or
10330          can't find their function symbol (shouldn't ever happen now).
10331          Also specially treat .fixup for the linux kernel.  .fixup
10332          contains branches, but only back to the function that hit an
10333          exception.  */
10334       if (isec->has_toc_reloc
10335           || (isec->flags & SEC_CODE) == 0
10336           || strcmp (isec->name, ".fixup") == 0)
10337         {
10338           if (elf_gp (isec->owner) != 0)
10339             htab->toc_curr = elf_gp (isec->owner);
10340         }
10341       else if (htab->stub_group[isec->id].toc_off == 0)
10342         {
10343           int ret = toc_adjusting_stub_needed (info, isec);
10344           if (ret < 0)
10345             return FALSE;
10346           else
10347             isec->makes_toc_func_call = ret & 1;
10348         }
10349     }
10350
10351   /* Functions that don't use the TOC can belong in any TOC group.
10352      Use the last TOC base.  This happens to make _init and _fini
10353      pasting work.  */
10354   htab->stub_group[isec->id].toc_off = htab->toc_curr;
10355   return TRUE;
10356 }
10357
10358 /* See whether we can group stub sections together.  Grouping stub
10359    sections may result in fewer stubs.  More importantly, we need to
10360    put all .init* and .fini* stubs at the beginning of the .init or
10361    .fini output sections respectively, because glibc splits the
10362    _init and _fini functions into multiple parts.  Putting a stub in
10363    the middle of a function is not a good idea.  */
10364
10365 static void
10366 group_sections (struct ppc_link_hash_table *htab,
10367                 bfd_size_type stub_group_size,
10368                 bfd_boolean stubs_always_before_branch)
10369 {
10370   asection **list;
10371   bfd_size_type stub14_group_size;
10372   bfd_boolean suppress_size_errors;
10373
10374   suppress_size_errors = FALSE;
10375   stub14_group_size = stub_group_size;
10376   if (stub_group_size == 1)
10377     {
10378       /* Default values.  */
10379       if (stubs_always_before_branch)
10380         {
10381           stub_group_size = 0x1e00000;
10382           stub14_group_size = 0x7800;
10383         }
10384       else
10385         {
10386           stub_group_size = 0x1c00000;
10387           stub14_group_size = 0x7000;
10388         }
10389       suppress_size_errors = TRUE;
10390     }
10391
10392   list = htab->input_list + htab->top_index;
10393   do
10394     {
10395       asection *tail = *list;
10396       while (tail != NULL)
10397         {
10398           asection *curr;
10399           asection *prev;
10400           bfd_size_type total;
10401           bfd_boolean big_sec;
10402           bfd_vma curr_toc;
10403
10404           curr = tail;
10405           total = tail->size;
10406           big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
10407                              ? stub14_group_size : stub_group_size);
10408           if (big_sec && !suppress_size_errors)
10409             (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10410                                      tail->owner, tail);
10411           curr_toc = htab->stub_group[tail->id].toc_off;
10412
10413           while ((prev = PREV_SEC (curr)) != NULL
10414                  && ((total += curr->output_offset - prev->output_offset)
10415                      < (ppc64_elf_section_data (prev)->has_14bit_branch
10416                         ? stub14_group_size : stub_group_size))
10417                  && htab->stub_group[prev->id].toc_off == curr_toc)
10418             curr = prev;
10419
10420           /* OK, the size from the start of CURR to the end is less
10421              than stub_group_size and thus can be handled by one stub
10422              section.  (or the tail section is itself larger than
10423              stub_group_size, in which case we may be toast.)  We
10424              should really be keeping track of the total size of stubs
10425              added here, as stubs contribute to the final output
10426              section size.  That's a little tricky, and this way will
10427              only break if stubs added make the total size more than
10428              2^25, ie. for the default stub_group_size, if stubs total
10429              more than 2097152 bytes, or nearly 75000 plt call stubs.  */
10430           do
10431             {
10432               prev = PREV_SEC (tail);
10433               /* Set up this stub group.  */
10434               htab->stub_group[tail->id].link_sec = curr;
10435             }
10436           while (tail != curr && (tail = prev) != NULL);
10437
10438           /* But wait, there's more!  Input sections up to stub_group_size
10439              bytes before the stub section can be handled by it too.
10440              Don't do this if we have a really large section after the
10441              stubs, as adding more stubs increases the chance that
10442              branches may not reach into the stub section.  */
10443           if (!stubs_always_before_branch && !big_sec)
10444             {
10445               total = 0;
10446               while (prev != NULL
10447                      && ((total += tail->output_offset - prev->output_offset)
10448                          < (ppc64_elf_section_data (prev)->has_14bit_branch
10449                             ? stub14_group_size : stub_group_size))
10450                      && htab->stub_group[prev->id].toc_off == curr_toc)
10451                 {
10452                   tail = prev;
10453                   prev = PREV_SEC (tail);
10454                   htab->stub_group[tail->id].link_sec = curr;
10455                 }
10456             }
10457           tail = prev;
10458         }
10459     }
10460   while (list-- != htab->input_list);
10461   free (htab->input_list);
10462 #undef PREV_SEC
10463 }
10464
10465 /* Determine and set the size of the stub section for a final link.
10466
10467    The basic idea here is to examine all the relocations looking for
10468    PC-relative calls to a target that is unreachable with a "bl"
10469    instruction.  */
10470
10471 bfd_boolean
10472 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size)
10473 {
10474   bfd_size_type stub_group_size;
10475   bfd_boolean stubs_always_before_branch;
10476   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10477
10478   if (htab == NULL)
10479     return FALSE;
10480
10481   stubs_always_before_branch = group_size < 0;
10482   if (group_size < 0)
10483     stub_group_size = -group_size;
10484   else
10485     stub_group_size = group_size;
10486
10487   group_sections (htab, stub_group_size, stubs_always_before_branch);
10488
10489   while (1)
10490     {
10491       bfd *input_bfd;
10492       unsigned int bfd_indx;
10493       asection *stub_sec;
10494
10495       htab->stub_iteration += 1;
10496
10497       for (input_bfd = info->input_bfds, bfd_indx = 0;
10498            input_bfd != NULL;
10499            input_bfd = input_bfd->link_next, bfd_indx++)
10500         {
10501           Elf_Internal_Shdr *symtab_hdr;
10502           asection *section;
10503           Elf_Internal_Sym *local_syms = NULL;
10504
10505           if (!is_ppc64_elf (input_bfd))
10506             continue;
10507
10508           /* We'll need the symbol table in a second.  */
10509           symtab_hdr = &elf_symtab_hdr (input_bfd);
10510           if (symtab_hdr->sh_info == 0)
10511             continue;
10512
10513           /* Walk over each section attached to the input bfd.  */
10514           for (section = input_bfd->sections;
10515                section != NULL;
10516                section = section->next)
10517             {
10518               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10519
10520               /* If there aren't any relocs, then there's nothing more
10521                  to do.  */
10522               if ((section->flags & SEC_RELOC) == 0
10523                   || (section->flags & SEC_ALLOC) == 0
10524                   || (section->flags & SEC_LOAD) == 0
10525                   || (section->flags & SEC_CODE) == 0
10526                   || section->reloc_count == 0)
10527                 continue;
10528
10529               /* If this section is a link-once section that will be
10530                  discarded, then don't create any stubs.  */
10531               if (section->output_section == NULL
10532                   || section->output_section->owner != info->output_bfd)
10533                 continue;
10534
10535               /* Get the relocs.  */
10536               internal_relocs
10537                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10538                                              info->keep_memory);
10539               if (internal_relocs == NULL)
10540                 goto error_ret_free_local;
10541
10542               /* Now examine each relocation.  */
10543               irela = internal_relocs;
10544               irelaend = irela + section->reloc_count;
10545               for (; irela < irelaend; irela++)
10546                 {
10547                   enum elf_ppc64_reloc_type r_type;
10548                   unsigned int r_indx;
10549                   enum ppc_stub_type stub_type;
10550                   struct ppc_stub_hash_entry *stub_entry;
10551                   asection *sym_sec, *code_sec;
10552                   bfd_vma sym_value, code_value;
10553                   bfd_vma destination;
10554                   bfd_boolean ok_dest;
10555                   struct ppc_link_hash_entry *hash;
10556                   struct ppc_link_hash_entry *fdh;
10557                   struct elf_link_hash_entry *h;
10558                   Elf_Internal_Sym *sym;
10559                   char *stub_name;
10560                   const asection *id_sec;
10561                   struct _opd_sec_data *opd;
10562                   struct plt_entry *plt_ent;
10563
10564                   r_type = ELF64_R_TYPE (irela->r_info);
10565                   r_indx = ELF64_R_SYM (irela->r_info);
10566
10567                   if (r_type >= R_PPC64_max)
10568                     {
10569                       bfd_set_error (bfd_error_bad_value);
10570                       goto error_ret_free_internal;
10571                     }
10572
10573                   /* Only look for stubs on branch instructions.  */
10574                   if (r_type != R_PPC64_REL24
10575                       && r_type != R_PPC64_REL14
10576                       && r_type != R_PPC64_REL14_BRTAKEN
10577                       && r_type != R_PPC64_REL14_BRNTAKEN)
10578                     continue;
10579
10580                   /* Now determine the call target, its name, value,
10581                      section.  */
10582                   if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
10583                                   r_indx, input_bfd))
10584                     goto error_ret_free_internal;
10585                   hash = (struct ppc_link_hash_entry *) h;
10586
10587                   ok_dest = FALSE;
10588                   fdh = NULL;
10589                   sym_value = 0;
10590                   if (hash == NULL)
10591                     {
10592                       sym_value = sym->st_value;
10593                       ok_dest = TRUE;
10594                     }
10595                   else if (hash->elf.root.type == bfd_link_hash_defined
10596                            || hash->elf.root.type == bfd_link_hash_defweak)
10597                     {
10598                       sym_value = hash->elf.root.u.def.value;
10599                       if (sym_sec->output_section != NULL)
10600                         ok_dest = TRUE;
10601                     }
10602                   else if (hash->elf.root.type == bfd_link_hash_undefweak
10603                            || hash->elf.root.type == bfd_link_hash_undefined)
10604                     {
10605                       /* Recognise an old ABI func code entry sym, and
10606                          use the func descriptor sym instead if it is
10607                          defined.  */
10608                       if (hash->elf.root.root.string[0] == '.'
10609                           && (fdh = lookup_fdh (hash, htab)) != NULL)
10610                         {
10611                           if (fdh->elf.root.type == bfd_link_hash_defined
10612                               || fdh->elf.root.type == bfd_link_hash_defweak)
10613                             {
10614                               sym_sec = fdh->elf.root.u.def.section;
10615                               sym_value = fdh->elf.root.u.def.value;
10616                               if (sym_sec->output_section != NULL)
10617                                 ok_dest = TRUE;
10618                             }
10619                           else
10620                             fdh = NULL;
10621                         }
10622                     }
10623                   else
10624                     {
10625                       bfd_set_error (bfd_error_bad_value);
10626                       goto error_ret_free_internal;
10627                     }
10628
10629                   destination = 0;
10630                   if (ok_dest)
10631                     {
10632                       sym_value += irela->r_addend;
10633                       destination = (sym_value
10634                                      + sym_sec->output_offset
10635                                      + sym_sec->output_section->vma);
10636                     }
10637
10638                   code_sec = sym_sec;
10639                   code_value = sym_value;
10640                   opd = get_opd_info (sym_sec);
10641                   if (opd != NULL)
10642                     {
10643                       bfd_vma dest;
10644
10645                       if (hash == NULL && opd->adjust != NULL)
10646                         {
10647                           long adjust = opd->adjust[sym_value / 8];
10648                           if (adjust == -1)
10649                             continue;
10650                           code_value += adjust;
10651                           sym_value += adjust;
10652                         }
10653                       dest = opd_entry_value (sym_sec, sym_value,
10654                                               &code_sec, &code_value);
10655                       if (dest != (bfd_vma) -1)
10656                         {
10657                           destination = dest;
10658                           if (fdh != NULL)
10659                             {
10660                               /* Fixup old ABI sym to point at code
10661                                  entry.  */
10662                               hash->elf.root.type = bfd_link_hash_defweak;
10663                               hash->elf.root.u.def.section = code_sec;
10664                               hash->elf.root.u.def.value = code_value;
10665                             }
10666                         }
10667                     }
10668
10669                   /* Determine what (if any) linker stub is needed.  */
10670                   plt_ent = NULL;
10671                   stub_type = ppc_type_of_stub (section, irela, &hash,
10672                                                 &plt_ent, destination);
10673
10674                   if (stub_type != ppc_stub_plt_call)
10675                     {
10676                       /* Check whether we need a TOC adjusting stub.
10677                          Since the linker pastes together pieces from
10678                          different object files when creating the
10679                          _init and _fini functions, it may be that a
10680                          call to what looks like a local sym is in
10681                          fact a call needing a TOC adjustment.  */
10682                       if (code_sec != NULL
10683                           && code_sec->output_section != NULL
10684                           && (htab->stub_group[code_sec->id].toc_off
10685                               != htab->stub_group[section->id].toc_off)
10686                           && (code_sec->has_toc_reloc
10687                               || code_sec->makes_toc_func_call))
10688                         stub_type = ppc_stub_long_branch_r2off;
10689                     }
10690
10691                   if (stub_type == ppc_stub_none)
10692                     continue;
10693
10694                   /* __tls_get_addr calls might be eliminated.  */
10695                   if (stub_type != ppc_stub_plt_call
10696                       && hash != NULL
10697                       && (hash == htab->tls_get_addr
10698                           || hash == htab->tls_get_addr_fd)
10699                       && section->has_tls_reloc
10700                       && irela != internal_relocs)
10701                     {
10702                       /* Get tls info.  */
10703                       char *tls_mask;
10704
10705                       if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
10706                                          irela - 1, input_bfd))
10707                         goto error_ret_free_internal;
10708                       if (*tls_mask != 0)
10709                         continue;
10710                     }
10711
10712                   /* Support for grouping stub sections.  */
10713                   id_sec = htab->stub_group[section->id].link_sec;
10714
10715                   /* Get the name of this stub.  */
10716                   stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10717                   if (!stub_name)
10718                     goto error_ret_free_internal;
10719
10720                   stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10721                                                      stub_name, FALSE, FALSE);
10722                   if (stub_entry != NULL)
10723                     {
10724                       /* The proper stub has already been created.  */
10725                       free (stub_name);
10726                       continue;
10727                     }
10728
10729                   stub_entry = ppc_add_stub (stub_name, section, htab);
10730                   if (stub_entry == NULL)
10731                     {
10732                       free (stub_name);
10733                     error_ret_free_internal:
10734                       if (elf_section_data (section)->relocs == NULL)
10735                         free (internal_relocs);
10736                     error_ret_free_local:
10737                       if (local_syms != NULL
10738                           && (symtab_hdr->contents
10739                               != (unsigned char *) local_syms))
10740                         free (local_syms);
10741                       return FALSE;
10742                     }
10743
10744                   stub_entry->stub_type = stub_type;
10745                   if (stub_type != ppc_stub_plt_call)
10746                     {
10747                       stub_entry->target_value = code_value;
10748                       stub_entry->target_section = code_sec;
10749                     }
10750                   else
10751                     {
10752                       stub_entry->target_value = sym_value;
10753                       stub_entry->target_section = sym_sec;
10754                     }
10755                   stub_entry->h = hash;
10756                   stub_entry->plt_ent = plt_ent;
10757                   stub_entry->addend = irela->r_addend;
10758
10759                   if (stub_entry->h != NULL)
10760                     htab->stub_globals += 1;
10761                 }
10762
10763               /* We're done with the internal relocs, free them.  */
10764               if (elf_section_data (section)->relocs != internal_relocs)
10765                 free (internal_relocs);
10766             }
10767
10768           if (local_syms != NULL
10769               && symtab_hdr->contents != (unsigned char *) local_syms)
10770             {
10771               if (!info->keep_memory)
10772                 free (local_syms);
10773               else
10774                 symtab_hdr->contents = (unsigned char *) local_syms;
10775             }
10776         }
10777
10778       /* We may have added some stubs.  Find out the new size of the
10779          stub sections.  */
10780       for (stub_sec = htab->stub_bfd->sections;
10781            stub_sec != NULL;
10782            stub_sec = stub_sec->next)
10783         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10784           {
10785             stub_sec->rawsize = stub_sec->size;
10786             stub_sec->size = 0;
10787             stub_sec->reloc_count = 0;
10788             stub_sec->flags &= ~SEC_RELOC;
10789           }
10790
10791       htab->brlt->size = 0;
10792       htab->brlt->reloc_count = 0;
10793       htab->brlt->flags &= ~SEC_RELOC;
10794       if (htab->relbrlt != NULL)
10795         htab->relbrlt->size = 0;
10796
10797       bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
10798
10799       if (info->emitrelocations
10800           && htab->glink != NULL && htab->glink->size != 0)
10801         {
10802           htab->glink->reloc_count = 1;
10803           htab->glink->flags |= SEC_RELOC;
10804         }
10805
10806       for (stub_sec = htab->stub_bfd->sections;
10807            stub_sec != NULL;
10808            stub_sec = stub_sec->next)
10809         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10810             && stub_sec->rawsize != stub_sec->size)
10811           break;
10812
10813       /* Exit from this loop when no stubs have been added, and no stubs
10814          have changed size.  */
10815       if (stub_sec == NULL)
10816         break;
10817
10818       /* Ask the linker to do its stuff.  */
10819       (*htab->layout_sections_again) ();
10820     }
10821
10822   /* It would be nice to strip htab->brlt from the output if the
10823      section is empty, but it's too late.  If we strip sections here,
10824      the dynamic symbol table is corrupted since the section symbol
10825      for the stripped section isn't written.  */
10826
10827   return TRUE;
10828 }
10829
10830 /* Called after we have determined section placement.  If sections
10831    move, we'll be called again.  Provide a value for TOCstart.  */
10832
10833 bfd_vma
10834 ppc64_elf_toc (bfd *obfd)
10835 {
10836   asection *s;
10837   bfd_vma TOCstart;
10838
10839   /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10840      order.  The TOC starts where the first of these sections starts.  */
10841   s = bfd_get_section_by_name (obfd, ".got");
10842   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10843     s = bfd_get_section_by_name (obfd, ".toc");
10844   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10845     s = bfd_get_section_by_name (obfd, ".tocbss");
10846   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10847     s = bfd_get_section_by_name (obfd, ".plt");
10848   if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10849     {
10850       /* This may happen for
10851          o  references to TOC base (SYM@toc / TOC[tc0]) without a
10852          .toc directive
10853          o  bad linker script
10854          o --gc-sections and empty TOC sections
10855
10856          FIXME: Warn user?  */
10857
10858       /* Look for a likely section.  We probably won't even be
10859          using TOCstart.  */
10860       for (s = obfd->sections; s != NULL; s = s->next)
10861         if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10862                          | SEC_EXCLUDE))
10863             == (SEC_ALLOC | SEC_SMALL_DATA))
10864           break;
10865       if (s == NULL)
10866         for (s = obfd->sections; s != NULL; s = s->next)
10867           if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
10868               == (SEC_ALLOC | SEC_SMALL_DATA))
10869             break;
10870       if (s == NULL)
10871         for (s = obfd->sections; s != NULL; s = s->next)
10872           if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10873               == SEC_ALLOC)
10874             break;
10875       if (s == NULL)
10876         for (s = obfd->sections; s != NULL; s = s->next)
10877           if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
10878             break;
10879     }
10880
10881   TOCstart = 0;
10882   if (s != NULL)
10883     TOCstart = s->output_section->vma + s->output_offset;
10884
10885   return TOCstart;
10886 }
10887
10888 /* Build all the stubs associated with the current output file.
10889    The stubs are kept in a hash table attached to the main linker
10890    hash table.  This function is called via gldelf64ppc_finish.  */
10891
10892 bfd_boolean
10893 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10894                        struct bfd_link_info *info,
10895                        char **stats)
10896 {
10897   struct ppc_link_hash_table *htab = ppc_hash_table (info);
10898   asection *stub_sec;
10899   bfd_byte *p;
10900   int stub_sec_count = 0;
10901
10902   if (htab == NULL)
10903     return FALSE;
10904
10905   htab->emit_stub_syms = emit_stub_syms;
10906
10907   /* Allocate memory to hold the linker stubs.  */
10908   for (stub_sec = htab->stub_bfd->sections;
10909        stub_sec != NULL;
10910        stub_sec = stub_sec->next)
10911     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10912         && stub_sec->size != 0)
10913       {
10914         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
10915         if (stub_sec->contents == NULL)
10916           return FALSE;
10917         /* We want to check that built size is the same as calculated
10918            size.  rawsize is a convenient location to use.  */
10919         stub_sec->rawsize = stub_sec->size;
10920         stub_sec->size = 0;
10921       }
10922
10923   if (htab->glink != NULL && htab->glink->size != 0)
10924     {
10925       unsigned int indx;
10926       bfd_vma plt0;
10927
10928       /* Build the .glink plt call stub.  */
10929       if (htab->emit_stub_syms)
10930         {
10931           struct elf_link_hash_entry *h;
10932           h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
10933                                     TRUE, FALSE, FALSE);
10934           if (h == NULL)
10935             return FALSE;
10936           if (h->root.type == bfd_link_hash_new)
10937             {
10938               h->root.type = bfd_link_hash_defined;
10939               h->root.u.def.section = htab->glink;
10940               h->root.u.def.value = 8;
10941               h->ref_regular = 1;
10942               h->def_regular = 1;
10943               h->ref_regular_nonweak = 1;
10944               h->forced_local = 1;
10945               h->non_elf = 0;
10946             }
10947         }
10948       plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10949       if (info->emitrelocations)
10950         {
10951           Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10952           if (r == NULL)
10953             return FALSE;
10954           r->r_offset = (htab->glink->output_offset
10955                          + htab->glink->output_section->vma);
10956           r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10957           r->r_addend = plt0;
10958         }
10959       p = htab->glink->contents;
10960       plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
10961       bfd_put_64 (htab->glink->owner, plt0, p);
10962       p += 8;
10963       bfd_put_32 (htab->glink->owner, MFLR_R12, p);
10964       p += 4;
10965       bfd_put_32 (htab->glink->owner, BCL_20_31, p);
10966       p += 4;
10967       bfd_put_32 (htab->glink->owner, MFLR_R11, p);
10968       p += 4;
10969       bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
10970       p += 4;
10971       bfd_put_32 (htab->glink->owner, MTLR_R12, p);
10972       p += 4;
10973       bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
10974       p += 4;
10975       bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
10976       p += 4;
10977       bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
10978       p += 4;
10979       bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
10980       p += 4;
10981       bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
10982       p += 4;
10983       bfd_put_32 (htab->glink->owner, BCTR, p);
10984       p += 4;
10985       while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10986         {
10987           bfd_put_32 (htab->glink->owner, NOP, p);
10988           p += 4;
10989         }
10990
10991       /* Build the .glink lazy link call stubs.  */
10992       indx = 0;
10993       while (p < htab->glink->contents + htab->glink->size)
10994         {
10995           if (indx < 0x8000)
10996             {
10997               bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
10998               p += 4;
10999             }
11000           else
11001             {
11002               bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11003               p += 4;
11004               bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11005               p += 4;
11006             }
11007           bfd_put_32 (htab->glink->owner,
11008                       B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11009           indx++;
11010           p += 4;
11011         }
11012       htab->glink->rawsize = p - htab->glink->contents;
11013     }
11014
11015   if (htab->brlt->size != 0)
11016     {
11017       htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11018                                          htab->brlt->size);
11019       if (htab->brlt->contents == NULL)
11020         return FALSE;
11021     }
11022   if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11023     {
11024       htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11025                                             htab->relbrlt->size);
11026       if (htab->relbrlt->contents == NULL)
11027         return FALSE;
11028     }
11029
11030   /* Build the stubs as directed by the stub hash table.  */
11031   bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11032
11033   if (htab->relbrlt != NULL)
11034     htab->relbrlt->reloc_count = 0;
11035
11036   for (stub_sec = htab->stub_bfd->sections;
11037        stub_sec != NULL;
11038        stub_sec = stub_sec->next)
11039     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11040       {
11041         stub_sec_count += 1;
11042         if (stub_sec->rawsize != stub_sec->size)
11043           break;
11044       }
11045
11046   if (stub_sec != NULL
11047       || htab->glink->rawsize != htab->glink->size)
11048     {
11049       htab->stub_error = TRUE;
11050       (*_bfd_error_handler) (_("stubs don't match calculated size"));
11051     }
11052
11053   if (htab->stub_error)
11054     return FALSE;
11055
11056   if (stats != NULL)
11057     {
11058       *stats = bfd_malloc (500);
11059       if (*stats == NULL)
11060         return FALSE;
11061
11062       sprintf (*stats, _("linker stubs in %u group%s\n"
11063                          "  branch       %lu\n"
11064                          "  toc adjust   %lu\n"
11065                          "  long branch  %lu\n"
11066                          "  long toc adj %lu\n"
11067                          "  plt call     %lu"),
11068                stub_sec_count,
11069                stub_sec_count == 1 ? "" : "s",
11070                htab->stub_count[ppc_stub_long_branch - 1],
11071                htab->stub_count[ppc_stub_long_branch_r2off - 1],
11072                htab->stub_count[ppc_stub_plt_branch - 1],
11073                htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11074                htab->stub_count[ppc_stub_plt_call - 1]);
11075     }
11076   return TRUE;
11077 }
11078
11079 /* This function undoes the changes made by add_symbol_adjust.  */
11080
11081 static bfd_boolean
11082 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11083 {
11084   struct ppc_link_hash_entry *eh;
11085
11086   if (h->root.type == bfd_link_hash_indirect)
11087     return TRUE;
11088
11089   if (h->root.type == bfd_link_hash_warning)
11090     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11091
11092   eh = (struct ppc_link_hash_entry *) h;
11093   if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11094     return TRUE;
11095
11096   eh->elf.root.type = bfd_link_hash_undefined;
11097   return TRUE;
11098 }
11099
11100 void
11101 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11102 {
11103   struct ppc_link_hash_table *htab = ppc_hash_table (info);
11104
11105   if (htab != NULL)
11106     elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11107 }
11108
11109 /* What to do when ld finds relocations against symbols defined in
11110    discarded sections.  */
11111
11112 static unsigned int
11113 ppc64_elf_action_discarded (asection *sec)
11114 {
11115   if (strcmp (".opd", sec->name) == 0)
11116     return 0;
11117
11118   if (strcmp (".toc", sec->name) == 0)
11119     return 0;
11120
11121   if (strcmp (".toc1", sec->name) == 0)
11122     return 0;
11123
11124   return _bfd_elf_default_action_discarded (sec);
11125 }
11126
11127 /* The RELOCATE_SECTION function is called by the ELF backend linker
11128    to handle the relocations for a section.
11129
11130    The relocs are always passed as Rela structures; if the section
11131    actually uses Rel structures, the r_addend field will always be
11132    zero.
11133
11134    This function is responsible for adjust the section contents as
11135    necessary, and (if using Rela relocs and generating a
11136    relocatable output file) adjusting the reloc addend as
11137    necessary.
11138
11139    This function does not have to worry about setting the reloc
11140    address or the reloc symbol index.
11141
11142    LOCAL_SYMS is a pointer to the swapped in local symbols.
11143
11144    LOCAL_SECTIONS is an array giving the section in the input file
11145    corresponding to the st_shndx field of each local symbol.
11146
11147    The global hash table entry for the global symbols can be found
11148    via elf_sym_hashes (input_bfd).
11149
11150    When generating relocatable output, this function must handle
11151    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
11152    going to be the section symbol corresponding to the output
11153    section, which means that the addend must be adjusted
11154    accordingly.  */
11155
11156 static bfd_boolean
11157 ppc64_elf_relocate_section (bfd *output_bfd,
11158                             struct bfd_link_info *info,
11159                             bfd *input_bfd,
11160                             asection *input_section,
11161                             bfd_byte *contents,
11162                             Elf_Internal_Rela *relocs,
11163                             Elf_Internal_Sym *local_syms,
11164                             asection **local_sections)
11165 {
11166   struct ppc_link_hash_table *htab;
11167   Elf_Internal_Shdr *symtab_hdr;
11168   struct elf_link_hash_entry **sym_hashes;
11169   Elf_Internal_Rela *rel;
11170   Elf_Internal_Rela *relend;
11171   Elf_Internal_Rela outrel;
11172   bfd_byte *loc;
11173   struct got_entry **local_got_ents;
11174   bfd_vma TOCstart;
11175   bfd_boolean ret = TRUE;
11176   bfd_boolean is_opd;
11177   /* Disabled until we sort out how ld should choose 'y' vs 'at'.  */
11178   bfd_boolean is_power4 = FALSE;
11179   bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11180
11181   /* Initialize howto table if needed.  */
11182   if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11183     ppc_howto_init ();
11184
11185   htab = ppc_hash_table (info);
11186   if (htab == NULL)
11187     return FALSE;
11188
11189   /* Don't relocate stub sections.  */
11190   if (input_section->owner == htab->stub_bfd)
11191     return TRUE;
11192
11193   BFD_ASSERT (is_ppc64_elf (input_bfd));
11194
11195   local_got_ents = elf_local_got_ents (input_bfd);
11196   TOCstart = elf_gp (output_bfd);
11197   symtab_hdr = &elf_symtab_hdr (input_bfd);
11198   sym_hashes = elf_sym_hashes (input_bfd);
11199   is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11200
11201   rel = relocs;
11202   relend = relocs + input_section->reloc_count;
11203   for (; rel < relend; rel++)
11204     {
11205       enum elf_ppc64_reloc_type r_type;
11206       bfd_vma addend, orig_addend;
11207       bfd_reloc_status_type r;
11208       Elf_Internal_Sym *sym;
11209       asection *sec;
11210       struct elf_link_hash_entry *h_elf;
11211       struct ppc_link_hash_entry *h;
11212       struct ppc_link_hash_entry *fdh;
11213       const char *sym_name;
11214       unsigned long r_symndx, toc_symndx;
11215       bfd_vma toc_addend;
11216       char tls_mask, tls_gd, tls_type;
11217       char sym_type;
11218       bfd_vma relocation;
11219       bfd_boolean unresolved_reloc;
11220       bfd_boolean warned;
11221       unsigned long insn, mask;
11222       struct ppc_stub_hash_entry *stub_entry;
11223       bfd_vma max_br_offset;
11224       bfd_vma from;
11225
11226       r_type = ELF64_R_TYPE (rel->r_info);
11227       r_symndx = ELF64_R_SYM (rel->r_info);
11228
11229       /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11230          symbol of the previous ADDR64 reloc.  The symbol gives us the
11231          proper TOC base to use.  */
11232       if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11233           && rel != relocs
11234           && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11235           && is_opd)
11236         r_symndx = ELF64_R_SYM (rel[-1].r_info);
11237
11238       sym = NULL;
11239       sec = NULL;
11240       h_elf = NULL;
11241       sym_name = NULL;
11242       unresolved_reloc = FALSE;
11243       warned = FALSE;
11244       orig_addend = rel->r_addend;
11245
11246       if (r_symndx < symtab_hdr->sh_info)
11247         {
11248           /* It's a local symbol.  */
11249           struct _opd_sec_data *opd;
11250
11251           sym = local_syms + r_symndx;
11252           sec = local_sections[r_symndx];
11253           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11254           sym_type = ELF64_ST_TYPE (sym->st_info);
11255           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11256           opd = get_opd_info (sec);
11257           if (opd != NULL && opd->adjust != NULL)
11258             {
11259               long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11260               if (adjust == -1)
11261                 relocation = 0;
11262               else
11263                 {
11264                   /* If this is a relocation against the opd section sym
11265                      and we have edited .opd, adjust the reloc addend so
11266                      that ld -r and ld --emit-relocs output is correct.
11267                      If it is a reloc against some other .opd symbol,
11268                      then the symbol value will be adjusted later.  */
11269                   if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11270                     rel->r_addend += adjust;
11271                   else
11272                     relocation += adjust;
11273                 }
11274             }
11275         }
11276       else
11277         {
11278           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11279                                    r_symndx, symtab_hdr, sym_hashes,
11280                                    h_elf, sec, relocation,
11281                                    unresolved_reloc, warned);
11282           sym_name = h_elf->root.root.string;
11283           sym_type = h_elf->type;
11284         }
11285       h = (struct ppc_link_hash_entry *) h_elf;
11286
11287       if (sec != NULL && elf_discarded_section (sec))
11288         {
11289           /* For relocs against symbols from removed linkonce sections,
11290              or sections discarded by a linker script, we just want the
11291              section contents zeroed.  Avoid any special processing.  */
11292           _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
11293                                contents + rel->r_offset);
11294           rel->r_info = 0;
11295           rel->r_addend = 0;
11296           continue;
11297         }
11298
11299       if (info->relocatable)
11300         continue;
11301
11302       /* TLS optimizations.  Replace instruction sequences and relocs
11303          based on information we collected in tls_optimize.  We edit
11304          RELOCS so that --emit-relocs will output something sensible
11305          for the final instruction stream.  */
11306       tls_mask = 0;
11307       tls_gd = 0;
11308       toc_symndx = 0;
11309       if (h != NULL)
11310         tls_mask = h->tls_mask;
11311       else if (local_got_ents != NULL)
11312         {
11313           struct plt_entry **local_plt = (struct plt_entry **)
11314             (local_got_ents + symtab_hdr->sh_info);
11315           char *lgot_masks = (char *)
11316             (local_plt + symtab_hdr->sh_info);
11317           tls_mask = lgot_masks[r_symndx];
11318         }
11319       if (tls_mask == 0
11320           && (r_type == R_PPC64_TLS
11321               || r_type == R_PPC64_TLSGD
11322               || r_type == R_PPC64_TLSLD))
11323         {
11324           /* Check for toc tls entries.  */
11325           char *toc_tls;
11326
11327           if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11328                              &local_syms, rel, input_bfd))
11329             return FALSE;
11330
11331           if (toc_tls)
11332             tls_mask = *toc_tls;
11333         }
11334
11335       /* Check that tls relocs are used with tls syms, and non-tls
11336          relocs are used with non-tls syms.  */
11337       if (r_symndx != 0
11338           && r_type != R_PPC64_NONE
11339           && (h == NULL
11340               || h->elf.root.type == bfd_link_hash_defined
11341               || h->elf.root.type == bfd_link_hash_defweak)
11342           && (IS_PPC64_TLS_RELOC (r_type)
11343               != (sym_type == STT_TLS
11344                   || (sym_type == STT_SECTION
11345                       && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11346         {
11347           if (tls_mask != 0
11348               && (r_type == R_PPC64_TLS
11349                   || r_type == R_PPC64_TLSGD
11350                   || r_type == R_PPC64_TLSLD))
11351             /* R_PPC64_TLS is OK against a symbol in the TOC.  */
11352             ;
11353           else
11354             (*_bfd_error_handler)
11355               (!IS_PPC64_TLS_RELOC (r_type)
11356                ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11357                : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
11358                input_bfd,
11359                input_section,
11360                (long) rel->r_offset,
11361                ppc64_elf_howto_table[r_type]->name,
11362                sym_name);
11363         }
11364
11365       /* Ensure reloc mapping code below stays sane.  */
11366       if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11367           || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11368           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TLSGD16 & 3)
11369           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11370           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11371           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11372           || (R_PPC64_GOT_TLSLD16 & 3)    != (R_PPC64_GOT_TPREL16_DS & 3)
11373           || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11374           || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11375           || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11376         abort ();
11377
11378       switch (r_type)
11379         {
11380         default:
11381           break;
11382
11383         case R_PPC64_TOC16:
11384         case R_PPC64_TOC16_LO:
11385         case R_PPC64_TOC16_DS:
11386         case R_PPC64_TOC16_LO_DS:
11387           {
11388             /* Check for toc tls entries.  */
11389             char *toc_tls;
11390             int retval;
11391
11392             retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11393                                    &local_syms, rel, input_bfd);
11394             if (retval == 0)
11395               return FALSE;
11396
11397             if (toc_tls)
11398               {
11399                 tls_mask = *toc_tls;
11400                 if (r_type == R_PPC64_TOC16_DS
11401                     || r_type == R_PPC64_TOC16_LO_DS)
11402                   {
11403                     if (tls_mask != 0
11404                         && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
11405                       goto toctprel;
11406                   }
11407                 else
11408                   {
11409                     /* If we found a GD reloc pair, then we might be
11410                        doing a GD->IE transition.  */
11411                     if (retval == 2)
11412                       {
11413                         tls_gd = TLS_TPRELGD;
11414                         if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11415                           goto tls_ldgd_opt;
11416                       }
11417                     else if (retval == 3)
11418                       {
11419                         if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11420                           goto tls_ldgd_opt;
11421                       }
11422                   }
11423               }
11424           }
11425           break;
11426
11427         case R_PPC64_GOT_TPREL16_DS:
11428         case R_PPC64_GOT_TPREL16_LO_DS:
11429           if (tls_mask != 0
11430               && (tls_mask & TLS_TPREL) == 0)
11431             {
11432             toctprel:
11433               insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11434               insn &= 31 << 21;
11435               insn |= 0x3c0d0000;       /* addis 0,13,0 */
11436               bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11437               r_type = R_PPC64_TPREL16_HA;
11438               if (toc_symndx != 0)
11439                 {
11440                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11441                   rel->r_addend = toc_addend;
11442                   /* We changed the symbol.  Start over in order to
11443                      get h, sym, sec etc. right.  */
11444                   rel--;
11445                   continue;
11446                 }
11447               else
11448                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11449             }
11450           break;
11451
11452         case R_PPC64_TLS:
11453           if (tls_mask != 0
11454               && (tls_mask & TLS_TPREL) == 0)
11455             {
11456               insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11457               insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11458               if (insn == 0)
11459                 abort ();
11460               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11461               /* Was PPC64_TLS which sits on insn boundary, now
11462                  PPC64_TPREL16_LO which is at low-order half-word.  */
11463               rel->r_offset += d_offset;
11464               r_type = R_PPC64_TPREL16_LO;
11465               if (toc_symndx != 0)
11466                 {
11467                   rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11468                   rel->r_addend = toc_addend;
11469                   /* We changed the symbol.  Start over in order to
11470                      get h, sym, sec etc. right.  */
11471                   rel--;
11472                   continue;
11473                 }
11474               else
11475                 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11476             }
11477           break;
11478
11479         case R_PPC64_GOT_TLSGD16_HI:
11480         case R_PPC64_GOT_TLSGD16_HA:
11481           tls_gd = TLS_TPRELGD;
11482           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11483             goto tls_gdld_hi;
11484           break;
11485
11486         case R_PPC64_GOT_TLSLD16_HI:
11487         case R_PPC64_GOT_TLSLD16_HA:
11488           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11489             {
11490             tls_gdld_hi:
11491               if ((tls_mask & tls_gd) != 0)
11492                 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11493                           + R_PPC64_GOT_TPREL16_DS);
11494               else
11495                 {
11496                   bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11497                   rel->r_offset -= d_offset;
11498                   r_type = R_PPC64_NONE;
11499                 }
11500               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11501             }
11502           break;
11503
11504         case R_PPC64_GOT_TLSGD16:
11505         case R_PPC64_GOT_TLSGD16_LO:
11506           tls_gd = TLS_TPRELGD;
11507           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11508             goto tls_ldgd_opt;
11509           break;
11510
11511         case R_PPC64_GOT_TLSLD16:
11512         case R_PPC64_GOT_TLSLD16_LO:
11513           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11514             {
11515               unsigned int insn1, insn2, insn3;
11516               bfd_vma offset;
11517
11518             tls_ldgd_opt:
11519               offset = (bfd_vma) -1;
11520               /* If not using the newer R_PPC64_TLSGD/LD to mark
11521                  __tls_get_addr calls, we must trust that the call
11522                  stays with its arg setup insns, ie. that the next
11523                  reloc is the __tls_get_addr call associated with
11524                  the current reloc.  Edit both insns.  */
11525               if (input_section->has_tls_get_addr_call
11526                   && rel + 1 < relend
11527                   && branch_reloc_hash_match (input_bfd, rel + 1,
11528                                               htab->tls_get_addr,
11529                                               htab->tls_get_addr_fd))
11530                 offset = rel[1].r_offset;
11531               if ((tls_mask & tls_gd) != 0)
11532                 {
11533                   /* IE */
11534                   insn1 = bfd_get_32 (output_bfd,
11535                                       contents + rel->r_offset - d_offset);
11536                   insn1 &= (1 << 26) - (1 << 2);
11537                   insn1 |= 58 << 26;    /* ld */
11538                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11539                   if (offset != (bfd_vma) -1)
11540                     rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11541                   if ((tls_mask & TLS_EXPLICIT) == 0)
11542                     r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11543                               + R_PPC64_GOT_TPREL16_DS);
11544                   else
11545                     r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
11546                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11547                 }
11548               else
11549                 {
11550                   /* LE */
11551                   insn1 = 0x3c6d0000;   /* addis 3,13,0 */
11552                   insn2 = 0x38630000;   /* addi 3,3,0 */
11553                   if (tls_gd == 0)
11554                     {
11555                       /* Was an LD reloc.  */
11556                       if (toc_symndx)
11557                         sec = local_sections[toc_symndx];
11558                       for (r_symndx = 0;
11559                            r_symndx < symtab_hdr->sh_info;
11560                            r_symndx++)
11561                         if (local_sections[r_symndx] == sec)
11562                           break;
11563                       if (r_symndx >= symtab_hdr->sh_info)
11564                         r_symndx = 0;
11565                       rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11566                       if (r_symndx != 0)
11567                         rel->r_addend -= (local_syms[r_symndx].st_value
11568                                           + sec->output_offset
11569                                           + sec->output_section->vma);
11570                     }
11571                   else if (toc_symndx != 0)
11572                     {
11573                       r_symndx = toc_symndx;
11574                       rel->r_addend = toc_addend;
11575                     }
11576                   r_type = R_PPC64_TPREL16_HA;
11577                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11578                   if (offset != (bfd_vma) -1)
11579                     {
11580                       rel[1].r_info = ELF64_R_INFO (r_symndx,
11581                                                     R_PPC64_TPREL16_LO);
11582                       rel[1].r_offset = offset + d_offset;
11583                       rel[1].r_addend = rel->r_addend;
11584                     }
11585                 }
11586               bfd_put_32 (output_bfd, insn1,
11587                           contents + rel->r_offset - d_offset);
11588               if (offset != (bfd_vma) -1)
11589                 {
11590                   insn3 = bfd_get_32 (output_bfd,
11591                                       contents + offset + 4);
11592                   if (insn3 == NOP
11593                       || insn3 == CROR_151515 || insn3 == CROR_313131)
11594                     {
11595                       rel[1].r_offset += 4;
11596                       bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11597                       insn2 = NOP;
11598                     }
11599                   bfd_put_32 (output_bfd, insn2, contents + offset);
11600                 }
11601               if ((tls_mask & tls_gd) == 0
11602                   && (tls_gd == 0 || toc_symndx != 0))
11603                 {
11604                   /* We changed the symbol.  Start over in order
11605                      to get h, sym, sec etc. right.  */
11606                   rel--;
11607                   continue;
11608                 }
11609             }
11610           break;
11611
11612         case R_PPC64_TLSGD:
11613           if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11614             {
11615               unsigned int insn2, insn3;
11616               bfd_vma offset = rel->r_offset;
11617
11618               if ((tls_mask & TLS_TPRELGD) != 0)
11619                 {
11620                   /* IE */
11621                   r_type = R_PPC64_NONE;
11622                   insn2 = 0x7c636a14;   /* add 3,3,13 */
11623                 }
11624               else
11625                 {
11626                   /* LE */
11627                   if (toc_symndx != 0)
11628                     {
11629                       r_symndx = toc_symndx;
11630                       rel->r_addend = toc_addend;
11631                     }
11632                   r_type = R_PPC64_TPREL16_LO;
11633                   rel->r_offset = offset + d_offset;
11634                   insn2 = 0x38630000;   /* addi 3,3,0 */
11635                 }
11636               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11637               /* Zap the reloc on the _tls_get_addr call too.  */
11638               BFD_ASSERT (offset == rel[1].r_offset);
11639               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11640               insn3 = bfd_get_32 (output_bfd,
11641                                   contents + offset + 4);
11642               if (insn3 == NOP
11643                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11644                 {
11645                   rel->r_offset += 4;
11646                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11647                   insn2 = NOP;
11648                 }
11649               bfd_put_32 (output_bfd, insn2, contents + offset);
11650               if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
11651                 {
11652                   rel--;
11653                   continue;
11654                 }
11655             }
11656           break;
11657
11658         case R_PPC64_TLSLD:
11659           if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11660             {
11661               unsigned int insn2, insn3;
11662               bfd_vma offset = rel->r_offset;
11663
11664               if (toc_symndx)
11665                 sec = local_sections[toc_symndx];
11666               for (r_symndx = 0;
11667                    r_symndx < symtab_hdr->sh_info;
11668                    r_symndx++)
11669                 if (local_sections[r_symndx] == sec)
11670                   break;
11671               if (r_symndx >= symtab_hdr->sh_info)
11672                 r_symndx = 0;
11673               rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11674               if (r_symndx != 0)
11675                 rel->r_addend -= (local_syms[r_symndx].st_value
11676                                   + sec->output_offset
11677                                   + sec->output_section->vma);
11678
11679               r_type = R_PPC64_TPREL16_LO;
11680               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11681               rel->r_offset = offset + d_offset;
11682               /* Zap the reloc on the _tls_get_addr call too.  */
11683               BFD_ASSERT (offset == rel[1].r_offset);
11684               rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11685               insn2 = 0x38630000;       /* addi 3,3,0 */
11686               insn3 = bfd_get_32 (output_bfd,
11687                                   contents + offset + 4);
11688               if (insn3 == NOP
11689                   || insn3 == CROR_151515 || insn3 == CROR_313131)
11690                 {
11691                   rel->r_offset += 4;
11692                   bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11693                   insn2 = NOP;
11694                 }
11695               bfd_put_32 (output_bfd, insn2, contents + offset);
11696               rel--;
11697               continue;
11698             }
11699           break;
11700
11701         case R_PPC64_DTPMOD64:
11702           if (rel + 1 < relend
11703               && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11704               && rel[1].r_offset == rel->r_offset + 8)
11705             {
11706               if ((tls_mask & TLS_GD) == 0)
11707                 {
11708                   rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11709                   if ((tls_mask & TLS_TPRELGD) != 0)
11710                     r_type = R_PPC64_TPREL64;
11711                   else
11712                     {
11713                       bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11714                       r_type = R_PPC64_NONE;
11715                     }
11716                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11717                 }
11718             }
11719           else
11720             {
11721               if ((tls_mask & TLS_LD) == 0)
11722                 {
11723                   bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11724                   r_type = R_PPC64_NONE;
11725                   rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11726                 }
11727             }
11728           break;
11729
11730         case R_PPC64_TPREL64:
11731           if ((tls_mask & TLS_TPREL) == 0)
11732             {
11733               r_type = R_PPC64_NONE;
11734               rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11735             }
11736           break;
11737         }
11738
11739       /* Handle other relocations that tweak non-addend part of insn.  */
11740       insn = 0;
11741       max_br_offset = 1 << 25;
11742       addend = rel->r_addend;
11743       switch (r_type)
11744         {
11745         default:
11746           break;
11747
11748           /* Branch taken prediction relocations.  */
11749         case R_PPC64_ADDR14_BRTAKEN:
11750         case R_PPC64_REL14_BRTAKEN:
11751           insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field.  */
11752           /* Fall thru.  */
11753
11754           /* Branch not taken prediction relocations.  */
11755         case R_PPC64_ADDR14_BRNTAKEN:
11756         case R_PPC64_REL14_BRNTAKEN:
11757           insn |= bfd_get_32 (output_bfd,
11758                               contents + rel->r_offset) & ~(0x01 << 21);
11759           /* Fall thru.  */
11760
11761         case R_PPC64_REL14:
11762           max_br_offset = 1 << 15;
11763           /* Fall thru.  */
11764
11765         case R_PPC64_REL24:
11766           /* Calls to functions with a different TOC, such as calls to
11767              shared objects, need to alter the TOC pointer.  This is
11768              done using a linkage stub.  A REL24 branching to these
11769              linkage stubs needs to be followed by a nop, as the nop
11770              will be replaced with an instruction to restore the TOC
11771              base pointer.  */
11772           stub_entry = NULL;
11773           fdh = h;
11774           if (h != NULL
11775               && h->oh != NULL
11776               && h->oh->is_func_descriptor)
11777             fdh = ppc_follow_link (h->oh);
11778           if (((fdh != NULL
11779                 && fdh->elf.plt.plist != NULL)
11780                || (sec != NULL
11781                    && sec->output_section != NULL
11782                    && sec->id <= htab->top_id
11783                    && (htab->stub_group[sec->id].toc_off
11784                        != htab->stub_group[input_section->id].toc_off))
11785                || (h == NULL
11786                    && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
11787               && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
11788                                                    rel, htab)) != NULL
11789               && (stub_entry->stub_type == ppc_stub_plt_call
11790                   || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11791                   || stub_entry->stub_type == ppc_stub_long_branch_r2off))
11792             {
11793               bfd_boolean can_plt_call = FALSE;
11794
11795               if (rel->r_offset + 8 <= input_section->size)
11796                 {
11797                   unsigned long nop;
11798                   nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11799                   if (nop == NOP
11800                       || nop == CROR_151515 || nop == CROR_313131)
11801                     {
11802                       if (h != NULL
11803                           && (h == htab->tls_get_addr_fd
11804                               || h == htab->tls_get_addr)
11805                           && !htab->no_tls_get_addr_opt)
11806                         {
11807                           /* Special stub used, leave nop alone.  */
11808                         }
11809                       else
11810                         bfd_put_32 (input_bfd, LD_R2_40R1,
11811                                     contents + rel->r_offset + 4);
11812                       can_plt_call = TRUE;
11813                     }
11814                 }
11815
11816               if (!can_plt_call)
11817                 {
11818                   if (stub_entry->stub_type == ppc_stub_plt_call)
11819                     {
11820                       /* If this is a plain branch rather than a branch
11821                          and link, don't require a nop.  However, don't
11822                          allow tail calls in a shared library as they
11823                          will result in r2 being corrupted.  */
11824                       unsigned long br;
11825                       br = bfd_get_32 (input_bfd, contents + rel->r_offset);
11826                       if (info->executable && (br & 1) == 0)
11827                         can_plt_call = TRUE;
11828                       else
11829                         stub_entry = NULL;
11830                     }
11831                   else if (h != NULL
11832                            && strcmp (h->elf.root.root.string,
11833                                       ".__libc_start_main") == 0)
11834                     {
11835                       /* Allow crt1 branch to go via a toc adjusting stub.  */
11836                       can_plt_call = TRUE;
11837                     }
11838                   else
11839                     {
11840                       if (strcmp (input_section->output_section->name,
11841                                   ".init") == 0
11842                           || strcmp (input_section->output_section->name,
11843                                      ".fini") == 0)
11844                         (*_bfd_error_handler)
11845                           (_("%B(%A+0x%lx): automatic multiple TOCs "
11846                              "not supported using your crt files; "
11847                              "recompile with -mminimal-toc or upgrade gcc"),
11848                            input_bfd,
11849                            input_section,
11850                            (long) rel->r_offset);
11851                       else
11852                         (*_bfd_error_handler)
11853                           (_("%B(%A+0x%lx): sibling call optimization to `%s' "
11854                              "does not allow automatic multiple TOCs; "
11855                              "recompile with -mminimal-toc or "
11856                              "-fno-optimize-sibling-calls, "
11857                              "or make `%s' extern"),
11858                            input_bfd,
11859                            input_section,
11860                            (long) rel->r_offset,
11861                            sym_name,
11862                            sym_name);
11863                       bfd_set_error (bfd_error_bad_value);
11864                       ret = FALSE;
11865                     }
11866                 }
11867
11868               if (can_plt_call
11869                   && stub_entry->stub_type == ppc_stub_plt_call)
11870                 unresolved_reloc = FALSE;
11871             }
11872
11873           if (stub_entry == NULL
11874               && get_opd_info (sec) != NULL)
11875             {
11876               /* The branch destination is the value of the opd entry. */
11877               bfd_vma off = (relocation + addend
11878                              - sec->output_section->vma
11879                              - sec->output_offset);
11880               bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11881               if (dest != (bfd_vma) -1)
11882                 {
11883                   relocation = dest;
11884                   addend = 0;
11885                 }
11886             }
11887
11888           /* If the branch is out of reach we ought to have a long
11889              branch stub.  */
11890           from = (rel->r_offset
11891                   + input_section->output_offset
11892                   + input_section->output_section->vma);
11893
11894           if (stub_entry == NULL
11895               && (relocation + addend - from + max_br_offset
11896                   >= 2 * max_br_offset)
11897               && r_type != R_PPC64_ADDR14_BRTAKEN
11898               && r_type != R_PPC64_ADDR14_BRNTAKEN)
11899             stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
11900                                              htab);
11901
11902           if (stub_entry != NULL)
11903             {
11904               /* Munge up the value and addend so that we call the stub
11905                  rather than the procedure directly.  */
11906               relocation = (stub_entry->stub_offset
11907                             + stub_entry->stub_sec->output_offset
11908                             + stub_entry->stub_sec->output_section->vma);
11909               addend = 0;
11910             }
11911
11912           if (insn != 0)
11913             {
11914               if (is_power4)
11915                 {
11916                   /* Set 'a' bit.  This is 0b00010 in BO field for branch
11917                      on CR(BI) insns (BO == 001at or 011at), and 0b01000
11918                      for branch on CTR insns (BO == 1a00t or 1a01t).  */
11919                   if ((insn & (0x14 << 21)) == (0x04 << 21))
11920                     insn |= 0x02 << 21;
11921                   else if ((insn & (0x14 << 21)) == (0x10 << 21))
11922                     insn |= 0x08 << 21;
11923                   else
11924                     break;
11925                 }
11926               else
11927                 {
11928                   /* Invert 'y' bit if not the default.  */
11929                   if ((bfd_signed_vma) (relocation + addend - from) < 0)
11930                     insn ^= 0x01 << 21;
11931                 }
11932
11933               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11934             }
11935
11936           /* NOP out calls to undefined weak functions.
11937              We can thus call a weak function without first
11938              checking whether the function is defined.  */
11939           else if (h != NULL
11940                    && h->elf.root.type == bfd_link_hash_undefweak
11941                    && h->elf.dynindx == -1
11942                    && r_type == R_PPC64_REL24
11943                    && relocation == 0
11944                    && addend == 0)
11945             {
11946               bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11947               continue;
11948             }
11949           break;
11950         }
11951
11952       /* Set `addend'.  */
11953       tls_type = 0;
11954       switch (r_type)
11955         {
11956         default:
11957           (*_bfd_error_handler)
11958             (_("%B: unknown relocation type %d for symbol %s"),
11959              input_bfd, (int) r_type, sym_name);
11960
11961           bfd_set_error (bfd_error_bad_value);
11962           ret = FALSE;
11963           continue;
11964
11965         case R_PPC64_NONE:
11966         case R_PPC64_TLS:
11967         case R_PPC64_TLSGD:
11968         case R_PPC64_TLSLD:
11969         case R_PPC64_GNU_VTINHERIT:
11970         case R_PPC64_GNU_VTENTRY:
11971           continue;
11972
11973           /* GOT16 relocations.  Like an ADDR16 using the symbol's
11974              address in the GOT as relocation value instead of the
11975              symbol's value itself.  Also, create a GOT entry for the
11976              symbol and put the symbol value there.  */
11977         case R_PPC64_GOT_TLSGD16:
11978         case R_PPC64_GOT_TLSGD16_LO:
11979         case R_PPC64_GOT_TLSGD16_HI:
11980         case R_PPC64_GOT_TLSGD16_HA:
11981           tls_type = TLS_TLS | TLS_GD;
11982           goto dogot;
11983
11984         case R_PPC64_GOT_TLSLD16:
11985         case R_PPC64_GOT_TLSLD16_LO:
11986         case R_PPC64_GOT_TLSLD16_HI:
11987         case R_PPC64_GOT_TLSLD16_HA:
11988           tls_type = TLS_TLS | TLS_LD;
11989           goto dogot;
11990
11991         case R_PPC64_GOT_TPREL16_DS:
11992         case R_PPC64_GOT_TPREL16_LO_DS:
11993         case R_PPC64_GOT_TPREL16_HI:
11994         case R_PPC64_GOT_TPREL16_HA:
11995           tls_type = TLS_TLS | TLS_TPREL;
11996           goto dogot;
11997
11998         case R_PPC64_GOT_DTPREL16_DS:
11999         case R_PPC64_GOT_DTPREL16_LO_DS:
12000         case R_PPC64_GOT_DTPREL16_HI:
12001         case R_PPC64_GOT_DTPREL16_HA:
12002           tls_type = TLS_TLS | TLS_DTPREL;
12003           goto dogot;
12004
12005         case R_PPC64_GOT16:
12006         case R_PPC64_GOT16_LO:
12007         case R_PPC64_GOT16_HI:
12008         case R_PPC64_GOT16_HA:
12009         case R_PPC64_GOT16_DS:
12010         case R_PPC64_GOT16_LO_DS:
12011         dogot:
12012           {
12013             /* Relocation is to the entry for this symbol in the global
12014                offset table.  */
12015             asection *got;
12016             bfd_vma *offp;
12017             bfd_vma off;
12018             unsigned long indx = 0;
12019             struct got_entry *ent;
12020
12021             if (tls_type == (TLS_TLS | TLS_LD)
12022                 && (h == NULL
12023                     || !h->elf.def_dynamic))
12024               ent = ppc64_tlsld_got (input_bfd);
12025             else
12026               {
12027
12028                 if (h != NULL)
12029                   {
12030                     bfd_boolean dyn = htab->elf.dynamic_sections_created;
12031                     if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12032                                                           &h->elf)
12033                         || (info->shared
12034                             && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
12035                       /* This is actually a static link, or it is a
12036                          -Bsymbolic link and the symbol is defined
12037                          locally, or the symbol was forced to be local
12038                          because of a version file.  */
12039                       ;
12040                     else
12041                       {
12042                         indx = h->elf.dynindx;
12043                         unresolved_reloc = FALSE;
12044                       }
12045                     ent = h->elf.got.glist;
12046                   }
12047                 else
12048                   {
12049                     if (local_got_ents == NULL)
12050                       abort ();
12051                     ent = local_got_ents[r_symndx];
12052                   }
12053
12054                 for (; ent != NULL; ent = ent->next)
12055                   if (ent->addend == orig_addend
12056                       && ent->owner == input_bfd
12057                       && ent->tls_type == tls_type)
12058                     break;
12059               }
12060
12061             if (ent == NULL)
12062               abort ();
12063             if (ent->is_indirect)
12064               ent = ent->got.ent;
12065             offp = &ent->got.offset;
12066             got = ppc64_elf_tdata (ent->owner)->got;
12067             if (got == NULL)
12068               abort ();
12069
12070             /* The offset must always be a multiple of 8.  We use the
12071                least significant bit to record whether we have already
12072                processed this entry.  */
12073             off = *offp;
12074             if ((off & 1) != 0)
12075               off &= ~1;
12076             else
12077               {
12078                 /* Generate relocs for the dynamic linker, except in
12079                    the case of TLSLD where we'll use one entry per
12080                    module.  */
12081                 asection *relgot;
12082                 bfd_boolean ifunc;
12083
12084                 *offp = off | 1;
12085                 relgot = NULL;
12086                 ifunc = (h != NULL
12087                          ? h->elf.type == STT_GNU_IFUNC
12088                          : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12089                 if ((info->shared || indx != 0)
12090                     && (h == NULL
12091                         || (tls_type == (TLS_TLS | TLS_LD)
12092                             && !h->elf.def_dynamic)
12093                         || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12094                         || h->elf.root.type != bfd_link_hash_undefweak))
12095                   relgot = ppc64_elf_tdata (ent->owner)->relgot;
12096                 else if (ifunc)
12097                   relgot = htab->reliplt;
12098                 if (relgot != NULL)
12099                   {
12100                     outrel.r_offset = (got->output_section->vma
12101                                        + got->output_offset
12102                                        + off);
12103                     outrel.r_addend = addend;
12104                     if (tls_type & (TLS_LD | TLS_GD))
12105                       {
12106                         outrel.r_addend = 0;
12107                         outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12108                         if (tls_type == (TLS_TLS | TLS_GD))
12109                           {
12110                             loc = relgot->contents;
12111                             loc += (relgot->reloc_count++
12112                                     * sizeof (Elf64_External_Rela));
12113                             bfd_elf64_swap_reloca_out (output_bfd,
12114                                                        &outrel, loc);
12115                             outrel.r_offset += 8;
12116                             outrel.r_addend = addend;
12117                             outrel.r_info
12118                               = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12119                           }
12120                       }
12121                     else if (tls_type == (TLS_TLS | TLS_DTPREL))
12122                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12123                     else if (tls_type == (TLS_TLS | TLS_TPREL))
12124                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12125                     else if (indx != 0)
12126                       outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12127                     else
12128                       {
12129                         if (ifunc)
12130                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12131                         else
12132                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12133
12134                         /* Write the .got section contents for the sake
12135                            of prelink.  */
12136                         loc = got->contents + off;
12137                         bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12138                                     loc);
12139                       }
12140
12141                     if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12142                       {
12143                         outrel.r_addend += relocation;
12144                         if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12145                           outrel.r_addend -= htab->elf.tls_sec->vma;
12146                       }
12147                     loc = relgot->contents;
12148                     loc += (relgot->reloc_count++
12149                             * sizeof (Elf64_External_Rela));
12150                     bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12151                   }
12152
12153                 /* Init the .got section contents here if we're not
12154                    emitting a reloc.  */
12155                 else
12156                   {
12157                     relocation += addend;
12158                     if (tls_type == (TLS_TLS | TLS_LD))
12159                       relocation = 1;
12160                     else if (tls_type != 0)
12161                       {
12162                         relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12163                         if (tls_type == (TLS_TLS | TLS_TPREL))
12164                           relocation += DTP_OFFSET - TP_OFFSET;
12165
12166                         if (tls_type == (TLS_TLS | TLS_GD))
12167                           {
12168                             bfd_put_64 (output_bfd, relocation,
12169                                         got->contents + off + 8);
12170                             relocation = 1;
12171                           }
12172                       }
12173
12174                     bfd_put_64 (output_bfd, relocation,
12175                                 got->contents + off);
12176                   }
12177               }
12178
12179             if (off >= (bfd_vma) -2)
12180               abort ();
12181
12182             relocation = got->output_section->vma + got->output_offset + off;
12183             addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12184           }
12185           break;
12186
12187         case R_PPC64_PLT16_HA:
12188         case R_PPC64_PLT16_HI:
12189         case R_PPC64_PLT16_LO:
12190         case R_PPC64_PLT32:
12191         case R_PPC64_PLT64:
12192           /* Relocation is to the entry for this symbol in the
12193              procedure linkage table.  */
12194
12195           /* Resolve a PLT reloc against a local symbol directly,
12196              without using the procedure linkage table.  */
12197           if (h == NULL)
12198             break;
12199
12200           /* It's possible that we didn't make a PLT entry for this
12201              symbol.  This happens when statically linking PIC code,
12202              or when using -Bsymbolic.  Go find a match if there is a
12203              PLT entry.  */
12204           if (htab->plt != NULL)
12205             {
12206               struct plt_entry *ent;
12207               for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12208                 if (ent->addend == orig_addend
12209                     && ent->plt.offset != (bfd_vma) -1)
12210                   {
12211                     relocation = (htab->plt->output_section->vma
12212                                   + htab->plt->output_offset
12213                                   + ent->plt.offset);
12214                     unresolved_reloc = FALSE;
12215                   }
12216             }
12217           break;
12218
12219         case R_PPC64_TOC:
12220           /* Relocation value is TOC base.  */
12221           relocation = TOCstart;
12222           if (r_symndx == 0)
12223             relocation += htab->stub_group[input_section->id].toc_off;
12224           else if (unresolved_reloc)
12225             ;
12226           else if (sec != NULL && sec->id <= htab->top_id)
12227             relocation += htab->stub_group[sec->id].toc_off;
12228           else
12229             unresolved_reloc = TRUE;
12230           goto dodyn;
12231
12232           /* TOC16 relocs.  We want the offset relative to the TOC base,
12233              which is the address of the start of the TOC plus 0x8000.
12234              The TOC consists of sections .got, .toc, .tocbss, and .plt,
12235              in this order.  */
12236         case R_PPC64_TOC16:
12237         case R_PPC64_TOC16_LO:
12238         case R_PPC64_TOC16_HI:
12239         case R_PPC64_TOC16_DS:
12240         case R_PPC64_TOC16_LO_DS:
12241         case R_PPC64_TOC16_HA:
12242           addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12243           break;
12244
12245           /* Relocate against the beginning of the section.  */
12246         case R_PPC64_SECTOFF:
12247         case R_PPC64_SECTOFF_LO:
12248         case R_PPC64_SECTOFF_HI:
12249         case R_PPC64_SECTOFF_DS:
12250         case R_PPC64_SECTOFF_LO_DS:
12251         case R_PPC64_SECTOFF_HA:
12252           if (sec != NULL)
12253             addend -= sec->output_section->vma;
12254           break;
12255
12256         case R_PPC64_REL16:
12257         case R_PPC64_REL16_LO:
12258         case R_PPC64_REL16_HI:
12259         case R_PPC64_REL16_HA:
12260           break;
12261
12262         case R_PPC64_REL14:
12263         case R_PPC64_REL14_BRNTAKEN:
12264         case R_PPC64_REL14_BRTAKEN:
12265         case R_PPC64_REL24:
12266           break;
12267
12268         case R_PPC64_TPREL16:
12269         case R_PPC64_TPREL16_LO:
12270         case R_PPC64_TPREL16_HI:
12271         case R_PPC64_TPREL16_HA:
12272         case R_PPC64_TPREL16_DS:
12273         case R_PPC64_TPREL16_LO_DS:
12274         case R_PPC64_TPREL16_HIGHER:
12275         case R_PPC64_TPREL16_HIGHERA:
12276         case R_PPC64_TPREL16_HIGHEST:
12277         case R_PPC64_TPREL16_HIGHESTA:
12278           if (h != NULL
12279               && h->elf.root.type == bfd_link_hash_undefweak
12280               && h->elf.dynindx == -1)
12281             {
12282               /* Make this relocation against an undefined weak symbol
12283                  resolve to zero.  This is really just a tweak, since
12284                  code using weak externs ought to check that they are
12285                  defined before using them.  */
12286               bfd_byte *p = contents + rel->r_offset - d_offset;
12287
12288               insn = bfd_get_32 (output_bfd, p);
12289               insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12290               if (insn != 0)
12291                 bfd_put_32 (output_bfd, insn, p);
12292               break;
12293             }
12294           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12295           if (info->shared)
12296             /* The TPREL16 relocs shouldn't really be used in shared
12297                libs as they will result in DT_TEXTREL being set, but
12298                support them anyway.  */
12299             goto dodyn;
12300           break;
12301
12302         case R_PPC64_DTPREL16:
12303         case R_PPC64_DTPREL16_LO:
12304         case R_PPC64_DTPREL16_HI:
12305         case R_PPC64_DTPREL16_HA:
12306         case R_PPC64_DTPREL16_DS:
12307         case R_PPC64_DTPREL16_LO_DS:
12308         case R_PPC64_DTPREL16_HIGHER:
12309         case R_PPC64_DTPREL16_HIGHERA:
12310         case R_PPC64_DTPREL16_HIGHEST:
12311         case R_PPC64_DTPREL16_HIGHESTA:
12312           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12313           break;
12314
12315         case R_PPC64_DTPMOD64:
12316           relocation = 1;
12317           addend = 0;
12318           goto dodyn;
12319
12320         case R_PPC64_TPREL64:
12321           addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12322           goto dodyn;
12323
12324         case R_PPC64_DTPREL64:
12325           addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12326           /* Fall thru */
12327
12328           /* Relocations that may need to be propagated if this is a
12329              dynamic object.  */
12330         case R_PPC64_REL30:
12331         case R_PPC64_REL32:
12332         case R_PPC64_REL64:
12333         case R_PPC64_ADDR14:
12334         case R_PPC64_ADDR14_BRNTAKEN:
12335         case R_PPC64_ADDR14_BRTAKEN:
12336         case R_PPC64_ADDR16:
12337         case R_PPC64_ADDR16_DS:
12338         case R_PPC64_ADDR16_HA:
12339         case R_PPC64_ADDR16_HI:
12340         case R_PPC64_ADDR16_HIGHER:
12341         case R_PPC64_ADDR16_HIGHERA:
12342         case R_PPC64_ADDR16_HIGHEST:
12343         case R_PPC64_ADDR16_HIGHESTA:
12344         case R_PPC64_ADDR16_LO:
12345         case R_PPC64_ADDR16_LO_DS:
12346         case R_PPC64_ADDR24:
12347         case R_PPC64_ADDR32:
12348         case R_PPC64_ADDR64:
12349         case R_PPC64_UADDR16:
12350         case R_PPC64_UADDR32:
12351         case R_PPC64_UADDR64:
12352         dodyn:
12353           if ((input_section->flags & SEC_ALLOC) == 0)
12354             break;
12355
12356           if (NO_OPD_RELOCS && is_opd)
12357             break;
12358
12359           if ((info->shared
12360                && (h == NULL
12361                    || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12362                    || h->elf.root.type != bfd_link_hash_undefweak)
12363                && (must_be_dyn_reloc (info, r_type)
12364                    || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12365               || (ELIMINATE_COPY_RELOCS
12366                   && !info->shared
12367                   && h != NULL
12368                   && h->elf.dynindx != -1
12369                   && !h->elf.non_got_ref
12370                   && !h->elf.def_regular)
12371               || (!info->shared
12372                   && (h != NULL
12373                       ? h->elf.type == STT_GNU_IFUNC
12374                       : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12375             {
12376               bfd_boolean skip, relocate;
12377               asection *sreloc;
12378               bfd_vma out_off;
12379
12380               /* When generating a dynamic object, these relocations
12381                  are copied into the output file to be resolved at run
12382                  time.  */
12383
12384               skip = FALSE;
12385               relocate = FALSE;
12386
12387               out_off = _bfd_elf_section_offset (output_bfd, info,
12388                                                  input_section, rel->r_offset);
12389               if (out_off == (bfd_vma) -1)
12390                 skip = TRUE;
12391               else if (out_off == (bfd_vma) -2)
12392                 skip = TRUE, relocate = TRUE;
12393               out_off += (input_section->output_section->vma
12394                           + input_section->output_offset);
12395               outrel.r_offset = out_off;
12396               outrel.r_addend = rel->r_addend;
12397
12398               /* Optimize unaligned reloc use.  */
12399               if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
12400                   || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
12401                 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
12402               else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
12403                        || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
12404                 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
12405               else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
12406                        || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
12407                 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
12408
12409               if (skip)
12410                 memset (&outrel, 0, sizeof outrel);
12411               else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
12412                        && !is_opd
12413                        && r_type != R_PPC64_TOC)
12414                 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
12415               else
12416                 {
12417                   /* This symbol is local, or marked to become local,
12418                      or this is an opd section reloc which must point
12419                      at a local function.  */
12420                   outrel.r_addend += relocation;
12421                   if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12422                     {
12423                       if (is_opd && h != NULL)
12424                         {
12425                           /* Lie about opd entries.  This case occurs
12426                              when building shared libraries and we
12427                              reference a function in another shared
12428                              lib.  The same thing happens for a weak
12429                              definition in an application that's
12430                              overridden by a strong definition in a
12431                              shared lib.  (I believe this is a generic
12432                              bug in binutils handling of weak syms.)
12433                              In these cases we won't use the opd
12434                              entry in this lib.  */
12435                           unresolved_reloc = FALSE;
12436                         }
12437                       if (!is_opd
12438                           && r_type == R_PPC64_ADDR64
12439                           && (h != NULL
12440                               ? h->elf.type == STT_GNU_IFUNC
12441                               : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12442                         outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12443                       else
12444                         {
12445                           outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12446
12447                           /* We need to relocate .opd contents for ld.so.
12448                              Prelink also wants simple and consistent rules
12449                              for relocs.  This make all RELATIVE relocs have
12450                              *r_offset equal to r_addend.  */
12451                           relocate = TRUE;
12452                         }
12453                     }
12454                   else
12455                     {
12456                       long indx = 0;
12457
12458                       if (h != NULL
12459                           ? h->elf.type == STT_GNU_IFUNC
12460                           : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12461                         {
12462                           (*_bfd_error_handler)
12463                             (_("%B(%A+0x%lx): relocation %s for indirect "
12464                                "function %s unsupported"),
12465                              input_bfd,
12466                              input_section,
12467                              (long) rel->r_offset,
12468                              ppc64_elf_howto_table[r_type]->name,
12469                              sym_name);
12470                           ret = FALSE;
12471                         }
12472                       else if (r_symndx == 0 || bfd_is_abs_section (sec))
12473                         ;
12474                       else if (sec == NULL || sec->owner == NULL)
12475                         {
12476                           bfd_set_error (bfd_error_bad_value);
12477                           return FALSE;
12478                         }
12479                       else
12480                         {
12481                           asection *osec;
12482
12483                           osec = sec->output_section;
12484                           indx = elf_section_data (osec)->dynindx;
12485
12486                           if (indx == 0)
12487                             {
12488                               if ((osec->flags & SEC_READONLY) == 0
12489                                   && htab->elf.data_index_section != NULL)
12490                                 osec = htab->elf.data_index_section;
12491                               else
12492                                 osec = htab->elf.text_index_section;
12493                               indx = elf_section_data (osec)->dynindx;
12494                             }
12495                           BFD_ASSERT (indx != 0);
12496
12497                           /* We are turning this relocation into one
12498                              against a section symbol, so subtract out
12499                              the output section's address but not the
12500                              offset of the input section in the output
12501                              section.  */
12502                           outrel.r_addend -= osec->vma;
12503                         }
12504
12505                       outrel.r_info = ELF64_R_INFO (indx, r_type);
12506                     }
12507                 }
12508
12509               sreloc = elf_section_data (input_section)->sreloc;
12510               if (!htab->elf.dynamic_sections_created)
12511                 sreloc = htab->reliplt;
12512               if (sreloc == NULL)
12513                 abort ();
12514
12515               if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
12516                   >= sreloc->size)
12517                 abort ();
12518               loc = sreloc->contents;
12519               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
12520               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12521
12522               /* If this reloc is against an external symbol, it will
12523                  be computed at runtime, so there's no need to do
12524                  anything now.  However, for the sake of prelink ensure
12525                  that the section contents are a known value.  */
12526               if (! relocate)
12527                 {
12528                   unresolved_reloc = FALSE;
12529                   /* The value chosen here is quite arbitrary as ld.so
12530                      ignores section contents except for the special
12531                      case of .opd where the contents might be accessed
12532                      before relocation.  Choose zero, as that won't
12533                      cause reloc overflow.  */
12534                   relocation = 0;
12535                   addend = 0;
12536                   /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
12537                      to improve backward compatibility with older
12538                      versions of ld.  */
12539                   if (r_type == R_PPC64_ADDR64)
12540                     addend = outrel.r_addend;
12541                   /* Adjust pc_relative relocs to have zero in *r_offset.  */
12542                   else if (ppc64_elf_howto_table[r_type]->pc_relative)
12543                     addend = (input_section->output_section->vma
12544                               + input_section->output_offset
12545                               + rel->r_offset);
12546                 }
12547             }
12548           break;
12549
12550         case R_PPC64_COPY:
12551         case R_PPC64_GLOB_DAT:
12552         case R_PPC64_JMP_SLOT:
12553         case R_PPC64_JMP_IREL:
12554         case R_PPC64_RELATIVE:
12555           /* We shouldn't ever see these dynamic relocs in relocatable
12556              files.  */
12557           /* Fall through.  */
12558
12559         case R_PPC64_PLTGOT16:
12560         case R_PPC64_PLTGOT16_DS:
12561         case R_PPC64_PLTGOT16_HA:
12562         case R_PPC64_PLTGOT16_HI:
12563         case R_PPC64_PLTGOT16_LO:
12564         case R_PPC64_PLTGOT16_LO_DS:
12565         case R_PPC64_PLTREL32:
12566         case R_PPC64_PLTREL64:
12567           /* These ones haven't been implemented yet.  */
12568
12569           (*_bfd_error_handler)
12570             (_("%B: relocation %s is not supported for symbol %s."),
12571              input_bfd,
12572              ppc64_elf_howto_table[r_type]->name, sym_name);
12573
12574           bfd_set_error (bfd_error_invalid_operation);
12575           ret = FALSE;
12576           continue;
12577         }
12578
12579       /* Do any further special processing.  */
12580       switch (r_type)
12581         {
12582         default:
12583           break;
12584
12585         case R_PPC64_ADDR16_HA:
12586         case R_PPC64_REL16_HA:
12587         case R_PPC64_ADDR16_HIGHERA:
12588         case R_PPC64_ADDR16_HIGHESTA:
12589         case R_PPC64_TOC16_HA:
12590         case R_PPC64_SECTOFF_HA:
12591         case R_PPC64_TPREL16_HA:
12592         case R_PPC64_DTPREL16_HA:
12593         case R_PPC64_TPREL16_HIGHER:
12594         case R_PPC64_TPREL16_HIGHERA:
12595         case R_PPC64_TPREL16_HIGHEST:
12596         case R_PPC64_TPREL16_HIGHESTA:
12597         case R_PPC64_DTPREL16_HIGHER:
12598         case R_PPC64_DTPREL16_HIGHERA:
12599         case R_PPC64_DTPREL16_HIGHEST:
12600         case R_PPC64_DTPREL16_HIGHESTA:
12601           /* It's just possible that this symbol is a weak symbol
12602              that's not actually defined anywhere. In that case,
12603              'sec' would be NULL, and we should leave the symbol
12604              alone (it will be set to zero elsewhere in the link).  */
12605           if (sec == NULL)
12606             break;
12607           /* Fall thru */
12608
12609         case R_PPC64_GOT16_HA:
12610         case R_PPC64_PLTGOT16_HA:
12611         case R_PPC64_PLT16_HA:
12612         case R_PPC64_GOT_TLSGD16_HA:
12613         case R_PPC64_GOT_TLSLD16_HA:
12614         case R_PPC64_GOT_TPREL16_HA:
12615         case R_PPC64_GOT_DTPREL16_HA:
12616           /* Add 0x10000 if sign bit in 0:15 is set.
12617              Bits 0:15 are not used.  */
12618           addend += 0x8000;
12619           break;
12620
12621         case R_PPC64_ADDR16_DS:
12622         case R_PPC64_ADDR16_LO_DS:
12623         case R_PPC64_GOT16_DS:
12624         case R_PPC64_GOT16_LO_DS:
12625         case R_PPC64_PLT16_LO_DS:
12626         case R_PPC64_SECTOFF_DS:
12627         case R_PPC64_SECTOFF_LO_DS:
12628         case R_PPC64_TOC16_DS:
12629         case R_PPC64_TOC16_LO_DS:
12630         case R_PPC64_PLTGOT16_DS:
12631         case R_PPC64_PLTGOT16_LO_DS:
12632         case R_PPC64_GOT_TPREL16_DS:
12633         case R_PPC64_GOT_TPREL16_LO_DS:
12634         case R_PPC64_GOT_DTPREL16_DS:
12635         case R_PPC64_GOT_DTPREL16_LO_DS:
12636         case R_PPC64_TPREL16_DS:
12637         case R_PPC64_TPREL16_LO_DS:
12638         case R_PPC64_DTPREL16_DS:
12639         case R_PPC64_DTPREL16_LO_DS:
12640           insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
12641           mask = 3;
12642           /* If this reloc is against an lq insn, then the value must be
12643              a multiple of 16.  This is somewhat of a hack, but the
12644              "correct" way to do this by defining _DQ forms of all the
12645              _DS relocs bloats all reloc switches in this file.  It
12646              doesn't seem to make much sense to use any of these relocs
12647              in data, so testing the insn should be safe.  */
12648           if ((insn & (0x3f << 26)) == (56u << 26))
12649             mask = 15;
12650           if (((relocation + addend) & mask) != 0)
12651             {
12652               (*_bfd_error_handler)
12653                 (_("%B: error: relocation %s not a multiple of %d"),
12654                  input_bfd,
12655                  ppc64_elf_howto_table[r_type]->name,
12656                  mask + 1);
12657               bfd_set_error (bfd_error_bad_value);
12658               ret = FALSE;
12659               continue;
12660             }
12661           break;
12662         }
12663
12664       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
12665          because such sections are not SEC_ALLOC and thus ld.so will
12666          not process them.  */
12667       if (unresolved_reloc
12668           && !((input_section->flags & SEC_DEBUGGING) != 0
12669                && h->elf.def_dynamic))
12670         {
12671           (*_bfd_error_handler)
12672             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
12673              input_bfd,
12674              input_section,
12675              (long) rel->r_offset,
12676              ppc64_elf_howto_table[(int) r_type]->name,
12677              h->elf.root.root.string);
12678           ret = FALSE;
12679         }
12680
12681       r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
12682                                     input_bfd,
12683                                     input_section,
12684                                     contents,
12685                                     rel->r_offset,
12686                                     relocation,
12687                                     addend);
12688
12689       if (r != bfd_reloc_ok)
12690         {
12691           if (sym_name == NULL)
12692             sym_name = "(null)";
12693           if (r == bfd_reloc_overflow)
12694             {
12695               if (warned)
12696                 continue;
12697               if (h != NULL
12698                   && h->elf.root.type == bfd_link_hash_undefweak
12699                   && ppc64_elf_howto_table[r_type]->pc_relative)
12700                 {
12701                   /* Assume this is a call protected by other code that
12702                      detects the symbol is undefined.  If this is the case,
12703                      we can safely ignore the overflow.  If not, the
12704                      program is hosed anyway, and a little warning isn't
12705                      going to help.  */
12706
12707                   continue;
12708                 }
12709
12710               if (!((*info->callbacks->reloc_overflow)
12711                     (info, (h ? &h->elf.root : NULL), sym_name,
12712                      ppc64_elf_howto_table[r_type]->name,
12713                      orig_addend, input_bfd, input_section, rel->r_offset)))
12714                 return FALSE;
12715             }
12716           else
12717             {
12718               (*_bfd_error_handler)
12719                 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
12720                  input_bfd,
12721                  input_section,
12722                  (long) rel->r_offset,
12723                  ppc64_elf_howto_table[r_type]->name,
12724                  sym_name,
12725                  (int) r);
12726               ret = FALSE;
12727             }
12728         }
12729     }
12730
12731   /* If we're emitting relocations, then shortly after this function
12732      returns, reloc offsets and addends for this section will be
12733      adjusted.  Worse, reloc symbol indices will be for the output
12734      file rather than the input.  Save a copy of the relocs for
12735      opd_entry_value.  */
12736   if (is_opd && (info->emitrelocations || info->relocatable))
12737     {
12738       bfd_size_type amt;
12739       amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
12740       rel = bfd_alloc (input_bfd, amt);
12741       BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
12742       ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
12743       if (rel == NULL)
12744         return FALSE;
12745       memcpy (rel, relocs, amt);
12746     }
12747   return ret;
12748 }
12749
12750 /* Adjust the value of any local symbols in opd sections.  */
12751
12752 static int
12753 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
12754                               const char *name ATTRIBUTE_UNUSED,
12755                               Elf_Internal_Sym *elfsym,
12756                               asection *input_sec,
12757                               struct elf_link_hash_entry *h)
12758 {
12759   struct _opd_sec_data *opd;
12760   long adjust;
12761   bfd_vma value;
12762
12763   if (h != NULL)
12764     return 1;
12765
12766   opd = get_opd_info (input_sec);
12767   if (opd == NULL || opd->adjust == NULL)
12768     return 1;
12769
12770   value = elfsym->st_value - input_sec->output_offset;
12771   if (!info->relocatable)
12772     value -= input_sec->output_section->vma;
12773
12774   adjust = opd->adjust[value / 8];
12775   if (adjust == -1)
12776     return 2;
12777
12778   elfsym->st_value += adjust;
12779   return 1;
12780 }
12781
12782 /* Finish up dynamic symbol handling.  We set the contents of various
12783    dynamic sections here.  */
12784
12785 static bfd_boolean
12786 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12787                                  struct bfd_link_info *info,
12788                                  struct elf_link_hash_entry *h,
12789                                  Elf_Internal_Sym *sym)
12790 {
12791   struct ppc_link_hash_table *htab;
12792   struct plt_entry *ent;
12793   Elf_Internal_Rela rela;
12794   bfd_byte *loc;
12795
12796   htab = ppc_hash_table (info);
12797   if (htab == NULL)
12798     return FALSE;
12799
12800   for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12801     if (ent->plt.offset != (bfd_vma) -1)
12802       {
12803         /* This symbol has an entry in the procedure linkage
12804            table.  Set it up.  */
12805         if (!htab->elf.dynamic_sections_created
12806             || h->dynindx == -1)
12807           {
12808             BFD_ASSERT (h->type == STT_GNU_IFUNC
12809                         && h->def_regular
12810                         && (h->root.type == bfd_link_hash_defined
12811                             || h->root.type == bfd_link_hash_defweak));
12812             rela.r_offset = (htab->iplt->output_section->vma
12813                              + htab->iplt->output_offset
12814                              + ent->plt.offset);
12815             rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
12816             rela.r_addend = (h->root.u.def.value
12817                              + h->root.u.def.section->output_offset
12818                              + h->root.u.def.section->output_section->vma
12819                              + ent->addend);
12820             loc = (htab->reliplt->contents
12821                    + (htab->reliplt->reloc_count++
12822                       * sizeof (Elf64_External_Rela)));
12823           }
12824         else
12825           {
12826             rela.r_offset = (htab->plt->output_section->vma
12827                              + htab->plt->output_offset
12828                              + ent->plt.offset);
12829             rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12830             rela.r_addend = ent->addend;
12831             loc = (htab->relplt->contents
12832                    + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12833                       / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12834           }
12835         bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12836       }
12837
12838   if (h->needs_copy)
12839     {
12840       /* This symbol needs a copy reloc.  Set it up.  */
12841
12842       if (h->dynindx == -1
12843           || (h->root.type != bfd_link_hash_defined
12844               && h->root.type != bfd_link_hash_defweak)
12845           || htab->relbss == NULL)
12846         abort ();
12847
12848       rela.r_offset = (h->root.u.def.value
12849                        + h->root.u.def.section->output_section->vma
12850                        + h->root.u.def.section->output_offset);
12851       rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12852       rela.r_addend = 0;
12853       loc = htab->relbss->contents;
12854       loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
12855       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12856     }
12857
12858   /* Mark some specially defined symbols as absolute.  */
12859   if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12860     sym->st_shndx = SHN_ABS;
12861
12862   return TRUE;
12863 }
12864
12865 /* Used to decide how to sort relocs in an optimal manner for the
12866    dynamic linker, before writing them out.  */
12867
12868 static enum elf_reloc_type_class
12869 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
12870 {
12871   enum elf_ppc64_reloc_type r_type;
12872
12873   r_type = ELF64_R_TYPE (rela->r_info);
12874   switch (r_type)
12875     {
12876     case R_PPC64_RELATIVE:
12877       return reloc_class_relative;
12878     case R_PPC64_JMP_SLOT:
12879       return reloc_class_plt;
12880     case R_PPC64_COPY:
12881       return reloc_class_copy;
12882     default:
12883       return reloc_class_normal;
12884     }
12885 }
12886
12887 /* Finish up the dynamic sections.  */
12888
12889 static bfd_boolean
12890 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12891                                    struct bfd_link_info *info)
12892 {
12893   struct ppc_link_hash_table *htab;
12894   bfd *dynobj;
12895   asection *sdyn;
12896
12897   htab = ppc_hash_table (info);
12898   if (htab == NULL)
12899     return FALSE;
12900
12901   dynobj = htab->elf.dynobj;
12902   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12903
12904   if (htab->elf.dynamic_sections_created)
12905     {
12906       Elf64_External_Dyn *dyncon, *dynconend;
12907
12908       if (sdyn == NULL || htab->got == NULL)
12909         abort ();
12910
12911       dyncon = (Elf64_External_Dyn *) sdyn->contents;
12912       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
12913       for (; dyncon < dynconend; dyncon++)
12914         {
12915           Elf_Internal_Dyn dyn;
12916           asection *s;
12917
12918           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
12919
12920           switch (dyn.d_tag)
12921             {
12922             default:
12923               continue;
12924
12925             case DT_PPC64_GLINK:
12926               s = htab->glink;
12927               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12928               /* We stupidly defined DT_PPC64_GLINK to be the start
12929                  of glink rather than the first entry point, which is
12930                  what ld.so needs, and now have a bigger stub to
12931                  support automatic multiple TOCs.  */
12932               dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
12933               break;
12934
12935             case DT_PPC64_OPD:
12936               s = bfd_get_section_by_name (output_bfd, ".opd");
12937               if (s == NULL)
12938                 continue;
12939               dyn.d_un.d_ptr = s->vma;
12940               break;
12941
12942             case DT_PPC64_OPDSZ:
12943               s = bfd_get_section_by_name (output_bfd, ".opd");
12944               if (s == NULL)
12945                 continue;
12946               dyn.d_un.d_val = s->size;
12947               break;
12948
12949             case DT_PLTGOT:
12950               s = htab->plt;
12951               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12952               break;
12953
12954             case DT_JMPREL:
12955               s = htab->relplt;
12956               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12957               break;
12958
12959             case DT_PLTRELSZ:
12960               dyn.d_un.d_val = htab->relplt->size;
12961               break;
12962
12963             case DT_RELASZ:
12964               /* Don't count procedure linkage table relocs in the
12965                  overall reloc count.  */
12966               s = htab->relplt;
12967               if (s == NULL)
12968                 continue;
12969               dyn.d_un.d_val -= s->size;
12970               break;
12971
12972             case DT_RELA:
12973               /* We may not be using the standard ELF linker script.
12974                  If .rela.plt is the first .rela section, we adjust
12975                  DT_RELA to not include it.  */
12976               s = htab->relplt;
12977               if (s == NULL)
12978                 continue;
12979               if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
12980                 continue;
12981               dyn.d_un.d_ptr += s->size;
12982               break;
12983             }
12984
12985           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
12986         }
12987     }
12988
12989   if (htab->got != NULL && htab->got->size != 0)
12990     {
12991       /* Fill in the first entry in the global offset table.
12992          We use it to hold the link-time TOCbase.  */
12993       bfd_put_64 (output_bfd,
12994                   elf_gp (output_bfd) + TOC_BASE_OFF,
12995                   htab->got->contents);
12996
12997       /* Set .got entry size.  */
12998       elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
12999     }
13000
13001   if (htab->plt != NULL && htab->plt->size != 0)
13002     {
13003       /* Set .plt entry size.  */
13004       elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13005         = PLT_ENTRY_SIZE;
13006     }
13007
13008   /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13009      brlt ourselves if emitrelocations.  */
13010   if (htab->brlt != NULL
13011       && htab->brlt->reloc_count != 0
13012       && !_bfd_elf_link_output_relocs (output_bfd,
13013                                        htab->brlt,
13014                                        &elf_section_data (htab->brlt)->rel_hdr,
13015                                        elf_section_data (htab->brlt)->relocs,
13016                                        NULL))
13017     return FALSE;
13018
13019   if (htab->glink != NULL
13020       && htab->glink->reloc_count != 0
13021       && !_bfd_elf_link_output_relocs (output_bfd,
13022                                        htab->glink,
13023                                        &elf_section_data (htab->glink)->rel_hdr,
13024                                        elf_section_data (htab->glink)->relocs,
13025                                        NULL))
13026     return FALSE;
13027
13028   /* We need to handle writing out multiple GOT sections ourselves,
13029      since we didn't add them to DYNOBJ.  We know dynobj is the first
13030      bfd.  */
13031   while ((dynobj = dynobj->link_next) != NULL)
13032     {
13033       asection *s;
13034
13035       if (!is_ppc64_elf (dynobj))
13036         continue;
13037
13038       s = ppc64_elf_tdata (dynobj)->got;
13039       if (s != NULL
13040           && s->size != 0
13041           && s->output_section != bfd_abs_section_ptr
13042           && !bfd_set_section_contents (output_bfd, s->output_section,
13043                                         s->contents, s->output_offset,
13044                                         s->size))
13045         return FALSE;
13046       s = ppc64_elf_tdata (dynobj)->relgot;
13047       if (s != NULL
13048           && s->size != 0
13049           && s->output_section != bfd_abs_section_ptr
13050           && !bfd_set_section_contents (output_bfd, s->output_section,
13051                                         s->contents, s->output_offset,
13052                                         s->size))
13053         return FALSE;
13054     }
13055
13056   return TRUE;
13057 }
13058
13059 #include "elf64-target.h"