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